@lofcz/tikz 0.0.0-stage → 0.2.0

package/runtime/dist/tex/cache-key.js

@@ -0,0 +1,150 @@
+/**
+ * cache-key.ts — content-addressed keys for the two TeX-bridge caches
+ * (docs/05 §6): L2 snippet keys and L1 document keys.
+ *
+ * Both are SHA-256 over a canonical, length-prefixed encoding, so no two
+ * distinct inputs can collide by concatenation ("ab"+"c" vs "a"+"bc"), and a
+ * snippet key can never equal a document key (each kind carries its own tag).
+ *
+ * The digest is computed by a small pure-TypeScript SHA-256 rather than
+ * `crypto.subtle.digest`, because the `make_text` hook that consults the
+ * snippet cache must answer synchronously and Web Crypto is Promise-only.
+ * Dependency-free and browser-safe.
+ */
+/* ---- canonical encoding --------------------------------------------------- */
+class Encoder {
+    parts = [];
+    total = 0;
+    static utf8 = new TextEncoder();
+    push(bytes) {
+        this.parts.push(bytes);
+        this.total += bytes.length;
+    }
+    u32(n) {
+        if (!Number.isInteger(n) || n < 0 || n > 0xffffffff)
+            throw new RangeError(`u32 out of range: ${n}`);
+        this.push(new Uint8Array([(n >>> 24) & 0xff, (n >>> 16) & 0xff, (n >>> 8) & 0xff, n & 0xff]));
+        return this;
+    }
+    /** A string as `u32 byteLength` + UTF-8 bytes. */
+    str(s) {
+        const b = Encoder.utf8.encode(s);
+        this.u32(b.length);
+        this.push(b);
+        return this;
+    }
+    /** A list of strings as `u32 count` + each string. */
+    list(items) {
+        this.u32(items.length);
+        for (const s of items)
+            this.str(s);
+        return this;
+    }
+    bytes() {
+        const out = new Uint8Array(this.total);
+        let o = 0;
+        for (const p of this.parts) {
+            out.set(p, o);
+            o += p.length;
+        }
+        return out;
+    }
+}
+/** Version the encodings so a change in layout can never alias an old key. */
+const SNIPPET_TAG = 'mp-tikz-wasm:snippet:1';
+const DOCUMENT_TAG = 'mp-tikz-wasm:document:1';
+/** L2 key: H(engineId, formatId, verbatimtex chain, body, texscriptmode). */
+export function snippetKey(parts) {
+    const mode = parts.texscriptmode ?? 1;
+    const enc = new Encoder()
+        .str(SNIPPET_TAG)
+        .str(parts.engineId)
+        .str(parts.formatId)
+        .list(parts.chain)
+        .str(parts.body)
+        .str(String(mode));
+    return sha256Hex(enc.bytes());
+}
+/** L1 key: H(full generated .tex, engineId, formatId). */
+export function documentKey(texSource, engineId, formatId) {
+    const enc = new Encoder().str(DOCUMENT_TAG).str(engineId).str(formatId).str(texSource);
+    return sha256Hex(enc.bytes());
+}
+/* ---- SHA-256 (FIPS 180-4), synchronous ------------------------------------ */
+const K = new Uint32Array([
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+]);
+/** SHA-256 of `data` (a string is UTF-8 encoded first) as lowercase hex. */
+export function sha256Hex(data) {
+    const d = sha256(typeof data === 'string' ? new TextEncoder().encode(data) : data);
+    let hex = '';
+    for (let i = 0; i < d.length; i++)
+        hex += (d[i] < 16 ? '0' : '') + d[i].toString(16);
+    return hex;
+}
+/** SHA-256 of `msg`, as 32 bytes. */
+export function sha256(msg) {
+    const H = new Uint32Array([
+        0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+    ]);
+    const W = new Uint32Array(64);
+    // Padding: 0x80, zeros, then the 64-bit big-endian bit length.
+    const len = msg.length;
+    const padded = new Uint8Array(((len + 9 + 63) >> 6) << 6);
+    padded.set(msg);
+    padded[len] = 0x80;
+    const bitsHi = Math.floor(len / 0x20000000); // len * 8 / 2^32
+    const bitsLo = (len << 3) >>> 0;
+    const view = new DataView(padded.buffer);
+    view.setUint32(padded.length - 8, bitsHi);
+    view.setUint32(padded.length - 4, bitsLo);
+    for (let off = 0; off < padded.length; off += 64) {
+        for (let t = 0; t < 16; t++)
+            W[t] = view.getUint32(off + t * 4);
+        for (let t = 16; t < 64; t++) {
+            const w15 = W[t - 15];
+            const w2 = W[t - 2];
+            const s0 = ((w15 >>> 7) | (w15 << 25)) ^ ((w15 >>> 18) | (w15 << 14)) ^ (w15 >>> 3);
+            const s1 = ((w2 >>> 17) | (w2 << 15)) ^ ((w2 >>> 19) | (w2 << 13)) ^ (w2 >>> 10);
+            W[t] = (W[t - 16] + s0 + W[t - 7] + s1) >>> 0;
+        }
+        let a = H[0], b = H[1], c = H[2], d = H[3], e = H[4], f = H[5], g = H[6], h = H[7];
+        for (let t = 0; t < 64; t++) {
+            const S1 = ((e >>> 6) | (e << 26)) ^ ((e >>> 11) | (e << 21)) ^ ((e >>> 25) | (e << 7));
+            const ch = (e & f) ^ (~e & g);
+            const T1 = (h + S1 + ch + K[t] + W[t]) >>> 0;
+            const S0 = ((a >>> 2) | (a << 30)) ^ ((a >>> 13) | (a << 19)) ^ ((a >>> 22) | (a << 10));
+            const maj = (a & b) ^ (a & c) ^ (b & c);
+            const T2 = (S0 + maj) >>> 0;
+            h = g;
+            g = f;
+            f = e;
+            e = (d + T1) >>> 0;
+            d = c;
+            c = b;
+            b = a;
+            a = (T1 + T2) >>> 0;
+        }
+        H[0] = (H[0] + a) >>> 0;
+        H[1] = (H[1] + b) >>> 0;
+        H[2] = (H[2] + c) >>> 0;
+        H[3] = (H[3] + d) >>> 0;
+        H[4] = (H[4] + e) >>> 0;
+        H[5] = (H[5] + f) >>> 0;
+        H[6] = (H[6] + g) >>> 0;
+        H[7] = (H[7] + h) >>> 0;
+    }
+    const out = new Uint8Array(32);
+    const ov = new DataView(out.buffer);
+    for (let i = 0; i < 8; i++)
+        ov.setUint32(i * 4, H[i]);
+    return out;
+}
+//# sourceMappingURL=cache-key.js.map

