@notectl/core 2.1.2 → 2.2.1

package/dist/plugins/formula/FormulaLocale.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Locale interface and default English strings for the formula plugin.
+ * All authoring surfaces (toolbar, overlay, palette) draw their labels here so
+ * the plugin is fully translatable and accessible out of the box.
+ */
+export interface FormulaLocale {
+    readonly insertInline: string;
+    readonly insertInlineTooltip: string;
+    readonly editFormula: string;
+    readonly latexLabel: string;
+    readonly latexPlaceholder: string;
+    readonly previewLabel: string;
+    readonly insertButton: string;
+    readonly updateButton: string;
+    readonly cancelButton: string;
+    readonly displayToggle: string;
+    readonly sizeLabel: string;
+    readonly sizeDefault: string;
+    readonly altLabel: string;
+    readonly altPlaceholder: string;
+    readonly paletteLabel: string;
+    readonly emptyPreview: string;
+    /** Announced when a formula is inserted. */
+    readonly inserted: string;
+    /** Announced when a formula is updated. */
+    readonly updated: string;
+    /** Announced when the editing overlay opens. */
+    readonly editing: string;
+    /** Announced when a formula node is selected (display math). */
+    readonly selected: string;
+    /** Builds the unknown-command error message. */
+    readonly unknownCommand: (command: string) => string;
+    /** Accessible group labels for the structural palette. */
+    readonly groupFractions: string;
+    readonly groupScripts: string;
+    readonly groupRoots: string;
+    readonly groupOperators: string;
+    readonly groupGreek: string;
+    readonly groupRelations: string;
+    readonly groupMatrices: string;
+    readonly groupArrows: string;
+}
+export declare const FORMULA_LOCALE_EN: FormulaLocale;
+export declare function loadFormulaLocale(lang: string): Promise<FormulaLocale>;
+//# sourceMappingURL=FormulaLocale.d.ts.map

package/dist/plugins/formula/FormulaLocale.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FormulaLocale.d.ts","sourceRoot":"","sources":["../../../src/plugins/formula/FormulaLocale.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH,MAAM,WAAW,aAAa;IAC7B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,4CAA4C;IAC5C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,2CAA2C;IAC3C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,gDAAgD;IAChD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,gEAAgE;IAChE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,gDAAgD;IAChD,QAAQ,CAAC,cAAc,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,CAAC;IACrD,0DAA0D;IAC1D,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC7B;AAID,eAAO,MAAM,iBAAiB,EAAE,aA8B/B,CAAC;AAQF,wBAAsB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CAE5E"}

package/dist/plugins/formula/FormulaOverlay.d.ts

@@ -0,0 +1,38 @@
+import { BlockId } from '../../model/TypeBrands.js';
+import { PluginContext } from '../Plugin.js';
+import { FormulaLocale } from './FormulaLocale.js';
+/** Identifies which existing formula node is being edited and where it sits. */
+export interface FormulaEditTarget {
+    readonly kind: 'inline' | 'display';
+    readonly latex: string;
+    readonly alt: string;
+    /** Current CSS font-size of the formula (e.g. `'24px'`); empty inherits. */
+    readonly fontSize: string;
+    /** Anchor rect; when null the overlay falls back to the caret position. */
+    readonly rect: DOMRect | null;
+    /** Inline: the containing block id + the node's offset within it. */
+    readonly blockId?: BlockId;
+    readonly offset?: number;
+    /** Display: the node's path. */
+    readonly path?: readonly BlockId[];
+}
+export declare class FormulaOverlay {
+    private readonly context;
+    private readonly locale;
+    private readonly fontSizes;
+    private panel;
+    private outsideHandler;
+    constructor(context: PluginContext, locale: FormulaLocale, fontSizes: readonly number[]);
+    /** Whether the overlay is currently open. */
+    isOpen(): boolean;
+    /** Opens the overlay at the caret to insert a new formula. */
+    openInsert(display: boolean): void;
+    /** Opens the overlay at an existing formula to edit it. */
+    openEdit(target: FormulaEditTarget): void;
+    /** Closes the overlay, optionally returning focus to the editor. */
+    close(returnFocus: boolean): void;
+    private commitEdit;
+    private open;
+    private installOutsideHandler;
+}
+//# sourceMappingURL=FormulaOverlay.d.ts.map

package/dist/plugins/formula/FormulaOverlay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FormulaOverlay.d.ts","sourceRoot":"","sources":["../../../src/plugins/formula/FormulaOverlay.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AASlD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAIxD,gFAAgF;AAChF,MAAM,WAAW,iBAAiB;IACjC,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,SAAS,CAAC;IACpC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,4EAA4E;IAC5E,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,2EAA2E;IAC3E,QAAQ,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAAC;IAC9B,qEAAqE;IACrE,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,gCAAgC;IAChC,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;CACnC;AAID,qBAAa,cAAc;IAKzB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAN3B,OAAO,CAAC,KAAK,CAA4B;IACzC,OAAO,CAAC,cAAc,CAA0C;gBAG9C,OAAO,EAAE,aAAa,EACtB,MAAM,EAAE,aAAa,EACrB,SAAS,EAAE,SAAS,MAAM,EAAE;IAG9C,6CAA6C;IAC7C,MAAM,IAAI,OAAO;IAIjB,8DAA8D;IAC9D,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAclC,2DAA2D;IAC3D,QAAQ,CAAC,MAAM,EAAE,iBAAiB,GAAG,IAAI;IAkBzC,oEAAoE;IACpE,KAAK,CAAC,WAAW,EAAE,OAAO,GAAG,IAAI;IAWjC,OAAO,CAAC,UAAU;IASlB,OAAO,CAAC,IAAI;IA2CZ,OAAO,CAAC,qBAAqB;CAc7B"}

package/dist/plugins/formula/FormulaPasteInterceptor.d.ts

@@ -0,0 +1,10 @@
+import { PasteInterceptor } from '../../model/PasteInterceptor.js';
+/**
+ * True when the HTML is essentially a single formula: it contains `<math>`, and
+ * once the `<math>` and any `aria-hidden` (visual-only) subtrees are removed,
+ * nothing but whitespace is left. Exported for unit testing.
+ */
+export declare function isStandaloneMathHtml(html: string): boolean;
+/** Creates the MathML paste interceptor. */
+export declare function createFormulaPasteInterceptor(): PasteInterceptor;
+//# sourceMappingURL=FormulaPasteInterceptor.d.ts.map

