@barocss/math-editor 0.2.1 → 0.5.0

package/dist/math-layout.d.ts

@@ -0,0 +1,12 @@
+import { type MathDocument } from './model.js';
+export type MathLayoutStyle = 'display' | 'text' | 'script' | 'scriptscript';
+/** Resolve mathematical style from model slots, independently of DOM ancestry.
+ * These values control operator presentation only; they are not saved in JSON.
+ */
+export declare function mathLayout(document: MathDocument, mode?: 'block' | 'inline'): {
+    rows: Map<string, MathLayoutStyle>;
+    operators: Map<string, {
+        style: MathLayoutStyle;
+        placement: "side" | "stacked";
+    }>;
+};

package/dist/math-layout.js

@@ -0,0 +1,59 @@
+import { documentRows, isGrid, } from './model.js';
+const scriptStyle = (style) => style === 'display' || style === 'text' ? 'script' : 'scriptscript';
+const large = new Set([
+    'sum',
+    'product',
+    'integral',
+    'doubleIntegral',
+    'tripleIntegral',
+    'contourIntegral',
+]);
+const limits = new Set(['limit', 'limsup', 'liminf']);
+/** Resolve mathematical style from model slots, independently of DOM ancestry.
+ * These values control operator presentation only; they are not saved in JSON.
+ */
+export function mathLayout(document, mode = 'block') {
+    const rows = new Map();
+    const operators = new Map();
+    const visit = (row, style) => {
+        rows.set(row.id, style);
+        for (const node of row.children) {
+            if (node.type === 'text')
+                continue;
+            const own = !isGrid(node) && node.mathStyle ? node.mathStyle : style;
+            if (large.has(node.type) || limits.has(node.type)) {
+                const integral = node.type.toLowerCase().includes('integral');
+                const explicit = !isGrid(node) ? node.limits : undefined;
+                operators.set(node.id, {
+                    style: own,
+                    placement: explicit === true || (explicit !== false && own === 'display' && !integral)
+                        ? 'stacked'
+                        : 'side',
+                });
+            }
+            node.slots.forEach((slot, index) => visit(slot, slotStyle(node, index, own)));
+        }
+    };
+    documentRows(document).forEach((row) => visit(row, mode === 'inline' ? 'text' : 'display'));
+    return { rows, operators };
+}
+function slotStyle(node, index, style) {
+    if (node.type === 'fraction' || node.type === 'binomial')
+        return style === 'display' ? 'text' : scriptStyle(style);
+    if (['superscript', 'subscript', 'scripts'].includes(node.type))
+        return index === 0 ? style : scriptStyle(style);
+    if (node.type === 'indexedRoot' && index === 0)
+        return 'scriptscript';
+    if (large.has(node.type))
+        return index < 2 ? scriptStyle(style) : style;
+    if (limits.has(node.type))
+        return index === 0 ? scriptStyle(style) : style;
+    if (['overset', 'underset', 'overbrace', 'underbrace', 'xrightarrow', 'xleftarrow'].includes(node.type))
+        return node.type.startsWith('x') || index === 0 ? scriptStyle(style) : style;
+    // AMS aligned cells explicitly enter display style, even inside a fraction.
+    if (node.type === 'aligned')
+        return 'display';
+    if (node.type === 'matrix' || node.type === 'cases')
+        return 'text';
+    return style;
+}

package/dist/math-spacing.d.ts

@@ -0,0 +1,13 @@
+import type { MathRow } from './model.js';
+export interface RunSpacing {
+    before: number;
+    after: number;
+    tightBefore?: number;
+    tightAfter?: number;
+}
+/** Text-run spacing in math units (18 mu = 1 em).
+ * Empty caret boundaries do not participate. Named functions and fractions
+ * share run spacing. Other structures still own their outer spacing.
+ * Literal text rows must not use these values.
+ */
+export declare function mathRunSpacing(row: MathRow): Map<string, RunSpacing>;

package/dist/math-spacing.js