package/runtime/dist/tex/mpto.d.ts

@@ -0,0 +1,60 @@
+/**
+ * mpto.ts — builds the batched TeX job from scanned blocks (docs/05 §3.1, §4).
+ *
+ * `buildTexJob` reproduces byte for byte the file that upstream `mpx_mpto`
+ * (texk/web2c/mplibdir/mpxout.w) writes for the same input. The string
+ * tables below are copied verbatim from mpxout.w — including their printf
+ * escapes, which `cfmt` interprets — so a future upstream change can be
+ * diffed against them directly.
+ */
+import type { TexBlock } from './scanner.js';
+export type MptoMode = 'tex' | 'troff';
+/**
+ * How the C library rendered the malformed conversion `%\n` that upstream's
+ * `mpx_pretex1` contains twice (`\bgroup%\n` and `\bgroup}%\n` — a printf
+ * format with `%` followed by a newline). The C standard leaves it undefined
+ * and libcs differ, so `mpost` binaries differ too:
+ *
+ *  - `glibc` (Linux): `printf_unknown` prints the spec verbatim, so the `%`
+ *    survives as the TeX comment the author intended. The default.
+ *  - `bsd` (Apple libc, FreeBSD): "pretend it was %c with argument ch", so
+ *    the `%` vanishes and only the newline is printed.
+ *  - musl (Emscripten's libc) rejects the format and prints *nothing* for
+ *    that fprintf — the whole prologue and the first `\mpxshipout% line`
+ *    are missing — which is why the wasm build must not call the C mpto.
+ *
+ * TeX skips the end-of-line space after the control word `\bgroup`, so the
+ * DVI and the .mpx are identical for both renderings.
+ */
+export type PrintfLibc = 'glibc' | 'bsd';
+export interface BuildTexJobOptions {
+    /** TeX (default) or troff output. Index 0 / 1 of the string tables. */
+    mode?: MptoMode;
+    /** Contents of the MPTEXPRE file (docs/05 §9); prepended as-is in TeX mode
+     * only, exactly as upstream copies the file — no newline is added. */
+    mptexpre?: string;
+    /** Which libc's rendering of the `%\n` quirk to reproduce; default 'glibc'. */
+    libc?: PrintfLibc;
+}
+/**
+ * mpto's "put no % at end if it's only 1 line total, starting with %" rule
+ * (the `%&format` special case): after trimming, a btex body gets a `%`
+ * appended unless it is a single line that begins with `%`. An empty body
+ * gets one too.
+ */
+export declare function needsPercent(body: string): boolean;
+/**
+ * Emit the TeX (or troff) job for `blocks`, in source order. Blocks may come
+ * from several files (their `file` and `line` are used for the
+ * `% line N file` wrapper comments); the "first btex" / "first verbatimtex"
+ * bookkeeping is per job, as it is per mpto run upstream.
+ */
+export declare function buildTexJob(blocks: readonly TexBlock[], options?: BuildTexJobOptions): string;
+/**
+ * DVI page `pageIndex` (0-based) was produced by the `pageIndex`-th `btex`
+ * block of the job: every btex block ships out exactly one page, in source
+ * order, and verbatimtex blocks ship nothing (docs/05 §3.1). Blocks that
+ * mpto flagged with an error still get a (blank) page. Returns undefined
+ * when the DVI has more pages than the job has btex blocks.
+ */
+export declare function blockForPage(blocks: readonly TexBlock[], pageIndex: number): TexBlock | undefined;