package/dist/plugins/formula/FormulaPasteInterceptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FormulaPasteInterceptor.d.ts","sourceRoot":"","sources":["../../../src/plugins/formula/FormulaPasteInterceptor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AAqBxE;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAS1D;AAWD,4CAA4C;AAC5C,wBAAgB,6BAA6B,IAAI,gBAAgB,CAchE"}

package/dist/plugins/formula/FormulaPlugin.d.ts

@@ -0,0 +1,22 @@
+import { Plugin, PluginContext } from '../Plugin.js';
+import { FormulaPluginConfig } from './FormulaTypes.js';
+export declare class FormulaPlugin implements Plugin {
+    readonly id = "formula";
+    readonly name = "Formula";
+    readonly priority = 46;
+    private readonly config;
+    private readonly resolvedKeymap;
+    private readonly fontSizes;
+    private locale;
+    private overlay;
+    private context;
+    private clickHandler;
+    constructor(config?: Partial<FormulaPluginConfig>);
+    init(context: PluginContext): Promise<void>;
+    destroy(): void;
+    private registerCommands;
+    private registerKeymap;
+    private installClickToEdit;
+    private editDisplay;
+}
+//# sourceMappingURL=FormulaPlugin.d.ts.map

package/dist/plugins/formula/FormulaPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FormulaPlugin.d.ts","sourceRoot":"","sources":["../../../src/plugins/formula/FormulaPlugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAgB1D,OAAO,EAMN,KAAK,mBAAmB,EACxB,MAAM,mBAAmB,CAAC;AAM3B,qBAAa,aAAc,YAAW,MAAM;IAC3C,QAAQ,CAAC,EAAE,aAAa;IACxB,QAAQ,CAAC,IAAI,aAAa;IAC1B,QAAQ,CAAC,QAAQ,MAAM;IAEvB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAsB;IAC7C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAuD;IACtF,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAoB;IAC9C,OAAO,CAAC,MAAM,CAAoC;IAClD,OAAO,CAAC,OAAO,CAA+B;IAC9C,OAAO,CAAC,OAAO,CAA8B;IAC7C,OAAO,CAAC,YAAY,CAA0C;gBAElD,MAAM,CAAC,EAAE,OAAO,CAAC,mBAAmB,CAAC;IAM3C,IAAI,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAsCjD,OAAO,IAAI,IAAI;IAUf,OAAO,CAAC,gBAAgB;IAsBxB,OAAO,CAAC,cAAc;IAgBtB,OAAO,CAAC,kBAAkB;IAgB1B,OAAO,CAAC,WAAW;CAKnB"}

package/dist/plugins/formula/FormulaRendering.d.ts

@@ -0,0 +1,18 @@
+import { FormulaAttrs } from './FormulaTypes.js';
+/** Returns the canonical `<math>` markup with its `alttext` set from `alt`. */
+export declare function mathMarkup(attrs: FormulaAttrs): string;
+/**
+ * Renders the formula into `host`. On malformed/empty MathML it falls back to
+ * the LaTeX source (or the alt label) as plain text so a formula is never
+ * silently invisible.
+ */
+export declare function renderFormulaInto(host: HTMLElement, attrs: FormulaAttrs): void;
+/**
+ * Applies the node's optional `fontSize` attribute to the host as a CSS
+ * `font-size`. MathML scales with the inherited font size, so this resizes the
+ * whole formula. An empty/missing value clears any previously set size.
+ */
+export declare function setFormulaFontSize(host: HTMLElement, attrs: Readonly<Record<string, unknown>> | undefined): void;
+/** Reads formula attributes from a model node's raw attrs, with safe defaults. */
+export declare function readFormulaAttrs(attrs: Readonly<Record<string, unknown>> | undefined): FormulaAttrs;
+//# sourceMappingURL=FormulaRendering.d.ts.map

package/dist/plugins/formula/FormulaRendering.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FormulaRendering.d.ts","sourceRoot":"","sources":["../../../src/plugins/formula/FormulaRendering.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAKtD,+EAA+E;AAC/E,wBAAgB,UAAU,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,CAGtD;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,YAAY,GAAG,IAAI,CAO9E;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CACjC,IAAI,EAAE,WAAW,EACjB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,SAAS,GAClD,IAAI,CAGN;AAED,kFAAkF;AAClF,wBAAgB,gBAAgB,CAC/B,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,SAAS,GAClD,YAAY,CAOd"}

package/dist/plugins/formula/FormulaStyles.d.ts

