xiaodao-editor 0.1.19 → 0.1.21

package/dist/core/Editor.d.ts

@@ -42,6 +42,23 @@ export declare class Editor {
     editable: boolean;
     /** The block id currently owning the focused contenteditable (set by the view). */
     focusBlockId: BlockId | null;
+    /**
+     * Extension-attached callables (e.g. async commands like
+     * `startImageUpload`). Plugins register these during `init` and look
+     * them up by name. Distinct from the synchronous `commands` proxy and
+     * from `Editor`'s own public API so extensions can advertise any
+     * callable without polluting the core surface.
+     *
+     * Invariant: every value stored here MUST be a callable. The map's
+     * value type is `unknown` (so we don't need a single vararg signature
+     * that every concrete function has to be assignable to); the
+     * `getExtensionMethod<T>` API is the only way to retrieve one, and
+     * it requires callers to assert the concrete function type at the
+     * use site (which is also where they actually know the signature).
+     */
+    private readonly extensionMethods;
+    /** Context handed to plugin `init` and `applyTransaction` hooks. */
+    private readonly pluginCtx;
     /** Public history API: canUndo/canRedo plus grouping helpers. */
     readonly history: EditorHistory;
     constructor(config: EditorConfig);
@@ -64,6 +81,21 @@ export declare class Editor {
     setDocument(json: DocumentData): void;
     /** Take ownership of a normalized document and reset the editor state. */
     private adoptDoc;
+    /**
+     * Register a callable under a string key. Throws if the key is already
+     * taken: there is no implicit override because extension authors
+     * should be explicit about who wins when two extensions want the same
+     * name. Returns an unregister function.
+     *
+     * `T` is inferred from the call site so concrete functions with
+     * specific parameter / return types (e.g. `(file: File) => Promise<…>`)
+     * are stored verbatim. The runtime map's value type is `unknown`
+     * (any value is structurally assignable to it); callers retrieve a
+     * typed function via `getExtensionMethod<T>(name)`.
+     */
+    registerExtensionMethod<T>(name: string, fn: T): () => void;
+    /** Look up a previously-registered extension method. */
+    getExtensionMethod<T = unknown>(name: string): T | undefined;
     dispatch(tr: Transaction): void;
     undo(): boolean;
     redo(): boolean;

package/dist/core/command/primitiveCommands.d.ts

@@ -58,7 +58,7 @@ export interface SetStartNumberArgs {
     readonly id: BlockId;
     /**
      * The explicit starting number for this ordered-list item.
-     * Pass `null` / `undefined` to clear the override — the item will then
+     * Pass `null` / `undefined` to clear the override: the item will then
      * follow the previous block's numbering (standard "continue" behavior).
      */
     readonly startNumber: number | null;

package/dist/core/plugin/Plugin.d.ts

@@ -1,23 +1,63 @@
 import { EditorState } from '../state/EditorState';
 import { Transaction } from '../state/Transaction';
+import { EditorRegistries } from '../extension/Registry';
 /** Opaque per-plugin state slice. Each plugin owns its concrete type. */
 export type PluginState = unknown;
+/**
+ * Minimal Editor surface exposed to plugins. Defined here (rather than
+ * importing the `Editor` class) to avoid a circular type dependency:
+ * `plugin/Plugin.ts` is imported by `Editor.ts`, which would otherwise
+ * import `Editor.ts` back. Any method added to the live Editor that
+ * plugins should be able to call needs to be declared here too.
+ *
+ * The interface intentionally mirrors what plugins actually use today
+ * (registries for schema reads, commands for transaction dispatch,
+ * dispatch for plugin-internal transactions, subscribe for side-channel
+ * cleanup tracking). It can grow as new plugins need more access.
+ */
+export interface PluginEditor {
+    readonly registries: EditorRegistries;
+    readonly commands: Record<string, (...args: unknown[]) => boolean>;
+    getState(): EditorState;
+    subscribe(listener: (update: {
+        readonly state: EditorState;
+    }) => void): () => void;
+    /**
+     * Register a callable under a string key. `T` is inferred from the
+     * call site so concrete function types are preserved. The returned
+     * function unregisters the method. Plugins use this to expose async
+     * commands (e.g. `startImageUpload`) or any other callable surface
+     * that the view layer needs to invoke through the editor.
+     */
+    registerExtensionMethod<T>(name: string, fn: T): () => void;
+    /** Look up a previously-registered extension method. */
+    getExtensionMethod<T = unknown>(name: string): T | undefined;
+}
+/** Context passed to `Plugin.init`. Provided once when the editor is built. */
+export interface PluginInitContext {
+    readonly editor: PluginEditor;
+}
 export interface EventContext {
     readonly state: EditorState;
     readonly dispatch: (tr: Transaction) => void;
     /** The focused block id, if any (the block owning the active contenteditable). */
     readonly focusBlockId: () => string | null;
+    /** The editor instance, exposing the same surface as `PluginInitContext.editor`. */
+    readonly editor: PluginEditor;
 }
 export interface Plugin {
     readonly name: string;
-    /** Called once when the editor is created. Returns the initial plugin state. */
-    init?(state: EditorState): PluginState;
+    /** Called once when the editor is created. Returns the initial plugin state.
+     *  `ctx` carries a handle to the editor so the plugin can register
+     *  extension methods on it. */
+    init?(state: EditorState, ctx: PluginInitContext): PluginState;
     /**
      * Called for every applied transaction. Receives the transaction, the
-     * *previous* state, and the new (doc/selection) state being assembled.
-     * Returns the plugin's new state slice.
+     * *previous* state, and the new (doc/selection) state being assembled,
+     * plus the same context as the event hooks. Returns the plugin's new
+     * state slice.
      */
-    applyTransaction?(tr: Transaction, prevState: EditorState, nextDoc: EditorState['doc'], nextSelection: EditorState['selection']): PluginState;
+    applyTransaction?(tr: Transaction, prevState: EditorState, nextDoc: EditorState['doc'], nextSelection: EditorState['selection'], ctx: PluginInitContext): PluginState;
     onKeyDown?(event: KeyboardEvent, ctx: EventContext): boolean;
     onInput?(event: InputEvent, ctx: EventContext): boolean;
     onCompositionStart?(event: CompositionEvent, ctx: EventContext): void;

package/dist/core/state/EditorState.d.ts

@@ -1,5 +1,5 @@
 import { DocState, Selection } from '../types';
-import { Plugin, PluginState } from '../plugin/Plugin';
+import { Plugin, PluginInitContext, PluginState } from '../plugin/Plugin';
 import { Transaction } from './Transaction';
 import { ApplyResult } from './Step';
 export interface EditorState {
@@ -19,8 +19,11 @@ interface TransactionApplier {
 /**
  * Apply a transaction to a state, producing a new state plus a diff
  * (changed / removed) that the view bridge consumes.
+ *
+ * `ctx` is forwarded to every plugin's `applyTransaction` hook so plugins
+ * can register / look up extension methods on the editor.
  */
-export declare function applyTransaction(state: EditorState, tr: Transaction, plugins: readonly TransactionApplier[]): ApplyTransactionResult;
+export declare function applyTransaction(state: EditorState, tr: Transaction, plugins: readonly TransactionApplier[], ctx: PluginInitContext): ApplyTransactionResult;
 /** Create the initial state from a document and a (possibly null) selection. */
 export declare function createState(doc: DocState, selection: Selection, pluginState?: Readonly<Record<string, PluginState>>): EditorState;
 export {};

package/dist/core/state/invert.d.ts

@@ -5,7 +5,7 @@ import { Step } from './Step';
  * that, when applied to the post-state, restores the pre-state. Steps are
  * inverted in reverse order so the last-applied change is undone first.
  *
- * Important — forward-step is a sequential program:
+ * Important: forward-step is a sequential program:
  *   [ setAttrs(A, x'), insertBlock(B), replaceBlock(B), setAttrs(B) ]
  * When reversing, we may see `replaceBlock(B)` / `setAttrs(B)` BEFORE we see
  * the `insertBlock(B)` that actually added B to the document. In that case
@@ -13,7 +13,7 @@ import { Step } from './Step';
  * not the mid-transaction intermediate). Inverting B's attribute/replace
  * changes is redundant because the final `insertBlock(B)` → inverse
  * `removeBlock(B)` already erases B entirely. So these "unknown id" cases
- * are skipped — the block is handled by its matching insertBlock inverse
+ * are skipped: the block is handled by its matching insertBlock inverse
  * further up the step list.
  */
 export declare function invertSteps(steps: readonly Step[], prevDoc: DocState): Step[];

package/dist/core/types.d.ts

@@ -9,7 +9,7 @@
  */
 /**
  * A stable, opaque identifier for a block. Branded so that a plain `string`
- * cannot be passed where a `BlockId` is expected — this catches an entire
+ * cannot be passed where a `BlockId` is expected: this catches an entire
  * class of bugs at compile time.
  */
 export type BlockId = string & {

package/dist/extensions/Equation.d.ts

@@ -2,29 +2,85 @@ import { PropType, VNode } from 'vue';
 import { Extension } from '../core/extension/Extension';
 import { Block, BlockId } from '../core/types';
 import { Editor } from '../core/Editor';
-export interface RenderResult {
-    /** KaTeX HTML output (safe to insert via v-html because trust:false). */
+export interface EquationRenderOptions {
+    /** Block-level formula (centered, limits above/below). Default: true. */
+    readonly displayMode?: boolean;
+}
+export interface EquationDiagnostic {
+    /** `error` surfaces a visible problem; `warning` is recoverable (e.g. unknown command). */
+    readonly severity: 'error' | 'warning';
+    readonly message: string;
+    readonly start: number;
+    readonly end: number;
+}
+export interface EquationRenderResult {
+    /** Safe HTML string, always available (export / SSR / non-Vue consumers). */
     readonly html: string;
-    /** True when the source could not be parsed by KaTeX. */
+    /**
+     * Vue VNode tree. When present the view renders it directly, so no HTML
+     * string is ever assigned to innerHTML. Adapters for string-only engines
+     * (KaTeX, MathJax) leave this `null` and fill `html` instead.
+     */
+    readonly vnode: VNode | VNode[] | null;
+    /** True when the expression has at least one `error` diagnostic. */
     readonly error: boolean;
+    readonly diagnostics: readonly EquationDiagnostic[];
+}
+export interface EquationRenderer {
+    render(expression: string, options?: EquationRenderOptions): EquationRenderResult;
 }
 /**
- * Render a LaTeX expression to HTML. Always returns a result — parse failures
- * surface as `error: true` with a KaTeX error span rather than throwing.
- * Safe to call on the server (no `document` access).
+ * Default renderer: Tokenizer -> Parser -> AST -> render tree -> VNode + HTML.
+ * Supports a lightweight subset of LaTeX math (see `SUPPORTED_COMMANDS`).
  */
+export declare const builtinEquationRenderer: EquationRenderer;
+/**
+ * Legacy convenience wrapper retained for backward compatibility: render with
+ * the built-in renderer and return the historical `{ html, error }` shape.
+ */
+export interface RenderResult {
+    /** Renderer HTML output (safe to insert via v-html: it is never raw input). */
+    readonly html: string;
+    /** True when the source could not be parsed. */
+    readonly error: boolean;
+}
 export declare function renderEquation(expression: string): RenderResult;
 export interface EquationAttrs {
     readonly expression: string;
 }
-/** Paragraph/text block → Equation: the block's plain text becomes the LaTeX source. */
+/** Paragraph/text block -> Equation: the block's plain text becomes the LaTeX source. */
 export declare function turnIntoEquation(editor: Editor, id: BlockId, expression: string): void;
 /**
- * Equation → Paragraph: the LaTeX source becomes the paragraph's text.
+ * Equation -> Paragraph: the LaTeX source becomes the paragraph's text.
  * (A plain convertBlock would drop the expression because the paragraph schema
  * has no `expression` attr, so we restore it as text explicitly.)
  */
 export declare function turnEquationIntoParagraph(editor: Editor, id: BlockId): void;
+/** Build the equation block component bound to a specific renderer. */
+export declare function createEquationBlock(renderer: EquationRenderer): import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    block: {
+        type: PropType<Block>;
+        required: true;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, () => VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    block: {
+        type: PropType<Block>;
+        required: true;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    placeholder: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+/** The equation block bound to the built-in (zero-dependency) renderer. */
 export declare const EquationBlock: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
     block: {
         type: PropType<Block>;
@@ -48,4 +104,13 @@ export declare const EquationBlock: import('vue').DefineComponent<import('vue').
 }>> & Readonly<{}>, {
     placeholder: string;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export interface EquationExtensionOptions {
+    /**
+     * Custom renderer (KaTeX / MathJax / ...). When omitted the built-in
+     * zero-dependency renderer is used. The renderer is captured at extension
+     * creation time, so the component and `serialize.toHTML` always agree.
+     */
+    readonly renderer?: EquationRenderer;
+}
+export declare function createEquationExtension(options?: EquationExtensionOptions): Extension;
 export declare const EquationExtension: Extension;

package/dist/extensions/Image.d.ts

@@ -1,5 +1,8 @@
 import { Extension } from '../core/extension/Extension';
 import { BlockId } from '../core/types';
+import { UploadImageHandler } from '../view/imageUpload';
+/** Synchronous command that aborts an in-flight upload for a block. */
+export declare const CANCEL_IMAGE_UPLOAD_COMMAND = "cancelImageUpload";
 export interface ImageAttrs {
     readonly align: string;
     readonly src: string;
@@ -9,26 +12,60 @@ export interface ImageAttrs {
     readonly height: number;
     readonly caption: string;
     /**
-     * Optional server-side file identifier (integer). Set by the external
-     * `uploadImage` handler when it returns a result. The editor tracks
-     * reference counts for each fileId and emits `cleanup:image-file` when
-     * the last block referencing a fileId is removed, so the consumer can
-     * reclaim cloud storage.
+     * Optional server-side file identifier (integer). Set by the
+     * `UploadImageHandler` passed to `createImageExtension({ upload })`
+     * when it resolves. The `image-upload` plugin tracks reference counts
+     * for each fileId and invokes `onFileCleanup` (also passed to
+     * `createImageExtension`) when the last block referencing a fileId is
+     * removed, so the consumer can reclaim cloud storage.
      * 0 (the default) means "no file id" / not uploaded yet / no managed file.
      */
     readonly fileId: number;
 }
-export interface InsertImageBlockArgs {
-    readonly after?: BlockId;
-    readonly parent?: BlockId | null;
-    readonly index?: number;
-    readonly attrs?: {
-        src?: string;
-        alt?: string;
-        title?: string;
-        width?: number;
-        height?: number;
-        caption?: string;
-    };
+export interface ImageExtensionOptions {
+    /**
+     * Real upload handler. When omitted the extension falls back to an
+     * in-memory mock upload that stores the file as an object URL: fine
+     * for demos but NOT for persisted documents (object URLs do not
+     * survive reload).
+     */
+    readonly upload?: UploadImageHandler;
+    /**
+     * Invoked when the LAST image block referencing a given fileId is
+     * removed/replaced. Hosts can use this to reclaim cloud storage.
+     */
+    readonly onFileCleanup?: (fileId: number) => void;
+}
+export interface BeginImageUploadOpts {
+    readonly relativeToBlockId?: BlockId | null;
+    readonly position?: 'after' | 'before' | 'replace';
+    readonly convertIfEmpty?: boolean;
 }
+export type BeginImageUploadFn = (fileOrSrc: File | string, opts?: BeginImageUploadOpts) => Promise<BlockId | null>;
+/** Key under which the async command is registered on the Editor. */
+export declare const START_IMAGE_UPLOAD_METHOD = "startImageUpload";
+/**
+ * Create the Image block extension with optional upload + cleanup hooks.
+ *
+ * Usage:
+ *   ```ts
+ *   const myExt = createImageExtension({
+ *     upload: async (name, file, controller, onProgress) => {
+ *       // upload `file` to your cloud; return { url, width, height, fileId }
+ *     },
+ *     onFileCleanup: (fileId) => api.deleteCloudFile(fileId),
+ *   });
+ *   new Editor({ extensions: [...BuiltinExtensions.filter(e => e.name !== 'image'), myExt] });
+ *   ```
+ *
+ * `BlockEditor.vue` itself does NOT know about upload or file cleanup:
+ * it only forwards the existing `useBeginImageUpload()` Vue injection to
+ * the async command this extension registers on the editor.
+ */
+export declare function createImageExtension(options?: ImageExtensionOptions): Extension;
+/**
+ * The default Image extension bundled with the editor. Uses an in-memory
+ * mock upload (object URLs) and never invokes a cleanup callback. Suitable
+ * for demos; persisted documents need `createImageExtension({ upload, onFileCleanup })`.
+ */
 export declare const ImageExtension: Extension;

package/dist/extensions/OrderedList.d.ts

@@ -10,7 +10,7 @@ import { siblingList } from '../core/state/store';
  * chain; an explicit `attrs.startNumber` acts as a reset anchor.
  *
  * This is strictly narrower than the old flat-indent model: blocks under a
- * DIFFERENT parent (even at the same depthOf) never share a counter —
+ * DIFFERENT parent (even at the same depthOf) never share a counter:
  * crossing any parent boundary resets numbering by design. This matches the
  * rendering (BlockList nests children) and user intuition.
  */

package/dist/extensions/Paragraph.d.ts

@@ -1,5 +1,5 @@
 import { Extension } from '../core/extension/Extension';
 import { BlockId } from '../core/types';
-/** Slash-menu icon — SVG string from shared icons module. */
+/** Slash-menu icon: SVG string from shared icons module. */
 export declare const ParagraphExtension: Extension;
 export declare const CURRENT_BLOCK_PLACEHOLDER: BlockId;

package/dist/extensions/Table.d.ts

@@ -55,7 +55,7 @@ export interface InsertTableArgs {
     readonly replaceCurrent?: boolean;
 }
 /** Build all table commands. The registry context is accepted for parity with
- *  other factories but currently unused — kept for future callers that need
+ *  other factories but currently unused: kept for future callers that need
  *  schema-level coordination. */
 export declare function createTableCommands(_registries: EditorRegistries): AnyCommandEntry[];
 export declare const TableExtension: Extension;

package/dist/extensions/math/ast.d.ts

@@ -0,0 +1,140 @@
+/**
+ * Math AST for xiaodao-editor's built-in (zero-dependency) equation renderer.
+ *
+ * The AST is a pure data structure: it knows nothing about the DOM, Vue, or the
+ * editor. Two independent backends consume it:
+ *   - `renderVNode.ts` -> Vue VNode tree (live editing, no innerHTML)
+ *   - `renderHtml.ts`  -> escaped HTML string (export / SSR / non-Vue callers)
+ *
+ * Every node carries the source span it was parsed from, so future work can
+ * highlight the exact offending range without re-parsing.
+ */
+/** Source span, in UTF-16 code units, half-open: [start, end). */
+export interface MathSpan {
+    readonly start: number;
+    readonly end: number;
+}
+/** Environments understood by the built-in renderer. */
+export type MathEnv = 'matrix' | 'aligned';
+/** Delimiters produced by `(`/`)`/`[`/`]`/`\{`/`|` and `\left`/`\right`. */
+export type MathDelimiter = '(' | ')' | '[' | ']' | '{' | '}' | '|' | '.';
+/** An ordered run of nodes (an argument, a numerator, a script, a cell, ...). */
+export type MathContent = readonly MathNode[];
+/** One cell of a matrix/aligned row. */
+export type MathCell = MathContent;
+/** One row of a matrix/aligned environment. */
+export type MathRow = readonly MathCell[];
+/** A run of ordinary characters that is not a single identifier (e.g. `abc`). */
+export interface MathTextNode extends MathSpan {
+    readonly type: 'text';
+    readonly value: string;
+}
+/** A numeric literal such as `2` or `3.14`. */
+export interface MathNumberNode extends MathSpan {
+    readonly type: 'number';
+    readonly value: string;
+}
+/** A single-letter variable such as `x`. Rendered italic. */
+export interface MathIdentifierNode extends MathSpan {
+    readonly type: 'identifier';
+    readonly value: string;
+}
+/** `+`, `-`, `=`, `<`, `>`, or a mapped command such as `\times`. */
+export interface MathOperatorNode extends MathSpan {
+    readonly type: 'operator';
+    readonly value: string;
+    /** The originating command name (without backslash) when it came from one. */
+    readonly command: string | null;
+    /**
+     * True for a unary (sign) usage such as `-b` or `x = -1`, where the minus
+     * hugs the operand that follows it. Absent/false for the binary minus.
+     */
+    readonly unary?: boolean;
+}
+/** A delimited group: `{...}`, `(...)`, `[...]`, or `\left(...\right)`. */
+export interface MathGroupNode extends MathSpan {
+    readonly type: 'group';
+    readonly body: MathContent;
+    /**
+     * `null` for a plain `{...}` grouping (braces stay invisible, as in TeX).
+     * A non-null value renders that glyph on the left/right of the body.
+     */
+    readonly open: MathDelimiter | null;
+    readonly close: MathDelimiter | null;
+}
+/** `\frac{num}{den}`. */
+export interface MathFractionNode extends MathSpan {
+    readonly type: 'fraction';
+    readonly numerator: MathContent;
+    readonly denominator: MathContent;
+}
+/** `\sqrt{x}` or `\sqrt[3]{x}`. */
+export interface MathRootNode extends MathSpan {
+    readonly type: 'root';
+    readonly radicand: MathContent;
+    /** Degree for `\sqrt[n]{}`; null for a plain square root. */
+    readonly index: MathContent | null;
+}
+/**
+ * `x^2`, `x_1`, and `x_1^2` all collapse into a SINGLE node so the renderer
+ * never has to deal with a nested/incorrect shape for combined scripts.
+ */
+export interface MathScriptsNode extends MathSpan {
+    readonly type: 'scripts';
+    readonly base: MathNode;
+    readonly sup: MathContent | null;
+    readonly sub: MathContent | null;
+}
+/** `\sin`, `\log`, `\lim`, ... rendered upright (`sin`, not `s i n`). */
+export interface MathFunctionNode extends MathSpan {
+    readonly type: 'function';
+    readonly name: string;
+    readonly command: string;
+}
+/** A mapped symbol such as `\alpha` -> alpha. */
+export interface MathSymbolNode extends MathSpan {
+    readonly type: 'symbol';
+    readonly char: string;
+    readonly command: string;
+}
+/** `\sum`, `\prod`, `\int`: carries its own limits for above/below layout. */
+export interface MathLargeOperatorNode extends MathSpan {
+    readonly type: 'largeOperator';
+    readonly symbol: string;
+    readonly command: string;
+    readonly sup: MathContent | null;
+    readonly sub: MathContent | null;
+}
+/** `\begin{matrix}...\end{matrix}` / `\begin{aligned}...\end{aligned}`. */
+export interface MathMatrixNode extends MathSpan {
+    readonly type: 'matrix';
+    readonly env: MathEnv;
+    readonly rows: readonly MathRow[];
+}
+/** A command the built-in renderer does not implement (graceful degradation). */
+export interface MathUnknownNode extends MathSpan {
+    readonly type: 'unknown';
+    readonly command: string;
+}
+/** A placeholder for a construct that could not be parsed. */
+export interface MathErrorNode extends MathSpan {
+    readonly type: 'error';
+    readonly message: string;
+}
+export type MathNode = MathTextNode | MathNumberNode | MathIdentifierNode | MathOperatorNode | MathGroupNode | MathFractionNode | MathRootNode | MathScriptsNode | MathFunctionNode | MathSymbolNode | MathLargeOperatorNode | MathMatrixNode | MathUnknownNode | MathErrorNode;
+export type MathNodeType = MathNode['type'];
+/**
+ * A parse outcome. `severity: 'error'` means the renderer should surface a
+ * visible error; `'warning'` means the input was recoverable (e.g. an unknown
+ * command that is rendered literally) and is NOT an error state.
+ */
+export interface MathDiagnostic {
+    readonly severity: 'error' | 'warning';
+    readonly message: string;
+    readonly start: number;
+    readonly end: number;
+}
+export interface ParseResult {
+    readonly nodes: MathContent;
+    readonly diagnostics: readonly MathDiagnostic[];
+}

package/dist/extensions/math/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Built-in, zero-dependency math engine for xiaodao-editor.
+ *
+ * Pipeline: expression -> tokenize -> parse (AST) -> render tree -> VNode / HTML
+ *
+ * Nothing in this folder depends on KaTeX, MathJax, the DOM, or the editor:
+ * it is a pure, dependency-free LaTeX-subset renderer.
+ */
+export type { MathCell, MathContent, MathDelimiter, MathDiagnostic, MathEnv, MathNode, MathNodeType, MathRow, MathSpan, ParseResult, } from './ast';
+export type { MathErrorNode, MathFractionNode, MathFunctionNode, MathGroupNode, MathIdentifierNode, MathLargeOperatorNode, MathMatrixNode, MathNumberNode, MathOperatorNode, MathRootNode, MathScriptsNode, MathSymbolNode, MathTextNode, MathUnknownNode, } from './ast';
+export { tokenize } from './tokens';
+export type { Token, TokenKind } from './tokens';
+export { FUNCTION_COMMANDS, GREEK_LETTERS, LARGE_OPERATORS, OPERATOR_COMMANDS, STRUCTURAL_COMMANDS, SUPPORTED_COMMANDS, isSupportedCommand, } from './symbols';
+export { parseMath } from './parser';
+export { buildRenderTree } from './renderTree';
+export type { MathElement, RenderContext } from './renderTree';
+export { renderMathToVNode } from './renderVNode';
+export { escapeHtmlText, renderMathToHtml } from './renderHtml';

package/dist/extensions/math/parser.d.ts

@@ -0,0 +1,5 @@
+import { ParseResult } from './ast';
+/**
+ * Parse a LaTeX-ish math expression. Always returns a result: never throws.
+ */
+export declare function parseMath(source: string): ParseResult;

package/dist/extensions/math/renderHtml.d.ts

@@ -0,0 +1,5 @@
+import { MathContent } from './ast';
+import { RenderContext } from './renderTree';
+export declare function renderMathToHtml(nodes: MathContent, ctx: RenderContext): string;
+/** Escape for element text content. */
+export declare function escapeHtmlText(value: string): string;

package/dist/extensions/math/renderTree.d.ts

@@ -0,0 +1,16 @@
+import { MathContent } from './ast';
+export interface RenderContext {
+    readonly displayMode: boolean;
+}
+export interface MathElement {
+    readonly tag: string;
+    /** Class name(s), or null. */
+    readonly class: string | null;
+    /** Inline style, or null. */
+    readonly style: Readonly<Record<string, string>> | null;
+    /** Text content for a leaf element; null when the element has children. */
+    readonly text: string | null;
+    readonly children: readonly MathElement[] | null;
+}
+/** Build the full render tree for a parsed expression. */
+export declare function buildRenderTree(nodes: MathContent, ctx: RenderContext): MathElement;

package/dist/extensions/math/renderVNode.d.ts

@@ -0,0 +1,4 @@
+import { VNode } from 'vue';
+import { MathContent } from './ast';
+import { RenderContext } from './renderTree';
+export declare function renderMathToVNode(nodes: MathContent, ctx: RenderContext): VNode;

package/dist/extensions/math/symbols.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Symbol tables for the built-in math renderer.
+ *
+ * This file is the single source of truth for "what does the built-in renderer
+ * understand". Everything listed here is rendered as a real math glyph; every
+ * other command degrades gracefully to an `unknown` node.
+ *
+ * Glyphs are plain Unicode characters: no font download, no SVG, no MathML.
+ */
+/** Greek letters, lowercase + the uppercase variants the spec requires. */
+export declare const GREEK_LETTERS: Readonly<Record<string, string>>;
+/** Binary relations / operators expressed as LaTeX commands. */
+export declare const OPERATOR_COMMANDS: Readonly<Record<string, string>>;
+/** Named functions, rendered upright (so `\sin x` never looks like `s i n x`). */
+export declare const FUNCTION_COMMANDS: Readonly<Record<string, string>>;
+/** Operators whose limits are placed above/below in display mode. */
+export declare const LARGE_OPERATORS: Readonly<Record<string, string>>;
+/** Structural commands handled directly by the parser. */
+export declare const STRUCTURAL_COMMANDS: readonly string[];
+/**
+ * Spacing commands spelled as letter commands: `\quad` (1 em) and `\qquad`
+ * (2 em), mapped to Unicode em spaces.
+ */
+export declare const SPACING_COMMANDS: Readonly<Record<string, string>>;
+/**
+ * TeX spacing commands that arrive from the tokenizer as escaped literal
+ * characters (`\,` `\:` `\;` `\!` `\ `), mapped to Unicode spaces:
+ * thin / medium math / thick / zero-width / no-break. (A negative space has
+ * no Unicode glyph; `\!` degrades to a zero-width, visually neutral space.)
+ */
+export declare const SPACING_ESCAPES: Readonly<Record<string, string>>;
+/**
+ * Every command name the built-in renderer understands. Exported so docs and
+ * tests can assert the supported surface without duplicating the tables.
+ */
+export declare const SUPPORTED_COMMANDS: readonly string[];
+export declare function isSupportedCommand(name: string): boolean;