package/runtime/dist/tex/mpto.js

@@ -0,0 +1,112 @@
+/* ---- static strings for mpto, verbatim from mpxout.w -------------------- */
+const mpx_predoc = ['', '.po 0\n'];
+const mpx_postdoc = ['\\end{document}\n', ''];
+const mpx_pretex1 = [
+    '\\gdef\\mpxshipout{\\shipout\\hbox\\bgroup%\n' +
+        '  \\setbox0=\\hbox\\bgroup}%\n' +
+        '\\gdef\\stopmpxshipout{\\egroup' +
+        '  \\dimen0=\\ht0 \\advance\\dimen0\\dp0\n' +
+        '  \\dimen1=\\ht0 \\dimen2=\\dp0\n' +
+        '  \\setbox0=\\hbox\\bgroup\n' +
+        '    \\box0\n' +
+        '    \\ifnum\\dimen0>0 \\vrule width1sp height\\dimen1 depth\\dimen2 \n' +
+        '    \\else \\vrule width1sp height1sp depth0sp\\relax\n' +
+        '    \\fi\\egroup\n' +
+        '  \\ht0=0pt \\dp0=0pt \\box0 \\egroup}\n' +
+        '\\mpxshipout%% line %d %s\n',
+    '.lf %d %s\n',
+];
+const mpx_pretex = ['\\mpxshipout%% line %d %s\n', '.bp\n.lf %d %s\n'];
+const mpx_posttex = ['\n\\stopmpxshipout\n', '\n'];
+const mpx_preverb1 = ['', '.lf %d %s\n']; /* if very first instance */
+const mpx_preverb = ['%% line %d %s\n', '.lf %d %s\n']; /* all other instances */
+const mpx_postverb = ['\n', '\n'];
+/** The subset of printf that the tables use: `%%`, `%d`, `%s` — plus the
+ * malformed `%\n`, rendered the way the chosen libc renders it. */
+function cfmt(fmt, line, file, libc) {
+    let out = '';
+    for (let i = 0; i < fmt.length; i++) {
+        const c = fmt[i];
+        if (c !== '%') {
+            out += c;
+            continue;
+        }
+        const d = fmt[++i];
+        if (d === '%')
+            out += '%';
+        else if (d === 'd')
+            out += String(line);
+        else if (d === 's')
+            out += file;
+        else if (d === undefined)
+            throw new Error('cfmt: format ends with %');
+        else
+            out += libc === 'bsd' ? d : '%' + d; // unknown conversion (see PrintfLibc)
+    }
+    return out;
+}
+/**
+ * mpto's "put no % at end if it's only 1 line total, starting with %" rule
+ * (the `%&format` special case): after trimming, a btex body gets a `%`
+ * appended unless it is a single line that begins with `%`. An empty body
+ * gets one too.
+ */
+export function needsPercent(body) {
+    return body.length === 0 || body.includes('\n') || body[0] !== '%';
+}
+/**
+ * Emit the TeX (or troff) job for `blocks`, in source order. Blocks may come
+ * from several files (their `file` and `line` are used for the
+ * `% line N file` wrapper comments); the "first btex" / "first verbatimtex"
+ * bookkeeping is per job, as it is per mpto run upstream.
+ */
+export function buildTexJob(blocks, options = {}) {
+    const m = options.mode === 'troff' ? 1 : 0;
+    const libc = options.libc ?? 'glibc';
+    let out = '';
+    if (m === 0 && options.mptexpre !== undefined)
+        out += options.mptexpre;
+    out += mpx_predoc[m];
+    let texcnt = 0;
+    let verbcnt = 0;
+    for (const b of blocks) {
+        if (b.kind === 'btex') {
+            out += cfmt(texcnt++ === 0 ? mpx_pretex1[m] : mpx_pretex[m], b.line, b.file, libc);
+            if (b.error === undefined) {
+                out += b.body;
+                if (m === 0 && needsPercent(b.body))
+                    out += '%';
+            }
+            out += mpx_posttex[m];
+        }
+        else {
+            out += cfmt(verbcnt++ === 0 && texcnt === 0 ? mpx_preverb1[m] : mpx_preverb[m], b.line, b.file, libc);
+            if (b.error === undefined)
+                out += b.body;
+            out += mpx_postverb[m];
+        }
+    }
+    out += mpx_postdoc[m];
+    return out;
+}
+/**
+ * DVI page `pageIndex` (0-based) was produced by the `pageIndex`-th `btex`
+ * block of the job: every btex block ships out exactly one page, in source
+ * order, and verbatimtex blocks ship nothing (docs/05 §3.1). Blocks that
+ * mpto flagged with an error still get a (blank) page. Returns undefined
+ * when the DVI has more pages than the job has btex blocks.
+ */
+export function blockForPage(blocks, pageIndex) {
+    if (pageIndex < 0 || !Number.isInteger(pageIndex))
+        return undefined;
+    let k = 0;
+    for (const b of blocks) {
+        if (b.kind !== 'btex')
+            continue;
+        if (k === pageIndex)
+            return b;
+        k++;
+    }
+    return undefined;
+}
+//# sourceMappingURL=mpto.js.map

