@barocss/math-editor 0.4.0 → 0.6.1

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/model.d.ts

@@ -64,8 +64,14 @@ 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;
+/** Delete before a structure unwraps it and keeps the caret before its retained contents. */
+export declare function unwrapNext(state: MathState): MathState;
 export declare function toLatex(document: MathDocument): string;
 export interface MathHistory {
     past: MathState[];

package/dist/model.js

@@ -81,7 +81,7 @@ const escapeLiteral = (text) => text.replace(/[\\{}_%$#&^~]/g, (char) => ({
     '\\': '\\textbackslash{}',
     '^': '\\textasciicircum{}',
     '~': '\\textasciitilde{}',
-}[char] ?? `\\${char}`));
+})[char] ?? `\\${char}`);
 /** Wrap the selection, or the preceding simple operand; never swallow a preceding + or =. */
 export function insertStructure(state, kind, consumeOperand = false, mathStyle) {
     if (isLiteralText(state.document, state.caret.id))
@@ -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)
@@ -298,6 +339,28 @@ export function unwrapPrevious(state) {
     const offset = target.text.length - current.text.length;
     return { document, caret: { id: target.id, start: offset, end: offset } };
 }
+/** Delete before a structure unwraps it and keeps the caret before its retained contents. */
+export function unwrapNext(state) {
+    if (state.caret.start !== state.caret.end)
+        return state;
+    const at = documentRows(state.document)
+        .map((line) => locate(line, state.caret.id))
+        .find(Boolean);
+    if (!at)
+        return state;
+    const current = at.row.children[at.index];
+    const structure = at.row.children[at.index + 1];
+    const after = at.row.children[at.index + 2];
+    if (current.type !== 'text' ||
+        state.caret.end !== current.text.length ||
+        !structure ||
+        structure.type === 'text' ||
+        isGrid(structure) ||
+        after?.type !== 'text')
+        return state;
+    const next = unwrapPrevious({ ...state, caret: { id: after.id, start: 0, end: 0 } });
+    return next.document === state.document ? state : { ...next, caret: { ...state.caret } };
+}
 const symbols = Object.fromEntries(mathSymbols
     .filter(([value, , , , latex]) => value !== latex)
     .map(([value, , , , latex]) => [value, `${latex} `]));
@@ -308,12 +371,12 @@ const escapeText = (text) => Array.from(text)
         '{': '\\{',
         '}': '\\}',
         _: '\\_',
-        '^': '\\textasciicircum{}',
+        '^': '\\char"005E{}',
         '%': '\\%',
         $: '\\$',
         '#': '\\#',
         '&': '\\&',
-        '~': '\\textasciitilde{}',
+        '~': '\\char"007E{}',
         ' ': '\\ ',
     }[c] ??
     c)
@@ -364,8 +427,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':

package/dist/range.d.ts

@@ -28,6 +28,14 @@ export declare function parseFragment(source: string): MathFragment | undefined;
 export declare const wrappingKinds: readonly ["bold", "calligraphic", "blackboard", "fraction", "binomial", "root", "vec", "hat", "tilde", "bar", "dot", "ddot", "widehat", "widetilde", "overline", "indexedRoot", "norm", "braces", "angle", "openClosed", "closedOpen", "overbrace", "underbrace", "overset", "underset", "superscript", "subscript", "parentheses", "brackets", "absolute"];
 export type WrappingKind = (typeof wrappingKinds)[number];
 /** Wrap one balanced row. Cross-slot ranges expand to their common structure. */
-export declare function wrapRange(state: MathState, range: MathRange, kind: WrappingKind): MathState;
+export declare function wrapRange(state: MathState, range: MathRange, kind: WrappingKind, fractionSlot?: 'numerator' | 'denominator'): MathState;
 /** Keyboard ranges share drag-selection normalization. Cross a structure as one atom. */
