@barocss/math-editor 0.2.1 → 0.4.0

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

@@ -79,4 +79,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

@@ -512,4 +512,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);
+            };
+        },
+    };
+}

package/dist/presentation-controls.d.ts

@@ -0,0 +1,10 @@
+import type { MathState, StructureKind } from './model.js';
+import type { MathPresentationChange } from './presentation.js';
+import type { MathLocale } from './i18n.js';
+export declare function PresentationControls(props: {
+    state: MathState;
+    locale: MathLocale;
+    disabled: boolean;
+    kinds?: readonly StructureKind[];
+    onChange(id: string, change: MathPresentationChange): void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/presentation-controls.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useLayoutEffect, useRef } from 'react';
+import { drawPresentationControls } from './dom/presentation-controls.js';
+export function PresentationControls(props) {
+    const host = useRef(null);
+    useLayoutEffect(() => {
+        drawPresentationControls(host.current, props.state, props.locale, props.onChange, props.disabled, props.kinds);
+    });
+    return _jsx("div", { ref: host });
+}

package/dist/presentation.d.ts

@@ -0,0 +1,13 @@
+import { type MathState, type MathStructure, type StructureKind } from './model.js';
+export type MathPresentationChange = {
+    fence: string;
+} | {
+    mathStyle: 'default' | 'display' | 'text';
+} | {
+    limits: 'default' | 'above-below' | 'side';
+};
+export declare const limitKinds: readonly StructureKind[];
+/** Nearest containing structure with presentation settings. Nested content is never flattened. */
+export declare function activePresentation(state: MathState): MathStructure | undefined;
+/** Change metadata only. Preserve node/slot IDs, contents and the model caret. */
+export declare function setMathPresentation(state: MathState, id: string, change: MathPresentationChange): MathState;

package/dist/presentation.js

@@ -0,0 +1,86 @@
+import { documentRows, isGrid, } from './model.js';
+import { fencePairs, fences } from './fences.js';
+export const limitKinds = [
+    'sum',
+    'product',
+    'integral',
+    'doubleIntegral',
+    'tripleIntegral',
+    'contourIntegral',
+    'limit',
+    'limsup',
+    'liminf',
+];
+const editable = (node) => !!fences(node) || ['fraction', 'binomial'].includes(node.type) || limitKinds.includes(node.type);
+/** Nearest containing structure with presentation settings. Nested content is never flattened. */
+export function activePresentation(state) {
+    const visit = (row) => {
+        for (const node of row.children) {
+            if (node.type === 'text') {
+                if (node.id === state.caret.id)
+                    return { contains: true };
+            }
+            else
+                for (const slot of node.slots) {
+                    const child = visit(slot);
+                    if (child.contains)
+                        return { contains: true, target: child.target ?? (editable(node) ? node : undefined) };
+                }
+        }
+        return { contains: false };
+    };
+    for (const row of documentRows(state.document)) {
+        const result = visit(row);
+        if (result.contains)
+            return result.target;
+    }
+}
+/** Change metadata only. Preserve node/slot IDs, contents and the model caret. */
+export function setMathPresentation(state, id, change) {
+    const document = structuredClone(state.document);
+    const find = (row) => {
+        for (const node of row.children)
+            if (node.type !== 'text') {
+                if (node.id === id)
+                    return node;
+                for (const slot of node.slots) {
+                    const found = find(slot);
+                    if (found)
+                        return found;
+                }
+            }
+    };
+    const node = documentRows(document).map(find).find(Boolean);
+    if (!node || isGrid(node))
+        return state;
+    if ('fence' in change) {
+        if (!fences(node) || !Object.hasOwn(fencePairs, change.fence))
+            return state;
+        node.type = change.fence;
+        delete node.left;
+        delete node.right;
+    }
+    else if ('mathStyle' in change) {
+        if (!['fraction', 'binomial'].includes(node.type) ||
+            !['default', 'display', 'text'].includes(change.mathStyle))
+            return state;
+        if (change.mathStyle === 'default')
+            delete node.mathStyle;
+        else
+            node.mathStyle = change.mathStyle;
+    }
+    else if ('limits' in change) {
+        if (!limitKinds.includes(node.type) ||
+            !['default', 'above-below', 'side'].includes(change.limits))
+            return state;
+        if (change.limits === 'default')
+            delete node.limits;
+        else
+            node.limits = change.limits === 'above-below';
+    }
+    else
+        return state;
+    return JSON.stringify(document) === JSON.stringify(state.document)
+        ? state
+        : { document, caret: { ...state.caret } };
+}

package/dist/quick-panel.d.ts

@@ -0,0 +1,2 @@
+import { mountQuickPanel } from './dom/quick-panel.js';
+export declare function QuickPanel(props: Parameters<typeof mountQuickPanel>[1]): import("react/jsx-runtime").JSX.Element;

package/dist/quick-panel.js

@@ -0,0 +1,17 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useLayoutEffect, useRef } from 'react';
+import { mountQuickPanel } from './dom/quick-panel.js';
+export function QuickPanel(props) {
+    const host = useRef(null);
+    const current = useRef(props);
+    current.current = props;
+    useLayoutEffect(() => {
+        const panel = mountQuickPanel(host.current, {
+            ...props,
+            onInsert: (item) => current.current.onInsert(item),
+            onClose: () => current.current.onClose(),
+        });
+        return () => panel.destroy();
+    }, [props.locale, props.preferences, props.allowedTemplates?.join(',')]);
+    return _jsx("div", { ref: host });
+}