@@ -0,0 +1,87 @@
+import { tokenizeMathText } from './tokens.js';
+const binary = new Set(Array.from('+−-±∓×·÷∗∪∩∖⊕⊗∧∨'));
+const relation = new Set(Array.from('=<>≤≥⩽⩾≠≈≃≅∼≡∝∈∉∋⊂⊃⊆⊇⊈⊥∥←→↔↑↓↕⇐⇒⇔⇑⇓⇕↦'));
+function atom(text) {
+    if (binary.has(text))
+        return 'binary';
+    if (relation.has(text) || /^[\u2190-\u21ff\u27f0-\u27ff\u2900-\u297f]$/u.test(text))
+        return 'relation';
+    if ('([{'.includes(text) && text.length === 1)
+        return 'open';
+    if (')]}'.includes(text) && text.length === 1)
+        return 'close';
+    if (text === ',' || text === ';')
+        return 'punctuation';
+    return 'ordinary';
+}
+/** Text-run spacing in math units (18 mu = 1 em).
+ * Empty caret boundaries do not participate. Named functions and fractions
+ * share run spacing. Other structures still own their outer spacing.
+ * Literal text rows must not use these values.
+ */
+export function mathRunSpacing(row) {
+    const entries = row.children.flatMap((node) => node.type === 'text'
+        ? tokenizeMathText(node.text)
+            .filter((token) => token.text && token.kind !== 'space')
+            .map((token) => ({ key: `${node.id}:${token.start}`, atom: atom(token.text) }))
+        : [
+            {
+                key: ['operatorName', 'fraction'].includes(node.type) ? node.id : '',
+                atom: (node.type === 'operatorName' ? 'operator' : 'ordinary'),
+            },
+        ]);
+    // A leading/trailing binary sign is unary. The same is true after an open
+    // fence, relation or operator, and before a closing fence or punctuation.
+    for (let index = 0; index < entries.length; index++) {
+        const entry = entries[index];
+        if (entry.atom !== 'binary')
+            continue;
+        const left = entries[index - 1]?.atom;
+        const right = entries[index + 1]?.atom;
+        if (!left ||
+            !right ||
+            ['binary', 'relation', 'open', 'punctuation', 'operator'].includes(left) ||
+            ['relation', 'close', 'punctuation'].includes(right))
+            entry.atom = 'ordinary';
+    }
+    const result = new Map();
+    entries.forEach((entry) => {
+        if (entry.key)
+            result.set(entry.key, { before: 0, after: 0 });
+    });
+    for (let index = 1; index < entries.length; index++) {
+        const left = entries[index - 1];
+        const right = entries[index];
+        let gap = 0;
+        if (left.atom !== 'open') {
+            if (right.atom === 'relation' &&
+                ['ordinary', 'close', 'punctuation', 'operator'].includes(left.atom))
+                gap = 5;
+            else if (left.atom === 'relation' && ['ordinary', 'open', 'operator'].includes(right.atom))
+                gap = 5;
+            else if (right.atom === 'binary' && ['ordinary', 'close'].includes(left.atom))
+                gap = 4;
+            else if (left.atom === 'binary' && ['ordinary', 'open', 'operator'].includes(right.atom))
+                gap = 4;
+            else if (left.atom === 'punctuation')
+                gap = 3;
+            else if ((right.atom === 'operator' && ['ordinary', 'close', 'operator'].includes(left.atom)) ||
+                (left.atom === 'operator' && right.atom === 'ordinary'))
+                gap = 3;
+        }
+        const tight = gap === 3 &&
+            (left.atom === 'operator' || right.atom === 'operator') &&
+            left.atom !== 'punctuation';
+        if (right.key) {
+            result.get(right.key).before = gap;
+            if (tight)
+                result.get(right.key).tightBefore = gap;
+        }
+        else if (left.key) {
+            result.get(left.key).after = gap;
+            if (tight)
+                result.get(left.key).tightAfter = gap;
+        }
+    }
+    return result;
+}

package/dist/matrix-range.d.ts

