@lofcz/tikz 0.0.0-stage → 0.2.0

package/runtime/dist/cli.js

@@ -0,0 +1,372 @@
+#!/usr/bin/env node
+/**
+ * mpost-wasm — a drop-in for `mpost` for the common flag set (docs/08 §5).
+ *
+ *   mpost-wasm [OPTION]... [MPNAME[.mp]] [COMMANDS]
+ *   mpost-wasm --dvitomp DVINAME[.dvi] [MPXNAME[.mpx]]
+ *   mpost-wasm --prerender [--figures=DIR | --base=DIR] [--force] [--dry-run] PAGE.html...
+ */
+import { MetaPost, LOG_LEVELS, DEFAULT_BUNDLES } from './index.js';
+import { prerender } from './prerender.js';
+const HELP = `Usage: mpost-wasm [OPTION]... [MPNAME[.mp]] [COMMANDS]
+       mpost-wasm --latex [OPTION]... DOC.tex
+       mpost-wasm --prerender [--figures=DIR | --base=DIR] [--force] [--dry-run] PAGE.html...
+  Run MetaPost (WebAssembly build) on MPNAME, writing output files to the
+  current directory like mpost does; or, with --latex, typeset a complete
+  LaTeX/TikZ (or plain TeX, with --plain) document with tex.wasm and convert
+  every page to DOC-<page>.svg with dvisvgm.wasm.
+
+  -interaction=MODE     batchmode|nonstopmode|scrollmode (default nonstopmode)
+  -numbersystem=SYSTEM  scaled|double|decimal (binary/interval are not built)
+  -jobname=STRING       output name (default: basename of MPNAME)
+  -tex=PROGRAM          tex|etex|latex|auto (default auto)
+  -s INTERNAL=VALUE     set an internal, e.g. -s prologues=3 -s outputformat="svg"
+  -halt-on-error        stop at the first error
+  -file-line-error      (accepted; diagnostics always carry file:line)
+  -recorder             write a .fls file listing every file opened
+  -T, -troff            accepted; troff mode is unsupported and warns
+  --format=eps|svg|json output format (default eps; or set outputformat)
+  --texmf=DIR           use a texmf directory (flattened layout) instead of bundles
+  --bundles=DIR         directory containing the bundles (default: next to this package)
+  --stdout              print the first figure to stdout instead of writing files
+  --latex               DOC.tex -> DOC-1.svg, DOC-2.svg ... (LaTeX); --plain for plain TeX
+  --engine=NAME         latex | lualatex | luatex | plain | tex | auto (default auto: lualatex when
+                        the document uses graphdrawing or \directlua)
+  --fonts=paths|woff2   how text is emitted in --latex mode (default paths)
+  --pdf                 with --latex: write DOC.pdf (pdfTeX's or LuaTeX's own PDF output)
+                        instead of SVG pages; with --stdout, the PDF goes to stdout
+  --opentype            load the OpenType bundles so \\usepackage{fontspec} works under
+                        --engine=lualatex; off by default because LaTeX initialises
+                        luaotfload on every LuaTeX run once it can find it
+  --prerender           typeset the <script type="text/tikz|metapost">, <tikz-diagram> and
+                        <metapost-diagram> elements of each PAGE and save each as figure-HASH.svg in
+                        the directory the page's auto.js loader names in data-figures (default
+                        figures/, next to the page); the tags then load the files instead of running
+                        the engines. Files that exist are kept: the name is the content.
+  --figures=DIR         save every page's figures in DIR instead
+  --base=DIR            resolve each page's data-figures against DIR instead of the page's own
+                        directory (for a rendered copy of a page saved elsewhere)
+  --force               re-render figures whose file exists
+  --dry-run             list what would be rendered, render nothing
+  -v, -vv, -vvv         more on stderr: timings; the engines' output as it runs; every file
+  -q, --quiet           nothing on stderr (not even TeX errors)
+  --log-level=LEVEL     silent|error|warn|info|debug|trace (default warn)
+  -help, -version
+`;
+function parseArgs(argv) {
+    const o = {
+        interaction: 'nonstop',
+        numbersystem: 'scaled',
+        jobname: '', tex: 'auto', internals: {},
+        halt: false, recorder: false, troff: false, format: '', texmf: '', bundles: '', opentype: false,
+        stdout: false, file: '', commands: '', help: false, version: false, dvitomp: false,
+        latex: false, plain: false, pdf: false, engine: 'auto', fonts: 'paths',
+        verbose: 0, quiet: false, logLevel: '',
+        prerender: false, figures: '', base: '', force: false, dryRun: false, args: [],
+    };
+    const rest = [];
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        const next = () => argv[++i];
+        const kv = (a.startsWith('--') ? a.slice(2) : a.slice(1));
+        const [k, v] = kv.includes('=') ? [kv.slice(0, kv.indexOf('=')), kv.slice(kv.indexOf('=') + 1)] : [kv, undefined];
+        if (!a.startsWith('-') || a === '-') {
+            rest.push(a);
+            continue;
+        }
+        switch (k) {
+            case 'interaction':
+                o.interaction = (v ?? next()).replace('mode', '');
+                break;
+            case 'numbersystem':
+                o.numbersystem = (v ?? next());
+                break;
+            case 'jobname':
+                o.jobname = v ?? next();
+                break;
+            case 'tex': {
+                const t = v ?? next();
+                o.tex = t === 'tex' ? 'plain' : t;
+                break;
+            }
+            case 's': {
+                const s = v ?? next();
+                const eq = s.indexOf('=');
+                const name = s.slice(0, eq);
+                let val = s.slice(eq + 1);
+                if (/^".*"$/.test(val))
+                    val = val.slice(1, -1);
+                else if (!isNaN(Number(val)))
+                    val = Number(val);
+                o.internals[name] = val;
+                break;
+            }
+            case 'halt-on-error':
+                o.halt = true;
+                break;
+            case 'file-line-error':
+            case 'file-line-error-style': break;
+            case 'no-file-line-error': break;
+            case 'recorder':
+                o.recorder = true;
+                break;
+            case 'T':
+            case 'troff':
+                o.troff = true;
+                break;
+            case 'format':
+                o.format = (v ?? next());
+                break;
+            case 'texmf':
+                o.texmf = v ?? next();
+                break;
+            case 'bundles':
+                o.bundles = v ?? next();
+                break;
+            case 'opentype':
+                o.opentype = true;
+                break;
+            case 'stdout':
+                o.stdout = true;
+                break;
+            case 'pdf':
+                o.pdf = true;
+                break;
+            case 'help':
+                o.help = true;
+                break;
+            case 'version':
+                o.version = true;
+                break;
+            case 'dvitomp':
+                o.dvitomp = true;
+                break;
+            case 'latex':
+                o.latex = true;
+                break;
+            case 'plain':
+                o.plain = true;
+                o.latex = true;
+                o.engine = 'plain';
+                break;
+            case 'engine':
+                o.engine = (v ?? next());
+                o.latex = true;
+                break;
+            case 'fonts':
+                o.fonts = (v ?? next());
+                break;
+            case 'prerender':
+                o.prerender = true;
+                break;
+            case 'figures':
+                o.figures = v ?? next();
+                break;
+            case 'base':
+                o.base = v ?? next();
+                break;
+            case 'force':
+                o.force = true;
+                break;
+            case 'dry-run':
+                o.dryRun = true;
+                break;
+            case 'v':
+            case 'verbose':
+                o.verbose++;
+                break;
+            case 'vv':
+                o.verbose += 2;
+                break;
+            case 'vvv':
+                o.verbose += 3;
+                break;
+            case 'q':
+            case 'quiet':
+                o.quiet = true;
+                break;
+            case 'log-level':
+                o.logLevel = (v ?? next());
+                break;
+            case 'ini':
+            case 'mem':
+            case 'progname':
+            case 'kpathsea-debug':
+            case 'restricted':
+            case 'debug':
+            case 'translate-file':
+            case '8bit':
+                console.error(`mpost-wasm: warning: option -${k} is accepted and ignored`);
+                if (v === undefined && ['mem', 'progname', 'kpathsea-debug', 'translate-file'].includes(k))
+                    next();
+                break;
+            default:
+                console.error(`mpost-wasm: unknown option ${a}`);
+                process.exit(1);
+        }
+    }
+    o.args = [...rest];
+    if (rest.length) {
+        const first = rest[0];
+        if (first.startsWith('&')) {
+            rest.shift();
+        }
+    }
+    if (rest.length) {
+        o.file = rest.shift();
+    }
+    o.commands = rest.join(' ');
+    return o;
+}
+async function main() {
+    const fs = await import('node:fs');
+    const path = await import('node:path');
+    const o = parseArgs(process.argv.slice(2));
+    if (o.help) {
+        process.stdout.write(HELP);
+        return;
+    }
+    const logLevel = o.logLevel || (o.quiet ? 'silent' : o.verbose >= 3 ? 'trace' : o.verbose === 2 ? 'debug' : o.verbose === 1 ? 'info' : 'warn');
+    if (!LOG_LEVELS.includes(logLevel)) {
+        console.error(`mpost-wasm: unknown log level ${logLevel} (${LOG_LEVELS.join(', ')})`);
+        process.exit(1);
+    }
+    // Everything the level admits goes to stderr, so stdout stays the transcript (and, with --stdout, the figure).
+    // MetaPost's own errors and warnings are left out: the transcript on stdout carries them, as with mpost.
+    const logger = (r) => {
+        if (!o.prerender && r.source === 'metapost' && (r.level === 'error' || r.level === 'warn'))
+            return;
+        const raw = (r.level === 'debug' || r.level === 'trace') && r.source !== 'host';
+        process.stderr.write(raw ? `${r.source}: ${r.message}\n` : `mpost-wasm: ${r.source === 'host' ? '' : r.source + ': '}${r.message}\n`);
+    };
+    if (o.prerender) {
+        // the browser's defaults (deterministic, seed 42), so the files are the bytes the tags would produce
+        const pages = o.args.filter((a) => !a.startsWith('&'));
+        if (!pages.length) {
+            console.error('mpost-wasm: --prerender needs one or more .html pages');
+            process.exit(1);
+        }
+        for (const p of pages)
+            if (!fs.existsSync(p)) {
+                console.error(`mpost-wasm: cannot open ${p}`);
+                process.exit(1);
+            }
+        // each page's own data-bundles decide its engine's bundles, as in the browser; --opentype adds to them
+        const r = await prerender(pages, {
+            createOptions: { texmfDir: o.texmf || undefined, bundleBaseUrl: o.bundles ? 'file://' + path.resolve(o.bundles) + '/' : undefined, logLevel, logger },
+            addBundles: o.opentype ? ['opentype', 'otf-fonts'] : undefined,
+            figuresDir: o.figures ? path.resolve(o.figures) : undefined, baseDir: o.base ? path.resolve(o.base) : undefined,
+            force: o.force, dryRun: o.dryRun, report: (l) => process.stdout.write(l + '\n'),
+        });
+        const pending = r.entries.filter((e) => e.status === 'pending').length;
+        process.stdout.write(`mpost-wasm: ${r.rendered} rendered, ${r.existing} already saved, ${r.failed} failed${o.dryRun ? `, ${pending} to render` : ''}\n`);
+        process.exit(r.failed ? 1 : 0);
+    }
+    const mp = await MetaPost.create({
+        numberSystem: o.numbersystem, tex: o.tex, interaction: o.interaction, haltOnError: o.halt,
+        texmfDir: o.texmf || undefined, bundleBaseUrl: o.bundles ? 'file://' + path.resolve(o.bundles) + '/' : undefined,
+        bundles: o.opentype ? [...DEFAULT_BUNDLES, 'opentype', 'otf-fonts'] : undefined,
+        deterministic: false, logLevel, logger,
+    });
+    if (o.version) {
+        console.log(`MetaPost ${mp.version.metapost} (mp-tikz-wasm) with ${mp.version.tex}`);
+        mp.dispose();
+        return;
+    }
+    if (o.troff)
+        console.error('mpost-wasm: warning: troff mode is not supported; continuing in TeX mode');
+    if (o.latex) {
+        if (!o.file) {
+            console.error('mpost-wasm: --latex needs a .tex file');
+            process.exit(1);
+        }
+        const f = fs.existsSync(o.file) ? o.file : fs.existsSync(o.file + '.tex') ? o.file + '.tex' : null;
+        if (!f) {
+            console.error(`mpost-wasm: cannot open ${o.file}`);
+            process.exit(1);
+        }
+        const job = o.jobname || path.basename(f).replace(/\.tex$/, '');
+        const sib = {};
+        // sibling inputs; PNG and JPEG too, which pdfTeX and LuaTeX include in PDF output
+        for (const e of fs.readdirSync(path.dirname(f)))
+            if (e !== path.basename(f) && /\.(tex|sty|cls|def|clo|fd|eps|dat|csv|txt|bib|png|jpe?g)$/i.test(e))
+                sib[e] = fs.readFileSync(path.join(path.dirname(f), e));
+        const r = await mp.latex(fs.readFileSync(f, 'utf8'), { engine: o.engine, jobName: job, files: sib, fonts: o.fonts, output: o.pdf ? 'pdf' : 'svg' });
+        // with --pdf --stdout, stdout is the PDF alone: the transcript goes to stderr instead
+        (o.pdf && o.stdout ? process.stderr : process.stdout).write(r.log.endsWith('\n') ? r.log : r.log + '\n');
+        if (o.pdf) {
+            if (r.pdf) {
+                if (o.stdout)
+                    process.stdout.write(r.pdf);
+                else
+                    fs.writeFileSync(`${job}.pdf`, r.pdf);
+            }
+        }
+        else if (o.stdout) {
+            if (r.pages[0])
+                process.stdout.write(r.pages[0]);
+        }
+        else
+            r.pages.forEach((svg, i) => fs.writeFileSync(`${job}-${i + 1}.svg`, svg));
+        fs.writeFileSync(`${job}.log`, r.texLog);
+        mp.dispose();
+        process.exit(r.status === 'error' || r.status === 'fatal' ? 1 : 0);
+    }
+    let source;
+    let jobname = o.jobname;
+    let files = {};
+    if (o.file) {
+        const f = fs.existsSync(o.file) ? o.file : fs.existsSync(o.file + '.mp') ? o.file + '.mp' : null;
+        if (!f) {
+            console.error(`mpost-wasm: cannot open ${o.file}`);
+            process.exit(1);
+        }
+        source = fs.readFileSync(f, 'utf8');
+        if (!jobname)
+            jobname = path.basename(f).replace(/\.mp$/, '');
+        // make sibling .mp files inputtable
+        for (const e of fs.readdirSync(path.dirname(f)))
+            if (/\.(mp|tex|dat|txt)$/.test(e) && e !== path.basename(f))
+                files[e] = fs.readFileSync(path.join(path.dirname(f), e));
+        if (o.commands)
+            source += '\n' + o.commands;
+    }
+    else if (o.commands) {
+        source = o.commands;
+        if (!jobname)
+            jobname = 'mpout';
+    }
+    else {
+        source = fs.readFileSync(0, 'utf8');
+        if (!jobname)
+            jobname = 'mpout';
+    }
+    const internals = { ...o.internals };
+    let format = o.format || 'eps';
+    if (!o.format && typeof internals.outputformat === 'string')
+        format = internals.outputformat === 'svg' ? 'svg' : 'eps';
+    const prologues = typeof internals.prologues === 'number' ? internals.prologues : format === 'svg' ? 3 : 0;
+    const r = await mp.run(source, { jobName: jobname, files, internals, format, prologues, svg: { precision: false, idPrefix: false } });
+    process.stdout.write(r.log.endsWith('\n') ? r.log : r.log + '\n'); // MetaPost's terminal transcript, like mpost
+    // like mpost: the default outputtemplate is %j.%c whatever the format; %o expands to the format's extension
+    const ext = format === 'svg' ? 'svg' : format === 'json' ? 'json' : 'eps';
+    const template = typeof internals.outputtemplate === 'string' ? internals.outputtemplate : `%j.%c`;
+    for (const fig of r.figures) {
+        const name = template.replace('%j', jobname).replace('%c', String(fig.charcode)).replace('%o', ext);
+        const body = format === 'svg' ? fig.svg : format === 'json' ? JSON.stringify(fig.json) : fig.eps;
+        if (o.stdout) {
+            process.stdout.write(body);
+            break;
+        }
+        fs.writeFileSync(name, body);
+    }
+    for (const [name, data] of Object.entries(r.artifacts))
+        if (name !== `${jobname}.log` || true)
+            fs.writeFileSync(name, data);
+    if (o.recorder)
+        fs.writeFileSync(`${jobname}.fls`, r.diagnostics.map(() => '').join(''));
+    mp.dispose();
+    process.exit(r.history >= 2 ? 1 : 0);
+}
+main().catch((e) => { console.error(e?.stack ?? String(e)); process.exit(2); });
+//# sourceMappingURL=cli.js.map