@@ -0,0 +1,12 @@
+/**
+ * CSS for formula nodes and the authoring surfaces (editor panel + overlay).
+ *
+ * The `font-family: 'Notectl Math', math` cascade is essential: a real-browser
+ * spike showed Chromium renders stretchy constructs (matrix brackets, large
+ * integrals/roots) incorrectly without an explicit OpenType MATH font, and
+ * correctly once one is applied. The bundled font is opt-in (see ./fonts); the
+ * `math` generic keyword is the graceful fallback.
+ */
+export declare const FORMULA_CSS = "\n.notectl-math math {\n\tfont-family: 'Notectl Math', math;\n}\n\n.notectl-math--inline {\n\tdisplay: inline-block;\n\tvertical-align: middle;\n\tpadding: 0 1px;\n\tborder-radius: 3px;\n\tcursor: pointer;\n}\n\n.notectl-math--inline:hover {\n\tbackground: var(--notectl-highlight, rgba(0, 0, 0, 0.06));\n}\n\n.notectl-math--inline:focus-visible {\n\toutline: 2px solid var(--notectl-primary);\n\toutline-offset: 1px;\n}\n\n.notectl-math--inline math {\n\tfont-size: 1.15em;\n}\n\n.notectl-math--display {\n\tdisplay: block;\n\tmargin: 12px 0;\n\ttext-align: center;\n\tcursor: pointer;\n\tuser-select: none;\n\t-webkit-user-select: none;\n}\n\n.notectl-math--display math {\n\tfont-size: 1.35em;\n\tdisplay: inline-block;\n}\n\n.notectl-math--display.notectl-math--selected {\n\toutline: 2px solid var(--notectl-primary);\n\toutline-offset: 4px;\n\tborder-radius: 6px;\n}\n\n.notectl-math__error,\n.notectl-math merror {\n\tcolor: var(--notectl-danger, #c0392b);\n\tbackground: var(--notectl-danger-bg, rgba(192, 57, 43, 0.1));\n\tborder-radius: 3px;\n\tpadding: 0 2px;\n}\n";
+export declare const FORMULA_EDITOR_CSS = "\n.notectl-formula-editor {\n\tdisplay: flex;\n\tflex-direction: column;\n\tgap: 8px;\n\tpadding: 10px;\n\tmin-width: 320px;\n\tmax-width: 460px;\n\tbox-sizing: border-box;\n}\n\n.notectl-formula-editor__field {\n\tdisplay: flex;\n\tflex-direction: column;\n\tgap: 4px;\n}\n\n.notectl-formula-editor__label {\n\tfont-size: 12px;\n\tfont-weight: 600;\n\tcolor: var(--notectl-fg-muted, #555);\n}\n\n.notectl-formula-editor__input {\n\twidth: 100%;\n\tbox-sizing: border-box;\n\tpadding: 6px 8px;\n\tfont-family: 'SF Mono', 'Fira Code', Menlo, Consolas, monospace;\n\tfont-size: 13px;\n\tline-height: 1.5;\n\tresize: vertical;\n\tmin-height: 56px;\n\tborder: 1px solid var(--notectl-border);\n\tborder-radius: 4px;\n\tbackground: var(--notectl-surface-overlay, #fff);\n\tcolor: var(--notectl-fg);\n}\n\n.notectl-formula-editor__alt {\n\twidth: 100%;\n\tbox-sizing: border-box;\n\tpadding: 5px 8px;\n\tfont-size: 13px;\n\tborder: 1px solid var(--notectl-border);\n\tborder-radius: 4px;\n\tbackground: var(--notectl-surface-overlay, #fff);\n\tcolor: var(--notectl-fg);\n}\n\n.notectl-formula-editor__size {\n\tbox-sizing: border-box;\n\tpadding: 5px 8px;\n\tfont-size: 13px;\n\tborder: 1px solid var(--notectl-border);\n\tborder-radius: 4px;\n\tbackground: var(--notectl-surface-overlay, #fff);\n\tcolor: var(--notectl-fg);\n\tcursor: pointer;\n}\n\n.notectl-formula-editor__size:focus-visible {\n\toutline: 2px solid var(--notectl-primary);\n\toutline-offset: 1px;\n}\n\n.notectl-formula-editor__preview {\n\tmin-height: 44px;\n\tpadding: 8px;\n\tborder: 1px dashed var(--notectl-border);\n\tborder-radius: 4px;\n\tbackground: var(--notectl-surface-raised, #fafafa);\n\ttext-align: center;\n\toverflow-x: auto;\n}\n\n.notectl-formula-editor__preview math {\n\tfont-family: 'Notectl Math', math;\n\tfont-size: 1.3em;\n}\n\n.notectl-formula-editor__preview-empty {\n\tcolor: var(--notectl-fg-muted, #888);\n\tfont-size: 13px;\n}\n\n.notectl-formula-editor__errors {\n\tcolor: var(--notectl-danger, #c0392b);\n\tfont-size: 12px;\n\tmargin: 0;\n\tpadding-inline-start: 16px;\n}\n\n.notectl-formula-editor__row {\n\tdisplay: flex;\n\tgap: 8px;\n\talign-items: center;\n}\n\n.notectl-formula-editor__toggle {\n\tdisplay: flex;\n\talign-items: center;\n\tgap: 6px;\n\tfont-size: 13px;\n\tcolor: var(--notectl-fg);\n}\n\n.notectl-formula-editor__actions {\n\tdisplay: flex;\n\tgap: 8px;\n\tjustify-content: flex-end;\n\tmargin-top: 2px;\n}\n\n.notectl-formula-editor__btn {\n\tpadding: 6px 14px;\n\tborder: 1px solid var(--notectl-border);\n\tborder-radius: 4px;\n\tbackground: var(--notectl-surface-raised);\n\tcolor: var(--notectl-fg);\n\tcursor: pointer;\n\tfont-size: 13px;\n}\n\n.notectl-formula-editor__btn--primary {\n\tbackground: var(--notectl-primary);\n\tborder-color: var(--notectl-primary);\n\tcolor: var(--notectl-primary-fg, #fff);\n}\n\n.notectl-formula-editor__btn:focus-visible {\n\toutline: 2px solid var(--notectl-primary);\n\toutline-offset: 2px;\n}\n\n.notectl-formula-overlay {\n\tposition: fixed;\n\tz-index: 1000;\n\tborder: 1px solid var(--notectl-border);\n\tborder-radius: 8px;\n\tbackground: var(--notectl-surface-overlay, #fff);\n\tbox-shadow: 0 6px 24px rgba(0, 0, 0, 0.18);\n}\n\n.notectl-math-palette {\n\tdisplay: flex;\n\tflex-wrap: wrap;\n\tgap: 8px;\n\tpadding: 2px 0 8px;\n\tborder-bottom: 1px solid var(--notectl-border);\n\tmargin-bottom: 2px;\n}\n\n.notectl-math-palette__group {\n\tdisplay: flex;\n\tflex-wrap: wrap;\n\tgap: 2px;\n}\n\n.notectl-math-palette__group + .notectl-math-palette__group {\n\tborder-inline-start: 1px solid var(--notectl-border);\n\tpadding-inline-start: 6px;\n}\n\n.notectl-math-palette__btn {\n\tmin-width: 30px;\n\theight: 30px;\n\tpadding: 0 6px;\n\tborder: 1px solid transparent;\n\tborder-radius: 4px;\n\tbackground: transparent;\n\tcolor: var(--notectl-fg);\n\tcursor: pointer;\n\tfont-size: 15px;\n\tline-height: 1;\n}\n\n.notectl-math-palette__btn:hover {\n\tbackground: var(--notectl-surface-raised);\n}\n\n.notectl-math-palette__btn:focus-visible {\n\toutline: 2px solid var(--notectl-primary);\n\toutline-offset: 1px;\n}\n";
+//# sourceMappingURL=FormulaStyles.d.ts.map