@@ -0,0 +1,40 @@
+import { type MathDocument, type MathMatrix, type MathRow, type MathState, type MatrixEnvironment } from './model.js';
+import { type MathFragment } from './range.js';
+/** Transient row-major cell addresses; never persisted in the formula document. */
+export interface MathMatrixRange {
+    matrixId: string;
+    anchor: number;
+    focus: number;
+}
+export interface MathMatrixFragment {
+    version: 1;
+    columns: number;
+    cells: MathRow[];
+    environment: MatrixEnvironment;
+}
+export declare const MATH_MATRIX_CLIPBOARD_TYPE = "application/x-barocss-math-matrix+json";
+export declare function findMatrix(document: MathDocument, id: string): MathMatrix | undefined;
+export declare function resolveMatrixRange(document: MathDocument, range: MathMatrixRange): {
+    matrix: MathMatrix;
+    top: number;
+    left: number;
+    rows: number;
+    columns: number;
+    indices: number[];
+} | undefined;
+/** A cross-cell drag selects the nearest matrix shared by both endpoints. */
+export declare function matrixRangeBetween(document: MathDocument, anchorId: string, focusId: string): MathMatrixRange | undefined;
+export declare function focusMatrixCell(state: MathState, matrixId: string, cell: number): MathState;
+export declare function extendMatrixRange(document: MathDocument, range: MathMatrixRange, key: string): MathMatrixRange;
+export declare function copyMatrixRange(document: MathDocument, range: MathMatrixRange): MathMatrixFragment | undefined;
+/** Regular fragment fallback lets a cell rectangle be pasted outside a matrix too. */
+export declare function matrixFragment(fragment: MathMatrixFragment): MathFragment;
+export declare function parseMatrixFragment(source: string): MathMatrixFragment | undefined;
+/** Spreadsheet text is cell text, never evaluated as HTML or implicit LaTeX. */
+export declare function matrixFromTSV(text: string): MathMatrixFragment | undefined;
+/** Clear cell contents, retaining the matrix geometry and all unselected cells. */
+export declare function clearMatrixRange(state: MathState, range: MathMatrixRange, replacement?: string): MathState;
+/** Paste atomically. A single cell is an anchor; larger rectangles require matching dimensions. */
+export declare function pasteMatrixFragment(state: MathState, fragment: MathMatrixFragment, range?: MathMatrixRange): MathState;
+/** Transpose the entire matrix; moving rows preserves every cell ID and the nested caret. */
+export declare function transposeMatrix(state: MathState, matrixId?: string | undefined): MathState;

package/dist/matrix-range.js

