vue3-math-editor 0.1.0 → 0.2.0

package/LICENSE

@@ -0,0 +1,14 @@
+
+   Copyright 2026 University of Auckland
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -91,3 +91,7 @@ yarn test:e2e     # browser tests (Playwright)
 ```sh
 yarn lint
 ```
+
+## License
+
+[Apache-2.0](LICENSE)

package/dist/style.css

@@ -0,0 +1,2 @@
+.math-field[data-v-12da93b7]{font-size:var(--me-line-font-size,1.05rem);cursor:text;border-radius:6px;outline:none;align-items:center;min-height:2.6rem;padding:.45rem .7rem;display:flex;position:relative;overflow-x:auto}.math-field.focused[data-v-12da93b7]{box-shadow:0 0 0 2px #2563eb59}.math-content[data-v-12da93b7]{z-index:1;min-width:0;position:relative}.selection[data-v-12da93b7]{z-index:0;pointer-events:none;background:#94a3b84d;border-radius:3px;position:absolute}.row-tint[data-v-12da93b7]{z-index:0;pointer-events:none;background:#2563eb12;border-radius:3px;position:absolute;box-shadow:inset 0 0 0 1px #2563eb2e}.math-field.focused .selection[data-v-12da93b7]{background:#2563eb33}.mark[data-v-12da93b7]{z-index:0;pointer-events:none;background:url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='6' height='3'%3E%3Cpath d='M0 2.5 L1.5 0.5 L3 2.5 L4.5 0.5 L6 2.5' fill='none' stroke='%23dc2626' stroke-width='1'/%3E%3C/svg%3E") 0 100%/6px 3px repeat-x,#dc262614;border-radius:2px;position:absolute}.mark-units[data-v-12da93b7]{background:url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='6' height='3'%3E%3Cpath d='M0 2.5 L1.5 0.5 L3 2.5 L4.5 0.5 L6 2.5' fill='none' stroke='%23d97706' stroke-width='1'/%3E%3C/svg%3E") 0 100%/6px 3px repeat-x,#d977061a}.math-field[data-v-12da93b7] .me-units{color:#60a5fa}.math-field[data-v-12da93b7] .me-ph.me-units-ph{color:#60a5fa;border:1px dashed #60a5fa;border-radius:3px;padding:0 .15em}.math-field.focused[data-v-12da93b7] .me-units-ph.me-ph-active{color:#3b82f6;background:#60a5fa1f}.math-field[data-v-12da93b7] .me-units-flag{width:0;height:0;display:inline-block;position:relative}.math-field[data-v-12da93b7] .me-units-flag:after{content:"";border-top:.22em solid #60a5fa;border-left:.22em solid #0000;position:absolute;bottom:.52em;right:-.05em}.mark-tip[data-v-12da93b7]{z-index:10;color:#f8fafc;white-space:normal;pointer-events:none;background:#1e293b;border-radius:.35rem;width:max-content;max-width:24rem;padding:.25rem .5rem;font-size:.75rem;line-height:1.3;position:fixed}.caret[data-v-12da93b7]{z-index:2;pointer-events:none;background:#2563eb;width:2px;margin-left:-1px;animation:1.1s step-end infinite math-field-blink-12da93b7;position:absolute}.math-field[data-v-12da93b7] .katex-display{text-align:left;margin:0}.math-field[data-v-12da93b7] .katex-display>.katex{text-align:left}.math-field[data-v-12da93b7] .me-ph{color:#94a3b8}.math-field.focused[data-v-12da93b7] .me-ph-active{color:#2563eb;background:#2563eb1f;border-radius:2px}@keyframes math-field-blink-12da93b7{50%{opacity:0}}.editor-grid[data-v-5c897b39],.gallery[data-v-5c897b39]{--me-accent:var(--math-editor-accent,#2563eb);--me-surface:var(--p-content-background,#fff);--me-subtle:var(--p-content-hover-background,#f1f5f9);--me-border:var(--p-content-border-color,#e2e8f0);--me-border-strong:var(--p-form-field-border-color,#cbd5e1);--me-text:var(--p-text-color,#0f172a);--me-muted:var(--p-text-muted-color,#64748b);--me-warn:#d97706;--me-caution:#ea580c;--me-danger:#dc2626;outline:none;grid-template-columns:minmax(0,1.35fr) minmax(0,1fr);grid-template-areas:"editor outputs";align-items:start;gap:1rem;max-width:1240px;margin:0 auto;display:grid}.editor-grid.has-side[data-v-5c897b39]{grid-template-rows:auto 1fr;grid-template-areas:"editor side""outputs side"}.editor-grid.no-outputs[data-v-5c897b39]{grid-template-columns:minmax(0,1fr);grid-template-areas:"editor"}.editor-grid.no-outputs.has-side[data-v-5c897b39]{grid-template:"editor side"/minmax(0,1.35fr) minmax(0,1fr)}.editor-panel[data-v-5c897b39]{border:1px solid var(--me-border);background:var(--me-surface);min-width:0;color:var(--me-text);border-radius:.75rem;grid-area:editor;padding:0 1rem .85rem}.output-card[data-v-5c897b39]{grid-area:outputs;min-width:0}.side-column[data-v-5c897b39]{grid-area:side;align-self:start;min-width:0;position:sticky;top:1rem}.toolbar[data-v-5c897b39]{top:var(--me-toolbar-top,0);z-index:2;border-bottom:1px solid var(--me-border);background:var(--me-surface);flex-wrap:wrap;align-items:center;gap:.35rem .75rem;margin:0 0 .6rem;padding:.5rem 0;display:flex;position:sticky}.toolbar-group[data-v-5c897b39]{flex-wrap:wrap;align-items:center;gap:.25rem;display:flex}.toolbar-lines[data-v-5c897b39] .p-button{width:2rem;height:2rem;padding:0}.tool-button[data-v-5c897b39]{border:1px solid var(--me-border-strong);background:var(--me-surface);min-width:2rem;height:2rem;color:var(--me-text);cursor:pointer;border-radius:.45rem;justify-content:center;align-items:center;padding:0 .35rem;font-size:.72rem;transition:border-color .12s,background .12s,box-shadow .12s;display:inline-flex}.tool-button[data-v-5c897b39]:disabled{opacity:.45;cursor:default}.tool-chevron[data-v-5c897b39]{color:var(--me-muted);margin-left:.2rem;font-size:.55rem}.tool-button[data-v-5c897b39]:hover:not(:disabled){border-color:var(--me-accent);background:color-mix(in srgb, var(--me-accent) 8%, var(--me-surface))}.tool-button[data-v-5c897b39]:active{box-shadow:inset 0 1px 3px #0f172a26}.gallery[data-v-5c897b39]{flex-direction:column;gap:.5rem;max-width:22rem;display:flex}.gallery-label[data-v-5c897b39]{color:var(--me-muted);margin-bottom:.25rem;font-size:.72rem}.gallery-items[data-v-5c897b39]{flex-wrap:wrap;gap:.25rem;display:flex}.gallery .tool-button[data-v-5c897b39]{min-width:2.4rem;font-size:.8rem}.equations-stack[data-v-5c897b39]{flex-direction:column;gap:.6rem;display:flex}.equation-row[data-v-5c897b39]{border:1px solid var(--me-border);background:var(--me-surface);color:var(--me-text);border-radius:.65rem;align-items:stretch;gap:.5rem;transition:border-color .12s,box-shadow .12s;display:flex}.equation-row.active[data-v-5c897b39]{border-color:var(--me-accent);box-shadow:0 0 0 3px color-mix(in srgb, var(--me-accent) 12%, transparent)}.equation-row.has-error[data-v-5c897b39]{border-color:var(--me-danger)}.equation-row.has-units-issue[data-v-5c897b39]{border-color:var(--me-warn)}.equation-row.active.has-error[data-v-5c897b39]{box-shadow:0 0 0 3px color-mix(in srgb, var(--me-danger) 14%, transparent)}.equation-row.active.has-units-issue[data-v-5c897b39]{box-shadow:0 0 0 3px color-mix(in srgb, var(--me-warn) 16%, transparent)}.equation-label[data-v-5c897b39]{color:var(--me-muted);font-variant-numeric:tabular-nums;border-right:1px solid var(--me-border);align-items:center;padding:0 .4rem 0 .65rem;font-size:.75rem;display:flex}.equation-field[data-v-5c897b39]{flex:1;min-width:0}.equation-field.focused[data-v-5c897b39]{box-shadow:none}.status-bar[data-v-5c897b39]{white-space:nowrap;border-radius:.45rem;align-items:center;gap:.5rem;height:1.75rem;margin-top:.5rem;padding:0 .6rem;font-size:.8rem;display:flex;overflow:hidden}.status-text[data-v-5c897b39]{text-overflow:ellipsis;min-width:0;overflow:hidden}.status-more[data-v-5c897b39]{opacity:.75;flex:none}.status-error[data-v-5c897b39],.status-units[data-v-5c897b39]{cursor:pointer}.status-error[data-v-5c897b39]{background:color-mix(in srgb, var(--me-danger) 12%, var(--me-surface));color:color-mix(in srgb, var(--me-danger) 55%, var(--me-text))}.status-units[data-v-5c897b39]{background:color-mix(in srgb, var(--me-caution) 14%, var(--me-surface));color:color-mix(in srgb, var(--me-caution) 55%, var(--me-text))}.status-info[data-v-5c897b39]{background:color-mix(in srgb, var(--me-accent) 8%, var(--me-surface));color:color-mix(in srgb, var(--me-accent) 45%, var(--me-text))}.status-command[data-v-5c897b39]{padding:0}.command-chip[data-v-5c897b39]{color:#e2e8f0;background:#0f172a;border-radius:.45rem;align-items:center;height:100%;padding:0 .6rem;font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,Liberation Mono,monospace;font-size:.9rem;display:inline-flex}.command-slash[data-v-5c897b39]{color:#7dd3fc}.command-caret[data-v-5c897b39]{background:#e2e8f0;width:2px;height:1em;margin-left:2px;animation:1s step-end infinite chip-blink-5c897b39}@keyframes chip-blink-5c897b39{50%{opacity:0}}.focus-meta[data-v-5c897b39]{color:var(--me-muted);margin:.75rem 0 0;font-size:.8rem}.output-actions[data-v-5c897b39]{justify-content:flex-end;margin-bottom:.25rem;display:flex}.tab-tag[data-v-5c897b39]{margin-left:.4rem;padding:.05rem .35rem;font-size:.7rem}.key-help[data-v-5c897b39]{margin-top:.75rem}.key-help summary[data-v-5c897b39]{cursor:pointer;width:fit-content;color:var(--me-muted);font-size:.85rem}.key-hint[data-v-5c897b39]{color:var(--me-muted);margin:.5rem 0 0;font-size:.8rem;line-height:1.5}.key-hint kbd[data-v-5c897b39]{border:1px solid var(--me-border-strong);background:var(--me-subtle);border-bottom-width:2px;border-radius:.3rem;margin:0 .08rem;padding:0 .3rem;font-family:inherit;font-size:.72rem;display:inline-block}.key-hint code[data-v-5c897b39]{background:var(--me-subtle);border-radius:.25rem;padding:.05rem .3rem}.output-card pre[data-v-5c897b39]{color:#e2e8f0;background:#0f172a;border-radius:.55rem;max-height:28rem;margin:0;padding:.85rem;font-size:.83rem;line-height:1.35;overflow:auto}@media (width<=900px){.editor-grid[data-v-5c897b39],.editor-grid.has-side[data-v-5c897b39],.editor-grid.no-outputs.has-side[data-v-5c897b39]{grid-template-rows:none;grid-template-columns:minmax(0,1fr);grid-template-areas:"editor""side""outputs"}.side-column[data-v-5c897b39]{position:static}}.units-form[data-v-effe158e]{background:#f8fbff;border:1px solid #bfdbfe;border-radius:.5rem;margin-top:.5rem;padding:.6rem}.form-name[data-v-effe158e]{color:#334155;align-items:center;gap:.5rem;font-size:.85rem;display:flex}.form-name input[data-v-effe158e]{flex:1}input[data-v-effe158e],select[data-v-effe158e]{font:inherit;background:#fff;border:1px solid #cbd5e1;border-radius:.3rem;min-width:0;padding:.2rem .35rem;font-size:.85rem}input[data-v-effe158e]:focus,select[data-v-effe158e]:focus{outline-offset:0;border-color:#60a5fa;outline:2px solid #93c5fd}.form-parts[data-v-effe158e]{border-collapse:collapse;width:100%;margin-top:.5rem}.form-parts th[data-v-effe158e]{color:#64748b;text-align:left;padding:0 .25rem .15rem 0;font-size:.72rem;font-weight:600}.form-parts td[data-v-effe158e]{padding:.1rem .25rem .1rem 0}.form-parts td input[data-v-effe158e],.form-parts td select[data-v-effe158e]{width:100%}.form-parts .number[data-v-effe158e]{width:4.5rem}.form-problems[data-v-effe158e]{color:#b91c1c;margin:.4rem 0 0;padding-left:1.1rem;font-size:.82rem}.form-actions[data-v-effe158e]{align-items:center;gap:.25rem;margin-top:.4rem;display:flex}.spacer[data-v-effe158e]{flex:1}.visually-hidden[data-v-effe158e]{clip:rect(0 0 0 0);width:1px;height:1px;position:absolute;overflow:hidden}.units-title[data-v-ada663af]{justify-content:space-between;align-items:center;gap:.75rem;display:flex}.units-section+.units-section[data-v-ada663af]{margin-top:1.25rem}.section-head[data-v-ada663af]{flex-wrap:wrap;justify-content:space-between;align-items:center;gap:.5rem;display:flex}.section-head h3[data-v-ada663af]{color:#0f172a;margin:0;font-size:.95rem;font-weight:600}.section-actions[data-v-ada663af]{align-items:center;gap:.25rem;display:flex}.hint[data-v-ada663af]{color:#64748b;margin:.4rem 0 0;font-size:.875rem}.files[data-v-ada663af]{gap:.5rem;margin:.5rem 0 0;padding:0;list-style:none;display:grid}.files>li[data-v-ada663af]{background:#fff;border:1px solid #e2e8f0;border-radius:.5rem;padding:.4rem .6rem}.file-head[data-v-ada663af]{align-items:center;gap:.5rem;display:flex}.file-name[data-v-ada663af]{color:#0f172a;overflow-wrap:anywhere;font-weight:600}.file-count[data-v-ada663af]{color:#64748b;flex:1;font-size:.8rem}.units-names[data-v-ada663af]{flex-wrap:wrap;gap:.25rem;margin-top:.25rem;display:flex}.units-names code[data-v-ada663af]{color:#334155;background:#f1f5f9;border-radius:.25rem;padding:.05rem .35rem;font-size:.78rem}.problems[data-v-ada663af]{color:#92400e;margin:.4rem 0 .1rem;padding-left:1.1rem;font-size:.82rem}.new-units[data-v-ada663af]{gap:.25rem;margin:.5rem 0 0;padding:0;list-style:none;display:grid}.new-units-row[data-v-ada663af]{align-items:center;gap:.4rem;display:flex}.new-units-name[data-v-ada663af]{color:#1d4ed8;background:#eff6ff;border-radius:.25rem;padding:.05rem .35rem;font-size:.85rem}.new-units-definition[data-v-ada663af]{color:#334155;overflow-wrap:anywhere;flex:1;font-size:.85rem}.missing-count[data-v-ada663af]{color:#b45309;font-size:.82rem}.variables[data-v-ada663af]{border-collapse:collapse;width:100%;margin-top:.5rem}.variables th[data-v-ada663af],.variables td[data-v-ada663af]{text-align:left;vertical-align:middle;padding:.2rem .5rem .2rem 0}.variables th[data-v-ada663af]{width:1%;padding-right:1rem}.variables td[data-v-ada663af]:nth-child(2){width:16rem}.variable-name[data-v-ada663af]{white-space:nowrap;color:#0f172a;font-family:KaTeX_Math,Times New Roman,serif;font-size:1.05rem;font-style:italic;font-weight:400}.units-input[data-v-ada663af]{width:100%;min-width:8rem;max-width:16rem;font:inherit;background:#fff;border:1px solid #cbd5e1;border-radius:.375rem;padding:.25rem .45rem;font-size:.9rem}.units-input[data-v-ada663af]:focus{outline-offset:0;border-color:#60a5fa;outline:2px solid #93c5fd}.state-missing .units-input[data-v-ada663af],.state-unknown .units-input[data-v-ada663af]{background:#fffbeb;border-color:#f59e0b}.variable-state[data-v-ada663af]{white-space:nowrap;color:#b45309;font-size:.8rem}.unused .variable-name[data-v-ada663af],.unused .variable-state[data-v-ada663af]{color:#94a3b8}
+/*$vite$:1*/

package/dist/types/components/EquationWorkbench.vue.d.ts

@@ -0,0 +1,49 @@
+import { type EquationLine, type EquationsChangeInfo, type LineCommitInfo, type UnitsIssue, type VariableUnits } from '../editor/units';
+import { type MathMLImport } from '../editor/mathmlImport';
+type __VLS_Props = {
+    cellml?: boolean;
+    issues?: readonly UnitsIssue[];
+    variableUnits?: VariableUnits;
+    greekNames?: boolean;
+    outputs?: boolean;
+    history?: boolean;
+    validate?: 'input' | 'commit';
+    readonly?: boolean;
+    autofocus?: boolean;
+    debug?: boolean;
+};
+declare function focusActive(): void;
+declare function setMathML(xml: string): MathMLImport;
+declare var __VLS_65: {};
+type __VLS_Slots = {} & {
+    side?: (props: typeof __VLS_65) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
+    setMathML: typeof setMathML;
+    focus: typeof focusActive;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "equations-change": (lines: EquationLine[], info: EquationsChangeInfo) => any;
+    "line-commit": (line: EquationLine, info: LineCommitInfo) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onEquations-change"?: ((lines: EquationLine[], info: EquationsChangeInfo) => any) | undefined;
+    "onLine-commit"?: ((line: EquationLine, info: LineCommitInfo) => any) | undefined;
+}>, {
+    autofocus: boolean;
+    readonly: boolean;
+    history: boolean;
+    cellml: boolean;
+    greekNames: boolean;
+    issues: readonly UnitsIssue[];
+    variableUnits: VariableUnits;
+    outputs: boolean;
+    validate: "input" | "commit";
+    debug: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/components/MathField.vue.d.ts

@@ -0,0 +1,39 @@
+import { type EditorState } from '../editor/commands';
+import { type Cursor } from '../editor/cursor';
+import { type EditInfo } from '../editor/history';
+import { type MathMLImport } from '../editor/mathmlImport';
+import { type Row } from '../editor/layout';
+import { type Mark } from '../editor/marks';
+export interface NavigationState {
+    cursor: Cursor;
+    anchor: Cursor | null;
+}
+export type { Mark, MarkKind } from '../editor/marks';
+type __VLS_Props = {
+    modelValue: Row;
+    cursor: Cursor;
+    anchor?: Cursor | null;
+    active?: boolean;
+    readonly?: boolean;
+    marks?: readonly Mark[];
+    greekNames?: boolean;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
+    focus: () => void | undefined;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    navigate: (state: NavigationState) => any;
+    import: (result: MathMLImport) => any;
+    edit: (state: EditorState, info: EditInfo) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onNavigate?: ((state: NavigationState) => any) | undefined;
+    onImport?: ((result: MathMLImport) => any) | undefined;
+    onEdit?: ((state: EditorState, info: EditInfo) => any) | undefined;
+}>, {
+    anchor: Cursor | null;
+    active: boolean;
+    readonly: boolean;
+    marks: readonly Mark[];
+    greekNames: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/editor/caretGeometry.d.ts

@@ -0,0 +1,38 @@
+import type { Cursor } from './cursor';
+import { type Row, type RowPath } from './layout';
+export interface Bounds {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+}
+export declare function paintedBounds(target: Element): Bounds | null;
+export interface GapGeometry {
+    x: number;
+    top: number;
+    bottom: number;
+    placeholder: boolean;
+}
+export declare function gapGeometry(container: Element, root: Row, path: RowPath, offset: number): GapGeometry | null;
+export interface CaretBox {
+    left: number;
+    top: number;
+    height: number;
+    placeholder: boolean;
+}
+export declare function caretBox(container: HTMLElement, root: Row, cursor: Cursor): CaretBox | null;
+export declare function nearestOffset(container: Element, root: Row, path: RowPath, clientX: number): number;
+export declare function hitTest(container: Element, root: Row, clientX: number, clientY: number): Cursor;
+export interface SelectionBox {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+export declare function selectionBox(container: HTMLElement, root: Row, selection: {
+    path: RowPath;
+    start: number;
+    end: number;
+}): SelectionBox | null;
+export declare function atomsBox(container: HTMLElement, atomIds: readonly string[], pad?: number): SelectionBox | null;
+export declare function rowBox(container: HTMLElement, path: RowPath, padX?: number, padY?: number): SelectionBox | null;

package/dist/types/editor/clipboard.d.ts

@@ -0,0 +1,9 @@
+import { type Row } from './layout';
+export declare const CLIPBOARD_MIME = "application/x-semantic-math+json";
+export declare function serializeAtoms(atoms: Row): string;
+export declare function deserializeAtoms(text: string | null | undefined): Row | null;
+export interface LatexOptions {
+    greekNames?: boolean;
+}
+export declare function rowToLatexSource(row: Row, options?: LatexOptions): string;
+export declare function latexToRow(text: string): Row;

package/dist/types/editor/commands.d.ts

@@ -0,0 +1,37 @@
+import { type Cursor } from './cursor';
+import { type Atom, type BranchName, type Row } from './layout';
+export interface EditorState {
+    root: Row;
+    cursor: Cursor;
+    anchor?: Cursor | null;
+}
+export type Command = (state: EditorState) => EditorState;
+export declare function emptyState(): EditorState;
+export declare const newPiece: Command;
+export declare const addOtherwise: Command;
+export declare function insertAtoms(atoms: Row): Command;
+export declare function insertSymbol(value: string): Command;
+export declare const typeEquals: Command;
+export declare const insertPiecewise: Command;
+export declare function insertStructure(atom: Atom, branch: BranchName): Command;
+export declare const fractionOfSelection: Command;
+export declare const insertFraction: Command;
+export declare const insertSuperscript: Command;
+export declare const openParen: Command;
+export declare const insertUnits: Command;
+export declare function typeSymbol(value: string): Command;
+export declare const closeUnits: Command;
+export declare const insertFloor: Command;
+export declare const insertCeiling: Command;
+export declare const closeParen: Command;
+export declare const absBar: Command;
+export declare const exitStructure: Command;
+export declare const deleteBackward: Command;
+export declare const deleteForward: Command;
+export declare function nextPlaceholder(direction: 'forward' | 'backward'): Command;
+export declare function insertFunction(name: string): Command;
+export declare const insertSquareRoot: Command;
+export declare const insertNthRoot: Command;
+export declare const insertAbs: Command;
+export declare const insertDerivative: Command;
+export declare function namedCommand(name: string): Command;

package/dist/types/editor/constants.d.ts

@@ -0,0 +1,13 @@
+import type { MathJsonValue } from '../renderers/mathjson';
+export interface Constant {
+    symbol: string;
+    latex: string;
+    mathml: string;
+    mathJson: MathJsonValue;
+    commands: readonly string[];
+}
+export declare const CONSTANTS: readonly Constant[];
+export declare const constantForSymbol: (value: string) => Constant | undefined;
+export declare const constantForCommand: (name: string) => Constant | undefined;
+export declare const constantForLatexCommand: (name: string) => string | undefined;
+export declare const constantForUprightText: (text: string) => string | undefined;

package/dist/types/editor/cursor.d.ts

@@ -0,0 +1,16 @@
+import { type Row, type RowPath } from './layout';
+export interface Cursor {
+    path: RowPath;
+    offset: number;
+}
+export declare function cursorAtStart(): Cursor;
+export declare function cursorAtEnd(root: Row): Cursor;
+export declare function cursorsEqual(a: Cursor, b: Cursor): boolean;
+export declare function describeCursor(cursor: Cursor): string;
+export declare function isValidCursor(root: Row, cursor: Cursor): boolean;
+export declare function allPositions(root: Row): Cursor[];
+export declare function moveRight(root: Row, cursor: Cursor): Cursor | null;
+export declare function moveLeft(root: Row, cursor: Cursor): Cursor | null;
+export type PickOffset = (target: Row, targetPath: RowPath, from: Cursor) => number;
+export declare function moveUp(root: Row, cursor: Cursor, pickOffset?: PickOffset): Cursor | null;
+export declare function moveDown(root: Row, cursor: Cursor, pickOffset?: PickOffset): Cursor | null;

package/dist/types/editor/exports.d.ts

@@ -0,0 +1,13 @@
+import { type LatexOptions } from './clipboard';
+import type { Row } from './layout';
+import { type ContentMathMLOptions } from '../renderers/mathml';
+export type ExportFormat = 'latex' | 'mathjson' | 'mathml';
+export declare const EXPORT_FORMATS: ReadonlyArray<{
+    format: ExportFormat;
+    label: string;
+}>;
+export declare const CELLML_NAMESPACE = "http://www.cellml.org/cellml/2.0#";
+export type ExportOptions = ContentMathMLOptions & LatexOptions;
+export declare function exportRow(row: Row, format: ExportFormat, options?: ExportOptions): string;
+export declare function contentMathML(row: Row, options?: ExportOptions): string;
+export declare function formatXml(xml: string, indent?: string): string;

package/dist/types/editor/history.d.ts

@@ -0,0 +1,34 @@
+export interface EditInfo {
+    kind: 'type' | 'deleteBackward' | 'deleteForward' | 'other';
+    text?: string;
+    replacedSelection?: boolean;
+    exponentSign?: boolean;
+}
+export declare const OTHER_EDIT: EditInfo;
+export interface UndoGroup {
+    key: string | null;
+    fresh: boolean;
+}
+export declare function undoGroup(line: number, edit: EditInfo): UndoGroup;
+export interface HistoryOptions {
+    limit?: number;
+    pauseMs?: number;
+    now?: () => number;
+}
+export declare class History<S> {
+    private undoStack;
+    private redoStack;
+    private openGroup;
+    private lastEditAt;
+    private readonly limit;
+    private readonly pauseMs;
+    private readonly now;
+    constructor(options?: HistoryOptions);
+    get canUndo(): boolean;
+    get canRedo(): boolean;
+    checkpoint(snapshot: () => S, group?: UndoGroup): void;
+    clear(): void;
+    breakGroup(): void;
+    undo(current: S): S | null;
+    redo(current: S): S | null;
+}

package/dist/types/editor/identifiers.d.ts

@@ -0,0 +1,33 @@
+import { type Atom, type GroupDelimiter, type PiecewiseAtom, type Row, type UnitsAtom } from './layout';
+import { type NumberRun } from './numbers';
+export declare const GREEK_NAMES: ReadonlySet<string>;
+export declare function functionForSpelling(spelling: string): string | undefined;
+export declare const isGreekAtom: (atom: Atom | undefined) => boolean;
+export declare const startsName: (atom: Atom | undefined) => boolean;
+export declare const continuesName: (atom: Atom | undefined) => boolean;
+export declare function nameEnd(row: Row, start: number): number;
+export declare function reservedConstant(name: string): string | undefined;
+export interface NameRun {
+    start: number;
+    end: number;
+    name: string;
+    functionName: string | null;
+}
+export declare function nameRuns(row: Row): NameRun[];
+export declare function numberRuns(row: Row): NumberRun[];
+export declare const unitsName: (atom: UnitsAtom) => string;
+export declare const DEFAULT_OTHERWISE = "0.0";
+export declare function inheritedOtherwiseUnits(atom: PiecewiseAtom): string | null;
+export declare function nameOccurrences(root: Row, name: string): string[][];
+export interface NumberOccurrence {
+    value: number;
+    atomIds: string[];
+    digitIds: string[];
+    units: string | null;
+    inherited?: boolean;
+}
+export declare function numberOccurrences(root: Row): NumberOccurrence[];
+export declare function bracketFunctionBefore(row: Row, offset: number): {
+    start: number;
+    open: GroupDelimiter;
+} | null;

package/dist/types/editor/keymap.d.ts

@@ -0,0 +1,7 @@
+import { type Command } from './commands';
+export interface KeyLike {
+    key: string;
+    shiftKey?: boolean;
+}
+export declare function typedText(event: KeyLike): string | null;
+export declare function commandForKey(event: KeyLike): Command | null;

package/dist/types/editor/layout.d.ts

@@ -0,0 +1,82 @@
+export type Row = Atom[];
+export type BranchName = 'num' | 'den' | 'sup' | 'index' | 'body' | 'expr' | 'variable' | `value${number}` | `cond${number}` | 'otherwise' | 'units';
+interface AtomBase {
+    id: string;
+}
+export interface SymbolAtom extends AtomBase {
+    kind: 'symbol';
+    value: string;
+}
+export interface FunctionAtom extends AtomBase {
+    kind: 'function';
+    name: string;
+}
+export interface FractionAtom extends AtomBase {
+    kind: 'fraction';
+    num: Row;
+    den: Row;
+}
+export interface SuperscriptAtom extends AtomBase {
+    kind: 'superscript';
+    sup: Row;
+}
+export interface RootAtom extends AtomBase {
+    kind: 'root';
+    index: Row | null;
+    body: Row;
+}
+export type GroupDelimiter = '(' | ')' | '|' | '⌊' | '⌋' | '⌈' | '⌉';
+export declare const CLOSING_DELIMITER: Record<string, GroupDelimiter>;
+export interface GroupAtom extends AtomBase {
+    kind: 'group';
+    open: GroupDelimiter;
+    close: GroupDelimiter;
+    body: Row;
+}
+export interface DerivativeAtom extends AtomBase {
+    kind: 'derivative';
+    expr: Row;
+    variable: Row;
+}
+export interface PiecewiseAtom extends AtomBase {
+    kind: 'piecewise';
+    pieces: Array<{
+        value: Row;
+        condition: Row;
+    }>;
+    otherwise: Row | null;
+}
+export interface UnitsAtom extends AtomBase {
+    kind: 'units';
+    units: Row;
+}
+export type StructureAtom = FractionAtom | SuperscriptAtom | RootAtom | GroupAtom | DerivativeAtom | PiecewiseAtom | UnitsAtom;
+export type Atom = SymbolAtom | FunctionAtom | StructureAtom;
+export interface RowPathSegment {
+    atom: number;
+    branch: BranchName;
+}
+export type RowPath = RowPathSegment[];
+export declare function childRows(atom: Atom): Array<[BranchName, Row]>;
+export declare function piecewiseBranch(branch: BranchName): {
+    part: 'value' | 'cond';
+    piece: number;
+} | {
+    part: 'otherwise';
+} | null;
+export declare function setChildRow<A extends Atom>(atom: A, branch: BranchName, child: Row): A;
+export declare function getChildRow(atom: Atom, branch: BranchName): Row | null;
+export declare function getRow(root: Row, path: RowPath): Row | null;
+export declare function rowPathsEqual(a: RowPath, b: RowPath): boolean;
+export declare function newAtomId(): string;
+export declare function symbol(value: string): SymbolAtom;
+export declare function func(name: string): FunctionAtom;
+export declare function fraction(num?: Row, den?: Row): FractionAtom;
+export declare function superscript(sup?: Row): SuperscriptAtom;
+export declare function root(body?: Row, index?: Row | null): RootAtom;
+export declare function group(body?: Row, open?: GroupDelimiter, close?: GroupDelimiter): GroupAtom;
+export declare function derivative(expr?: Row, variable?: Row): DerivativeAtom;
+export declare function unitsAtom(units?: Row): UnitsAtom;
+export declare function piecewise(pieces?: Array<[value: Row, condition: Row]>, otherwise?: Row | null): PiecewiseAtom;
+export declare function row(...items: Array<string | Atom>): Row;
+export {};

package/dist/types/editor/marks.d.ts

@@ -0,0 +1,8 @@
+export type MarkKind = 'error' | 'units' | 'hint';
+export interface Mark {
+    message: string;
+    atomIds: readonly string[];
+    kind?: MarkKind;
+}
+export declare const markKind: (mark: Mark) => MarkKind;
+export declare const isProblem: (mark: Mark) => boolean;

package/dist/types/editor/mathmlImport.d.ts

@@ -0,0 +1,8 @@
+import { type Row } from './layout';
+export interface MathMLImport {
+    equations: Row[];
+    problems: string[];
+    lineProblems: string[][];
+}
+export declare function looksLikeContentMathML(text: string): boolean;
+export declare function importContentMathML(text: string): MathMLImport | null;

package/dist/types/editor/names.d.ts

@@ -0,0 +1,15 @@
+import type { Cursor } from './cursor';
+import { type Row } from './layout';
+export interface NameOptions {
+    greekNames?: boolean;
+    cursorAway?: boolean;
+}
+interface EditorLike {
+    root: Row;
+    cursor: Cursor;
+    anchor?: Cursor | null;
+}
+export declare function greekWord(word: string): string | null;
+export declare function nameAtoms(name: string, options?: NameOptions): Row;
+export declare function settleNames<S extends EditorLike>(state: S, options?: NameOptions): S;
+export {};

package/dist/types/editor/numberUnits.d.ts

@@ -0,0 +1,15 @@
+import type { Cursor } from './cursor';
+import { type Atom, type Row } from './layout';
+export declare const isUnits: (atom: Atom | undefined) => boolean;
+export declare const inUnits: (cursor: Cursor) => boolean;
+export declare function openUnitsId(root: Row, cursor: Cursor): string | null;
+export declare function followsNumber(row: Row, index: number): boolean;
+export declare function continuesNumber(row: Row, unitsIndex: number, text: string): boolean;
+export declare function settleCursor(root: Row, cursor: Cursor): Cursor;
+interface EditorLike {
+    root: Row;
+    cursor: Cursor;
+    anchor?: Cursor | null;
+}
+export declare function settleState<S extends EditorLike>(state: S): S;
+export {};

package/dist/types/editor/numbers.d.ts

@@ -0,0 +1,11 @@
+import type { Atom, Row } from './layout';
+export interface NumberRun {
+    start: number;
+    end: number;
+    text: string;
+    mantissa: string;
+    exponent: string | null;
+}
+export declare const startsNumber: (atom: Atom | undefined) => boolean;
+export declare function numberAt(row: Row, start: number): NumberRun | null;
+export declare function isExponentSignPosition(row: Row, offset: number): boolean;

package/dist/types/editor/operators.d.ts

@@ -0,0 +1,28 @@
+export type ComparisonType = 'Less' | 'Greater' | 'LessEqual' | 'GreaterEqual' | 'NotEqual';
+export type LogicType = 'And' | 'Or' | 'Xor';
+export interface ComparisonOperator {
+    role: 'comparison';
+    symbol: string;
+    type: ComparisonType;
+}
+export interface LogicOperator {
+    role: 'logic';
+    symbol: string;
+    type: LogicType;
+}
+export interface NotOperator {
+    role: 'not';
+    symbol: string;
+    type: 'Not';
+}
+export type ConditionOperator = (ComparisonOperator | LogicOperator | NotOperator) & {
+    latex: string;
+    mathml: string;
+    commands: readonly string[];
+};
+export declare const CONDITION_OPERATORS: readonly ConditionOperator[];
+export declare const conditionOperator: (symbol: string) => ConditionOperator | undefined;
+export declare const conditionOperatorOfType: (type: string) => ConditionOperator | undefined;
+export declare const conditionOperatorForCommand: (name: string) => ConditionOperator | undefined;
+export declare const combinedWithEquals: (symbol: string) => string | undefined;
+export declare const KEY_SYMBOLS: Record<string, string>;

package/dist/types/editor/parse.d.ts

@@ -0,0 +1,12 @@
+import type { AstNode } from '../types/ast';
+import type { Row } from './layout';
+export interface ParseDiagnostic {
+    message: string;
+    atomIds: string[];
+    incomplete?: true;
+}
+export interface ParseResult {
+    ast: AstNode;
+    diagnostics: ParseDiagnostic[];
+}
+export declare function parseRow(row: Row): ParseResult;

package/dist/types/editor/selection.d.ts

@@ -0,0 +1,22 @@
+import { type Cursor, type PickOffset } from './cursor';
+import { type Row, type RowPath } from './layout';
+export interface SelectableState {
+    root: Row;
+    cursor: Cursor;
+    anchor?: Cursor | null;
+}
+export interface Selection {
+    path: RowPath;
+    start: number;
+    end: number;
+}
+export declare function selectionOf(state: SelectableState): Selection | null;
+export declare function selectedAtoms(state: SelectableState): Row;
+export declare function describeSelection(selection: Selection): string;
+export declare function extendSelection<S extends SelectableState>(state: S, direction: 'forward' | 'backward'): S;
+export declare function extendSelectionTo<S extends SelectableState>(state: S, edge: 'start' | 'end'): S;
+export declare function selectAll<S extends SelectableState>(state: S): S;
+export declare function selectBetween<S extends SelectableState>(state: S, anchor: Cursor, cursor: Cursor): S;
+export declare function collapseSelection<S extends SelectableState>(state: S, to?: 'start' | 'end' | 'cursor'): S;
+export declare function navigateHorizontal<S extends SelectableState>(state: S, direction: 'forward' | 'backward'): S | null;
+export declare function navigateVertical<S extends SelectableState>(state: S, direction: 'up' | 'down', pickOffset?: PickOffset): S | null;

package/dist/types/editor/toolbar.d.ts

@@ -0,0 +1,18 @@
+import { type Command } from './commands';
+export interface ToolButton {
+    latex: string;
+    title: string;
+    command: Command;
+}
+export interface ToolSection {
+    label?: string;
+    items: ToolButton[];
+}
+export interface ToolGroup {
+    id: string;
+    title: string;
+    latex: string;
+    command?: Command;
+    sections?: ToolSection[];
+}
+export declare const TOOLBAR: readonly ToolGroup[];

package/dist/types/editor/units.d.ts

@@ -0,0 +1,27 @@
+import { type Row } from './layout';
+import type { Mark } from './marks';
+import type { ParseResult } from './parse';
+export interface EquationLine {
+    id: string;
+    mathml: string;
+    variables: string[];
+    units: string[];
+    complete: boolean;
+}
+export interface EquationsChangeInfo {
+    source: 'load' | 'edit';
+}
+export interface LineCommitInfo {
+    reason: 'enter' | 'new-line' | 'navigate' | 'blur' | 'paste';
+}
+export interface UnitsIssue {
+    lineId: string;
+    message: string;
+    variables?: readonly string[];
+    numbers?: readonly number[];
+    units?: readonly string[];
+}
+export type VariableUnits = Readonly<Record<string, string>>;
+export declare function equationLine(id: string, root: Row, parsed: ParseResult | null, otherProblems?: number): EquationLine;
+export declare function unitsIssueMarks(root: Row, issues: readonly UnitsIssue[]): Mark[];
+export declare function unitsHintMarks(root: Row, variableUnits: VariableUnits | null): Mark[];

package/dist/types/index.d.ts

@@ -0,0 +1,8 @@
+export { default as EquationWorkbench } from './components/EquationWorkbench.vue';
+export { default as UnitsPanel } from './units/UnitsPanel.vue';
+export { importContentMathML, type MathMLImport } from './editor/mathmlImport';
+export type { EquationLine, EquationsChangeInfo, LineCommitInfo, UnitsIssue, VariableUnits, } from './editor/units';
+export { LIBCELLML_KEY, type ProvidedLibCellML, type UnitsCheckerOptions, type UnitsCheckerStatus, useUnitsChecker, } from './units/useUnitsChecker';
+export type { UnitsDefinition, UnitsPart } from './units/definitions';
+export type { UnitsSource, UnitsLibraryProblem } from './units/library';
+export type { LibCellML } from './units/libcellml';

package/dist/types/registry/nodes.d.ts

@@ -0,0 +1,21 @@
+export interface FunctionDefinition {
+    name: string;
+    latexName: string;
+    latexCommand: boolean;
+    mathMlTag: string;
+    mathJson: string;
+    aliases?: readonly string[];
+}
+export declare const FUNCTION_REGISTRY: Record<string, FunctionDefinition>;
+export declare function getFunctionDefinition(name: string): FunctionDefinition | null;
+export declare function functionLatex(name: string): string;
+interface BracketFunction {
+    open: string;
+    close: string;
+    latexOpen: string;
+    latexClose: string;
+}
+export declare const bracketsForFunction: (name: string) => BracketFunction;
+export declare function functionForBracket(open: string): string | undefined;
+export declare function delimiterLatex(delimiter: string): string;
+export {};