retail-print-kit 0.0.0-stage → 0.2.0

package/dist/preview/html.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.opsToHtml = opsToHtml;
+const bitmap_1 = require("../core/bitmap");
+const barcode1d_1 = require("../core/barcode1d");
+const png_1 = require("./png");
+const base64_1 = require("../util/base64");
+function esc(s) {
+    return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+/**
+ * Paper-like HTML of the ops: monospaced lines at the profile's column count, with size, style,
+ * alignment and font honoured, and QR / barcodes / images inlined as PNG. Meant for on-screen
+ * preview and for a designer; not byte-exact with any printer.
+ */
+function opsToHtml(ops, profile, options = {}) {
+    const cell = options.cellWidth ?? 8;
+    const paperPx = profile.columns.a * cell;
+    const state = { align: 'left', font: 'a', w: 1, h: 1, style: {} };
+    const lines = [];
+    let pending = '';
+    const styleAttr = () => {
+        const parts = [`text-align:${state.align}`];
+        if (state.w !== 1 || state.h !== 1)
+            parts.push(`transform:scale(${state.w},${state.h});transform-origin:${state.align} top`, `height:${state.h}em`);
+        if (state.font === 'b')
+            parts.push('font-size:0.78em');
+        if (state.style.bold)
+            parts.push('font-weight:bold');
+        if (state.style.underline)
+            parts.push(`text-decoration:underline${state.style.underline === 2 ? ' double' : ''}`);
+        if (state.style.invert)
+            parts.push('background:#000;color:#fff');
+        return parts.join(';');
+    };
+    const flush = (force) => {
+        if (!pending && !force)
+            return;
+        const cols = Math.max(1, Math.floor(profile.columns[state.font] / state.w));
+        const parts = [];
+        for (let i = 0; i < pending.length; i += cols)
+            parts.push(pending.slice(i, i + cols));
+        if (!parts.length)
+            parts.push('');
+        for (const p of parts)
+            lines.push(`<div class="l" style="${styleAttr()}">${esc(p) || '&nbsp;'}</div>`);
+        pending = '';
+    };
+    const img = (png, width, alt) => lines.push(`<div class="l" style="text-align:${state.align}"><img alt="${esc(alt)}" width="${Math.round((width / profile.dots) * paperPx)}" src="data:image/png;base64,${(0, base64_1.toBase64)(png)}"></div>`);
+    for (const op of ops) {
+        switch (op.kind) {
+            case 'text': {
+                const ls = op.text.split('\n');
+                for (let i = 0; i < ls.length; i++) {
+                    pending += ls[i];
+                    if (i < ls.length - 1)
+                        flush(true);
+                }
+                break;
+            }
+            case 'newline':
+                for (let i = 0; i < op.count; i++)
+                    flush(true);
+                break;
+            case 'feed':
+                flush(false);
+                for (let i = 0; i < op.lines; i++)
+                    lines.push('<div class="l">&nbsp;</div>');
+                break;
+            case 'align':
+                flush(false);
+                state.align = op.align;
+                break;
+            case 'font':
+                flush(false);
+                state.font = op.font;
+                break;
+            case 'size':
+                flush(false);
+                state.w = op.width;
+                state.h = op.height;
+                break;
+            case 'style':
+                flush(false);
+                state.style = op.style;
+                break;
+            case 'qr': {
+                flush(false);
+                const b = (0, bitmap_1.qrBitmap)(op.data, op.options);
+                img((0, png_1.bitmapToPng)(b), b.width, `QR ${op.data}`);
+                break;
+            }
+            case 'barcode': {
+                flush(false);
+                const b = (0, barcode1d_1.barcodeBitmap)(op.type, op.data, op.options.width ?? 2, op.options.height ?? 80);
+                img((0, png_1.bitmapToPng)(b), b.width, `${op.type} ${op.data}`);
+                const pos = op.options.position ?? 'below';
+                if (pos === 'below' || pos === 'both') {
+                    pending = op.data;
+                    flush(true);
+                }
+                break;
+            }
+            case 'raster': {
+                flush(false);
+                img((0, png_1.bitmapToPng)({ width: op.width, height: op.height, bits: op.bits }), op.width, 'image');
+                break;
+            }
+            case 'cut':
+                flush(false);
+                lines.push('<div class="cut"></div>');
+                break;
+            case 'drawer':
+                flush(false);
+                lines.push('<div class="note">[drawer kick]</div>');
+                break;
+            default: break;
+        }
+    }
+    flush(false);
+    const body = `<div class="paper" style="width:${paperPx}px">${lines.join('')}</div>`;
+    if (options.document === false)
+        return body;
+    return `<!doctype html><html><head><meta charset="utf-8"><title>${esc(profile.model)} preview</title><style>
+body{background:#777;margin:0;padding:16px;font-family:ui-monospace,Menlo,Consolas,monospace;font-size:${cell * 1.6}px;line-height:1.25}
+.paper{background:#fff;color:#000;padding:12px ${cell}px;margin:0 auto;box-shadow:0 2px 8px rgba(0,0,0,.4);box-sizing:content-box}
+.l{white-space:pre;overflow:hidden;min-height:1.25em}
+.cut{border-top:2px dashed #999;margin:6px -${cell}px}
+.note{color:#999;font-size:.7em;text-align:center}
+img{image-rendering:pixelated;vertical-align:top}
+</style></head><body>${body}</body></html>`;
+}

package/dist/preview/index.d.ts

@@ -0,0 +1,8 @@
+import { Op } from '../core/ops';
+import { Profile } from '../profiles/types';
+import { Rasterizer } from '../core/rasterizer';
+export { bitmapToPng } from './png';
+export { opsToHtml } from './html';
+export type { HtmlPreviewOptions } from './html';
+/** PNG of the ops as a bitmap printer would lay them out (needs a canvas, see CanvasRasterizer). */
+export declare function opsToPng(ops: Op[], profile: Profile, rasterizer?: Rasterizer): Uint8Array;

package/dist/preview/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.opsToHtml = exports.bitmapToPng = void 0;
+exports.opsToPng = opsToPng;
+const rasterizer_1 = require("../core/rasterizer");
+const png_1 = require("./png");
+var png_2 = require("./png");
+Object.defineProperty(exports, "bitmapToPng", { enumerable: true, get: function () { return png_2.bitmapToPng; } });
+var html_1 = require("./html");
+Object.defineProperty(exports, "opsToHtml", { enumerable: true, get: function () { return html_1.opsToHtml; } });
+/** PNG of the ops as a bitmap printer would lay them out (needs a canvas, see CanvasRasterizer). */
+function opsToPng(ops, profile, rasterizer = new rasterizer_1.CanvasRasterizer()) {
+    return (0, png_1.bitmapToPng)(rasterizer.render(ops, profile));
+}

package/dist/preview/png.d.ts

@@ -0,0 +1,3 @@
+import { Bitmap } from '../core/bitmap';
+/** Encodes a 1-bit bitmap as a PNG (1-bit greyscale, black = ink). No dependencies; works in browsers. */
+export declare function bitmapToPng(b: Bitmap): Uint8Array;

package/dist/preview/png.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bitmapToPng = bitmapToPng;
+const bitmap_1 = require("../core/bitmap");
+const CRC_TABLE = (() => {
+    const t = new Uint32Array(256);
+    for (let n = 0; n < 256; n++) {
+        let c = n;
+        for (let k = 0; k < 8; k++)
+            c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+        t[n] = c >>> 0;
+    }
+    return t;
+})();
+function crc32(buf) {
+    let c = 0xffffffff;
+    for (const b of buf)
+        c = CRC_TABLE[(c ^ b) & 0xff] ^ (c >>> 8);
+    return (c ^ 0xffffffff) >>> 0;
+}
+function u32(n) {
+    return [(n >>> 24) & 0xff, (n >>> 16) & 0xff, (n >>> 8) & 0xff, n & 0xff];
+}
+function concat(parts) {
+    const out = new Uint8Array(parts.reduce((n, p) => n + p.length, 0));
+    let o = 0;
+    for (const p of parts) {
+        out.set(p, o);
+        o += p.length;
+    }
+    return out;
+}
+function chunk(type, data) {
+    const body = concat([new Uint8Array([...type].map((c) => c.charCodeAt(0))), data]);
+    return concat([new Uint8Array(u32(data.length)), body, new Uint8Array(u32(crc32(body)))]);
+}
+function adler32(data) {
+    let a = 1;
+    let b = 0;
+    for (const d of data) {
+        a = (a + d) % 65521;
+        b = (b + a) % 65521;
+    }
+    return ((b << 16) | a) >>> 0;
+}
+/** zlib stream with stored (uncompressed) deflate blocks; used where Node's zlib is unavailable. */
+function deflateStored(data) {
+    const blocks = [new Uint8Array([0x78, 0x01])];
+    const MAX = 65535;
+    for (let i = 0; i < data.length || i === 0; i += MAX) {
+        const slice = data.subarray(i, Math.min(i + MAX, data.length));
+        const last = i + MAX >= data.length ? 1 : 0;
+        const len = slice.length;
+        blocks.push(new Uint8Array([last, len & 0xff, len >> 8, ~len & 0xff, (~len >> 8) & 0xff]), slice);
+        if (data.length === 0)
+            break;
+    }
+    blocks.push(new Uint8Array(u32(adler32(data))));
+    return concat(blocks);
+}
+function deflate(data) {
+    try {
+        const zlib = require('zlib');
+        const out = zlib.deflateSync(data);
+        return new Uint8Array(out.buffer, out.byteOffset, out.byteLength);
+    }
+    catch {
+        return deflateStored(data);
+    }
+}
+/** Encodes a 1-bit bitmap as a PNG (1-bit greyscale, black = ink). No dependencies; works in browsers. */
+function bitmapToPng(b) {
+    const rowBytes = Math.ceil(b.width / 8);
+    const raw = new Uint8Array((rowBytes + 1) * b.height);
+    for (let y = 0; y < b.height; y++) {
+        for (let x = 0; x < b.width; x++) {
+            if (!(0, bitmap_1.getPixel)(b, x, y))
+                raw[y * (rowBytes + 1) + 1 + (x >> 3)] |= 0x80 >> (x & 7);
+        }
+    }
+    const ihdr = new Uint8Array([...u32(b.width), ...u32(b.height), 1, 0, 0, 0, 0]);
+    const png = concat([
+        new Uint8Array([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]),
+        chunk('IHDR', ihdr),
+        chunk('IDAT', deflate(raw)),
+        chunk('IEND', new Uint8Array(0)),
+    ]);
+    return typeof Buffer !== 'undefined' ? Buffer.from(png.buffer, png.byteOffset, png.byteLength) : png;
+}

package/dist/profiles/epson.d.ts

@@ -0,0 +1,10 @@
+import { Profile } from './types';
+export declare const epsonTmT88: Profile;
+export declare const epsonTmT20: Profile;
+export declare const epsonTmM30: Profile;
+/**
+ * Cheap Epson-compatible units (Xprinter, Rongta, HPRT, POS-X and similar). They answer to the
+ * common subset but often mishandle GS V 65/66, so cutting feeds with LF first and uses GS V 0/1.
+ */
+export declare const genericEscPos: Profile;
+export declare const genericEscPos58: Profile;

package/dist/profiles/epson.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.genericEscPos58 = exports.genericEscPos = exports.epsonTmM30 = exports.epsonTmT20 = exports.epsonTmT88 = void 0;
+const epsonBase = {
+    vendor: 'Epson',
+    set: 'escpos',
+    paper: 80,
+    dots: 576,
+    columns: { a: 48, b: 64 },
+    encoding: 'cp437',
+    codepage: 0,
+    cut: 'feed-and-cut',
+    drawer: { on: 25, off: 250 },
+    features: { nativeQr: true, raster: true, italic: false, invert: true, beep: false },
+};
+exports.epsonTmT88 = {
+    ...epsonBase,
+    id: 'epson-tm-t88',
+    model: 'TM-T88V / VI / VII',
+    usb: [{ vendorId: 0x04b8 }],
+};
+exports.epsonTmT20 = {
+    ...epsonBase,
+    id: 'epson-tm-t20',
+    model: 'TM-T20III',
+    usb: [{ vendorId: 0x04b8 }],
+};
+exports.epsonTmM30 = {
+    ...epsonBase,
+    id: 'epson-tm-m30',
+    model: 'TM-m30II / III',
+    usb: [{ vendorId: 0x04b8 }],
+};
+/**
+ * Cheap Epson-compatible units (Xprinter, Rongta, HPRT, POS-X and similar). They answer to the
+ * common subset but often mishandle GS V 65/66, so cutting feeds with LF first and uses GS V 0/1.
+ */
+exports.genericEscPos = {
+    ...epsonBase,
+    vendor: 'Generic',
+    id: 'generic-escpos',
+    model: 'ESC/POS compatible 80 mm',
+    cut: 'legacy',
+    drawer: { on: 60, off: 120 },
+    features: { nativeQr: true, raster: true, italic: false, invert: true, beep: true },
+};
+exports.genericEscPos58 = {
+    ...exports.genericEscPos,
+    id: 'generic-escpos-58',
+    model: 'ESC/POS compatible 58 mm',
+    paper: 58,
+    dots: 384,
+    columns: { a: 32, b: 42 },
+};

package/dist/profiles/index.d.ts

@@ -0,0 +1,7 @@
+import { Profile } from './types';
+import { epsonTmT88, epsonTmT20, epsonTmM30, genericEscPos, genericEscPos58 } from './epson';
+import { starTsp650, starMcPrint3, starTsp100 } from './star';
+export * from './types';
+export { epsonTmT88, epsonTmT20, epsonTmM30, genericEscPos, genericEscPos58, starTsp650, starMcPrint3, starTsp100 };
+export declare const profiles: Record<string, Profile>;
+export declare function profileById(id: string): Profile;

package/dist/profiles/index.js

@@ -0,0 +1,36 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.profiles = exports.starTsp100 = exports.starMcPrint3 = exports.starTsp650 = exports.genericEscPos58 = exports.genericEscPos = exports.epsonTmM30 = exports.epsonTmT20 = exports.epsonTmT88 = void 0;
+exports.profileById = profileById;
+const epson_1 = require("./epson");
+Object.defineProperty(exports, "epsonTmT88", { enumerable: true, get: function () { return epson_1.epsonTmT88; } });
+Object.defineProperty(exports, "epsonTmT20", { enumerable: true, get: function () { return epson_1.epsonTmT20; } });
+Object.defineProperty(exports, "epsonTmM30", { enumerable: true, get: function () { return epson_1.epsonTmM30; } });
+Object.defineProperty(exports, "genericEscPos", { enumerable: true, get: function () { return epson_1.genericEscPos; } });
+Object.defineProperty(exports, "genericEscPos58", { enumerable: true, get: function () { return epson_1.genericEscPos58; } });
+const star_1 = require("./star");
+Object.defineProperty(exports, "starTsp650", { enumerable: true, get: function () { return star_1.starTsp650; } });
+Object.defineProperty(exports, "starMcPrint3", { enumerable: true, get: function () { return star_1.starMcPrint3; } });
+Object.defineProperty(exports, "starTsp100", { enumerable: true, get: function () { return star_1.starTsp100; } });
+__exportStar(require("./types"), exports);
+exports.profiles = Object.fromEntries([epson_1.epsonTmT88, epson_1.epsonTmT20, epson_1.epsonTmM30, epson_1.genericEscPos, epson_1.genericEscPos58, star_1.starTsp650, star_1.starMcPrint3, star_1.starTsp100].map((p) => [p.id, p]));
+function profileById(id) {
+    const p = exports.profiles[id];
+    if (!p)
+        throw new Error(`retail-print-kit: unknown profile "${id}"`);
+    return p;
+}

package/dist/profiles/star.d.ts

@@ -0,0 +1,7 @@
+import { Profile } from './types';
+/** TSP650II, TSP700II, TSP800II in Star Line Mode (the factory setting). */
+export declare const starTsp650: Profile;
+/** mC-Print3 / mC-Print2 in Star Line Mode. */
+export declare const starMcPrint3: Profile;
+/** TSP100 / TSP143 family: raster only, everything is rendered to a bitmap first. */
+export declare const starTsp100: Profile;

package/dist/profiles/star.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.starTsp100 = exports.starMcPrint3 = exports.starTsp650 = void 0;
+const starBase = {
+    vendor: 'Star Micronics',
+    paper: 80,
+    dots: 576,
+    columns: { a: 48, b: 64 },
+    encoding: 'cp437',
+    codepage: 1,
+    cut: 'feed-and-cut',
+    drawer: { on: 100, off: 100 },
+    usb: [{ vendorId: 0x0519 }],
+};
+/** TSP650II, TSP700II, TSP800II in Star Line Mode (the factory setting). */
+exports.starTsp650 = {
+    ...starBase,
+    id: 'star-tsp650',
+    model: 'TSP650II / TSP700II (Star Line Mode)',
+    set: 'star-line',
+    features: { nativeQr: true, raster: true, italic: false, invert: true, beep: false },
+};
+/** mC-Print3 / mC-Print2 in Star Line Mode. */
+exports.starMcPrint3 = {
+    ...starBase,
+    id: 'star-mc-print3',
+    model: 'mC-Print3 (Star Line Mode)',
+    set: 'star-line',
+    features: { nativeQr: true, raster: true, italic: false, invert: true, beep: false },
+};
+/** TSP100 / TSP143 family: raster only, everything is rendered to a bitmap first. */
+exports.starTsp100 = {
+    ...starBase,
+    id: 'star-tsp100',
+    model: 'TSP100 / TSP143 (raster)',
+    set: 'star-graphic',
+    codepage: null,
+    features: { nativeQr: false, raster: true, italic: false, invert: true, beep: false },
+};

package/dist/profiles/types.d.ts

@@ -0,0 +1,41 @@
+export type CommandSet = 'escpos' | 'star-line' | 'star-graphic';
+export interface DrawerPulse {
+    /** ESC p t1: on time in units of 2 ms. */
+    on: number;
+    /** ESC p t2: off time in units of 2 ms. */
+    off: number;
+}
+export interface Profile {
+    id: string;
+    vendor: string;
+    model: string;
+    set: CommandSet;
+    /** Paper width in millimetres. */
+    paper: 58 | 76 | 80;
+    /** Printable dots across the paper (8 dots per mm on 203 dpi heads). */
+    dots: number;
+    /** Characters per line for font A and font B. */
+    columns: {
+        a: number;
+        b: number;
+    };
+    /** iconv-lite encoding name used for text. */
+    encoding: string;
+    /** ESC t n value selected on open; null leaves the printer default. */
+    codepage: number | null;
+    /** Full/partial cut using GS V 65/66 with feed (Epson) or GS V 0/1 after LF feed (legacy). */
+    cut: 'feed-and-cut' | 'legacy';
+    drawer: DrawerPulse;
+    features: {
+        nativeQr: boolean;
+        raster: boolean;
+        italic: boolean;
+        invert: boolean;
+        beep: boolean;
+    };
+    /** USB vendor and product ids that identify this printer, when known. */
+    usb?: Array<{
+        vendorId: number;
+        productId?: number;
+    }>;
+}

package/dist/profiles/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/template/expr.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Template values: `{{path}}` and `{{path | filter | filter:arg}}`. Paths are dotted, resolved
+ * against the current scope first, then the root data. `this` is the current scope, `@index`
+ * the position in an `each`. Missing values print as empty strings.
+ */
+export interface Scope {
+    root: unknown;
+    current: unknown;
+    index?: number;
+}
+export type Filter = (value: unknown, arg?: string) => unknown;
+export declare const filters: Record<string, Filter>;
+export declare function lookup(path: string, scope: Scope): unknown;
+export declare function evaluate(expression: string, scope: Scope): unknown;
+export declare function interpolate(text: string, scope: Scope): string;
+export declare function truthy(expression: string, scope: Scope): boolean;

package/dist/template/expr.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filters = void 0;
+exports.lookup = lookup;
+exports.evaluate = evaluate;
+exports.interpolate = interpolate;
+exports.truthy = truthy;
+exports.filters = {
+    upper: (v) => String(v ?? '').toUpperCase(),
+    lower: (v) => String(v ?? '').toLowerCase(),
+    trim: (v) => String(v ?? '').trim(),
+    money: (v, arg) => {
+        const n = Number(v);
+        if (!isFinite(n))
+            return '';
+        const s = Math.abs(n).toFixed(2);
+        return `${n < 0 ? '-' : ''}${arg ?? ''}${s}`;
+    },
+    fixed: (v, arg) => {
+        const n = Number(v);
+        return isFinite(n) ? n.toFixed(Number(arg ?? 2)) : '';
+    },
+    pad: (v, arg) => String(v ?? '').padStart(Number(arg ?? 0)),
+    padEnd: (v, arg) => String(v ?? '').padEnd(Number(arg ?? 0)),
+    default: (v, arg) => (v === undefined || v === null || v === '' ? arg ?? '' : v),
+    date: (v, arg) => {
+        const d = v instanceof Date ? v : new Date(String(v));
+        if (isNaN(d.getTime()))
+            return '';
+        return arg === 'time' ? d.toLocaleTimeString() : arg === 'datetime' ? d.toLocaleString() : d.toLocaleDateString();
+    },
+    count: (v) => (Array.isArray(v) ? v.length : 0),
+};
+function lookup(path, scope) {
+    const p = path.trim();
+    if (p === 'this')
+        return scope.current;
+    if (p === '@index')
+        return scope.index;
+    if (p === '@number')
+        return scope.index === undefined ? undefined : scope.index + 1;
+    if (/^-?\d+(\.\d+)?$/.test(p))
+        return Number(p);
+    if (/^'.*'$/.test(p) || /^".*"$/.test(p))
+        return p.slice(1, -1);
+    const fromCurrent = walk(scope.current, p);
+    if (fromCurrent !== undefined)
+        return fromCurrent;
+    return walk(scope.root, p);
+}
+function walk(obj, path) {
+    let cur = obj;
+    for (const part of path.split('.')) {
+        if (cur === null || cur === undefined)
+            return undefined;
+        cur = cur[part];
+    }
+    return cur;
+}
+function evaluate(expression, scope) {
+    const [head, ...pipes] = expression.split('|').map((s) => s.trim());
+    let value = lookup(head, scope);
+    for (const pipe of pipes) {
+        const idx = pipe.indexOf(':');
+        const name = idx === -1 ? pipe : pipe.slice(0, idx);
+        const arg = idx === -1 ? undefined : pipe.slice(idx + 1);
+        const f = exports.filters[name];
+        if (!f)
+            throw new Error(`retail-print-kit: unknown template filter "${name}"`);
+        value = f(value, arg);
+    }
+    return value;
+}
+function interpolate(text, scope) {
+    return text.replace(/\{\{([^}]+)\}\}/g, (_, expr) => {
+        const v = evaluate(expr, scope);
+        return v === undefined || v === null ? '' : String(v);
+    });
+}
+function truthy(expression, scope) {
+    const not = expression.trim().startsWith('!');
+    const v = evaluate(not ? expression.trim().slice(1) : expression, scope);
+    const t = Array.isArray(v) ? v.length > 0 : !!v;
+    return not ? !t : t;
+}