@@ -0,0 +1,242 @@
+import { documentRows, row, textNode, textNodes, } from './model.js';
+import { activeMatrix, MATRIX_MAX_SIZE } from './matrix.js';
+import { parseFragment } from './range.js';
+export const MATH_MATRIX_CLIPBOARD_TYPE = 'application/x-barocss-math-matrix+json';
+export function findMatrix(document, id) {
+    const visit = (r) => {
+        for (const node of r.children) {
+            if (node.type === 'matrix' && node.id === id)
+                return node;
+            if (node.type !== 'text')
+                for (const slot of node.slots) {
+                    const found = visit(slot);
+                    if (found)
+                        return found;
+                }
+        }
+    };
+    for (const line of documentRows(document)) {
+        const found = visit(line);
+        if (found)
+            return found;
+    }
+}
+export function resolveMatrixRange(document, range) {
+    const matrix = findMatrix(document, range.matrixId);
+    if (!matrix ||
+        ![range.anchor, range.focus].every((cell) => Number.isInteger(cell) && cell >= 0 && cell < matrix.slots.length))
+        return;
+    const top = Math.min(Math.floor(range.anchor / matrix.columns), Math.floor(range.focus / matrix.columns));
+    const bottom = Math.max(Math.floor(range.anchor / matrix.columns), Math.floor(range.focus / matrix.columns));
+    const left = Math.min(range.anchor % matrix.columns, range.focus % matrix.columns);
+    const right = Math.max(range.anchor % matrix.columns, range.focus % matrix.columns);
+    const indices = [];
+    for (let r = top; r <= bottom; r++)
+        for (let c = left; c <= right; c++)
+            indices.push(r * matrix.columns + c);
+    return { matrix, top, left, rows: bottom - top + 1, columns: right - left + 1, indices };
+}
+/** A cross-cell drag selects the nearest matrix shared by both endpoints. */
+export function matrixRangeBetween(document, anchorId, focusId) {
+    const parents = (id) => {
+        const result = [];
+        const visit = (r) => {
+            for (const node of r.children) {
+                if (node.type === 'text') {
+                    if (node.id === id)
+                        return true;
+                }
+                else
+                    for (const [cell, slot] of node.slots.entries()) {
+                        if (visit(slot)) {
+                            if (node.type === 'matrix')
+                                result.push({ matrixId: node.id, cell });
+                            return true;
+                        }
+                    }
+            }
+            return false;
+        };
+        documentRows(document).some(visit);
+        return result;
+    };
+    const focus = parents(focusId);
+    for (const anchor of parents(anchorId)) {
+        const target = focus.find((item) => item.matrixId === anchor.matrixId);
+        if (target)
+            return target.cell === anchor.cell
+                ? undefined
+                : {
+                    matrixId: anchor.matrixId,
+                    anchor: anchor.cell,
+                    focus: target.cell,
+                };
+    }
+}
+export function focusMatrixCell(state, matrixId, cell) {
+    const slot = findMatrix(state.document, matrixId)?.slots[cell];
+    if (!slot)
+        return state;
+    const node = textNodes({ version: 1, root: slot })[0];
+    return { ...state, caret: { id: node.id, start: 0, end: 0 } };
+}
+export function extendMatrixRange(document, range, key) {
+    const bounds = resolveMatrixRange(document, range);
+    if (!bounds)
+        return range;
+    const matrix = bounds.matrix;
+    let r = Math.floor(range.focus / matrix.columns), c = range.focus % matrix.columns;
+    if (key === 'ArrowUp')
+        r--;
+    if (key === 'ArrowDown')
+        r++;
+    if (key === 'ArrowLeft')
+        c--;
+    if (key === 'ArrowRight')
+        c++;
+    r = Math.max(0, Math.min(matrix.slots.length / matrix.columns - 1, r));
+    c = Math.max(0, Math.min(matrix.columns - 1, c));
+    return { ...range, focus: r * matrix.columns + c };
+}
+export function copyMatrixRange(document, range) {
+    const bounds = resolveMatrixRange(document, range);
+    if (!bounds)
+        return;
+    return {
+        version: 1,
+        columns: bounds.columns,
+        environment: bounds.matrix.environment,
+        cells: bounds.indices.map((index) => structuredClone(bounds.matrix.slots[index])),
+    };
+}
+/** Regular fragment fallback lets a cell rectangle be pasted outside a matrix too. */
+export function matrixFragment(fragment) {
+    const root = row();
+    root.children.push({
+        type: 'matrix',
+        id: row().id,
+        columns: fragment.columns,
+        environment: fragment.environment,
+        slots: structuredClone(fragment.cells),
+    }, textNode());
+    return { version: 1, rows: [root] };
+}
+export function parseMatrixFragment(source) {
+    if (source.length > 200000)
+        return;
+    try {
+        const value = JSON.parse(source);
+        if (value?.version !== 1 ||
+            !Array.isArray(value.cells) ||
+            !Number.isInteger(value.columns) ||
+            value.columns < 1 ||
+            value.columns > MATRIX_MAX_SIZE ||
+            !value.cells.length ||
+            value.cells.length > MATRIX_MAX_SIZE * value.columns ||
+            value.cells.length % value.columns)
+            return;
+        // Reuse the same bounded presentation-tree validation as normal math clipboard data.
+        if (!parseFragment(JSON.stringify(matrixFragment(value))))
+            return;
+        return {
+            version: 1,
+            columns: value.columns,
+            environment: value.environment,
+            cells: value.cells,
+        };
+    }
+    catch {
+        return;
+    }
+}
+/** Spreadsheet text is cell text, never evaluated as HTML or implicit LaTeX. */
+export function matrixFromTSV(text) {
+    if (text.length > 200000 || !text.includes('\t'))
+        return;
+    const lines = text
+        .replace(/\r\n?/g, '\n')
+        .replace(/\n$/, '')
+        .split('\n')
+        .map((line) => line.split('\t'));
+    const columns = lines[0].length;
+    if (lines.length > MATRIX_MAX_SIZE ||
+        columns > MATRIX_MAX_SIZE ||
+        lines.some((line) => line.length !== columns))
+        return;
+    return {
+        version: 1,
+        columns,
+        environment: 'bmatrix',
+        cells: lines.flat().map((text) => row(text)),
+    };
+}
+const freshCell = (cell) => ({
+    id: row().id,
+    children: cell.children.map((node) => node.type === 'text'
+        ? textNode(node.text)
+        : { ...node, id: row().id, slots: node.slots.map(freshCell) }),
+});
+/** Clear cell contents, retaining the matrix geometry and all unselected cells. */
+export function clearMatrixRange(state, range, replacement = '') {
+    const bounds = resolveMatrixRange(state.document, range);
+    if (!bounds)
+        return state;
+    const next = { ...state, document: structuredClone(state.document) };
+    const matrix = findMatrix(next.document, range.matrixId);
+    bounds.indices.forEach((index, at) => {
+        matrix.slots[index] = row(at === 0 ? replacement : '');
+    });
+    const focused = focusMatrixCell(next, matrix.id, bounds.indices[0]);
+    focused.caret.start = focused.caret.end = replacement.length;
+    return focused;
+}
+/** Paste atomically. A single cell is an anchor; larger rectangles require matching dimensions. */
+export function pasteMatrixFragment(state, fragment, range) {
+    const safe = parseMatrixFragment(JSON.stringify(fragment));
+    const context = activeMatrix(state);
+    const bounds = range && resolveMatrixRange(state.document, range);
+    if (!safe || (range && !bounds) || (!bounds && !context))
+        return state;
+    const target = bounds ? bounds.matrix : context.matrix;
+    const top = bounds ? bounds.top : context.row, left = bounds ? bounds.left : context.column;
+    let rows = safe.cells.length / safe.columns, columns = safe.columns;
+    const fill = !!bounds && safe.cells.length === 1;
+    if (bounds && bounds.indices.length > 1) {
+        if (!fill && (rows !== bounds.rows || columns !== bounds.columns))
+            return state;
+        rows = bounds.rows;
+        columns = bounds.columns;
+    }
+    const totalRows = Math.max(target.slots.length / target.columns, top + rows);
+    const totalColumns = Math.max(target.columns, left + columns);
+    if (totalRows > MATRIX_MAX_SIZE || totalColumns > MATRIX_MAX_SIZE)
+        return state;
+    const next = { ...state, document: structuredClone(state.document) };
+    const matrix = findMatrix(next.document, target.id);
+    const slots = [];
+    for (let r = 0; r < totalRows; r++)
+        for (let c = 0; c < totalColumns; c++) {
+            const inside = r >= top && r < top + rows && c >= left && c < left + columns;
+            slots.push(inside
+                ? freshCell(safe.cells[fill ? 0 : (r - top) * safe.columns + c - left])
+                : r < target.slots.length / target.columns && c < target.columns
+                    ? matrix.slots[r * target.columns + c]
+                    : row());
+        }
+    matrix.columns = totalColumns;
+    matrix.slots = slots;
+    return focusMatrixCell(next, matrix.id, top * totalColumns + left);
+}
+/** Transpose the entire matrix; moving rows preserves every cell ID and the nested caret. */
+export function transposeMatrix(state, matrixId = activeMatrix(state)?.matrix.id) {
+    const current = matrixId && findMatrix(state.document, matrixId);
+    if (!current || current.slots.length === 1)
+        return state;
+    const next = { ...state, document: structuredClone(state.document) };
+    const matrix = findMatrix(next.document, current.id);
+    const rows = matrix.slots.length / matrix.columns, columns = matrix.columns;
+    const slots = matrix.slots;
+    matrix.slots = Array.from({ length: slots.length }, (_, i) => slots[(i % rows) * columns + Math.floor(i / rows)]);
+    matrix.columns = rows;
+    return next;
+}