package/dist/plugins/formula/FormulaStyles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FormulaStyles.d.ts","sourceRoot":"","sources":["../../../src/plugins/formula/FormulaStyles.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,eAAO,MAAM,WAAW,wjCAqDvB,CAAC;AAEF,eAAO,MAAM,kBAAkB,8/HAwL9B,CAAC"}

package/dist/plugins/formula/FormulaToolbar.d.ts

@@ -0,0 +1,5 @@
+import { PluginContext } from '../Plugin.js';
+import { FormulaLocale } from './FormulaLocale.js';
+/** Registers the "Insert formula" toolbar item (group: insert). */
+export declare function registerFormulaToolbar(context: PluginContext, locale: FormulaLocale, fontSizes: readonly number[]): void;
+//# sourceMappingURL=FormulaToolbar.d.ts.map

package/dist/plugins/formula/FormulaToolbar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FormulaToolbar.d.ts","sourceRoot":"","sources":["../../../src/plugins/formula/FormulaToolbar.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAGlD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAaxD,mEAAmE;AACnE,wBAAgB,sBAAsB,CACrC,OAAO,EAAE,aAAa,EACtB,MAAM,EAAE,aAAa,EACrB,SAAS,EAAE,SAAS,MAAM,EAAE,GAC1B,IAAI,CAwBN"}

package/dist/plugins/formula/FormulaTypes.d.ts

@@ -0,0 +1,64 @@
+import { FontDefinition } from '../font/FontPlugin.js';
+import { FormulaLocale } from './FormulaLocale.js';
+/** Inline math node type name (atomic InlineNode, width 1, contenteditable=false). */
+export declare const INLINE_MATH_TYPE = "math_inline";
+/** Display math node type name (selectable void block on its own line). */
+export declare const DISPLAY_MATH_TYPE = "math_display";
+/**
+ * Attributes stored on every formula node. The canonical `mathml` carries the
+ * LaTeX source as a TeX annotation; `latex` duplicates it for cheap re-editing
+ * and `alt` is the accessible fallback label (rendered as native `alttext`).
+ */
+export interface FormulaAttrs {
+    readonly mathml: string;
+    readonly latex: string;
+    readonly alt: string;
+    /** CSS font-size for the whole formula (e.g. `'24px'`); empty string inherits. */
+    readonly fontSize: string;
+}
+declare module '../../model/AttrRegistry.js' {
+    interface InlineNodeAttrRegistry {
+        math_inline: {
+            mathml: string;
+            latex: string;
+            alt: string;
+            fontSize: string;
+        };
+    }
+    interface NodeAttrRegistry {
+        math_display: {
+            mathml: string;
+            latex: string;
+            alt: string;
+            fontSize: string;
+        };
+    }
+}
+export interface FormulaKeymap {
+    /** Insert/open an inline formula. */
+    readonly insertInline?: string | null;
+    /** Insert/open a display (block) formula. */
+    readonly insertDisplay?: string | null;
+}
+export declare const DEFAULT_FORMULA_KEYMAP: Readonly<Record<keyof FormulaKeymap, string>>;
+/** Preset px sizes offered by the formula editor's size control. */
+export declare const DEFAULT_FORMULA_FONT_SIZES: readonly number[];
+export interface FormulaPluginConfig {
+    /** Locale override for user-facing strings. */
+    readonly locale?: FormulaLocale;
+    /** Keyboard shortcut overrides. */
+    readonly keymap?: FormulaKeymap;
+    /**
+     * Preset px sizes shown in the formula editor's size control. Pass an empty
+     * array to hide the control. Defaults to {@link DEFAULT_FORMULA_FONT_SIZES}.
+     */
+    readonly fontSizes?: readonly number[];
+    /**
+     * Optional OpenType MATH font, registered as `@font-face` for correct
+     * stretchy rendering in Chromium. Import `NOTECTL_MATH_FONT` from
+     * `@notectl/core/fonts`. Opt-in to keep the font payload out of the bundle.
+     */
+    readonly mathFont?: FontDefinition;
+}
+export declare const DEFAULT_FORMULA_CONFIG: FormulaPluginConfig;
+//# sourceMappingURL=FormulaTypes.d.ts.map

package/dist/plugins/formula/FormulaTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FormulaTypes.d.ts","sourceRoot":"","sources":["../../../src/plugins/formula/FormulaTypes.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAExD,sFAAsF;AACtF,eAAO,MAAM,gBAAgB,gBAAgB,CAAC;AAE9C,2EAA2E;AAC3E,eAAO,MAAM,iBAAiB,iBAAiB,CAAC;AAEhD;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC5B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,kFAAkF;IAClF,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC1B;AAID,OAAO,QAAQ,6BAA6B,CAAC;IAC5C,UAAU,sBAAsB;QAC/B,WAAW,EAAE;YAAE,MAAM,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAC;YAAC,GAAG,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAE,CAAC;KAC9E;IACD,UAAU,gBAAgB;QACzB,YAAY,EAAE;YAAE,MAAM,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAC;YAAC,GAAG,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAE,CAAC;KAC/E;CACD;AAID,MAAM,WAAW,aAAa;IAC7B,qCAAqC;IACrC,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtC,6CAA6C;IAC7C,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACvC;AAED,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,aAAa,EAAE,MAAM,CAAC,CAGhF,CAAC;AAEF,oEAAoE;AACpE,eAAO,MAAM,0BAA0B,EAAE,SAAS,MAAM,EAAyC,CAAC;AAIlG,MAAM,WAAW,mBAAmB;IACnC,+CAA+C;IAC/C,QAAQ,CAAC,MAAM,CAAC,EAAE,aAAa,CAAC;IAChC,mCAAmC;IACnC,QAAQ,CAAC,MAAM,CAAC,EAAE,aAAa,CAAC;IAChC;;;OAGG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,cAAc,CAAC;CACnC;AAED,eAAO,MAAM,sBAAsB,EAAE,mBAAwB,CAAC"}

package/dist/plugins/formula/InlineMathNodeSpec.d.ts

