@barocss/math-editor 0.2.0 → 0.4.0

package/dist/session.d.ts

@@ -1,14 +1,24 @@
+import { type MathPresentationChange } from './presentation.js';
+import { type MathPreferences } from './preferences.js';
+import { type LatexInsertionResult } from './latex-insertion.js';
 import { type LatexParseResult } from './latex.js';
 import { type MathDocument, type MathState, type MathCaret, type StructureKind } from './model.js';
 import { type MathRange, type MathFragment } from './range.js';
 import type { MathLocale } from './i18n.js';
+import { type MathMatrixRange, type MathMatrixFragment } from './matrix-range.js';
 export type MathEditorMode = 'block' | 'inline';
 export interface MathSessionOptions {
+    /** UI-only preference store. Supply one store to share it across editors. */
+    preferences?: MathPreferences;
     document?: MathDocument;
     mode?: MathEditorMode;
     locale?: MathLocale;
 }
 export type MathCommand = {
+    type: 'presentation';
+    id: string;
+    change: MathPresentationChange;
+} | {
     type: 'text';
     value: string;
 } | {
@@ -23,10 +33,18 @@ export type MathCommand = {
     type: 'undo';
 } | {
     type: 'redo';
+} | {
+    type: 'matrix-select';
+    all?: boolean;
+} | {
+    type: 'matrix-transpose';
+} | {
+    type: 'matrix-clear';
 };
 export interface MathSessionSnapshot {
     state: MathState;
     range?: MathRange;
+    matrixRange?: MathMatrixRange;
     locale: MathLocale;
     mode: MathEditorMode;
     canUndo: boolean;
@@ -35,14 +53,26 @@ export interface MathSessionSnapshot {
 }
 /** Framework-free session. Snapshots are copies; consumers cannot mutate history. */
 export declare function createMathSession(options?: MathSessionOptions): {
+    preferences: {
+        getSnapshot: () => import("./preferences.js").MathPreferencesSnapshot;
+        record(id: string): void;
+        toggleFavorite(id: string): void;
+        clearRecent(): void;
+        subscribe(listener: () => void): () => void;
+    };
     getSnapshot: () => MathSessionSnapshot;
     subscribe(listener: (snapshot: MathSessionSnapshot, documentChanged: boolean) => void): () => void;
     apply: (next: MathState) => boolean;
     select(caret: MathCaret): void;
     selectRange(next?: MathRange): void;
-    configure(next: Omit<MathSessionOptions, "document">): void;
+    selectMatrixRange(next?: MathMatrixRange): boolean;
+    copyMatrix(): MathMatrixFragment | undefined;
+    pasteMatrix(fragment: MathMatrixFragment): boolean;
+    configure(next: Omit<MathSessionOptions, "document" | "preferences">): void;
     /** Atomic replacement in the existing history. Syntax/policy failures emit no changes. */
     importLatex(source: string): LatexParseResult;
+    /** Explicit LaTeX paste replaces only the current range and creates one Undo entry. */
+    pasteLatex(source: string): LatexInsertionResult;
     load(document: MathDocument): void;
     copy(): MathFragment | undefined;
     paste(fragment: MathFragment): boolean;
@@ -50,4 +80,3 @@ export declare function createMathSession(options?: MathSessionOptions): {
     destroy(): void;
 };
 export type MathSession = ReturnType<typeof createMathSession>;
-//# sourceMappingURL=session.d.ts.map

package/dist/session.js

@@ -1,12 +1,17 @@
+import { setMathPresentation } from './presentation.js';
+import { createMathPreferences } from './preferences.js';
+import { insertLatex } from './latex-insertion.js';
 import { parseLatex } from './latex.js';
 import { commit, createHistory, initialState, insertStructure, toLatex, row, undo, redo, } from './model.js';
 import { copyRange, pasteFragment, wrapRange, wrappingKinds, } from './range.js';
 import { insertTemplate } from './templates.js';
 import { splitLine } from './lines.js';
+import { activeMatrix } from './matrix.js';
+import { clearMatrixRange, copyMatrixRange, focusMatrixCell, matrixFragment, pasteMatrixFragment, resolveMatrixRange, transposeMatrix, } from './matrix-range.js';
 /** Framework-free session. Snapshots are copies; consumers cannot mutate history. */
 export function createMathSession(options = {}) {
     let history = createHistory(initialState(options.document ? structuredClone(options.document) : undefined));
-    let mode = options.mode ?? 'block', locale = options.locale ?? 'ko', range;
+    let mode = options.mode ?? 'block', locale = options.locale ?? 'ko', range, matrixRange;
     const listeners = new Set();
     const valid = (document) => mode !== 'inline' || !document.additionalLines?.length;
     if (!valid(history.present.document))
@@ -14,6 +19,7 @@ export function createMathSession(options = {}) {
     const getSnapshot = () => ({
         state: structuredClone(history.present),
         range: range && structuredClone(range),
+        matrixRange: matrixRange && structuredClone(matrixRange),
         locale,
         mode,
         canUndo: !!history.past.length,
@@ -32,12 +38,16 @@ export function createMathSession(options = {}) {
         history = changed
             ? commit(history, next)
             : { ...history, present: { ...history.present, caret: next.caret } };
-        if (changed)
+        if (changed) {
             range = undefined;
+            matrixRange = undefined;
+        }
         emit(changed);
         return true;
     };
+    const preferences = options.preferences ?? createMathPreferences();
     return {
+        preferences,
         getSnapshot,
         subscribe(listener) {
             listeners.add(listener);
@@ -52,12 +62,34 @@ export function createMathSession(options = {}) {
                 present: { ...history.present, caret: { ...caret } },
             };
             range = undefined;
+            matrixRange = undefined;
             emit(false);
         },
         selectRange(next) {
+            matrixRange = undefined;
             range = next && structuredClone(next);
             emit(false);
         },
+        selectMatrixRange(next) {
+            if (next && !resolveMatrixRange(history.present.document, next))
+                return false;
+            matrixRange = next && structuredClone(next);
+            range = undefined;
+            if (next)
+                history = {
+                    ...history,
+                    present: focusMatrixCell(history.present, next.matrixId, next.focus),
+                };
+            emit(false);
+            return true;
+        },
+        copyMatrix() {
+            return matrixRange ? copyMatrixRange(history.present.document, matrixRange) : undefined;
+        },
+        pasteMatrix(fragment) {
+            const next = pasteMatrixFragment(history.present, fragment, matrixRange);
+            return next !== history.present && apply(next);
+        },
         configure(next) {
             const targetMode = next.mode ?? mode;
             if (targetMode === 'inline' && history.present.document.additionalLines?.length)
@@ -73,17 +105,44 @@ export function createMathSession(options = {}) {
                 apply(initialState(result.document));
             return result;
         },
+        /** Explicit LaTeX paste replaces only the current range and creates one Undo entry. */
+        pasteLatex(source) {
+            if (matrixRange)
+                return {
+                    ok: false,
+                    source,
+                    diagnostics: [
+                        {
+                            code: 'unsupported-structure',
+                            message: 'Select one insertion point before pasting LaTeX.',
+                            start: 0,
+                            end: source.length,
+                        },
+                    ],
+                };
+            const result = insertLatex(history.present, source, range, { multiline: mode !== 'inline' });
+            if (result.ok)
+                apply(result.state);
+            return result;
+        },
         load(document) {
             if (!valid(document))
                 throw new Error('Inline mode requires a single top-level row.');
             history = createHistory(initialState(structuredClone(document)));
             range = undefined;
+            matrixRange = undefined;
             emit(true);
         },
         copy() {
+            if (matrixRange) {
+                const fragment = copyMatrixRange(history.present.document, matrixRange);
+                return fragment && matrixFragment(fragment);
+            }
             return range ? copyRange(history.present.document, range) : undefined;
         },
         paste(fragment) {
+            if (matrixRange)
+                return false;
             return apply(pasteFragment(history.present, fragment, range));
         },
         execute(command) {
@@ -96,19 +155,62 @@ export function createMathSession(options = {}) {
                 const changed = next.present.document !== state.document;
                 history = next;
                 range = undefined;
+                matrixRange = undefined;
                 emit(changed);
                 return changed;
             }
-            if (command.type === 'text')
-                return apply(pasteFragment(state, {
+            if (command.type === 'presentation') {
+                if (range || matrixRange)
+                    return false;
+                const next = setMathPresentation(state, command.id, command.change);
+                return next !== state && apply(next);
+            }
+            if (command.type === 'matrix-select') {
+                const context = activeMatrix(state);
+                if (!context)
+                    return false;
+                matrixRange = {
+                    matrixId: context.matrix.id,
+                    anchor: command.all ? 0 : context.cell,
+                    focus: command.all ? context.matrix.slots.length - 1 : context.cell,
+                };
+                range = undefined;
+                history = {
+                    ...history,
+                    present: focusMatrixCell(state, matrixRange.matrixId, matrixRange.focus),
+                };
+                emit(false);
+                return true;
+            }
+            if (command.type === 'matrix-transpose') {
+                const next = transposeMatrix(state, matrixRange?.matrixId);
+                return next !== state && apply(next);
+            }
+            if (command.type === 'matrix-clear')
+                return !!matrixRange && apply(clearMatrixRange(state, matrixRange));
+            if (matrixRange)
+                return (command.type === 'text' &&
+                    !command.value.includes('\n') &&
+                    !command.value.includes('\r') &&
+                    apply(clearMatrixRange(state, matrixRange, command.value)));
+            if (command.type === 'text') {
+                const inserted = apply(pasteFragment(state, {
                     version: 1,
                     rows: command.value
                         .replace(/\r\n?/g, '\n')
                         .split('\n')
                         .map((value) => row(value)),
                 }, range));
-            if (command.type === 'template')
-                return apply(insertTemplate(state, command.id, range));
+                if (inserted)
+                    preferences.record(`symbol-${command.value}`);
+                return inserted;
+            }
+            if (command.type === 'template') {
+                const inserted = apply(insertTemplate(state, command.id, range));
+                if (inserted)
+                    preferences.record(`template-${command.id}`);
+                return inserted;
+            }
             if (command.type === 'newline')
                 return mode === 'inline' ? false : apply(splitLine(state));
             if (range)
@@ -121,4 +223,3 @@ export function createMathSession(options = {}) {
         },
     };
 }
-//# sourceMappingURL=session.js.map

package/dist/solid.d.ts

@@ -9,4 +9,3 @@ declare module 'solid-js' {
 }
 /** Solid directive: <div use:mathEditor={options()} />. */
 export declare function mathEditor(host: HTMLElement, options: Accessor<DOMMathEditorOptions>): void;
-//# sourceMappingURL=solid.d.ts.map

package/dist/solid.js

@@ -6,4 +6,3 @@ export function mathEditor(host, options) {
     createEffect(() => editor.update(options()));
     onCleanup(() => editor.destroy());
 }
-//# sourceMappingURL=solid.js.map

package/dist/suggestions.d.ts

@@ -7,7 +7,11 @@ export interface MathSuggestion {
     mathStyle?: 'display' | 'text';
     templateId?: string;
     identity?: boolean;
+    /** Fill each matrix cell with an editable zero. */
+    zero?: boolean;
+    /** Row count; matrices are square unless matrixColumns is supplied. */
     matrixSize?: number;
+    matrixColumns?: number;
     id: string;
     /** Catalog entries hold message keys; findSuggestions returns localized display text. */
     label: string;
@@ -28,4 +32,3 @@ export declare function findSuggestions(text: string, caret: number, locale?: Ma
     candidates: MathSuggestion[];
 };
 export declare function acceptSuggestion(state: MathState, query: string, candidate: MathSuggestion): MathState;
-//# sourceMappingURL=suggestions.d.ts.map

package/dist/suggestions.js

@@ -1,8 +1,9 @@
 import { mathLocaleAliases, translate, } from './i18n.js';
 import { insertTemplate, mathTemplates } from './templates.js';
-import { insertIdentityMatrix, insertMatrix } from './matrix.js';
+import { activeMatrix, insertIdentityMatrix, insertMatrix, MATRIX_MAX_SIZE } from './matrix.js';
 import { insertStructure, namedFunctions, moveCaret, setText, textNodes, } from './model.js';
 import { mathSymbols } from './symbols.js';
+import { wrappingKinds } from './range.js';
 const structure = (kind, glyph, label, aliases, triggers, detail) => ({
     id: kind,
     kind,
@@ -15,7 +16,7 @@ const structure = (kind, glyph, label, aliases, triggers, detail) => ({
 export const mathStructures = [
     structure('matrix', '[▦]', 'structure.matrix', ['matrix', '행렬', 'vector', '벡터'], [], 'structure.matrixDetail'),
     structure('aligned', '≡', 'structure.aligned', ['aligned', 'align', '정렬', '등호'], [], 'structure.alignedDetail'),
-    structure('cases', '{', 'structure.cases', ['cases', 'case', '조건', '구간'], [], 'structure.casesDetail'),
+    structure('cases', '{', 'structure.cases', ['cases', 'case', '조건', '구간'], ['{'], 'structure.casesDetail'),
     structure('fraction', 'a/b', 'structure.fraction', ['frac', 'fraction', 'division'], ['/'], 'structure.fractionDetail'),
     structure('root', '√', 'structure.root', ['sqrt', 'root'], ['√'], 'structure.rootDetail'),
     structure('indexedRoot', 'ⁿ√', 'structure.indexedRoot', ['nthroot', 'nroot', '제곱근'], [], 'structure.indexedRootDetail'),
@@ -129,14 +130,58 @@ const catalog = [
     })),
 ];
 const triggers = [...new Set(catalog.flatMap((c) => c.triggers))].sort((a, b) => b.length - a.length);
+/** Generate only the requested size, with identity matrices reserved for square shapes. */
+function matrixDimensionSuggestions(rows, columns) {
+    const sizeId = rows === columns ? String(rows) : `${rows}x${columns}`;
+    const dimensions = { rows, columns };
+    const empty = {
+        ...mathStructures[0],
+        id: `matrix-${sizeId}`,
+        label: 'matrix.size',
+        labelParameters: dimensions,
+        detail: 'grid.dimensions',
+        detailParameters: dimensions,
+        matrixSize: rows,
+        matrixColumns: columns,
+    };
+    const candidates = [empty];
+    if (rows === columns) {
+        candidates.push({
+            ...empty,
+            id: `identity-${sizeId}`,
+            glyph: 'I',
+            label: 'matrix.identity',
+            detail: 'matrix.identityDetail',
+            identity: true,
+        });
+    }
+    candidates.push({
+        ...empty,
+        id: `template-zero-${sizeId}`,
+        glyph: '0',
+        label: 'matrix.zero',
+        zero: true,
+    });
+    return candidates;
+}
 export function findSuggestions(text, caret, locale = 'ko') {
     const before = text.slice(0, caret);
+    // Size shortcuts are complete tokens, not the tail of a number or identifier.
+    // They remain ordinary text until the user accepts a matrix candidate.
+    const dimensionMatch = /^[\p{L}\p{M}\p{N}_.]/u.test(text.slice(caret))
+        ? null
+        : before.match(/(?<![\p{L}\p{M}\p{N}_.\\])([1-9]\d?)[xX×]([1-9]\d?)$/u);
+    const dimension = dimensionMatch &&
+        Number(dimensionMatch[1]) <= MATRIX_MAX_SIZE &&
+        Number(dimensionMatch[2]) <= MATRIX_MAX_SIZE
+        ? dimensionMatch
+        : null;
     // Recognize the longest symbolic spelling first: E/ must never become a fraction query.
     const trigger = triggers.find((t) => before.endsWith(t) &&
         (t.length > 1 || !/[A-Za-z]/.test(t) || !/[\p{L}\p{N}]/u.test(before.at(-2) ?? '')));
     const word = before.match(/(?:\\)?[\p{L}\p{M}]+$/u)?.[0];
     const operand = before.match(/(?:\d+(?:\.\d+)?|[\p{L}\p{M}]+)$/u)?.[0];
-    const query = trigger ?? word ?? operand ?? '';
+    const query = dimension?.[0] ?? trigger ?? word ?? operand ?? '';
     if (!query)
         return { query: '', candidates: [] };
     const name = query.replace(/^\\/, '');
@@ -160,12 +205,16 @@ export function findSuggestions(text, caret, locale = 'ko') {
             return 3;
         return 4;
     };
-    const candidates = trigger
-        ? catalog.filter((item) => item.triggers.includes(trigger))
-        : /^\d+(?:\.\d+)?$/.test(name)
-            ? []
-            : catalog.filter((item) => names(item).some((value) => normalize(value).includes(needle)));
+    const candidates = dimension
+        ? matrixDimensionSuggestions(Number(dimension[1]), Number(dimension[2]))
+        : trigger
+            ? catalog.filter((item) => item.triggers.includes(trigger))
+            : /^\d+(?:\.\d+)?$/.test(name)
+                ? []
+                : catalog.filter((item) => names(item).some((value) => normalize(value).includes(needle)));
     candidates.sort((a, b) => {
+        if (dimension)
+            return 0;
         if (trigger === '-' || trigger === '->') {
             const preferred = trigger === '-' ? ['−', '→'] : ['→'];
             const order = (item) => {
@@ -175,6 +224,8 @@ export function findSuggestions(text, caret, locale = 'ko') {
             if (order(a) !== order(b))
                 return order(a) - order(b);
         }
+        if (trigger === '{')
+            return Number(b.kind === 'braces') - Number(a.kind === 'braces');
         if (trigger === '_')
             return Number(b.kind === 'subscript') - Number(a.kind === 'subscript');
         if (!trigger && rank(a) !== rank(b))
@@ -214,6 +265,16 @@ export function findSuggestions(text, caret, locale = 'ko') {
             });
         }
     }
+    // A partial name after a coefficient is an operand (4ab), not an "absolute"
+    // command. Keep explicit commands such as 4abs and \\abs working as before.
+    if (!trigger && /^\p{L}+$/u.test(query) && /\d$/.test(before.slice(0, -query.length))) {
+        for (let index = 0; index < candidates.length; index++) {
+            const item = candidates[index];
+            if (item.kind && wrappingKinds.some((kind) => kind === item.kind) && rank(item) >= 3) {
+                candidates[index] = { ...item, wrapOperand: true, detail: 'suggestion.wrapOperand' };
+            }
+        }
+    }
     return {
         query,
         candidates: candidates.map((item) => ({
@@ -228,6 +289,13 @@ export function acceptSuggestion(state, query, candidate) {
     const start = state.caret.start - query.length;
     if (!node || start < 0 || node.text.slice(start, state.caret.start) !== query)
         return state;
+    if (candidate.matrixSize !== undefined) {
+        const rows = candidate.matrixSize;
+        const columns = candidate.matrixColumns ?? rows;
+        if (![rows, columns].every((size) => Number.isInteger(size) && size >= 1 && size <= MATRIX_MAX_SIZE) ||
+            (candidate.identity && rows !== columns))
+            return state;
+    }
     if (candidate.wrapOperand && candidate.kind) {
         const selected = { ...state, caret: { ...state.caret, start, end: state.caret.start } };
         const wrapped = insertStructure(selected, candidate.kind);
@@ -251,12 +319,34 @@ export function acceptSuggestion(state, query, candidate) {
         const inserted = insertStructure(next, 'operatorName');
         return moveCaret(setText(inserted, candidate.operatorName, candidate.operatorName.length), 1);
     }
-    if (candidate.templateId)
-        return insertTemplate(next, candidate.templateId);
-    if (candidate.matrixSize)
-        return (candidate.identity ? insertIdentityMatrix : insertMatrix)(next, candidate.matrixSize);
+    if (candidate.templateId) {
+        const inserted = insertTemplate(next, candidate.templateId);
+        if (!candidate.templateId.startsWith('zero-') || inserted === next)
+            return inserted;
+        // Matrix suggestions start cell editing, including populated zero templates.
+        // Pasting a template otherwise leaves the caret after its last structure.
+        const matrix = activeMatrix(moveCaret(inserted, -1))?.matrix;
+        const first = matrix?.slots[0].children[0];
+        return first?.type === 'text'
+            ? { ...inserted, caret: { id: first.id, start: 0, end: 0 } }
+            : inserted;
+    }
+    if (candidate.matrixSize) {
+        const inserted = candidate.identity
+            ? insertIdentityMatrix(next, candidate.matrixSize)
+            : insertMatrix(next, candidate.matrixSize, candidate.matrixColumns);
+        if (inserted === next)
+            return state;
+        if (candidate.zero) {
+            activeMatrix(inserted)?.matrix.slots.forEach((cell) => {
+                const first = cell.children[0];
+                if (first.type === 'text')
+                    first.text = '0';
+            });
+        }
+        return inserted;
+    }
     return candidate.kind
         ? insertStructure(next, candidate.kind, ['fraction', 'binomial', 'superscript', 'subscript'].includes(candidate.kind), candidate.mathStyle)
         : next;
 }
-//# sourceMappingURL=suggestions.js.map

package/dist/svelte.d.ts

@@ -2,4 +2,3 @@ import type { Action } from 'svelte/action';
 import { type DOMMathEditorOptions } from './dom.js';
 /** Svelte action: <div use:mathEditor={options} />. */
 export declare const mathEditor: Action<HTMLElement, DOMMathEditorOptions | undefined>;
-//# sourceMappingURL=svelte.d.ts.map

package/dist/svelte.js

@@ -11,4 +11,3 @@ export const mathEditor = (host, options) => {
         },
     };
 };
-//# sourceMappingURL=svelte.js.map

package/dist/symbol-browser.d.ts

@@ -5,4 +5,3 @@ export declare function SymbolBrowser({ locale, onInsert, onClose, }: {
     onInsert: (glyph: string) => void;
     onClose: () => void;
 }): import("react/jsx-runtime").JSX.Element;
-//# sourceMappingURL=symbol-browser.d.ts.map

package/dist/symbol-browser.js

@@ -29,4 +29,3 @@ export function SymbolBrowser({ locale, onInsert, onClose, }) {
             }
         }, children: [_jsxs("div", { className: "me-symbol-browser-heading", children: [_jsxs("strong", { children: [t('symbols.title'), ' ', _jsxs("small", { children: [matches.length, " / ", mathSymbols.length] })] }), _jsx("button", { type: "button", onClick: onClose, children: t('common.close') })] }), _jsxs("label", { className: "me-symbol-search", children: [t('symbols.search'), _jsx("input", { ref: search, type: "search", value: query, onChange: (event) => setQuery(event.target.value), placeholder: t('symbols.searchPlaceholder') })] }), _jsx("p", { className: "me-symbol-help", children: t('symbols.help') }), _jsx("div", { className: "me-symbol-grid", children: matches.map(([glyph, label]) => (_jsxs("button", { type: "button", "aria-label": `${glyph} — ${t(label)}`, title: `${translate('en', label)} / ${translate('ko', label)}`, onClick: () => onInsert(glyph), children: [_jsx("span", { className: "me-symbol-glyph", "aria-hidden": "true", children: glyph }), _jsx("span", { children: t(label) })] }, glyph))) }), !matches.length && _jsx("p", { role: "status", children: t('symbols.noMatches') })] }));
 }
-//# sourceMappingURL=symbol-browser.js.map

package/dist/symbols.d.ts

@@ -1,3 +1,2 @@
 /** One catalog powers discovery and LaTeX export. */
 export declare const mathSymbols: readonly [readonly ["↑", "symbol.upArrow", "uparrow arrow 화살표", "- ->", "\\uparrow"], readonly ["↕", "symbol.upDownArrow", "updownarrow arrow 화살표", "- ->", "\\updownarrow"], readonly ["⇐", "symbol.doubleLeftArrow", "Leftarrow arrow 화살표", "- ->", "\\Leftarrow"], readonly ["⇑", "symbol.doubleUpArrow", "Uparrow arrow 화살표", "- ->", "\\Uparrow"], readonly ["⇓", "symbol.doubleDownArrow", "Downarrow arrow 화살표", "- ->", "\\Downarrow"], readonly ["⇕", "symbol.doubleUpDownArrow", "Updownarrow arrow 화살표", "- ->", "\\Updownarrow"], readonly ["↗", "symbol.northEastArrow", "nearrow arrow 화살표", "- ->", "\\nearrow"], readonly ["↘", "symbol.southEastArrow", "searrow arrow 화살표", "- ->", "\\searrow"], readonly ["↙", "symbol.southWestArrow", "swarrow arrow 화살표", "- ->", "\\swarrow"], readonly ["↖", "symbol.northWestArrow", "nwarrow arrow 화살표", "- ->", "\\nwarrow"], readonly ["⟶", "symbol.longRightArrow", "longrightarrow arrow 화살표", "- ->", "\\longrightarrow"], readonly ["⟵", "symbol.longLeftArrow", "longleftarrow arrow 화살표", "- ->", "\\longleftarrow"], readonly ["⟷", "symbol.longLeftRightArrow", "longleftrightarrow arrow 화살표", "-", "\\longleftrightarrow"], readonly ["⟹", "symbol.longDoubleRightArrow", "Longrightarrow arrow 화살표", "- ->", "\\Longrightarrow"], readonly ["⟸", "symbol.longDoubleLeftArrow", "Longleftarrow arrow 화살표", "- ->", "\\Longleftarrow"], readonly ["⟺", "symbol.longDoubleLeftRightArrow", "Longleftrightarrow arrow 화살표", "", "\\Longleftrightarrow"], readonly ["↪", "symbol.hookRightArrow", "hookrightarrow arrow 화살표", "- ->", "\\hookrightarrow"], readonly ["↩", "symbol.hookLeftArrow", "hookleftarrow arrow 화살표", "- ->", "\\hookleftarrow"], readonly ["⇀", "symbol.rightHarpoonUp", "rightharpoonup arrow 화살표", "- ->", "\\rightharpoonup"], readonly ["↼", "symbol.leftHarpoonUp", "leftharpoonup arrow 화살표", "- ->", "\\leftharpoonup"], readonly ["⇁", "symbol.rightHarpoonDown", "rightharpoondown arrow 화살표", "- ->", "\\rightharpoondown"], readonly ["↽", "symbol.leftHarpoonDown", "leftharpoondown arrow 화살표", "- ->", "\\leftharpoondown"], readonly ["⇌", "symbol.rightLeftHarpoons", "rightleftharpoons arrow 화살표", "- ->", "\\rightleftharpoons"], readonly ["⇋", "symbol.leftRightHarpoons", "leftrightharpoons arrow 화살표", "- ->", "\\leftrightharpoons"], readonly ["↓", "symbol.downArrow", "downarrow down 아래화살표 아래쪽화살표", "- ->", "\\downarrow"], readonly ["⩾", "symbol.greaterOrEqualSlanted", "geqslant", "", "\\geqslant"], readonly ["⩽", "symbol.lessOrEqualSlanted", "leqslant", "", "\\leqslant"], readonly ["∋", "symbol.contains", "ni contains", "", "\\ni"], readonly ["⊃", "symbol.superset", "supset superset", "", "\\supset"], readonly ["⊇", "symbol.supersetOrEqual", "supseteq", "", "\\supseteq"], readonly ["⊈", "symbol.notSubsetOrEqual", "nsubseteq", "", "\\nsubseteq"], readonly ["∖", "symbol.setDifference", "setminus difference", "", "\\setminus"], readonly ["ℕ", "symbol.naturals", "naturals natural", "", "\\mathbb{N}"], readonly ["ℤ", "symbol.integers", "integers integer", "", "\\mathbb{Z}"], readonly ["ℚ", "symbol.rationals", "rationals rational", "", "\\mathbb{Q}"], readonly ["ℝ", "symbol.reals", "reals real", "", "\\mathbb{R}"], readonly ["ℂ", "symbol.complexes", "complexes complex", "", "\\mathbb{C}"], readonly ["⊥", "symbol.perpendicular", "perp perpendicular", "", "\\perp"], readonly ["∥", "symbol.parallel", "parallel", "", "\\parallel"], readonly ["≅", "symbol.congruent", "cong congruent", "", "\\cong"], readonly ["∼", "symbol.similar", "sim similar", "", "\\sim"], readonly ["↦", "symbol.mapsTo", "mapsto maps arrow 화살표", "|-> - ->", "\\mapsto"], readonly ["…", "symbol.ellipsis", "ldots ellipsis", "", "\\ldots"], readonly ["⋯", "symbol.centeredDots", "cdots", "", "\\cdots"], readonly ["⋮", "symbol.verticalDots", "vdots", "", "\\vdots"], readonly ["⋱", "symbol.diagonalDots", "ddots", "", "\\ddots"], readonly ["°", "symbol.degree", "degree degrees 각도", "", "{}^{\\circ}"], readonly ["∠", "symbol.angle", "angle", "", "\\angle"], readonly ["+", "symbol.plus", "plus sum", "+", "+"], readonly ["−", "symbol.minus", "minus", "-", "-"], readonly ["±", "symbol.plusMinus", "plusminus sum", "+- +", "\\pm"], readonly ["∓", "symbol.minusPlus", "minusplus", "-+ -", "\\mp"], readonly ["×", "symbol.times", "times multiply", "*", "\\times"], readonly ["·", "symbol.dot", "dot multiply", "*", "\\cdot"], readonly ["÷", "symbol.divide", "divide division", "/", "\\div"], readonly ["=", "symbol.equal", "equal", "=", "="], readonly ["≠", "symbol.notEqual", "neq unequal", "!= /= =", "\\ne"], readonly ["≈", "symbol.approximatelyEqual", "approx", "~ ~~ =", "\\approx"], readonly ["≡", "symbol.equivalent", "equiv", "=== =", "\\equiv"], readonly ["<", "symbol.lessThan", "less", "<", "<"], readonly [">", "symbol.greaterThan", "greater", ">", ">"], readonly ["≤", "symbol.lessOrEqual", "leq less", "<= <- <", "\\le"], readonly ["≥", "symbol.greaterOrEqual", "geq greater", ">= >- >", "\\ge"], readonly ["∝", "symbol.proportional", "proportional", "~", "\\propto"], readonly ["→", "symbol.rightArrow", "rightarrow arrow", "-> -", "\\to"], readonly ["←", "symbol.leftArrow", "leftarrow arrow", "<- < - ->", "\\leftarrow"], readonly ["↔", "symbol.leftRightArrow", "leftrightarrow arrow", "<-> - ->", "\\leftrightarrow"], readonly ["⇒", "symbol.implies", "implies arrow 화살표", "=> = - ->", "\\Rightarrow"], readonly ["⇔", "symbol.iff", "iff arrow 화살표", "<=> - ->", "\\Leftrightarrow"], readonly ["∈", "symbol.elementOf", "in element", "E", "\\in"], readonly ["∉", "symbol.notElementOf", "notin element", "E/", "\\notin"], readonly ["∀", "symbol.forAll", "forall", "A", "\\forall"], readonly ["∃", "symbol.exists", "exists", "E", "\\exists"], readonly ["∪", "symbol.union", "union", "U", "\\cup"], readonly ["∩", "symbol.intersection", "intersection", "", "\\cap"], readonly ["⊂", "symbol.subset", "subset", "<", "\\subset"], readonly ["⊆", "symbol.subsetOrEqual", "subseteq", "<=", "\\subseteq"], readonly ["∅", "symbol.emptySet", "emptyset", "", "\\emptyset"], readonly ["∞", "symbol.infinity", "infinity infty", "", "\\infty"], readonly ["∂", "symbol.partialDerivative", "partial derivative", "", "\\partial"], readonly ["∇", "symbol.nabla", "nabla gradient", "", "\\nabla"], readonly ["∧", "symbol.logicalAnd", "and wedge", "^", "\\wedge"], readonly ["∨", "symbol.logicalOr", "or vee", "", "\\vee"], readonly ["¬", "symbol.logicalNot", "not neg", "!", "\\neg"], readonly ["α", "symbol.alpha", "alpha", "", "\\alpha"], readonly ["β", "symbol.beta", "beta", "", "\\beta"], readonly ["γ", "symbol.gamma", "gamma", "", "\\gamma"], readonly ["δ", "symbol.delta", "delta", "", "\\delta"], readonly ["ε", "symbol.epsilon", "epsilon", "", "\\epsilon"], readonly ["ζ", "symbol.zeta", "zeta", "", "\\zeta"], readonly ["η", "symbol.eta", "eta", "", "\\eta"], readonly ["θ", "symbol.theta", "theta", "", "\\theta"], readonly ["ι", "symbol.iota", "iota", "", "\\iota"], readonly ["κ", "symbol.kappa", "kappa", "", "\\kappa"], readonly ["λ", "symbol.lambda", "lambda", "", "\\lambda"], readonly ["μ", "symbol.mu", "mu", "", "\\mu"], readonly ["ν", "symbol.nu", "nu", "", "\\nu"], readonly ["ξ", "symbol.xi", "xi", "", "\\xi"], readonly ["π", "symbol.pi", "pi", "", "\\pi"], readonly ["ρ", "symbol.rho", "rho", "", "\\rho"], readonly ["σ", "symbol.sigma", "sigma", "", "\\sigma"], readonly ["τ", "symbol.tau", "tau", "", "\\tau"], readonly ["υ", "symbol.upsilon", "upsilon", "", "\\upsilon"], readonly ["φ", "symbol.phi", "phi", "", "\\phi"], readonly ["χ", "symbol.chi", "chi", "", "\\chi"], readonly ["ψ", "symbol.psi", "psi", "", "\\psi"], readonly ["ω", "symbol.omega", "omega", "", "\\omega"], readonly ["Γ", "symbol.upperGamma", "Gamma", "", "\\Gamma"], readonly ["Δ", "symbol.upperDelta", "Delta", "", "\\Delta"], readonly ["Θ", "symbol.upperTheta", "Theta", "", "\\Theta"], readonly ["Λ", "symbol.upperLambda", "Lambda", "", "\\Lambda"], readonly ["Ξ", "symbol.upperXi", "Xi", "", "\\Xi"], readonly ["Π", "symbol.upperPi", "Pi", "", "\\Pi"], readonly ["Σ", "symbol.upperSigma", "Sigma", "", "\\Sigma"], readonly ["Φ", "symbol.upperPhi", "Phi", "", "\\Phi"], readonly ["Ψ", "symbol.upperPsi", "Psi", "", "\\Psi"], readonly ["Ω", "symbol.upperOmega", "Omega", "", "\\Omega"]];
-//# sourceMappingURL=symbols.d.ts.map

package/dist/symbols.js

@@ -142,4 +142,3 @@ export const mathSymbols = [
     ['Ψ', 'symbol.upperPsi', 'Psi', '', '\\Psi'],
     ['Ω', 'symbol.upperOmega', 'Omega', '', '\\Omega'],
 ];
-//# sourceMappingURL=symbols.js.map

package/dist/templates.d.ts

@@ -13,4 +13,3 @@ export declare const mathTemplates: MathTemplate[];
 /** Each call creates independent, editable nodes; templates are not opaque LaTeX. */
 export declare function createTemplate(id: string): MathFragment | undefined;
 export declare function insertTemplate(state: MathState, id: string, range?: MathRange): MathState;
-//# sourceMappingURL=templates.d.ts.map

package/dist/templates.js

@@ -83,4 +83,3 @@ export function insertTemplate(state, id, range) {
     const fragment = createTemplate(id);
     return fragment ? pasteFragment(state, fragment, range) : state;
 }
-//# sourceMappingURL=templates.js.map

package/dist/tokens.d.ts

@@ -8,4 +8,3 @@ export interface MathToken {
 /** Lexical input units, not inferred mathematical definitions (e and c remain variables). */
 export declare function tokenizeMathText(text: string): MathToken[];
 export declare function tokenIndexAt(tokens: MathToken[], offset: number, affinity?: 'forward' | 'backward'): number;
-//# sourceMappingURL=tokens.d.ts.map

package/dist/tokens.js

@@ -21,4 +21,3 @@ export function tokenIndexAt(tokens, offset, affinity = 'backward') {
         : offset > token.start && offset <= token.end);
     return index >= 0 ? index : offset <= 0 ? 0 : tokens.length - 1;
 }
-//# sourceMappingURL=tokens.js.map

package/dist/vertical-navigation.d.ts

@@ -0,0 +1,15 @@
+import { type MathCaret, type MathState } from './model.js';
+import type { MathPoint } from './range.js';
+type VerticalPoint = MathPoint & Pick<MathCaret, 'affinity'>;
+/** Viewport coordinates of a rendered insertion point, including either side of a token boundary. */
+export type MathCaretGeometry = (point: VerticalPoint) => {
+    x: number;
+    y: number;
+} | undefined;
+/**
+ * Move through the nearest vertical structure, then enclosing grids and equation lines.
+ * Geometry is optional so the same operation works in headless sessions and either renderer.
+ * Native text selections and literal text retain their own arrow-key behavior.
+ */
+export declare function moveVertical(state: MathState, direction: -1 | 1, geometry?: MathCaretGeometry): MathState;
+export {};