package/dist/matrix.d.ts

@@ -26,4 +26,3 @@ export declare function activeMatrix(state: MathState): {
     rows: number;
 } | undefined;
 export declare function insertIdentityMatrix(state: MathState, size: number): MathState;
-//# sourceMappingURL=matrix.d.ts.map

package/dist/matrix.js

@@ -122,4 +122,3 @@ export function insertIdentityMatrix(state, size) {
     });
     return next;
 }
-//# sourceMappingURL=matrix.js.map

package/dist/model.d.ts

@@ -64,6 +64,10 @@ export declare const namedFunctions: readonly ["sin", "cos", "tan", "cot", "sec"
 /** Wrap the selection, or the preceding simple operand; never swallow a preceding + or =. */
 export declare function insertStructure(state: MathState, kind: StructureKind, consumeOperand?: boolean, mathStyle?: 'display' | 'text'): MathState;
 export declare function moveCaret(state: MathState, direction: -1 | 1): MathState;
+/** Remove the wrapper of an empty slot while retaining its other slots' content.
+ * Grid cells keep their shape; row/column deletion has its own explicit commands.
+ */
+export declare function unwrapEmptySlot(state: MathState): MathState;
 /** At the right edge of a structure, unwrap it instead of silently deleting its contents. */
 export declare function unwrapPrevious(state: MathState): MathState;
 export declare function toLatex(document: MathDocument): string;
@@ -79,4 +83,3 @@ export declare function redo(history: MathHistory): MathHistory;
 /** Grids can be selected from either outside edge or their first/last direct text slot. */
 export declare function gridDeletionTarget(state: MathState, direction: -1 | 1): MathGrid | undefined;
 export declare function removeGrid(state: MathState, gridId: string): MathState;
-//# sourceMappingURL=model.d.ts.map

package/dist/model.js

@@ -233,6 +233,47 @@ export function moveCaret(state, direction) {
     const offset = direction < 0 ? next.text.length : 0;
     return { ...state, caret: { id: next.id, start: offset, end: offset } };
 }
+/** Remove the wrapper of an empty slot while retaining its other slots' content.
+ * Grid cells keep their shape; row/column deletion has its own explicit commands.
+ */
+export function unwrapEmptySlot(state) {
+    if (state.caret.start !== 0 || state.caret.end !== 0)
+        return state;
+    const visit = (line) => {
+        for (let index = 0; index < line.children.length; index++) {
+            const node = line.children[index];
+            if (node.type === 'text')
+                continue;
+            const emptySlot = node.slots.findIndex((slot) => slot.children.length === 1 &&
+                slot.children[0].id === state.caret.id &&
+                slot.children[0].type === 'text' &&
+                slot.children[0].text === '');
+            if (emptySlot >= 0) {
+                if (isGrid(node))
+                    return state;
+                // Preserve the remaining script or radicand instead of flattening it.
+                if ((node.type === 'indexedRoot' && emptySlot === 0) ||
+                    (node.type === 'scripts' && emptySlot > 0))
+                    return unwrapPrevious(state);
+                const after = line.children[index + 1];
+                if (after?.type !== 'text')
+                    return state;
+                return unwrapPrevious({ ...state, caret: { id: after.id, start: 0, end: 0 } });
+            }
+            for (const slot of node.slots) {
+                const next = visit(slot);
+                if (next)
+                    return next;
+            }
+        }
+    };
+    for (const line of documentRows(state.document)) {
+        const next = visit(line);
+        if (next)
+            return next;
+    }
+    return state;
+}
 /** At the right edge of a structure, unwrap it instead of silently deleting its contents. */
 export function unwrapPrevious(state) {
     if (state.caret.start !== 0 || state.caret.end !== 0)
@@ -308,12 +349,12 @@ const escapeText = (text) => Array.from(text)
         '{': '\\{',
         '}': '\\}',
         _: '\\_',
-        '^': '\\textasciicircum{}',
+        '^': '\\char"005E{}',
         '%': '\\%',
         $: '\\$',
         '#': '\\#',
         '&': '\\&',
-        '~': '\\textasciitilde{}',
+        '~': '\\char"007E{}',
         ' ': '\\ ',
     }[c] ??
     c)
