@barocss/math-editor 0.1.0 → 0.2.1

package/dist/latex.js

@@ -0,0 +1,689 @@
+import { fenceCharacters, fencePairs } from './fences.js';
+import { row, namedFunctions, textNode, documentRows, } from './model.js';
+import { mathSymbols } from './symbols.js';
+import { parseMathDocument } from './document-codec.js';
+const commands = new Map(mathSymbols
+    .filter((item) => /^\\[a-zA-Z]+$/.test(item[4]))
+    .map((item) => [item[4].slice(1), item[0]]));
+for (const [alias, canonical] of Object.entries({
+    neq: 'ne',
+    leq: 'le',
+    geq: 'ge',
+    rightarrow: 'to',
+    gets: 'leftarrow',
+    land: 'wedge',
+    lor: 'vee',
+    lnot: 'neg',
+}))
+    commands.set(alias, commands.get(canonical));
+const matrices = ['matrix', 'pmatrix', 'bmatrix', 'Bmatrix', 'vmatrix', 'Vmatrix'];
+/** A bounded parser for the editor's presentation grammar, not a TeX macro interpreter. */
+class LatexParser {
+    source;
+    at = 0;
+    end;
+    depth = 0;
+    scopeStop = () => false;
+    constructor(source) {
+        this.source = source;
+        this.end = source.length;
+    }
+    fail(code, message, start = this.at) {
+        throw {
+            code,
+            message,
+            start,
+            end: Math.min(this.source.length, Math.max(start + 1, this.at)),
+        };
+    }
+    starts(value) {
+        return this.source.startsWith(value, this.at);
+    }
+    isCommand(name) {
+        return (this.starts(`\\${name}`) && !/[a-zA-Z]/.test(this.source[this.at + name.length + 1] ?? ''));
+    }
+    skip() {
+        while (this.at < this.end) {
+            if (/\s/.test(this.source[this.at]))
+                this.at++;
+            else if (this.source[this.at] === '%') {
+                while (this.at < this.end && this.source[this.at] !== '\n')
+                    this.at++;
+            }
+            else
+                break;
+        }
+    }
+    command() {
+        const start = this.at++;
+        const word = this.source.slice(this.at, this.end).match(/^[a-zA-Z]+/)?.[0];
+        if (word) {
+            this.at += word.length;
+            return word;
+        }
+        if (this.at >= this.end)
+            this.fail('syntax', 'Incomplete command.', start);
+        return this.source[this.at++];
+    }
+    structure(type, slots) {
+        return { type, id: row().id, slots };
+    }
+    append(target, atom) {
+        for (const node of atom.children) {
+            const previous = target.children.at(-1);
+            if (node.type === 'text' && previous?.type === 'text')
+                previous.text += node.text;
+            else
+                target.children.push(node);
+        }
+    }
+    wrap(node) {
+        const result = row();
+        result.children.push(node, textNode());
+        return result;
+    }
+    expression(stop) {
+        const result = row();
+        const previousStop = this.scopeStop;
+        this.scopeStop = stop;
+        try {
+            while (true) {
+                this.skip();
+                if (this.at >= this.end || stop())
+                    return result;
+                const atom = this.scriptedAtom();
+                this.append(result, atom);
+            }
+        }
+        finally {
+            this.scopeStop = previousStop;
+        }
+    }
+    /** Recognize a plain parenthesized base before a script, without treating an
+     * unmatched literal parenthesis elsewhere as a failed import. */
+    scriptedParenthesisEnd() {
+        if (!this.starts('('))
+            return;
+        let parentheses = 0, braces = 0;
+        for (let i = this.at; i < this.end; i++) {
+            const char = this.source[i];
+            if (char === '\\') {
+                i++;
+                continue;
+            }
+            if (char === '%') {
+                while (i < this.end && this.source[i] !== '\n')
+                    i++;
+                continue;
+            }
+            if (char === '{') {
+                braces++;
+                continue;
+            }
+            if (char === '}') {
+                if (--braces < 0)
+                    return;
+                continue;
+            }
+            if (braces)
+                continue;
+            if (char === '(') {
+                if (++parentheses > 40)
+                    this.fail('limit', 'Parenthesis nesting limit exceeded.');
+            }
+            else if (char === ')' && --parentheses === 0)
+                return /^\s*[_^]/.test(this.source.slice(i + 1, this.end)) ? i : undefined;
+        }
+    }
+    scriptedAtom() {
+        const closing = this.scriptedParenthesisEnd();
+        let atom;
+        if (closing !== undefined) {
+            if (++this.depth > 40)
+                this.fail('limit', 'Nesting exceeds 40 levels.');
+            try {
+                this.at++;
+                const content = this.expression(() => this.at === closing);
+                this.at++;
+                atom = this.wrap(this.structure('parentheses', [content]));
+            }
+            finally {
+                this.depth--;
+            }
+        }
+        else
+            atom = this.atom();
+        this.skip();
+        if (this.starts('^{\\circ}')) {
+            this.at += 8;
+            this.append(atom, row('°'));
+            return atom;
+        }
+        if (this.starts('^') || this.starts('_')) {
+            const marker = this.source[this.at++];
+            const script = this.argument();
+            this.skip();
+            if (this.starts('^') || this.starts('_')) {
+                const second = this.source[this.at++];
+                if (second === marker)
+                    this.fail('syntax', 'Repeated script needs explicit grouping.');
+                const other = this.argument();
+                atom = this.wrap(this.structure('scripts', marker === '_' ? [atom, script, other] : [atom, other, script]));
+                this.skip();
+                if (this.starts('^') || this.starts('_'))
+                    this.fail('syntax', 'Repeated script needs explicit grouping.');
+            }
+            else {
+                atom = this.wrap(this.structure(marker === '^' ? 'superscript' : 'subscript', [atom, script]));
+            }
+        }
+        return atom;
+    }
+    literalArgument() {
+        this.skip();
+        if (!this.starts('{'))
+            this.fail('syntax', 'Expected a braced text argument.');
+        this.at++;
+        let value = '', depth = 1;
+        while (this.at < this.end) {
+            const char = this.source[this.at];
+            if (char === '\\') {
+                const start = this.at;
+                const command = this.command();
+                if (['{', '}', '_', '%', '$', '#', '&', ' '].includes(command))
+                    value += command;
+                else if (['textbackslash', 'textasciicircum', 'textasciitilde'].includes(command)) {
+                    if (!this.starts('{}'))
+                        this.fail('syntax', 'Expected an empty argument.', start);
+                    this.at += 2;
+                    value += { textbackslash: '\\', textasciicircum: '^', textasciitilde: '~' }[command];
+                }
+                else
+                    this.fail('unsupported-command', 'Unsupported command inside literal text.', start);
+            }
+            else if (char === '{') {
+                this.at++;
+                if (++depth > 40)
+                    this.fail('limit', 'Text nesting limit exceeded.');
+            }
+            else if (char === '}') {
+                this.at++;
+                if (--depth === 0)
+                    return row(value);
+            }
+            else if (char === '%') {
+                while (this.at < this.end && this.source[this.at] !== '\n')
+                    this.at++;
+            }
+            else if (/[$&#_^~]/.test(char))
+                this.fail('unsupported-structure', 'Escape special characters inside literal text.');
+            else {
+                value += char;
+                this.at++;
+            }
+        }
+        this.fail('syntax', 'Missing closing text brace.');
+    }
+    argument() {
+        this.skip();
+        if (this.at >= this.end)
+            this.fail('syntax', 'Expected an argument.');
+        return this.atom();
+    }
+    group() {
+        this.at++;
+        const result = this.expression(() => this.starts('}'));
+        if (!this.starts('}'))
+            this.fail('syntax', 'Missing closing brace.');
+        this.at++;
+        return result;
+    }
+    environmentName() {
+        this.skip();
+        const match = this.source.slice(this.at, this.end).match(/^\{([a-zA-Z*]+)\}/);
+        if (!match)
+            this.fail('syntax', 'Expected an environment name.');
+        this.at += match[0].length;
+        return match[1];
+    }
+    delimiter() {
+        this.skip();
+        if (this.at >= this.end)
+            this.fail('syntax', 'Missing delimiter.');
+        if (!this.starts('\\'))
+            return this.source[this.at++];
+        const start = this.at;
+        const name = this.command();
+        const delimiters = {
+            '{': '{',
+            '}': '}',
+            lbrace: '{',
+            rbrace: '}',
+            langle: '⟨',
+            rangle: '⟩',
+            lparen: '(',
+            rparen: ')',
+            lbrack: '[',
+            rbrack: ']',
+            lvert: '|',
+            rvert: '|',
+            vert: '|',
+            lVert: '‖',
+            rVert: '‖',
+            Vert: '‖',
+            '|': '‖',
+        };
+        if (!Object.hasOwn(delimiters, name))
+            this.fail('unsupported-structure', 'Unsupported delimiter.', start);
+        return delimiters[name];
+    }
+    grid(name) {
+        const rows = [[]];
+        while (true) {
+            rows
+                .at(-1)
+                .push(this.expression(() => this.starts('&') || this.starts('\\\\') || this.isCommand('end')));
+            if (this.starts('&')) {
+                this.at++;
+                continue;
+            }
+            if (this.starts('\\\\')) {
+                this.at += 2;
+                rows.push([]);
+                if (rows.length > 200)
+                    this.fail('limit', 'Too many rows.');
+                continue;
+            }
+            if (!this.isCommand('end'))
+                this.fail('syntax', `Missing \\end{${name}}.`);
+            this.command();
+            if (this.environmentName() !== name)
+                this.fail('syntax', 'Mismatched environment.');
+            break;
+        }
+        // A cases row may contain just an expression (for example a system of equations).
+        // Keep the model's two-column shape by adding an editable empty condition.
+        if (name === 'cases') {
+            if (rows.some((cells) => cells.length > 2))
+                this.fail('unsupported-structure', 'Cases supports at most two cells per row.');
+            for (const cells of rows)
+                if (cells.length === 1)
+                    cells.push(row());
+        }
+        const columns = rows[0].length;
+        if (rows.some((cells) => cells.length !== columns))
+            this.fail('unsupported-structure', 'All rows must have the same number of cells.');
+        if (name === 'gathered') {
+            if (columns !== 1)
+                this.fail('unsupported-structure', 'Gathered rows cannot contain alignment cells.');
+            return rows.map((cells) => cells[0]);
+        }
+        if (columns > 20 || rows.length > 20)
+            this.fail('limit', 'Grids support up to 20 rows and columns.');
+        if ((name === 'aligned' || name === 'cases') && columns !== 2)
+            this.fail('unsupported-structure', 'Aligned and cases require two cells per row.');
+        const node = matrices.includes(name)
+            ? {
+                type: 'matrix',
+                id: row().id,
+                environment: name,
+                columns,
+                slots: rows.flat(),
+            }
+            : { type: name, id: row().id, columns, slots: rows.flat() };
+        return [this.wrap(node)];
+    }
+    atom() {
+        if (++this.depth > 40)
+            this.fail('limit', 'Nesting exceeds 40 levels.');
+        try {
+            return this.readAtom();
+        }
+        finally {
+            this.depth--;
+        }
+    }
+    readAtom() {
+        this.skip();
+        const start = this.at;
+        if (this.at >= this.end)
+            this.fail('syntax', 'Expected an expression.');
+        // The degree catalog entry has an empty base; recognize its exact exported spelling.
+        if (this.starts('{}^{\\circ}')) {
+            this.at += 10;
+            return row('°');
+        }
+        if (this.starts('{'))
+            return this.group();
+        const char = this.source[this.at];
+        if (/[}\^_&$#~]/.test(char))
+            this.fail('syntax', `Unexpected ${char}.`);
+        if (char !== '\\') {
+            const value = String.fromCodePoint(this.source.codePointAt(this.at));
+            this.at += value.length;
+            return row(value);
+        }
+        const command = this.command();
+        if (namedFunctions.includes(command))
+            return this.wrap(this.structure('operatorName', [row(command)]));
+        if (command === 'text' || command === 'operatorname')
+            return this.wrap(this.structure(command === 'text' ? 'textGroup' : 'operatorName', [this.literalArgument()]));
+        // The declaration lasts to this group's/cell's boundary; export a scoped command.
+        if (command === 'rm')
+            return this.wrap(this.structure('roman', [this.expression(this.scopeStop)]));
+        if (command === 'mathbf' || command === 'mathcal')
+            return this.wrap(this.structure(command === 'mathbf' ? 'bold' : 'calligraphic', [this.argument()]));
+        if (command === 'mathrm')
+            return this.wrap(this.structure('roman', [this.argument()]));
+        const spacingCommands = {
+            ',': 'thinSpace',
+            ':': 'mediumSpace',
+            ';': 'thickSpace',
+            '!': 'negativeThinSpace',
+        };
+        if (Object.hasOwn(spacingCommands, command))
+            return this.wrap(this.structure(spacingCommands[command], []));
+        if (command === 'quad' || command === 'qquad')
+            return this.wrap(this.structure(command, []));
+        if (commands.has(command))
+            return row(commands.get(command));
+        if (['{', '}', '_', '%', '$', '#', '&', ' '].includes(command))
+            return row(command);
+        if (command === 'backslash')
+            return row('\\');
+        if (command === 'textasciicircum' || command === 'textasciitilde') {
+            this.skip();
+            if (!this.starts('{}'))
+                this.fail('syntax', 'Expected an empty argument.', start);
+            this.at += 2;
+            return row(command === 'textasciicircum' ? '^' : '~');
+        }
+        if (command === 'mathbb') {
+            this.skip();
+            const match = this.source
+                .slice(this.at, this.end)
+                .match(/^(?:\{\s*([NZQRC])\s*\}|([NZQRC]))/);
+            if (!match)
+                return this.wrap(this.structure('blackboard', [this.argument()]));
+            this.at += match[0].length;
+            return row({ N: 'ℕ', Z: 'ℤ', Q: 'ℚ', R: 'ℝ', C: 'ℂ' }[(match[1] ?? match[2])]);
+        }
+        if (['vec', 'hat', 'overline', 'tilde', 'bar', 'dot', 'ddot', 'widehat', 'widetilde'].includes(command))
+            return this.wrap(this.structure(command, [this.argument()]));
+        if (['binom', 'dbinom', 'tbinom', 'dfrac', 'tfrac'].includes(command)) {
+            const node = this.structure(command.endsWith('binom') ? 'binomial' : 'fraction', [
+                this.argument(),
+                this.argument(),
+            ]);
+            if (command !== 'binom')
+                Object.assign(node, { mathStyle: command.startsWith('d') ? 'display' : 'text' });
+            return this.wrap(node);
+        }
+        if (command === 'overbrace' || command === 'underbrace') {
+            const body = this.argument();
+            this.skip();
+            const marker = command === 'overbrace' ? '^' : '_';
+            let annotation = row();
+            if (this.starts(marker)) {
+                this.at++;
+                annotation = this.argument();
+                this.skip();
+                if (this.starts(marker))
+                    this.fail('syntax', 'Repeated brace annotation.');
+            }
+            return this.wrap(this.structure(command, [annotation, body]));
+        }
+        if (command === 'xrightarrow' || command === 'xleftarrow') {
+            this.skip();
+            let lower = row();
+            if (this.starts('[')) {
+                this.at++;
+                lower = this.expression(() => this.starts(']'));
+                if (!this.starts(']'))
+                    this.fail('syntax', 'Missing closing arrow label bracket.', start);
+                this.at++;
+            }
+            return this.wrap(this.structure(command, [this.argument(), lower]));
+        }
+        if (command === 'overset' || command === 'underset')
+            return this.wrap(this.structure(command, [this.argument(), this.argument()]));
+        if (command === 'lVert') {
+            const body = this.expression(() => this.isCommand('rVert'));
+            if (!this.isCommand('rVert'))
+                this.fail('syntax', 'Missing rVert.', start);
+            this.command();
+            return this.wrap(this.structure('norm', [body]));
+        }
+        if (command === 'langle') {
+            const body = this.expression(() => this.isCommand('rangle'));
+            if (!this.isCommand('rangle'))
+                this.fail('syntax', 'Missing rangle.', start);
+            this.command();
+            return this.wrap(this.structure('angle', [body]));
+        }
+        if (command === 'frac')
+            return this.wrap(this.structure('fraction', [this.argument(), this.argument()]));
+        if (command === 'sqrt') {
+            this.skip();
+            if (this.starts('[')) {
+                this.at++;
+                const index = this.expression(() => this.starts(']'));
+                if (!this.starts(']'))
+                    this.fail('syntax', 'Missing closing root index bracket.', start);
+                this.at++;
+                return this.wrap(this.structure('indexedRoot', [index, this.argument()]));
+            }
+            return this.wrap(this.structure('root', [this.argument()]));
+        }
+        if (command === 'left') {
+            this.skip();
+            const open = this.delimiter();
+            if (!fenceCharacters.includes(open))
+                this.fail('unsupported-structure', 'Unsupported delimiter.', start);
+            const content = this.expression(() => this.isCommand('right'));
+            if (!this.isCommand('right'))
+                this.fail('syntax', 'Missing right delimiter.', start);
+            this.command();
+            const close = this.delimiter();
+            if (!fenceCharacters.includes(close))
+                this.fail('unsupported-structure', 'Unsupported delimiter.', start);
+            const kind = Object.keys(fencePairs).find((key) => fencePairs[key][0] === open && fencePairs[key][1] === close);
+            const node = this.structure((kind ?? 'fenced'), [content]);
+            if (!kind)
+                Object.assign(node, { left: open, right: close });
+            return this.wrap(node);
+        }
+        let explicitLimits;
+        if (['lim', 'limsup', 'liminf', 'sum', 'prod', 'int', 'iint', 'iiint', 'oint'].includes(command)) {
+            this.skip();
+            if (this.isCommand('limits') || this.isCommand('nolimits')) {
+                explicitLimits = this.command() === 'limits';
+                this.skip();
+            }
+        }
+        if (['lim', 'limsup', 'liminf'].includes(command)) {
+            this.skip();
+            let condition = row();
+            if (this.starts('_')) {
+                this.at++;
+                condition = this.argument();
+                this.skip();
+            }
+            if (this.starts('_') || this.starts('^'))
+                this.fail('unsupported-structure', 'A limit accepts one lower condition.', start);
+            // Preserve the same explicit-body convention as the other large operators.
+            const body = this.at >= this.end ||
+                this.starts('}') ||
+                this.starts('&') ||
+                this.starts('\\\\') ||
+                this.isCommand('end') ||
+                this.isCommand('right')
+                ? row()
+                : this.scriptedAtom();
+            const limit = this.structure(command === 'lim' ? 'limit' : command, [
+                condition,
+                body,
+            ]);
+            if (explicitLimits !== undefined)
+                Object.assign(limit, { limits: explicitLimits });
+            return this.wrap(limit);
+        }
+        if (['sum', 'prod', 'int', 'iint', 'iiint', 'oint'].includes(command)) {
+            let lower = row(), upper = row();
+            const seen = new Set();
+            this.skip();
+            while (this.starts('_') || this.starts('^')) {
+                const marker = this.source[this.at++];
+                if (seen.has(marker))
+                    this.fail('syntax', 'Repeated operator limit.', start);
+                seen.add(marker);
+                const value = this.argument();
+                if (marker === '_')
+                    lower = value;
+                else
+                    upper = value;
+                this.skip();
+            }
+            // An exported operator always has an explicit body. For ordinary input, consume one atom.
+            const body = this.at >= this.end ||
+                this.starts('}') ||
+                this.starts('&') ||
+                this.isCommand('end') ||
+                this.isCommand('right')
+                ? row()
+                : this.scriptedAtom();
+            const operator = this.structure({
+                sum: 'sum',
+                prod: 'product',
+                int: 'integral',
+                iint: 'doubleIntegral',
+                iiint: 'tripleIntegral',
+                oint: 'contourIntegral',
+            }[command], [lower, upper, body]);
+            if (explicitLimits !== undefined)
+                Object.assign(operator, { limits: explicitLimits });
+            return this.wrap(operator);
+        }
+        if (command === 'begin') {
+            const name = this.environmentName();
+            if (![...matrices, 'aligned', 'cases'].includes(name))
+                this.fail('unsupported-environment', `Unsupported nested environment: ${name}.`, start);
+            return this.grid(name)[0];
+        }
+        this.fail('unsupported-command', `Unsupported command: \\${command}.`, start);
+    }
+    parse() {
+        this.skip();
+        const delimiter = ['$$', '$', '\\(', '\\['].find((value) => this.starts(value));
+        if (delimiter) {
+            const closing = { $$: '$$', $: '$', '\\(': '\\)', '\\[': '\\]' }[delimiter];
+            this.at += delimiter.length;
+            while (/\s/.test(this.source[this.end - 1] ?? '') && this.end > this.at)
+                this.end--;
+            if (!this.source.slice(0, this.end).endsWith(closing))
+                this.fail('syntax', 'Missing math delimiter.');
+            const closingAt = this.end - closing.length;
+            let inComment = false;
+            for (let offset = this.at; offset < closingAt; offset++) {
+                const char = this.source[offset];
+                if (char === '\n' || char === '\r')
+                    inComment = false;
+                else if (!inComment && char === '\\')
+                    offset++;
+                else if (!inComment && char === '%')
+                    inComment = true;
+            }
+            if (inComment)
+                this.fail('syntax', 'The closing math delimiter is inside a comment.', closingAt);
+            this.end = closingAt;
+        }
+        this.skip();
+        let lines;
+        const beginning = this.at;
+        let environment;
+        if (this.isCommand('begin')) {
+            this.command();
+            environment = this.environmentName();
+        }
+        if (environment === 'equation')
+            this.fail('unsupported-environment', 'Numbered equations are not supported; use equation* for formula-only import.', beginning);
+        if (environment === 'equation*') {
+            lines = [this.expression(() => this.isCommand('end'))];
+            if (!this.isCommand('end'))
+                this.fail('syntax', 'Missing equation* end.');
+            this.command();
+            if (this.environmentName() !== 'equation*')
+                this.fail('syntax', 'Mismatched equation* end.');
+        }
+        else if (environment === 'gathered')
+            lines = this.grid('gathered');
+        else {
+            this.at = beginning;
+            lines = [this.expression(() => false)];
+        }
+        this.skip();
+        if (this.at !== this.end)
+            this.fail('unsupported-structure', 'Unexpected content after the expression.');
+        return {
+            version: 1,
+            root: lines[0],
+            ...(lines.length > 1 ? { additionalLines: lines.slice(1) } : {}),
+        };
+    }
+}
+/** Parse without changing editor state. Failures retain the complete original source. */
+export function parseLatex(source, options = {}) {
+    if (source.length > 10000)
+        return {
+            ok: false,
+            source,
+            diagnostics: [
+                {
+                    code: 'limit',
+                    message: 'Input exceeds 10,000 characters.',
+                    start: 10000,
+                    end: source.length,
+                },
+            ],
+        };
+    try {
+        const document = new LatexParser(source).parse();
+        if (!parseMathDocument(JSON.stringify(document)))
+            return {
+                ok: false,
+                source,
+                diagnostics: [
+                    {
+                        code: 'limit',
+                        message: 'The resulting document exceeds the persistence limits.',
+                        start: 0,
+                        end: source.length,
+                    },
+                ],
+            };
+        const excluded = new Set(options.excludedStructures ?? []);
+        const allowed = (value) => value.children.every((node) => node.type === 'text' || (!excluded.has(node.type) && node.slots.every(allowed)));
+        if ((options.multiline === false && document.additionalLines?.length) ||
+            !documentRows(document).every(allowed)) {
+            return {
+                ok: false,
+                source,
+                diagnostics: [
+                    {
+                        code: 'unsupported-structure',
+                        message: 'This formula is not allowed by the host editing policy.',
+                        start: 0,
+                        end: source.length,
+                    },
+                ],
+            };
+        }
+        return { ok: true, document, source, diagnostics: [] };
+    }
+    catch (error) {
+        if (error && typeof error === 'object' && 'code' in error && 'start' in error)
+            return { ok: false, source, diagnostics: [error] };
+        throw error;
+    }
+}
+//# sourceMappingURL=latex.js.map