package/dist/range.d.ts

@@ -11,6 +11,8 @@ export interface MathFragment {
     version: 1;
     rows: MathRow[];
 }
+/** Plain arrows leave a model selection at its document-ordered edge. */
+export declare function collapseKeyboardRange(document: MathDocument, range: MathRange | undefined, key: string): MathPoint | undefined;
 export declare function resolveRange(document: MathDocument, range: MathRange): {
     row: MathRow;
     start: number;
@@ -29,4 +31,3 @@ export type WrappingKind = (typeof wrappingKinds)[number];
 export declare function wrapRange(state: MathState, range: MathRange, kind: WrappingKind): 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;
-//# sourceMappingURL=range.d.ts.map

package/dist/range.js

@@ -33,6 +33,17 @@ function ordered(document, range) {
         ? { a: b, b: a, start: range.focus, end: range.anchor }
         : { a, b, start: range.anchor, end: range.focus };
 }
+/** Plain arrows leave a model selection at its document-ordered edge. */
+export function collapseKeyboardRange(document, range, key) {
+    if (!range || !['ArrowLeft', 'ArrowRight', 'ArrowUp', 'ArrowDown'].includes(key))
+        return;
+    const bounds = ordered(document, range);
+    if (!bounds)
+        return;
+    const point = key === 'ArrowLeft' || key === 'ArrowUp' ? bounds.start : bounds.end;
+    const node = textNodes(document).find((node) => node.id === point.id);
+    return { id: point.id, offset: Math.max(0, Math.min(point.offset, node.text.length)) };
+}
 function offset(p, depth, point, end) {
     const at = p[depth], base = at.row.children.slice(0, at.index).reduce((n, node) => n + size(node), 0);
     return (base +
@@ -428,4 +439,3 @@ export function extendKeyboardRange(state, range, key) {
     const target = direction < 0 ? nodes.at(-1) : nodes[0];
     return { anchor, focus: { id: target.id, offset: direction < 0 ? target.text.length : 0 } };
 }
-//# sourceMappingURL=range.js.map

package/dist/react.d.ts

@@ -8,4 +8,3 @@ export declare function MathEditorSurface(props: DOMMathEditorOptions & {
     ref: import("react").RefObject<HTMLSpanElement | null>;
     className: string | undefined;
 }, HTMLSpanElement>;
-//# sourceMappingURL=react.d.ts.map

package/dist/react.js

@@ -17,4 +17,3 @@ export function MathEditorSurface(props) {
     });
     return createElement('span', { ref: host, className: props.className });
 }
-//# sourceMappingURL=react.js.map