@@ -0,0 +1,5 @@
+import { InlineNodeSpec } from '../../model/InlineNodeSpec.js';
+import { INLINE_MATH_TYPE } from './FormulaTypes.js';
+/** Builds the inline math `InlineNodeSpec`. */
+export declare function createInlineMathNodeSpec(): InlineNodeSpec<typeof INLINE_MATH_TYPE>;
+//# sourceMappingURL=InlineMathNodeSpec.d.ts.map

package/dist/plugins/formula/InlineMathNodeSpec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InlineMathNodeSpec.d.ts","sourceRoot":"","sources":["../../../src/plugins/formula/InlineMathNodeSpec.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAOpE,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAIrD,+CAA+C;AAC/C,wBAAgB,wBAAwB,IAAI,cAAc,CAAC,OAAO,gBAAgB,CAAC,CAsClF"}

package/dist/plugins/formula/MathFont.d.ts

@@ -0,0 +1,4 @@
+import { FontDefinition } from '../font/FontPlugin.js';
+/** Subset of Noto Sans Math as a self-hosted WOFF2 `FontDefinition` (family: "Notectl Math"). */
+export declare const NOTECTL_MATH_FONT: FontDefinition;
+//# sourceMappingURL=MathFont.d.ts.map

package/dist/plugins/formula/MathFont.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MathFont.d.ts","sourceRoot":"","sources":["../../../src/plugins/formula/MathFont.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAK5D,iGAAiG;AACjG,eAAO,MAAM,iBAAiB,EAAE,cAY/B,CAAC"}

package/dist/plugins/formula/MathFontFace.d.ts

@@ -0,0 +1,4 @@
+import { FontDefinition } from '../font/FontPlugin.js';
+/** Returns `@font-face` CSS for every descriptor in the font definition. */
+export declare function buildMathFontFaceCss(font: FontDefinition): string;
+//# sourceMappingURL=MathFontFace.d.ts.map

package/dist/plugins/formula/MathFontFace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MathFontFace.d.ts","sourceRoot":"","sources":["../../../src/plugins/formula/MathFontFace.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D,4EAA4E;AAC5E,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,cAAc,GAAG,MAAM,CAUjE"}

package/dist/plugins/formula/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Public barrel for the formula (math) plugin.
+ *
+ * Re-exports the notectl plugin plus the standalone, framework-agnostic
+ * LaTeX→MathML converter for advanced/standalone use.
+ */
+export { FormulaPlugin } from './FormulaPlugin.js';
+export { DEFAULT_FORMULA_KEYMAP, type FormulaAttrs, type FormulaKeymap, type FormulaPluginConfig, } from './FormulaTypes.js';
+export type { FormulaLocale } from './FormulaLocale.js';
+export { FORMULA_LOCALE_EN, loadFormulaLocale } from './FormulaLocale.js';
+export { latexToMathML } from './latex/index.js';
+export type { LatexConversionResult, LatexError, LatexToMathMLOptions, } from './latex/index.js';
+export { buildMathML, MATHML_ATTRS, MATHML_TAGS } from './mathml/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/plugins/formula/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/formula/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EACN,sBAAsB,EACtB,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,mBAAmB,GACxB,MAAM,mBAAmB,CAAC;AAC3B,YAAY,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAG1E,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,YAAY,EACX,qBAAqB,EACrB,UAAU,EACV,oBAAoB,GACpB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/plugins/formula/latex/LatexParser.d.ts

@@ -0,0 +1,8 @@
+import { Atom } from './LatexParserTypes.js';
+import { LatexError } from './LatexToMathML.js';
+/** Parses a LaTeX source string into top-level atoms plus collected errors. */
+export declare function parseLatex(src: string, display: boolean): {
+    readonly atoms: readonly Atom[];
+    readonly errors: readonly LatexError[];
+};
+//# sourceMappingURL=LatexParser.d.ts.map

package/dist/plugins/formula/latex/LatexParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LatexParser.d.ts","sourceRoot":"","sources":["../../../../src/plugins/formula/latex/LatexParser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAkBH,OAAO,KAAK,EAAE,IAAI,EAAa,MAAM,uBAAuB,CAAC;AAG7D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAqCrD,+EAA+E;AAC/E,wBAAgB,UAAU,CACzB,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,OAAO,GACd;IAAE,QAAQ,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,SAAS,UAAU,EAAE,CAAA;CAAE,CAI7E"}

package/dist/plugins/formula/latex/LatexParserTypes.d.ts

@@ -0,0 +1,61 @@
+import { SymbolKind } from './LatexSymbols.js';
+import { LatexError } from './LatexToMathML.js';
+import { Token } from './LatexTokenizer.js';
+/**
+ * A single parsed atom. The parser accumulates a list of these per group so
+ * `^`/`_`/`'` can attach to the *preceding* atom and big-operator limit
+ * placement can key off the atom's kind.
+ */
+export interface Atom {
+    /** The MathML markup for this atom (already built via the builder). */
+    readonly node: string;
+    /** Symbol kind, when the atom came from a known symbol; drives limits. */
+    readonly kind?: SymbolKind;
+    /** True when this atom is a big operator that takes movable limits. */
+    readonly bigOp?: boolean;
+    /** True for integral-family operators, whose limits stay as side scripts. */
+    readonly intLike?: boolean;
+}
+/** Builds a plain ordinary atom from finished markup. */
+export declare function atom(node: string, kind?: SymbolKind): Atom;
+/**
+ * Builds a big-operator atom (∑, ∫, lim, …) that accepts movable limits.
+ * `intLike` marks integral-family operators whose limits stay as side scripts
+ * even in display mode (standard typographic convention).
+ */
+export declare function bigOpAtom(node: string, kind: SymbolKind, intLike?: boolean): Atom;
+/**
+ * Parser surface exposed to per-category command handlers. Keeps handlers free
+ * of the concrete parser class so they stay small and independently testable.
+ */
+export interface ParserApi {
+    /** Whether display (block) style is active; affects limit placement. */
+    readonly display: boolean;
+    /** Returns the next token without consuming it, or undefined at EOF. */
+    peek(): Token | undefined;
+    /** Consumes and returns the next token, or undefined at EOF. */
+    next(): Token | undefined;
+    /**
+     * Parses one mandatory argument (a `{...}` group or a single token) and
+     * returns its MathML markup. At EOF returns `''` (graceful recovery).
+     */
+    parseArgument(): string;
+    /**
+     * Parses an optional bracketed argument `[...]` if present, returning its
+     * markup, or undefined when the next token is not `[`.
+     */
+    parseOptionalArgument(): string | undefined;
+    /**
+     * Parses one mandatory argument as literal source text (no math markup),
+     * used by `\text`/`\operatorname`. At EOF returns `''`.
+     */
+    parseRawArgument(): string;
+    /**
+     * Parses tokens until the matching group close (or a custom stop), returning
+     * the assembled atoms. Used for environment cells and delimiter bodies.
+     */
+    parseAtomsUntil(stop: (token: Token) => boolean): readonly Atom[];
+    /** Records a recoverable error. */
+    error(err: LatexError): void;
+}
+//# sourceMappingURL=LatexParserTypes.d.ts.map