package/dist/template/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types';
+export { render, renderBlocks } from './render';
+export { filters, interpolate, evaluate, lookup, truthy } from './expr';
+export type { Scope, Filter } from './expr';

package/dist/template/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.truthy = exports.lookup = exports.evaluate = exports.interpolate = exports.filters = exports.renderBlocks = exports.render = void 0;
+__exportStar(require("./types"), exports);
+var render_1 = require("./render");
+Object.defineProperty(exports, "render", { enumerable: true, get: function () { return render_1.render; } });
+Object.defineProperty(exports, "renderBlocks", { enumerable: true, get: function () { return render_1.renderBlocks; } });
+var expr_1 = require("./expr");
+Object.defineProperty(exports, "filters", { enumerable: true, get: function () { return expr_1.filters; } });
+Object.defineProperty(exports, "interpolate", { enumerable: true, get: function () { return expr_1.interpolate; } });
+Object.defineProperty(exports, "evaluate", { enumerable: true, get: function () { return expr_1.evaluate; } });
+Object.defineProperty(exports, "lookup", { enumerable: true, get: function () { return expr_1.lookup; } });
+Object.defineProperty(exports, "truthy", { enumerable: true, get: function () { return expr_1.truthy; } });

package/dist/template/render.d.ts

@@ -0,0 +1,8 @@
+import { Op } from '../core/ops';
+import { OpBuilder } from '../core/builder';
+import { Profile } from '../profiles/types';
+import { Block, Template } from './types';
+import { Scope } from './expr';
+/** Renders a template with data into ops for the given profile. */
+export declare function render(template: Template, data: unknown, profile: Profile): Op[];
+export declare function renderBlocks(blocks: Block[], scope: Scope, b: OpBuilder): void;