package/runtime/dist/tex/mpx.d.ts

@@ -0,0 +1,25 @@
+/**
+ * mpx.ts — splits a `.mpx` file (dvitomp output) into one MetaPost primary
+ * per typeset block (docs/05 §4.1).
+ *
+ * The format, as written by `mpx_run_dvitomp`:
+ *
+ *   % Written by metapost version 2.11        <- banner
+ *   begingroup save _p,_r,_s,_n; ...          <- chunk 0
+ *   _p endgroup
+ *   mpxbreak
+ *   begingroup ...                            <- chunk 1
+ *   _p endgroup
+ *   mpxbreak
+ *
+ * Chunk k corresponds to btex block k; each chunk is self-contained and is a
+ * valid MetaPost primary, so it can be returned from `make_text` verbatim.
+ */
+/**
+ * Drop the leading `%` banner, split on lines equal to `mpxbreak`, and return
+ * the chunks. Leading and trailing empty lines of a chunk are removed (so a
+ * chunk ends with `_p endgroup`, not a newline); a trailing chunk that is
+ * empty or whitespace-only — the normal remainder after the final `mpxbreak`
+ * — is ignored. CRLF line ends are accepted.
+ */
+export declare function splitMpx(mpx: string): string[];

package/runtime/dist/tex/mpx.js

@@ -0,0 +1,54 @@
+/**
+ * mpx.ts — splits a `.mpx` file (dvitomp output) into one MetaPost primary
+ * per typeset block (docs/05 §4.1).
+ *
+ * The format, as written by `mpx_run_dvitomp`:
+ *
+ *   % Written by metapost version 2.11        <- banner
+ *   begingroup save _p,_r,_s,_n; ...          <- chunk 0
+ *   _p endgroup
+ *   mpxbreak
+ *   begingroup ...                            <- chunk 1
+ *   _p endgroup
+ *   mpxbreak
+ *
+ * Chunk k corresponds to btex block k; each chunk is self-contained and is a
+ * valid MetaPost primary, so it can be returned from `make_text` verbatim.
+ */
+/**
+ * Drop the leading `%` banner, split on lines equal to `mpxbreak`, and return
+ * the chunks. Leading and trailing empty lines of a chunk are removed (so a
+ * chunk ends with `_p endgroup`, not a newline); a trailing chunk that is
+ * empty or whitespace-only — the normal remainder after the final `mpxbreak`
+ * — is ignored. CRLF line ends are accepted.
+ */
+export function splitMpx(mpx) {
+    const lines = mpx.split('\n').map((l) => (l.endsWith('\r') ? l.slice(0, -1) : l));
+    if (lines.length > 0 && lines[lines.length - 1] === '')
+        lines.pop(); // trailing newline
+    if (lines.length > 0 && lines[0].startsWith('%'))
+        lines.shift(); // banner
+    const chunks = [];
+    let cur = [];
+    const flush = (last) => {
+        while (cur.length > 0 && cur[0] === '')
+            cur.shift();
+        while (cur.length > 0 && cur[cur.length - 1] === '')
+            cur.pop();
+        if (last && cur.every((l) => l.trim() === '')) {
+            cur = [];
+            return;
+        }
+        chunks.push(cur.join('\n'));
+        cur = [];
+    };
+    for (const line of lines) {
+        if (line === 'mpxbreak')
+            flush(false);
+        else
+            cur.push(line);
+    }
+    flush(true);
+    return chunks;
+}
+//# sourceMappingURL=mpx.js.map