@@ -364,8 +405,12 @@ export function toLatex(document) {
                 return `\\${n.mathStyle === 'display' ? 'dbinom' : n.mathStyle === 'text' ? 'tbinom' : 'binom'}{${a}}{${b}}`;
             case 'fraction':
                 return `\\${n.mathStyle === 'display' ? 'dfrac' : n.mathStyle === 'text' ? 'tfrac' : 'frac'}{${a}}{${b}}`;
-            case 'indexedRoot':
-                return `\\sqrt[${a}]{${b}}`;
+            case 'indexedRoot': {
+                // Group complex optional arguments: nested brackets and leading
+                // script groups otherwise terminate KaTeX's root-index scan early.
+                const index = /[{}\[\]]/.test(a) ? `{${a}}` : a;
+                return `\\sqrt[${index}]{${b}}`;
+            }
             case 'vec':
             case 'hat':
             case 'tilde':
@@ -512,4 +557,3 @@ export function removeGrid(state, gridId) {
     at.row.children.splice(at.index, 2);
     return { document, caret: { id: before.id, start: offset, end: offset } };
 }
-//# sourceMappingURL=model.js.map

package/dist/outputs.d.ts

@@ -10,4 +10,3 @@ export interface MathPreviewOptions {
 export declare function mountMathLatex(host: HTMLElement, session: MathSession): MathOutput;
 /** Optional renderer adapter. The core package has no KaTeX, SVG or image-export dependency. */
 export declare function mountMathPreview(host: HTMLElement, session: MathSession, options: MathPreviewOptions): MathOutput;
-//# sourceMappingURL=outputs.d.ts.map

package/dist/outputs.js

@@ -58,4 +58,3 @@ export function mountMathPreview(host, session, options) {
         },
     };
 }