package/dist/plugins/formula/latex/LatexParserTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LatexParserTypes.d.ts","sourceRoot":"","sources":["../../../../src/plugins/formula/latex/LatexParserTypes.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAEjD;;;;GAIG;AACH,MAAM,WAAW,IAAI;IACpB,uEAAuE;IACvE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,0EAA0E;IAC1E,QAAQ,CAAC,IAAI,CAAC,EAAE,UAAU,CAAC;IAC3B,uEAAuE;IACvE,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IACzB,6EAA6E;IAC7E,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,yDAAyD;AACzD,wBAAgB,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,UAAU,GAAG,IAAI,CAE1D;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,EAAE,OAAO,UAAQ,GAAG,IAAI,CAE/E;AAED;;;GAGG;AACH,MAAM,WAAW,SAAS;IACzB,wEAAwE;IACxE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,wEAAwE;IACxE,IAAI,IAAI,KAAK,GAAG,SAAS,CAAC;IAC1B,gEAAgE;IAChE,IAAI,IAAI,KAAK,GAAG,SAAS,CAAC;IAC1B;;;OAGG;IACH,aAAa,IAAI,MAAM,CAAC;IACxB;;;OAGG;IACH,qBAAqB,IAAI,MAAM,GAAG,SAAS,CAAC;IAC5C;;;OAGG;IACH,gBAAgB,IAAI,MAAM,CAAC;IAC3B;;;OAGG;IACH,eAAe,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,OAAO,GAAG,SAAS,IAAI,EAAE,CAAC;IAClE,mCAAmC;IACnC,KAAK,CAAC,GAAG,EAAE,UAAU,GAAG,IAAI,CAAC;CAC7B"}

package/dist/plugins/formula/latex/LatexSymbols.d.ts

@@ -0,0 +1,87 @@
+/**
+ * LaTeX symbol and command lookup tables for the zero-dependency converter.
+ *
+ * Layer A (framework-agnostic, zero notectl imports). Maps each supported LaTeX
+ * command to the real Unicode character it produces plus a `kind` that drives
+ * the choice of MathML element (`mi` vs `mo`, stretchy fences, big-operator
+ * limit placement, upright function names).
+ *
+ * Supported commands by category (curated subset):
+ *
+ * - Greek letters (lowercase): \alpha \beta \gamma \delta \epsilon \varepsilon
+ *   \zeta \eta \theta \vartheta \iota \kappa \lambda \mu \nu \xi \pi \varpi \rho
+ *   \varrho \sigma \varsigma \tau \upsilon \phi \varphi \chi \psi \omega
+ * - Greek letters (uppercase): \Gamma \Delta \Theta \Lambda \Xi \Pi \Sigma
+ *   \Upsilon \Phi \Psi \Omega
+ * - Named functions (upright mi): \sin \cos \tan \cot \sec \csc \sinh \cosh
+ *   \tanh \coth \arcsin \arccos \arctan \log \ln \lg \exp \deg \det \dim \hom
+ *   \ker \arg \Pr
+ * - Big operators with limits: \sum \prod \coprod \int \iint \iiint \oint
+ *   \bigcup \bigcap \bigsqcup \bigvee \bigwedge \bigoplus \bigotimes \bigodot
+ *   \biguplus \lim \limsup \liminf \max \min \sup \inf \gcd \injlim \projlim
+ * - Binary operators: \times \div \pm \mp \cdot \ast \star \circ \bullet \oplus
+ *   \ominus \otimes \oslash \odot \cap \cup \uplus \sqcap \sqcup \wedge \vee
+ *   \setminus \wr \diamond \bigtriangleup \bigtriangledown \triangleleft
+ *   \triangleright \amalg \dagger \ddagger \cdot
+ * - Relations: \leq \le \geq \ge \neq \ne \equiv \sim \simeq \cong \approx
+ *   \propto \prec \succ \preceq \succeq \ll \gg \subset \supset \subseteq
+ *   \supseteq \sqsubseteq \sqsupseteq \in \ni \notin \mid \parallel \perp
+ *   \models \vdash \dashv \doteq \asymp \bowtie \smile \frown \lll \ggg \ne
+ *   \subsetneq \supsetneq
+ * - Arrows: \leftarrow \rightarrow \to \gets \leftrightarrow \Leftarrow
+ *   \Rightarrow \Leftrightarrow \mapsto \longrightarrow \longleftarrow
+ *   \longleftrightarrow \Longrightarrow \Longleftarrow \Longleftrightarrow
+ *   \uparrow \downarrow \updownarrow \nearrow \searrow \swarrow \nwarrow
+ *   \hookleftarrow \hookrightarrow \rightharpoonup \rightharpoondown
+ *   \leftharpoonup \leftharpoondown \implies \iff \nleftarrow \nrightarrow
+ * - Delimiters (used bare and by \left/\right): ( ) [ ] \{ \} \langle \rangle
+ *   \lceil \rceil \lfloor \rfloor \lvert \rvert \lVert \rVert \vert \Vert
+ *   \lbrace \rbrace \lbrack \rbrack \| \backslash
+ * - Misc ordinary symbols: \infty \partial \nabla \forall \exists \nexists
+ *   \emptyset \varnothing \aleph \hbar \ell \Re \Im \wp \prime \angle \triangle
+ *   \neg \lnot \top \bot \flat \natural \sharp \clubsuit \diamondsuit
+ *   \heartsuit \spadesuit \surd \cdots \ldots \vdots \ddots \dots \dotsb
+ *   \square \blacksquare \bigstar \complement \degree \checkmark
+ * - Punctuation operators: \colon \cdotp \ldotp
+ *
+ * Accents, fonts/styles, spacing, fractions, roots, big-op limit logic, and
+ * environments are handled in the parser, not these tables.
+ */
+/** How a symbol maps onto MathML markup. */
+export declare enum SymbolKind {
+    /** Ordinary atom: rendered as `<mi>` (variable-like). */
+    Ordinary = "ordinary",
+    /** Binary operator: `<mo>` (e.g. + × ∪). */
+    Binary = "binary",
+    /** Relation: `<mo>` (e.g. = ≤ ∈). */
+    Relation = "relation",
+    /** Arrow: `<mo>`, treated like a relation for spacing. */
+    Arrow = "arrow",
+    /** Opening fence: `<mo fence="true">`. */
+    Open = "open",
+    /** Closing fence: `<mo fence="true">`. */
+    Close = "close",
+    /** Named function (e.g. sin, log): upright multi-letter `<mi>`. */
+    Function = "function",
+    /** Big operator with limits (e.g. ∑ ∫ lim): `<mo>` with movable limits. */
+    BigOp = "bigop",
+    /** Punctuation: `<mo>` (e.g. comma-like separators). */
+    Punct = "punct"
+}
+/** A resolved symbol: the Unicode glyph plus how to render it. */
+export interface SymbolEntry {
+    /** The literal Unicode character(s); never pre-escaped (the builder escapes). */
+    readonly char: string;
+    /** How the symbol maps onto a MathML element. */
+    readonly kind: SymbolKind;
+}
+/** All symbol commands merged into a single lookup table. */
+export declare const SYMBOLS: Readonly<Record<string, SymbolEntry>>;
+/** Returns the symbol entry for a command name (without the leading backslash). */
+export declare function lookupSymbol(name: string): SymbolEntry | undefined;
+/**
+ * Resolves a delimiter spec (as used after `\left`/`\right`) to its glyph.
+ * Accepts literal chars, the `.` null delimiter, and delimiter commands.
+ */
+export declare function resolveDelimiter(spec: string): SymbolEntry | undefined;
+//# sourceMappingURL=LatexSymbols.d.ts.map