package/runtime/dist/tex/scanner.d.ts

@@ -0,0 +1,78 @@
+/**
+ * scanner.ts — a faithful TypeScript port of upstream mpto's lexer
+ * (`mpx_getline`, `mpx_match_str`, `mpx_getbta`, `mpx_copy_mpto` and the
+ * "Do a line" loop of `mpx_mpto` in texk/web2c/mplibdir/mpxout.w).
+ *
+ * The port exists so that the TeX bridge (docs/05 §3) can find `btex` /
+ * `verbatimtex` blocks without writing temporaries, and so that
+ * `buildTexJob(scanTexBlocks(src))` (src/ts/tex/mpto.ts) reproduces the .tex
+ * file that C `mpx_mpto` writes byte for byte. Where the C and this file
+ * disagree, the C is right; test/unit/scanner.test.ts diffs the two.
+ *
+ * Dependency-free and browser-safe: no Node imports.
+ */
+export interface TexBlock {
+    kind: 'btex' | 'verbatimtex';
+    /**
+     * The block text exactly as mpto emits it between its wrapper lines:
+     * for `btex` leading and trailing whitespace is stripped; for the first
+     * `verbatimtex` block of a file only leading whitespace is stripped; later
+     * `verbatimtex` blocks are untouched. Line ends are normalised to "\n".
+     * The `%` that mpto appends to a `btex` body in TeX mode is NOT part of
+     * `body` (see `needsPercent` in mpto.ts) so the same block can be rendered
+     * in troff mode too.
+     */
+    body: string;
+    /** 1-based line of the opening keyword, counted the way mpto counts. */
+    line: number;
+    /** The file name the block was scanned from (used in `% line N file`). */
+    file: string;
+    /** Position of this block in source order, 0-based, counting both kinds. */
+    index: number;
+    /**
+     * The untrimmed text mpto accumulated for the block (its `res` buffer),
+     * before whitespace handling. Kept for callers that need the raw form.
+     */
+    raw: string;
+    /**
+     * Set when mpto would report an error for this block ("btex in TeX mode",
+     * "verbatimtex in TeX mode", "btex section does not end"). mpto still
+     * writes the wrapper lines for such a block but no body at all — not even
+     * the `%` — and `buildTexJob` reproduces that.
+     */
+    error?: string;
+}
+export interface ScanError {
+    message: string;
+    /** mpto's line counter at the time of the error (1-based). */
+    line: number;
+    file: string;
+}
+export interface ScanResult {
+    blocks: TexBlock[];
+    /** Every "makempx error:" mpto would print, in order. */
+    errors: ScanError[];
+}
+/**
+ * Scan MetaPost source for `btex ... etex` and `verbatimtex ... etex` blocks
+ * exactly as upstream mpto does, and report the errors mpto would report.
+ *
+ * One deliberate deviation: on an unterminated string literal upstream
+ * `mpx_mpto` loops forever printing "string does not end" (its do/while
+ * never advances once `mpx_getbta` has reached the end of the line). This
+ * port reports the error once and treats the rest of the line as the string.
+ */
+export declare function scanTex(source: string, fileName: string): ScanResult;
+/** The blocks of `scanTex`, for callers that do not need the error list. */
+export declare function scanTexBlocks(source: string, fileName: string): TexBlock[];
+/**
+ * Find the file names referenced by `input name` / `input "name"` statements
+ * (docs/05 §3.2). Lexical only: comments, string literals and the inside of
+ * btex/verbatimtex blocks are skipped, `input` must be a whole symbolic
+ * token, and the name is delimited the way `mp_scan_file_name` delimits it —
+ * it ends at a space, tab, `;`, `%` or end of line unless inside quotes, and
+ * the quotes themselves are not part of the name. Names are returned as
+ * written, in order, without deduplication; `scantokens`-built inputs are
+ * invisible to this function by design.
+ */
+export declare function scanInputs(source: string): string[];