-//# sourceMappingURL=outputs.js.map

package/dist/preferences.d.ts

@@ -0,0 +1,24 @@
+import type { MathMessageParameters } from './i18n.js';
+export interface MathQuickItem {
+    id: string;
+    label: string;
+    labelParameters?: MathMessageParameters;
+    glyph: string;
+    template?: string;
+    aliases?: readonly string[];
+}
+export declare const mathQuickItems: readonly MathQuickItem[];
+export interface MathPreferencesSnapshot {
+    version: 1;
+    recent: string[];
+    favorites: string[];
+}
+/** UI preferences are separate from formula JSON and Undo. The host owns persistence. */
+export declare function createMathPreferences(initial?: unknown): {
+    getSnapshot: () => MathPreferencesSnapshot;
+    record(id: string): void;
+    toggleFavorite(id: string): void;
+    clearRecent(): void;
+    subscribe(listener: () => void): () => void;
+};
+export type MathPreferences = ReturnType<typeof createMathPreferences>;

package/dist/preferences.js

@@ -0,0 +1,66 @@
+import { mathSymbols } from './symbols.js';
+import { mathTemplates } from './templates.js';
+export const mathQuickItems = [
+    ...mathSymbols.map(([glyph, label, aliases, triggers, latex]) => ({
+        id: `symbol-${glyph}`,
+        glyph,
+        label,
+        aliases: [aliases, triggers, latex],
+    })),
+    ...mathTemplates.map((item) => ({
+        id: `template-${item.id}`,
+        label: item.label,
+        labelParameters: item.labelParameters,
+        aliases: item.aliases,
+        glyph: item.size ? '▦' : 'ƒ',
+        template: item.id,
+    })),
+];
+/** UI preferences are separate from formula JSON and Undo. The host owns persistence. */
+export function createMathPreferences(initial) {
+    const ids = new Set(mathQuickItems.map((item) => item.id));
+    const clean = (value, limit) => Array.isArray(value)
+        ? [
+            ...new Set(value.filter((id) => typeof id === 'string' && ids.has(id))),
+        ].slice(0, limit)
+        : [];
+    const saved = initial && typeof initial === 'object' ? initial : {};
+    let recent = saved.version === 1 ? clean(saved.recent, 12) : [];
+    let favorites = saved.version === 1 ? clean(saved.favorites, 100) : [];
+    const listeners = new Set();
+    const emit = () => {
+        for (const listener of listeners)
+            listener();
+    };
+    return {
+        getSnapshot: () => ({
+            version: 1,
+            recent: [...recent],
+            favorites: [...favorites],
+        }),
+        record(id) {
+            if (!ids.has(id))
+                return;
+            recent = [id, ...recent.filter((value) => value !== id)].slice(0, 12);
+            emit();
+        },
+        toggleFavorite(id) {
+            if (!ids.has(id))
+                return;
+            favorites = favorites.includes(id)
+                ? favorites.filter((value) => value !== id)
+                : [...favorites, id].slice(0, 100);
+            emit();
+        },
+        clearRecent() {
+            recent = [];
+            emit();
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+    };
+}