package/dist/plugins/formula/latex/LatexSymbols.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LatexSymbols.d.ts","sourceRoot":"","sources":["../../../../src/plugins/formula/latex/LatexSymbols.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AAEH,4CAA4C;AAC5C,oBAAY,UAAU;IACrB,yDAAyD;IACzD,QAAQ,aAAa;IACrB,4CAA4C;IAC5C,MAAM,WAAW;IACjB,qCAAqC;IACrC,QAAQ,aAAa;IACrB,0DAA0D;IAC1D,KAAK,UAAU;IACf,0CAA0C;IAC1C,IAAI,SAAS;IACb,0CAA0C;IAC1C,KAAK,UAAU;IACf,mEAAmE;IACnE,QAAQ,aAAa;IACrB,2EAA2E;IAC3E,KAAK,UAAU;IACf,wDAAwD;IACxD,KAAK,UAAU;CACf;AAED,kEAAkE;AAClE,MAAM,WAAW,WAAW;IAC3B,iFAAiF;IACjF,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,iDAAiD;IACjD,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;CAC1B;AA8SD,6DAA6D;AAC7D,eAAO,MAAM,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAUzD,CAAC;AAEF,mFAAmF;AACnF,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,CAElE;AAYD;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,CAWtE"}

package/dist/plugins/formula/latex/LatexToMathML.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Public entry point for the zero-dependency LaTeX → Presentation MathML converter.
+ *
+ * Layer A (framework-agnostic, zero notectl imports). Tokenizes the source,
+ * runs the recursive-descent parser, and groups the top-level atoms into a
+ * single MathML root element. Never throws: malformed input is recovered, and
+ * every problem is surfaced both as a visible `merror`/marker in the output and
+ * as a recorded `LatexError`.
+ */
+/** A single recoverable problem encountered while converting LaTeX. */
+export interface LatexError {
+    /** Human-readable description (e.g. 'Unknown command'). */
+    readonly message: string;
+    /** The offending command, including the leading backslash, when applicable. */
+    readonly command?: string;
+    /** Zero-based source position of the problem, when known. */
+    readonly position?: number;
+}
+/** The result of a LaTeX → MathML conversion. */
+export interface LatexConversionResult {
+    /** A SINGLE root presentation-MathML element string (e.g. `<mrow>…</mrow>`). Never empty: uses `<mrow></mrow>`. */
+    readonly presentation: string;
+    /** Every problem encountered; empty when the input converted cleanly. */
+    readonly errors: readonly LatexError[];
+}
+/** Options controlling how the LaTeX source is converted. */
+export interface LatexToMathMLOptions {
+    /** Display (block) vs inline. Affects displaystyle / big-operator limit placement. */
+    readonly display?: boolean;
+}
+/** Converts a LaTeX math string to a presentation-MathML root element. Never throws. */
+export declare function latexToMathML(latex: string, opts?: LatexToMathMLOptions): LatexConversionResult;
+//# sourceMappingURL=LatexToMathML.d.ts.map

package/dist/plugins/formula/latex/LatexToMathML.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LatexToMathML.d.ts","sourceRoot":"","sources":["../../../../src/plugins/formula/latex/LatexToMathML.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAMH,uEAAuE;AACvE,MAAM,WAAW,UAAU;IAC1B,2DAA2D;IAC3D,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,+EAA+E;IAC/E,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,6DAA6D;IAC7D,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,iDAAiD;AACjD,MAAM,WAAW,qBAAqB;IACrC,mHAAmH;IACnH,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,yEAAyE;IACzE,QAAQ,CAAC,MAAM,EAAE,SAAS,UAAU,EAAE,CAAC;CACvC;AAED,6DAA6D;AAC7D,MAAM,WAAW,oBAAoB;IACpC,sFAAsF;IACtF,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;CAC3B;AAID,wFAAwF;AACxF,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,oBAAoB,GAAG,qBAAqB,CAM/F"}