-export declare function extendKeyboardRange(state: MathState, range: MathRange | undefined, key: string): MathRange;
+export declare function extendKeyboardRange(state: MathState, range: MathRange | undefined, key: string, unit?: 'character' | 'token'): MathRange;
+/** Match host-platform word movement without taking AltGr or OS shortcuts. */
+export declare function isTokenNavigationKey(event: {
+    key: string;
+    altKey: boolean;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    isComposing?: boolean;
+}, platform: string): boolean;

package/dist/range.js

@@ -1,3 +1,4 @@
+import { tokenizeMathText } from './tokens.js';
 import { fenceCharacters } from './fences.js';
 import { documentRows, isLiteralText, row, textNode, textNodes, } from './model.js';
 const size = (node) => (node.type === 'text' ? node.text.length : 1);
@@ -353,7 +354,7 @@ export const wrappingKinds = [
     'absolute',
 ];
 /** Wrap one balanced row. Cross-slot ranges expand to their common structure. */
-export function wrapRange(state, range, kind) {
+export function wrapRange(state, range, kind, fractionSlot = 'numerator') {
     if (isLiteralText(state.document, range.anchor.id))
         return state;
     const fragment = copyRange(state.document, range);
@@ -367,7 +368,8 @@ export function wrapRange(state, range, kind) {
             : ['parentheses', 'brackets', 'absolute', 'root', 'matrix'].includes(meaningful[0].type));
     if (kind === 'superscript' && !grouped)
         content = normalize([{ type: 'parentheses', id: row().id, slots: [content] }]);
-    const slots = ['indexedRoot', 'overset', 'underset', 'overbrace', 'underbrace'].includes(kind)
+    const denominator = kind === 'fraction' && fractionSlot === 'denominator';
+    const slots = denominator || ['indexedRoot', 'overset', 'underset', 'overbrace', 'underbrace'].includes(kind)
         ? [row(), content]
         : ['fraction', 'binomial', 'superscript', 'subscript'].includes(kind)
             ? [content, row()]
@@ -390,11 +392,14 @@ export function wrapRange(state, range, kind) {
     const wrapper = location?.row.children[location.index - 1];
     if (!wrapper || wrapper.type === 'text')
         return next;
-    const target = wrapper.slots[['indexedRoot', 'overset', 'underset', 'overbrace', 'underbrace'].includes(kind) ? 0 : 1].children[0];
+    const target = wrapper.slots[denominator ||
+        ['indexedRoot', 'overset', 'underset', 'overbrace', 'underbrace'].includes(kind)
+        ? 0
+        : 1].children[0];
     return { ...next, caret: { id: target.id, start: 0, end: 0 } };
 }
 /** Keyboard ranges share drag-selection normalization. Cross a structure as one atom. */
-export function extendKeyboardRange(state, range, key) {
+export function extendKeyboardRange(state, range, key, unit = 'character') {
     const anchor = range?.anchor ?? { id: state.caret.id, offset: state.caret.start };
     const point = range?.focus ?? { id: state.caret.id, offset: state.caret.end };
     const at = address(state.document, point);
@@ -414,11 +419,20 @@ export function extendKeyboardRange(state, range, key) {
     const node = local.row.children[local.index];
     if (node.type !== 'text')
         return { anchor, focus: point };
+    if (unit === 'token') {
+        const tokens = tokenizeMathText(node.text).filter((token) => token.kind !== 'space');
+        const token = direction < 0
+            ? tokens.reverse().find((token) => token.start < point.offset)
+            : tokens.find((token) => token.end > point.offset);
+        if (token)
+            return { anchor, focus: { id: point.id, offset: direction < 0 ? token.start : token.end } };
+        // Skip remaining whitespace before crossing a structure or leaving this slot.
+    }
     const chars = direction < 0
         ? Array.from(node.text.slice(0, point.offset))
         : Array.from(node.text.slice(point.offset));
     const char = direction < 0 ? chars.at(-1) : chars[0];
-    if (char)
+    if (char && unit === 'character')
         return { anchor, focus: { id: point.id, offset: point.offset + direction * char.length } };
     // A sibling structure is skipped intact; leaving a nested slot selects its enclosing structure.
     for (let depth = at.path.length - 1; depth >= 0; depth--) {
@@ -434,8 +448,19 @@ export function extendKeyboardRange(state, range, key) {
     }
     const line = documentRows(state.document)[at.line + direction];
     if (!line)
-        return { anchor, focus: point };
+        return {
+            anchor,
+            focus: unit === 'token' ? { id: point.id, offset: direction < 0 ? 0 : node.text.length } : point,
+        };
     const nodes = textNodes({ version: 1, root: line });
     const target = direction < 0 ? nodes.at(-1) : nodes[0];
     return { anchor, focus: { id: target.id, offset: direction < 0 ? target.text.length : 0 } };
 }
+/** Match host-platform word movement without taking AltGr or OS shortcuts. */
+export function isTokenNavigationKey(event, platform) {
+    if (event.isComposing || event.metaKey || !['ArrowLeft', 'ArrowRight'].includes(event.key))
+        return false;
+    return /Mac|iPhone|iPad|iPod/.test(platform)
+        ? event.altKey && !event.ctrlKey
+        : event.ctrlKey && !event.altKey;
+}

package/dist/root-transform.d.ts

@@ -0,0 +1,19 @@
+import { type MathState, type MathStructure } from './model.js';
+/** Use the nearest enclosing radical, including from one of its nested slots. */
+export declare function activeRoot(state: MathState): MathStructure | undefined;
+/** An explicit non-square index cannot be discarded by a presentation change. */
+export declare function canUseSquareRoot(root: MathStructure): boolean;
+/** Preserve the radicand's entire tree and IDs, and focus the newly editable index. */
+export declare function transformRoot(state: MathState, targetId: string, kind: 'root' | 'indexedRoot'): MathState;
+/** Footer context is independent of the typed query and suggestion dismissal. */
+export declare function rootEditingContext(state: MathState): {
+    id: string;
+    kind: "root" | "indexedRoot";
+    target: "root" | "indexedRoot";
+    canTransform: boolean;
+    indexCaret: {
+        id: string;
+        start: number;
+        end: number;
+    } | undefined;
+} | undefined;

package/dist/root-transform.js

@@ -0,0 +1,69 @@
+import { documentRows, isLiteralText, row, textNodes, } from './model.js';
+/** Use the nearest enclosing radical, including from one of its nested slots. */
+export function activeRoot(state) {
+    if (isLiteralText(state.document, state.caret.id))
+        return;
+    const visit = (line, parent) => {
+        for (const node of line.children) {
+            if (node.type === 'text') {
+                if (node.id === state.caret.id)
+                    return parent;
+            }
+            else {
+                for (const slot of node.slots) {
+                    const found = visit(slot, ['root', 'indexedRoot'].includes(node.type) ? node : parent);
+                    if (found)
+                        return found;
+                }
+            }
+        }
+    };
+    for (const line of documentRows(state.document)) {
+        const found = visit(line);
+        if (found)
+            return found;
+    }
+}
+/** An explicit non-square index cannot be discarded by a presentation change. */
+export function canUseSquareRoot(root) {
+    if (root.type !== 'indexedRoot')
+        return false;
+    const index = root.slots[0];
+    if (index.children.some((node) => node.type !== 'text'))
+        return false;
+    const value = index.children
+        .map((node) => (node.type === 'text' ? node.text : ''))
+        .join('')
+        .trim();
+    return value === '' || value === '2';
+}
+/** Preserve the radicand's entire tree and IDs, and focus the newly editable index. */
+export function transformRoot(state, targetId, kind) {
+    const current = activeRoot(state);
+    if (!current || current.id !== targetId || current.type === kind)
+        return state;
+    if (kind === 'root' && !canUseSquareRoot(current))
+        return state;
+    const next = { ...state, document: structuredClone(state.document) };
+    const root = activeRoot(next);
+    const radicand = root.slots[root.type === 'root' ? 0 : 1];
+    root.type = kind;
+    // Start at 2 to retain the formula's meaning; select it so typing n replaces it.
+    root.slots = kind === 'indexedRoot' ? [row('2'), radicand] : [radicand];
+    const first = textNodes({ version: 1, root: root.slots[0] })[0];
+    return { ...next, caret: { id: first.id, start: 0, end: kind === 'indexedRoot' ? 1 : 0 } };
+}
+/** Footer context is independent of the typed query and suggestion dismissal. */
+export function rootEditingContext(state) {
+    const root = activeRoot(state);
+    if (!root)
+        return;
+    const index = root.type === 'indexedRoot' ? textNodes({ version: 1, root: root.slots[0] })[0] : undefined;
+    return {
+        id: root.id,
+        kind: root.type,
+        target: root.type === 'root' ? 'indexedRoot' : 'root',
+        canTransform: root.type === 'root' || canUseSquareRoot(root),
+        indexCaret: index ? { id: index.id, start: 0, end: index.text.length } : undefined,
+    };
+}

package/dist/selection-shortcuts.d.ts

@@ -0,0 +1,13 @@
+import type { MathState } from './model.js';
+import { type MathRange } from './range.js';
+/** A typed opening symbol wraps a selection before ordinary replacement runs.
+ * Shift is allowed because several symbols require it on common keyboards.
+ * Returning the original state consumes unsupported multi-line wrapping safely.
+ */
+export declare function wrapSelectionShortcut(state: MathState, range: MathRange | undefined, event: {
+    key: string;
+    ctrlKey?: boolean;
+    metaKey?: boolean;
+    altKey?: boolean;
+    isComposing?: boolean;
+}): MathState | undefined;

package/dist/selection-shortcuts.js

@@ -0,0 +1,35 @@
+import { isLiteralText } from './model.js';
+import { wrapRange } from './range.js';
+const wrappers = {
+    '(': 'parentheses',
+    '[': 'brackets',
+    '{': 'braces',
+    '|': 'absolute',
+    '/': 'fraction',
+    '^': 'superscript',
+    _: 'subscript',
+};
+/** A typed opening symbol wraps a selection before ordinary replacement runs.
+ * Shift is allowed because several symbols require it on common keyboards.
+ * Returning the original state consumes unsupported multi-line wrapping safely.
+ */
+export function wrapSelectionShortcut(state, range, event) {
+    if (event.ctrlKey || event.metaKey || event.altKey || event.isComposing)
+        return;
+    const kind = wrappers[event.key];
+    if (!kind)
+        return;
+    const selection = range ??
+        (state.caret.start !== state.caret.end
+            ? {
+                anchor: { id: state.caret.id, offset: state.caret.start },
+                focus: { id: state.caret.id, offset: state.caret.end },
+            }
+            : undefined);
+    if (!selection ||
+        (selection.anchor.id === selection.focus.id &&
+            selection.anchor.offset === selection.focus.offset) ||
+        isLiteralText(state.document, selection.anchor.id))
+        return;
+    return wrapRange(state, selection, kind);
+}

package/dist/session.d.ts

@@ -24,6 +24,7 @@ export type MathCommand = {
 } | {
     type: 'structure';
     kind: StructureKind;
+    fractionSlot?: 'numerator' | 'denominator';
 } | {
     type: 'template';
     id: string;

package/dist/session.js

@@ -215,7 +215,7 @@ export function createMathSession(options = {}) {
                 return mode === 'inline' ? false : apply(splitLine(state));
             if (range)
                 return (wrappingKinds.includes(command.kind) &&
-                    apply(wrapRange(state, range, command.kind)));
+                    apply(wrapRange(state, range, command.kind, command.fractionSlot)));
             return apply(insertStructure(state, command.kind, ['fraction', 'binomial', 'superscript', 'subscript'].includes(command.kind)));
         },
         destroy() {

package/dist/suggestions.d.ts

@@ -1,6 +1,10 @@
 import { type MathLocale, type MathMessageParameters } from './i18n.js';
 import { type MathState, type StructureKind } from './model.js';
 export interface MathSuggestion {
+    /** Convert this enclosing structure without consuming the typed query. */
+    transformRootId?: string;
+    /** Change the current fence without inserting a wrapper or consuming text. */
+    transformFenceId?: string;
     /** Preserve the query as an operand instead of replacing a command name. */
     wrapOperand?: boolean;
     operatorName?: string;
@@ -31,4 +35,9 @@ export declare function findSuggestions(text: string, caret: number, locale?: Ma
     query: string;
     candidates: MathSuggestion[];
 };
+/** Combine text search with changes available for the current formula structure. */
+export declare function findStateSuggestions(state: MathState, locale?: MathLocale, caret?: number): {
+    query: string;
+    candidates: MathSuggestion[];
+};
 export declare function acceptSuggestion(state: MathState, query: string, candidate: MathSuggestion): MathState;

package/dist/suggestions.js

@@ -1,3 +1,6 @@
+import { transformRoot } from './root-transform.js';
+import { structureEditingContext, changeContextFence } from './context-tools.js';
+import { fencePairs } from './fences.js';
 import { mathLocaleAliases, translate, } from './i18n.js';
 import { insertTemplate, mathTemplates } from './templates.js';
 import { activeMatrix, insertIdentityMatrix, insertMatrix, MATRIX_MAX_SIZE } from './matrix.js';
@@ -284,7 +287,57 @@ export function findSuggestions(text, caret, locale = 'ko') {
         })),
     };
 }
+/** Combine text search with changes available for the current formula structure. */
+export function findStateSuggestions(state, locale = 'ko', caret = state.caret.start) {
+    const text = textNodes(state.document).find((node) => node.id === state.caret.id)?.text ?? '';
+    const result = findSuggestions(text, caret, locale);
+    const context = structureEditingContext(state);
+    const root = context?.root;
+    const kind = root?.canTransform ? root.target : undefined;
+    if (root && kind) {
+        const item = mathStructures.find((entry) => entry.kind === kind);
+        result.candidates.push({
+            ...item,
+            id: `transform-${kind}`,
+            transformRootId: root.id,
+            label: translate(locale, 'suggestion.transform', {
+                kind: translate(locale, `context.${kind}`),
+            }),
+            detail: translate(locale, 'suggestion.transformRootDetail'),
+        });
+    }
+    if (context?.fence) {
+        const fence = context.fence;
+        const changes = Object.keys(fencePairs)
+            .filter((kind) => kind !== fence.type)
+            .map((kind) => {
+            const item = mathStructures.find((entry) => entry.kind === kind);
+            return {
+                ...item,
+                id: `transform-fence-${kind}`,
+                transformFenceId: fence.id,
+                label: translate(locale, 'suggestion.transformFence', {
+                    kind: translate(locale, item.label),
+                }),
+                detail: translate(locale, 'suggestion.transformFenceDetail'),
+            };
+        });
+        // Explicit symbol/command matches stay first. Changes precede new wrapping actions.
+        const wrapping = result.candidates.findIndex((item) => item.wrapOperand);
+        result.candidates.splice(wrapping < 0 ? result.candidates.length : wrapping, 0, ...changes);
+    }
+    return result;
+}
 export function acceptSuggestion(state, query, candidate) {
+    if (candidate.transformFenceId)
+        return candidate.kind
+            ? changeContextFence(state, candidate.transformFenceId, candidate.kind)
+            : state;
+    if (candidate.transformRootId) {
+        return candidate.kind === 'root' || candidate.kind === 'indexedRoot'
+            ? transformRoot(state, candidate.transformRootId, candidate.kind)
+            : state;
+    }
     const node = textNodes(state.document).find((n) => n.id === state.caret.id);
     const start = state.caret.start - query.length;
     if (!node || start < 0 || node.text.slice(start, state.caret.start) !== query)