package/runtime/dist/core.d.ts

@@ -0,0 +1,124 @@
+/**
+ * core.ts — the orchestrator (docs/01 §3). Runs in a Worker (browser) or on
+ * the main thread (Node). Owns one mplib.wasm instance for its lifetime and
+ * creates one tex.wasm instance per TeX invocation.
+ */
+import { type MplibModule, type MplibFactory } from './mplib.js';
+import { type TexFactory } from './texengine.js';
+import { type DvisvgmFactory } from './dvisvgm.js';
+import type { Ghostscript } from './ghostscript.js';
+import { BundleSet } from './vfs/bundle.js';
+import { Logger } from './logger.js';
+import type { MetaPostOptions, RunOptions, RunResult, Diagnostic, ProgressEvent, LatexRunOptions, LatexResult, BibtexOptions, MakeindexOptions, ToolResult } from './types.js';
+/** The local references (href="#id") in an SVG that name no element in it. */
+export declare function danglingRefs(svg: string): string[];
+/** Where MetaPost looks for each file type (docs/06 §2). */
+export declare const SEARCH_PATHS: Record<number, string[]>;
+export interface CoreEnv {
+    mplibFactory: MplibFactory;
+    texFactory?: TexFactory;
+    /** luatex.wasm, same module interface as tex.wasm; needed for engine 'lualatex' / 'luatex' */
+    luatexFactory?: TexFactory;
+    dvisvgmFactory?: DvisvgmFactory;
+    /** the Ghostscript module for dvisvgm's PostScript (ghostscript.ts), when enabled; null if it cannot be loaded */
+    ghostscript?: () => Promise<Ghostscript | null>;
+    /** bibtex.wasm and makeindex.wasm, loaded on first use; undefined if this build has none */
+    tools?: (name: 'bibtex' | 'makeindex') => Promise<TexFactory | undefined>;
+    /** bundles merged into /texmf (browser, or Node without texmfDir) */
+    bundles?: BundleSet;
+    /** Node: real directory mounted at /texmf with NODEFS */
+    texmfDir?: string;
+    options: MetaPostOptions;
+    onProgress?: (e: ProgressEvent) => void;
+    onLog?: (line: string) => void;
+    /** where every part of a run reports (docs/08 §4); silent if absent */
+    logger?: Logger;
+}
+export declare class MetaPostCore {
+    private env;
+    M: MplibModule;
+    private cache;
+    private bridge?;
+    readonly version: {
+        metapost: string;
+        tex: string;
+        build: string;
+    };
+    private userFiles;
+    /**
+     * luaotfload's font cache (TEXMF_VAR), carried from one LuaTeX run to the
+     * next. Parsing an OpenType face costs about a second, and every TeX run
+     * gets a fresh filesystem, so without this each render pays that again.
+     */
+    private texmfVar;
+    private get logger();
+    constructor(env: CoreEnv);
+    init(): Promise<void>;
+    private progress;
+    /** The errors and warnings of a finished run, one record each; a MetaPost help paragraph is indented under its error. */
+    private report;
+    private formatId;
+    private installTexmf;
+    /** Restore the font cache this instance has accumulated (LuaTeX runs only). */
+    private installTexmfVar;
+    /**
+     * Start the font cache from the prebuilt name database, if the tree has one
+     * (the `opentype` bundle, or a mounted texmfDir built by make-fontdb). Its
+     * paths are the /texmf ones every instance sees; luaotfload checks only the
+     * index version, and rescans by itself when a lookup misses.
+     */
+    private seedFontDb;
+    /** Keep whatever luaotfload wrote, so the next run starts warm. */
+    private collectTexmfVar;
+    private copyUserFiles;
+    /** Last-chance file resolution when the C search failed: consult bundles, then the user hook. */
+    private findFile;
+    private findFileImpl;
+    private chain;
+    private misses;
+    private stats;
+    private engine;
+    private texDiagnostics;
+    private makeText;
+    private runScript;
+    addFiles(files: Record<string, string | Uint8Array>): void;
+    /**
+     * Take files off this instance that addFiles (or a run's `files`) put there, named as they were
+     * given; with no names, all of them. They otherwise stay for the instance's lifetime, so a host
+     * typesetting one document after another would hand the first one's .aux to the next.
+     */
+    removeFiles(names?: string[]): void;
+    clearCache(): void;
+    run(source: string, ro?: RunOptions): Promise<RunResult>;
+    private lastTexLog;
+    private recentOutput;
+    /**
+     * Typeset a complete LaTeX (or plain TeX) document with tex.wasm and convert
+     * every page to SVG with dvisvgm.wasm — the TikZ/PGF pipeline. Text becomes
+     * glyph outlines unless fonts: 'woff2' is requested.
+     */
+    latex(source: string, lo?: LatexRunOptions): Promise<LatexResult>;
+    /**
+     * BibTeX (bibtex.wasm) on the .aux a latex() run wrote: doc.bbl and doc.blg come back in
+     * artifacts, for the next latex() run. Like latex(), a fresh module each time.
+     */
+    bibtex(bo?: BibtexOptions): Promise<ToolResult>;
+    /** makeindex (makeindex.wasm) on the .idx a latex() run wrote: doc.ind and doc.ilg come back in artifacts. */
+    makeindex(mo?: MakeindexOptions): Promise<ToolResult>;
+    /** One run of a TeX Live utility: what it wrote in /work comes back, its transcript as diagnostics. */
+    private runTool;
+    private hasSnapshot;
+    private typeset;
+    private runMetaPost;
+    /**
+     * Scan the job and every `input`-ed file reachable from it (lexically),
+     * splicing each input file's blocks in at the line of the `input` statement
+     * so the verbatimtex chain seen by the pre-scan matches the run's order.
+     */
+    private scanAll;
+    private resolveInput;
+}
+/** Errors (`! ...` + `l.N`) and package warnings from a TeX transcript, attributed to the document. */
+export declare function parseTexLogDocument(log: string, file: string): Diagnostic[];
+/** Does a LaTeX source need LuaTeX? (TikZ graphdrawing, \directlua, luacode.) Used by engine 'auto'. */
+export declare function needsLuaTeX(source: string): boolean;