package/dist/plugins/formula/latex/LatexTokenizer.d.ts

@@ -0,0 +1,45 @@
+/**
+ * LaTeX math-mode tokenizer for the zero-dependency converter.
+ *
+ * Layer A (framework-agnostic, zero notectl imports). Splits a LaTeX source
+ * string into a flat token list the parser consumes. Pure string work, no DOM.
+ */
+/** The lexical category of a token. */
+export declare enum TokenType {
+    /** A `\name` command or control symbol (e.g. `\frac`, `\,`, `\{`). */
+    Command = "command",
+    /** Group open `{`. */
+    GroupOpen = "groupOpen",
+    /** Group close `}`. */
+    GroupClose = "groupClose",
+    /** Superscript marker `^`. */
+    Superscript = "superscript",
+    /** Subscript marker `_`. */
+    Subscript = "subscript",
+    /** Prime marker `'`. */
+    Prime = "prime",
+    /** Alignment tab `&` (matrix/cases cell separator). */
+    Ampersand = "ampersand",
+    /** Row break `\\` (matrix/cases row separator). */
+    RowBreak = "rowBreak",
+    /** A non-breaking space `~`. */
+    NbSpace = "nbSpace",
+    /** A run of digits (and a trailing decimal point group). */
+    Number = "number",
+    /** A single ordinary character (letter, punctuation, operator char). */
+    Char = "char"
+}
+/** A single lexical token with its source position. */
+export interface Token {
+    /** The lexical category. */
+    readonly type: TokenType;
+    /** The raw value: command name without backslash, or the literal char(s). */
+    readonly value: string;
+    /** Zero-based index in the source where the token starts. */
+    readonly position: number;
+}
+/** Tokenizes a LaTeX math string. Never throws; unknown chars become `Char`. */
+export declare function tokenize(src: string): readonly Token[];
+/** True when a one-character command body is a recognized control symbol. */
+export declare function isControlSymbol(value: string): boolean;
+//# sourceMappingURL=LatexTokenizer.d.ts.map

package/dist/plugins/formula/latex/LatexTokenizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LatexTokenizer.d.ts","sourceRoot":"","sources":["../../../../src/plugins/formula/latex/LatexTokenizer.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,uCAAuC;AACvC,oBAAY,SAAS;IACpB,sEAAsE;IACtE,OAAO,YAAY;IACnB,sBAAsB;IACtB,SAAS,cAAc;IACvB,uBAAuB;IACvB,UAAU,eAAe;IACzB,8BAA8B;IAC9B,WAAW,gBAAgB;IAC3B,4BAA4B;IAC5B,SAAS,cAAc;IACvB,wBAAwB;IACxB,KAAK,UAAU;IACf,uDAAuD;IACvD,SAAS,cAAc;IACvB,mDAAmD;IACnD,QAAQ,aAAa;IACrB,gCAAgC;IAChC,OAAO,YAAY;IACnB,4DAA4D;IAC5D,MAAM,WAAW;IACjB,wEAAwE;IACxE,IAAI,SAAS;CACb;AAED,uDAAuD;AACvD,MAAM,WAAW,KAAK;IACrB,4BAA4B;IAC5B,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,6EAA6E;IAC7E,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,6DAA6D;IAC7D,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC1B;AA6ED,gFAAgF;AAChF,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,KAAK,EAAE,CAgCtD;AAuBD,6EAA6E;AAC7E,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAEtD"}

package/dist/plugins/formula/latex/MathAlphabet.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Unicode "Mathematical Alphanumeric Symbols" mapping for math-alphabet fonts.
+ *
+ * Layer A (framework-agnostic, zero notectl imports). Chromium's MathML Core has
+ * dropped support for most `mathvariant` values (double-struck, script, fraktur,
+ * bold, …), so wrapping a letter in `<mstyle mathvariant="…">` no longer renders
+ * the styled glyph. Instead — exactly like KaTeX's MathML output — each ASCII
+ * letter/digit is remapped to its dedicated codepoint in the Mathematical
+ * Alphanumeric Symbols block (U+1D400…U+1D7FF) and emitted as a literal glyph.
+ *
+ * The block has well-known "holes": a handful of letters live in the older
+ * Letterlike Symbols block (U+2100…) instead of the contiguous range, so the
+ * per-style tables list those exceptions explicitly.
+ */
+/** A math-alphabet font style backed by a Unicode symbol block. */
+export type MathAlphabetStyle = 'double-struck' | 'script' | 'fraktur' | 'bold' | 'italic' | 'sans-serif' | 'monospace';
+/**
+ * Maps a single ASCII letter/digit to its styled Unicode glyph for `style`.
+ *
+ * Returns the literal glyph string (a single astral code point built with
+ * `String.fromCodePoint`), or `null` when there is no mapping — i.e. the
+ * character is not an A–Z / a–z / 0–9, or the style has no digit block (so
+ * digits keep their ASCII form, e.g. under italic). Callers fall back to the
+ * plain character on `null`.
+ */
+export declare function mathAlphaChar(ch: string, style: MathAlphabetStyle): string | null;
+/**
+ * Remaps every ASCII letter/digit in the leaf identifiers/numbers of `markup`
+ * to its styled Unicode glyph, rebuilding the element so the glyph renders in
+ * engines without `mathvariant` support. Characters with no mapping (operators,
+ * spaces, already-styled symbols, digits under a digit-less style) are left
+ * untouched, which lets `\mathbb{+}` pass the `+` through unchanged.
+ */
+export declare function applyMathAlphabet(markup: string, style: MathAlphabetStyle): string;
+/**
+ * Forces upright rendering for `\mathrm`: adds `mathvariant="normal"` to every
+ * bare leaf `<mi>` so multi-letter content stays upright even in engines that
+ * dropped `mathvariant` on `<mstyle>`. `normal` is the one variant value MathML
+ * Core retained on `<mi>`. Numbers and operators already render upright.
+ */
+export declare function applyUprightIdentifiers(markup: string): string;
+//# sourceMappingURL=MathAlphabet.d.ts.map