ooxml-core 0.4.0 → 0.5.0

package/dist/math/latex-omml-siblings.d.ts

@@ -0,0 +1,21 @@
+import type { OmmlNode } from './omml-to-mathml.js';
+export interface Token {
+    type: 'command' | 'text' | 'group_start' | 'group_end' | 'superscript' | 'subscript' | 'whitespace';
+    value: string;
+}
+export declare function tokenize(latex: string): Token[];
+/**
+ * Merge parsed sibling nodes into a single OMML container object.
+ *
+ * When tags interleave (`m:sSup`, `m:r`, `m:sSup`, ... for a^2+b^2=c^2), the
+ * collapsed tag-keyed shape cannot represent the sibling order under plain
+ * keys, so repeated tags get position-marked keys (`m:r#pptx-order-1`, via
+ * core's `orderedXmlKey`): object insertion order then carries the true
+ * sequence. This is the same convention core's load pipeline applies to real
+ * decks (`omml-sibling-order.ts`), and core's save-side XMLBuilder strips the
+ * markers from emitted tag names, so the serialized OOXML is the natural
+ * interleaved sequence PowerPoint itself writes. Grouped-by-tag sequences
+ * keep the compact merged shape.
+ */
+export declare function mergeSiblings(nodes: OmmlNode[]): OmmlNode;
+//# sourceMappingURL=latex-omml-siblings.d.ts.map

package/dist/math/latex-omml-siblings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"latex-omml-siblings.d.ts","sourceRoot":"","sources":["../../src/math/latex-omml-siblings.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAIpD,MAAM,WAAW,KAAK;IACrB,IAAI,EACD,SAAS,GACT,MAAM,GACN,aAAa,GACb,WAAW,GACX,aAAa,GACb,WAAW,GACX,YAAY,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;CACd;AAKD,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,EAAE,CA0C/C;AA0BD;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,QAAQ,CAoCzD"}

package/dist/math/latex-omml-symbols.d.ts

@@ -0,0 +1,42 @@
+/**
+ * latex-omml-symbols: the symbol tables shared by both directions of the
+ * LaTeX <-> OMML converters (`latex-to-omml.ts`, `omml-to-latex.ts`).
+ *
+ * Forward maps go from a LaTeX command to the Unicode character OMML stores in
+ * `m:t` / `m:chr`; the `REVERSE_*` maps invert them (first command wins for
+ * characters reachable from several aliases, e.g. `\le` and `\leq`).
+ */
+export declare const GREEK_MAP: Record<string, string>;
+export declare const OPERATOR_MAP: Record<string, string>;
+/**
+ * LaTeX escapes for characters that are syntax in the LaTeX grammar but plain
+ * text in an OMML run. `omml-to-latex` emits these so a run holding `{` or
+ * `_` survives the trip through the tokenizer.
+ */
+export declare const ESCAPE_MAP: Record<string, string>;
+export declare const NARY_MAP: Record<string, string>;
+export declare const FUNC_NAMES: Set<string>;
+/**
+ * Function names whose `_{...}` argument typesets beneath the name (LaTeX
+ * "limits" operators). `\lim_{x \to 0}` becomes `m:limLow`, not `m:sSub`,
+ * which is the structure PowerPoint itself writes for a limit.
+ */
+export declare const LIMIT_FUNC_NAMES: Set<string>;
+/** LaTeX accent command -> combining character stored in `m:accPr/m:chr`. */
+export declare const ACCENT_MAP: Record<string, string>;
+/** Accent characters that are aliases of a mapped one (macron == overline). */
+export declare const ACCENT_ALIASES: Record<string, string>;
+/** LaTeX delimiter command -> the character stored in `m:begChr` / `m:endChr`. */
+export declare const DELIM_MAP: Record<string, string>;
+/** Matrix environments -> the delimiter pair (empty for none). */
+export declare const MATRIX_ENVS: Record<string, [string, string]>;
+/** Equation-array environments (aligned rows, `m:eqArr`). */
+export declare const EQARR_ENVS: Set<string>;
+export declare const REVERSE_GREEK: Record<string, string>;
+export declare const REVERSE_OPERATOR: Record<string, string>;
+export declare const REVERSE_NARY: Record<string, string>;
+export declare const REVERSE_ACCENT: Record<string, string>;
+export declare const REVERSE_DELIM: Record<string, string>;
+/** Characters a run must escape so the LaTeX tokenizer treats them as text. */
+export declare const REVERSE_ESCAPE: Record<string, string>;
+//# sourceMappingURL=latex-omml-symbols.d.ts.map

package/dist/math/latex-omml-symbols.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"latex-omml-symbols.d.ts","sourceRoot":"","sources":["../../src/math/latex-omml-symbols.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,eAAO,MAAM,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAqC5C,CAAC;AAIF,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CA2C/C,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAoB7C,CAAC;AAIF,eAAO,MAAM,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAY3C,CAAC;AAIF,eAAO,MAAM,UAAU,aA6BrB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,aAA6D,CAAC;AAI3F,6EAA6E;AAC7E,eAAO,MAAM,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAc7C,CAAC;AAEF,+EAA+E;AAC/E,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAKjD,CAAC;AAIF,kFAAkF;AAClF,eAAO,MAAM,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAkB5C,CAAC;AAEF,kEAAkE;AAClE,eAAO,MAAM,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAQxD,CAAC;AAEF,6DAA6D;AAC7D,eAAO,MAAM,UAAU,aAUrB,CAAC;AAcH,eAAO,MAAM,aAAa,wBAAoB,CAAC;AAC/C,eAAO,MAAM,gBAAgB,wBAAuB,CAAC;AACrD,eAAO,MAAM,YAAY,wBAAmB,CAAC;AAC7C,eAAO,MAAM,cAAc,wBAAqB,CAAC;AACjD,eAAO,MAAM,aAAa,wBAAoB,CAAC;AAE/C,+EAA+E;AAC/E,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAUjD,CAAC"}

package/dist/math/latex-to-omml-commands.d.ts

@@ -0,0 +1,9 @@
+import type { LatexParserContext } from './latex-to-omml-constructs.js';
+import type { OmmlNode } from './omml-to-mathml.js';
+/**
+ * Build the construct for an already-consumed `\command` token. Returns null
+ * for commands that produce no node of their own (`\right`, `\\`, `\limits`,
+ * spacing that collapses to nothing, ...).
+ */
+export declare function parseCommand(ctx: LatexParserContext, cmd: string): OmmlNode | null;
+//# sourceMappingURL=latex-to-omml-commands.d.ts.map

package/dist/math/latex-to-omml-commands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"latex-to-omml-commands.d.ts","sourceRoot":"","sources":["../../src/math/latex-to-omml-commands.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AAkBxE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAgDpD;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,kBAAkB,EAAE,GAAG,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI,CAyElF"}

package/dist/math/latex-to-omml-constructs.d.ts

@@ -0,0 +1,39 @@
+import type { Token } from './latex-omml-siblings.js';
+import type { OmmlNode } from './omml-to-mathml.js';
+export interface LatexParserContext {
+    peek: () => Token | undefined;
+    next: () => Token | undefined;
+    parseGroup: () => OmmlNode[];
+    parseSingleOrGroup: () => OmmlNode[];
+    parseAtom: () => OmmlNode | null;
+    wrapE: (nodes: OmmlNode[]) => OmmlNode;
+    makeRun: (text: string, normal?: boolean) => OmmlNode;
+}
+export interface ScriptArgs {
+    sub: OmmlNode[];
+    sup: OmmlNode[];
+    hasSub: boolean;
+    hasSup: boolean;
+}
+/** Consume up to one `_{...}` and one `^{...}` in either order (whitespace between is ignored). */
+export declare function parseScriptArgs(ctx: LatexParserContext): ScriptArgs;
+/** Wrap `base` in sSub / sSup / sSubSup according to the parsed script args. */
+export declare function applyScripts(ctx: LatexParserContext, base: OmmlNode, args: ScriptArgs): OmmlNode;
+/** Try to parse trailing ^ and _ to wrap the base in superscript/subscript. */
+export declare function tryParseScripts(ctx: LatexParserContext, base: OmmlNode): OmmlNode;
+/** Parse an n-ary operator with optional `\limits`, sub/superscripts and body. */
+export declare function parseNary(ctx: LatexParserContext, operatorChar: string): OmmlNode;
+/** Parse a \left...\right delimiter pair. */
+export declare function parseDelimiter(ctx: LatexParserContext): OmmlNode;
+/**
+ * Parse a function application like `\sin{x}`, `\sin^{2}{x}` or
+ * `\lim_{x \to 0}{f}`. Limit-style names put a lone subscript beneath the
+ * name (`m:limLow`), matching PowerPoint's own structure for a limit.
+ */
+export declare function parseFuncApplication(ctx: LatexParserContext, name: string): OmmlNode;
+/**
+ * Read the raw text of a `\text{...}` argument, keeping spaces and mapping
+ * escapes (`\{`, `\%`) and symbol commands back to their characters.
+ */
+export declare function parseTextArgument(ctx: LatexParserContext): string;
+//# sourceMappingURL=latex-to-omml-constructs.d.ts.map

package/dist/math/latex-to-omml-constructs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"latex-to-omml-constructs.d.ts","sourceRoot":"","sources":["../../src/math/latex-to-omml-constructs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAOtD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAEpD,MAAM,WAAW,kBAAkB;IAClC,IAAI,EAAE,MAAM,KAAK,GAAG,SAAS,CAAC;IAC9B,IAAI,EAAE,MAAM,KAAK,GAAG,SAAS,CAAC;IAC9B,UAAU,EAAE,MAAM,QAAQ,EAAE,CAAC;IAC7B,kBAAkB,EAAE,MAAM,QAAQ,EAAE,CAAC;IACrC,SAAS,EAAE,MAAM,QAAQ,GAAG,IAAI,CAAC;IACjC,KAAK,EAAE,CAAC,KAAK,EAAE,QAAQ,EAAE,KAAK,QAAQ,CAAC;IACvC,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,KAAK,QAAQ,CAAC;CACtD;AAED,MAAM,WAAW,UAAU;IAC1B,GAAG,EAAE,QAAQ,EAAE,CAAC;IAChB,GAAG,EAAE,QAAQ,EAAE,CAAC;IAChB,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,EAAE,OAAO,CAAC;CAChB;AAED,mGAAmG;AACnG,wBAAgB,eAAe,CAAC,GAAG,EAAE,kBAAkB,GAAG,UAAU,CAkBnE;AAED,gFAAgF;AAChF,wBAAgB,YAAY,CAAC,GAAG,EAAE,kBAAkB,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,UAAU,GAAG,QAAQ,CA2BhG;AAED,+EAA+E;AAC/E,wBAAgB,eAAe,CAAC,GAAG,EAAE,kBAAkB,EAAE,IAAI,EAAE,QAAQ,GAAG,QAAQ,CAEjF;AAED,kFAAkF;AAClF,wBAAgB,SAAS,CAAC,GAAG,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,GAAG,QAAQ,CAmCjF;AAgBD,6CAA6C;AAC7C,wBAAgB,cAAc,CAAC,GAAG,EAAE,kBAAkB,GAAG,QAAQ,CA+BhE;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,kBAAkB,EAAE,IAAI,EAAE,MAAM,GAAG,QAAQ,CAkCpF;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,kBAAkB,GAAG,MAAM,CA0BjE"}

package/dist/math/latex-to-omml-environments.d.ts

@@ -0,0 +1,28 @@
+import type { LatexParserContext } from './latex-to-omml-constructs.js';
+import type { OmmlNode } from './omml-to-mathml.js';
+/** Wrap `inner` in an `m:d` with the given (possibly empty) delimiters. */
+export declare function wrapDelimited(ctx: LatexParserContext, inner: OmmlNode, open: string, close: string): OmmlNode;
+/** Parse `\begin{env} ... \end{env}` into a matrix, delimited matrix, eqArr or cases. */
+export declare function parseEnvironment(ctx: LatexParserContext): OmmlNode | null;
+/** `\hat{x}` and friends: `m:acc` with the combining character in `m:chr`. */
+export declare function parseAccent(ctx: LatexParserContext, chr: string): OmmlNode;
+/** `\overline{x}` / `\underline{x}`: `m:bar` with an explicit position. */
+export declare function parseBar(ctx: LatexParserContext, pos: 'top' | 'bot'): OmmlNode;
+/**
+ * `\underbrace{x}_{n}` / `\overbrace{x}^{n}`: `m:groupChr`, wrapped in
+ * `m:limLow` / `m:limUpp` when a label follows on the matching side.
+ */
+export declare function parseGroupChr(ctx: LatexParserContext, chr: string, pos: 'top' | 'bot'): OmmlNode;
+/** `\underset{lim}{base}` -> `m:limLow`; `\overset{lim}{base}` -> `m:limUpp`. */
+export declare function parseUnderOverset(ctx: LatexParserContext, tag: 'm:limLow' | 'm:limUpp'): OmmlNode;
+/** `\boxed{x}` -> `m:borderBox`. */
+export declare function parseBoxed(ctx: LatexParserContext): OmmlNode;
+/** `\phantom` / `\hphantom` / `\vphantom` -> `m:phant` with the matching flags. */
+export declare function parsePhantom(ctx: LatexParserContext, kind: 'full' | 'h' | 'v'): OmmlNode;
+/** Build `m:sPre` from already-parsed sub/sup arguments and the base atom. */
+export declare function buildPrescript(ctx: LatexParserContext, sub: OmmlNode[], sup: OmmlNode[]): OmmlNode;
+/** `\prescript{sup}{sub}{base}` (mathtools). */
+export declare function parsePrescript(ctx: LatexParserContext): OmmlNode;
+/** `\operatorname{name}{arg}`: an arbitrary function name in `m:func`. */
+export declare function parseOperatorName(ctx: LatexParserContext): OmmlNode;
+//# sourceMappingURL=latex-to-omml-environments.d.ts.map

package/dist/math/latex-to-omml-environments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"latex-to-omml-environments.d.ts","sourceRoot":"","sources":["../../src/math/latex-to-omml-environments.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AAOxE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAMpD,2EAA2E;AAC3E,wBAAgB,aAAa,CAC5B,GAAG,EAAE,kBAAkB,EACvB,KAAK,EAAE,QAAQ,EACf,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,GACX,QAAQ,CAcV;AAyED,yFAAyF;AACzF,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,kBAAkB,GAAG,QAAQ,GAAG,IAAI,CAqBzE;AAID,8EAA8E;AAC9E,wBAAgB,WAAW,CAAC,GAAG,EAAE,kBAAkB,EAAE,GAAG,EAAE,MAAM,GAAG,QAAQ,CAO1E;AAED,2EAA2E;AAC3E,wBAAgB,QAAQ,CAAC,GAAG,EAAE,kBAAkB,EAAE,GAAG,EAAE,KAAK,GAAG,KAAK,GAAG,QAAQ,CAO9E;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,kBAAkB,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,KAAK,GAAG,KAAK,GAAG,QAAQ,CAmBhG;AAED,iFAAiF;AACjF,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,kBAAkB,EAAE,GAAG,EAAE,UAAU,GAAG,UAAU,GAAG,QAAQ,CAKjG;AAED,oCAAoC;AACpC,wBAAgB,UAAU,CAAC,GAAG,EAAE,kBAAkB,GAAG,QAAQ,CAE5D;AAED,mFAAmF;AACnF,wBAAgB,YAAY,CAAC,GAAG,EAAE,kBAAkB,EAAE,IAAI,EAAE,MAAM,GAAG,GAAG,GAAG,GAAG,GAAG,QAAQ,CAcxF;AAED,8EAA8E;AAC9E,wBAAgB,cAAc,CAC7B,GAAG,EAAE,kBAAkB,EACvB,GAAG,EAAE,QAAQ,EAAE,EACf,GAAG,EAAE,QAAQ,EAAE,GACb,QAAQ,CASV;AAED,gDAAgD;AAChD,wBAAgB,cAAc,CAAC,GAAG,EAAE,kBAAkB,GAAG,QAAQ,CAIhE;AAED,0EAA0E;AAC1E,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,kBAAkB,GAAG,QAAQ,CAEnE"}

package/dist/math/latex-to-omml.d.ts

@@ -0,0 +1,9 @@
+export { convertOmmlToLatex } from './omml-to-latex.js';
+/**
+ * Convert a LaTeX math string into an OMML XML object (fast-xml-parser shape).
+ *
+ * The returned object has the shape `{ "m:oMathPara": { "m:oMath": { … } } }`,
+ * matching what the core pipeline stores as `TextSegment.equationXml`.
+ */
+export declare function convertLatexToOmml(latex: string): Record<string, unknown>;
+//# sourceMappingURL=latex-to-omml.d.ts.map

package/dist/math/latex-to-omml.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"latex-to-omml.d.ts","sourceRoot":"","sources":["../../src/math/latex-to-omml.ts"],"names":[],"mappings":"AA2BA,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAiLxD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAsBzE"}

package/dist/math/omml-color.d.ts

@@ -0,0 +1,11 @@
+import type { OmmlNode as XmlObject } from './omml-node.js';
+/**
+ * Read the first explicit DrawingML run colour nested inside an OMML tree.
+ * Office Math stores formatting in `a:rPr`, not in `m:rPr`, so this colour
+ * must travel with the generated MathML rather than the text shape's default
+ * paragraph style.
+ */
+export declare function getOmmlMathColor(node: XmlObject | undefined): string | undefined;
+/** Read the first explicit DrawingML run size, stored in hundredths of a point. */
+export declare function getOmmlMathFontSize(node: XmlObject | undefined): number | undefined;
+//# sourceMappingURL=omml-color.d.ts.map

package/dist/math/omml-color.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"omml-color.d.ts","sourceRoot":"","sources":["../../src/math/omml-color.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,IAAI,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE5D;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,SAAS,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAqChF;AAED,mFAAmF;AACnF,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,SAAS,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAgCnF"}

package/dist/math/omml-dom.d.ts

@@ -0,0 +1,7 @@
+import { type XmlElement } from '../xml/index.js';
+import type { OmmlNode } from './omml-node.js';
+/** Adapt an ordered, namespace-aware OOXML DOM without a product parser. */
+export declare function ommlFromElement(element: XmlElement): OmmlNode;
+/** Parse standalone OMML using the shared XML parser's validation and DTD rejection. */
+export declare function parseOmml(xml: string): OmmlNode;
+//# sourceMappingURL=omml-dom.d.ts.map

package/dist/math/omml-dom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"omml-dom.d.ts","sourceRoot":"","sources":["../../src/math/omml-dom.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAEtE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAS/C,4EAA4E;AAC5E,wBAAgB,eAAe,CAAC,OAAO,EAAE,UAAU,GAAG,QAAQ,CAiB7D;AAED,wFAAwF;AACxF,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ,CAE/C"}

package/dist/math/omml-mathml-converters.d.ts

@@ -0,0 +1,39 @@
+import type { OmmlNode } from './omml-node.js';
+import { type ChildrenConverter } from './omml-mathml-helpers.js';
+/** m:r : text run: classify as identifier, number, or operator. */
+export declare function convertRun(node: OmmlNode): string;
+/** m:f : fraction. */
+export declare function convertFraction(node: OmmlNode, cc: ChildrenConverter): string;
+/** m:rad : radical: square root or nth root. */
+export declare function convertRadical(node: OmmlNode, cc: ChildrenConverter): string;
+/** m:sSup : superscript. */
+export declare function convertSuperscript(node: OmmlNode, cc: ChildrenConverter): string;
+/** m:sSub : subscript. */
+export declare function convertSubscript(node: OmmlNode, cc: ChildrenConverter): string;
+/** m:sSubSup : simultaneous subscript and superscript. */
+export declare function convertSubSup(node: OmmlNode, cc: ChildrenConverter): string;
+/** m:sPre : pre-sub-superscript (e.g. isotope notation). */
+export declare function convertPreSubSup(node: OmmlNode, cc: ChildrenConverter): string;
+/** m:nary : n-ary operator (sum, integral, product, etc.). */
+export declare function convertNary(node: OmmlNode, cc: ChildrenConverter): string;
+/** m:d : delimiter (parentheses, brackets, pipes, etc.). */
+export declare function convertDelimiter(node: OmmlNode, cc: ChildrenConverter): string;
+/** m:m : matrix / array layout. */
+export declare function convertMatrix(node: OmmlNode, cc: ChildrenConverter): string;
+/** m:acc : accent mark (hat, bar, tilde, dot, etc.). */
+export declare function convertAccent(node: OmmlNode, cc: ChildrenConverter): string;
+/** m:bar : overbar or underbar. */
+export declare function convertBar(node: OmmlNode, cc: ChildrenConverter): string;
+/** m:limLow : lower limit. */
+export declare function convertLimLow(node: OmmlNode, cc: ChildrenConverter): string;
+/** m:limUpp : upper limit. */
+export declare function convertLimUpp(node: OmmlNode, cc: ChildrenConverter): string;
+/** m:groupChr : grouping character (brace under/over). */
+export declare function convertGroupChr(node: OmmlNode, cc: ChildrenConverter): string;
+/** m:eqArr : equation array (aligned equations). */
+export declare function convertEqArr(node: OmmlNode, cc: ChildrenConverter): string;
+/** m:box / m:borderBox : grouping box (transparent container). */
+export declare function convertBox(node: OmmlNode, cc: ChildrenConverter): string;
+/** m:func : function application (sin, cos, log, lim, etc.). */
+export declare function convertFunc(node: OmmlNode, cc: ChildrenConverter): string;
+//# sourceMappingURL=omml-mathml-converters.d.ts.map

package/dist/math/omml-mathml-converters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"omml-mathml-converters.d.ts","sourceRoot":"","sources":["../../src/math/omml-mathml-converters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EAYN,KAAK,iBAAiB,EACtB,MAAM,0BAA0B,CAAC;AAGlC,mEAAmE;AACnE,wBAAgB,UAAU,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,CAqBjD;AAED,sBAAsB;AACtB,wBAAgB,eAAe,CAAC,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,iBAAiB,GAAG,MAAM,CAa7E;AAED,gDAAgD;AAChD,wBAAgB,cAAc,CAAC,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,iBAAiB,GAAG,MAAM,CAU5E;AAED,4BAA4B;AAC5B,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,iBAAiB,GAAG,MAAM,CAIhF;AAED,0BAA0B;AAC1B,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,iBAAiB,GAAG,MAAM,CAI9E;AAED,0DAA0D;AAC1D,wBAAgB,aAAa,CAAC,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,iBAAiB,GAAG,MAAM,CAK3E;AAED,4DAA4D;AAC5D,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,iBAAiB,GAAG,MAAM,CAK9E;AAED,8DAA8D;AAC9D,wBAAgB,WAAW,CAAC,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,iBAAiB,GAAG,MAAM,CAwCzE;AAED,4DAA4D;AAC5D,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,iBAAiB,GAAG,MAAM,CA0B9E;AAED,mCAAmC;AACnC,wBAAgB,aAAa,CAAC,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,iBAAiB,GAAG,MAAM,CAc3E;AAED,wDAAwD;AACxD,wBAAgB,aAAa,CAAC,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,iBAAiB,GAAG,MAAM,CAQ3E;AAED,mCAAmC;AACnC,wBAAgB,UAAU,CAAC,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,iBAAiB,GAAG,MAAM,CASxE;AAED,8BAA8B;AAC9B,wBAAgB,aAAa,CAAC,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,iBAAiB,GAAG,MAAM,CAI3E;AAED,8BAA8B;AAC9B,wBAAgB,aAAa,CAAC,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,iBAAiB,GAAG,MAAM,CAI3E;AAED,0DAA0D;AAC1D,wBAAgB,eAAe,CAAC,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,iBAAiB,GAAG,MAAM,CAY7E;AAED,oDAAoD;AACpD,wBAAgB,YAAY,CAAC,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,iBAAiB,GAAG,MAAM,CAS1E;AAED,kEAAkE;AAClE,wBAAgB,UAAU,CAAC,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,iBAAiB,GAAG,MAAM,CAExE;AAED,gEAAgE;AAChE,wBAAgB,WAAW,CAAC,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,iBAAiB,GAAG,MAAM,CAIzE"}

package/dist/math/omml-mathml-helpers.d.ts

@@ -0,0 +1,23 @@
+import type { OmmlNode } from './omml-node.js';
+export type ChildrenConverter = (node: OmmlNode) => string;
+/** Safely retrieve a child node, always returning an object (never undefined). */
+export declare function child(node: OmmlNode | undefined, key: string): OmmlNode;
+/** Ensure a value is an array of OmmlNode. */
+export declare function ensureArray(value: OmmlNode[keyof OmmlNode]): OmmlNode[];
+/** Read a string attribute from a node. */
+export declare function attr(node: OmmlNode | undefined, name: string): string;
+/** Read the `@_val` attribute (extremely common in OMML property nodes). */
+export declare function val(node: OmmlNode | undefined): string;
+/** Escape angle brackets and ampersands for safe embedding in MathML. */
+export declare function escapeXml(text: string): string;
+/** Read an `m:t` text run value (object/string/number) as a string. */
+export declare function readText(node: OmmlNode): string;
+/** Set of characters treated as mathematical operators. */
+export declare const OPERATOR_CHARS: Set<string>;
+export declare function isOperator(ch: string): boolean;
+export declare function isNumeric(text: string): boolean;
+export declare const ACCENT_MAP: Record<string, string>;
+export declare const NARY_CHAR_MAP: Record<string, string>;
+export declare const DELIM_BEGIN_MAP: Record<string, string>;
+export declare const DELIM_END_MAP: Record<string, string>;
+//# sourceMappingURL=omml-mathml-helpers.d.ts.map

package/dist/math/omml-mathml-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"omml-mathml-helpers.d.ts","sourceRoot":"","sources":["../../src/math/omml-mathml-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC/C,MAAM,MAAM,iBAAiB,GAAG,CAAC,IAAI,EAAE,QAAQ,KAAK,MAAM,CAAC;AAG3D,kFAAkF;AAClF,wBAAgB,KAAK,CAAC,IAAI,EAAE,QAAQ,GAAG,SAAS,EAAE,GAAG,EAAE,MAAM,GAAG,QAAQ,CASvE;AAED,8CAA8C;AAC9C,wBAAgB,WAAW,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,QAAQ,CAAC,GAAG,QAAQ,EAAE,CAWvE;AAED,2CAA2C;AAC3C,wBAAgB,IAAI,CAAC,IAAI,EAAE,QAAQ,GAAG,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAMrE;AAED,4EAA4E;AAC5E,wBAAgB,GAAG,CAAC,IAAI,EAAE,QAAQ,GAAG,SAAS,GAAG,MAAM,CAEtD;AAED,yEAAyE;AACzE,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE9C;AAED,uEAAuE;AACvE,wBAAgB,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,CAa/C;AAID,2DAA2D;AAC3D,eAAO,MAAM,cAAc,aAyDzB,CAAC;AAEH,wBAAgB,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAE9C;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE/C;AAID,eAAO,MAAM,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAgB7C,CAAC;AAIF,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAYhD,CAAC;AAIF,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CASlD,CAAC;AAEF,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAShD,CAAC"}

package/dist/math/omml-node.d.ts

@@ -0,0 +1,7 @@
+/** OMML compatibility tree: attributes use `@_`, text uses `#text`. */
+export type OmmlNode = Record<string, unknown>;
+/** Retain the established encoded key spelling when returning legacy object trees. */
+export declare function orderedXmlKey(baseName: string, order: number): string;
+/** Accept both the legacy spelling and the neutral DOM adapter's ordered keys. */
+export declare function stripXmlOrderSuffix(tagName: string): string;
+//# sourceMappingURL=omml-node.d.ts.map

package/dist/math/omml-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"omml-node.d.ts","sourceRoot":"","sources":["../../src/math/omml-node.ts"],"names":[],"mappings":"AAAA,uEAAuE;AACvE,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAE/C,sFAAsF;AACtF,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAErE;AAED,kFAAkF;AAClF,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAE3D"}

package/dist/math/omml-to-latex-helpers.d.ts

@@ -0,0 +1,41 @@
+export type XmlRecord = Record<string, unknown>;
+export declare function ensureArr(val: unknown): XmlRecord[];
+export declare function childNode(node: XmlRecord | undefined, key: string): XmlRecord;
+export declare function attrVal(node: XmlRecord | undefined): string;
+/** True when the property node exists (even with an empty `m:val`). */
+export declare function hasAttr(node: XmlRecord | undefined): boolean;
+/** OMML boolean property: `1`, `on`, `true` (or a bare presence) are truthy. */
+export declare function isOn(node: XmlRecord | undefined): boolean;
+/** Read an `m:t` value (string / number / `{ '#text' }` object) as a string. */
+export declare function readRunText(run: XmlRecord): string;
+/** Content keys of a container: everything but attributes and `*Pr` property nodes. */
+export declare function contentKeys(node: XmlRecord): string[];
+/**
+ * When `container` holds exactly one child element, return its tag and node;
+ * otherwise `null`. Used to recognise `m:d( m:m )` as `pmatrix`, etc.
+ */
+export declare function soleChild(container: XmlRecord | undefined): {
+    tag: string;
+    node: XmlRecord;
+} | null;
+/** Escape one character of run text for the LaTeX tokenizer. */
+export declare function escapeChar(ch: string): string;
+/** Escape a whole run of math text (symbols become commands, syntax is escaped). */
+export declare function escapeMathText(text: string): string;
+/**
+ * Escape text destined for a `\text{...}` argument: only the brace syntax
+ * matters. One pass over a character class, so the backslash a brace escape
+ * introduces is never itself re-escaped by a later pass.
+ */
+export declare function escapeTextArgument(text: string): string;
+/**
+ * True when the LaTeX for `container` is a single atom that can take a script
+ * directly (`x^{2}`); multi-atom bases need braces (`{10}^{2}`, `{ab}_{i}`).
+ */
+export declare function isSingleAtom(container: XmlRecord | undefined): boolean;
+/**
+ * Graceful fallback for constructs with no LaTeX spelling: collect every
+ * `m:t` in document order so the user still sees (and keeps) the content.
+ */
+export declare function collectText(node: unknown): string;
+//# sourceMappingURL=omml-to-latex-helpers.d.ts.map

package/dist/math/omml-to-latex-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"omml-to-latex-helpers.d.ts","sourceRoot":"","sources":["../../src/math/omml-to-latex-helpers.ts"],"names":[],"mappings":"AAQA,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEhD,wBAAgB,SAAS,CAAC,GAAG,EAAE,OAAO,GAAG,SAAS,EAAE,CAWnD;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,SAAS,GAAG,SAAS,EAAE,GAAG,EAAE,MAAM,GAAG,SAAS,CAY7E;AAED,wBAAgB,OAAO,CAAC,IAAI,EAAE,SAAS,GAAG,SAAS,GAAG,MAAM,CAS3D;AAED,uEAAuE;AACvE,wBAAgB,OAAO,CAAC,IAAI,EAAE,SAAS,GAAG,SAAS,GAAG,OAAO,CAE5D;AAED,gFAAgF;AAChF,wBAAgB,IAAI,CAAC,IAAI,EAAE,SAAS,GAAG,SAAS,GAAG,OAAO,CAGzD;AAED,gFAAgF;AAChF,wBAAgB,WAAW,CAAC,GAAG,EAAE,SAAS,GAAG,MAAM,CAgBlD;AAED,uFAAuF;AACvF,wBAAgB,WAAW,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,EAAE,CAQrD;AAED;;;GAGG;AACH,wBAAgB,SAAS,CACxB,SAAS,EAAE,SAAS,GAAG,SAAS,GAC9B;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,SAAS,CAAA;CAAE,GAAG,IAAI,CAazC;AAED,gEAAgE;AAChE,wBAAgB,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAQ7C;AAED,oFAAoF;AACpF,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEnD;AASD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,SAAS,EAAE,SAAS,GAAG,SAAS,GAAG,OAAO,CAatE;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,CA6BjD"}

package/dist/math/omml-to-latex-layout.d.ts

@@ -0,0 +1,18 @@
+import type { XmlRecord } from './omml-to-latex-helpers.js';
+/** Recursive emitters supplied by `omml-to-latex.ts`. */
+export interface LatexEmitter {
+    /** All content children of a container, in document order. */
+    children(node: XmlRecord | undefined): string;
+    /** The content of one named child (`m:e`, `m:num`, ...). */
+    arg(node: XmlRecord, key: string): string;
+}
+export declare function naryToLatex(emit: LatexEmitter, node: XmlRecord): string;
+export declare function rowsToLatex(emit: LatexEmitter, rows: XmlRecord[]): string;
+export declare function matrixToLatex(emit: LatexEmitter, node: XmlRecord, env: string): string;
+export declare function eqArrToLatex(emit: LatexEmitter, node: XmlRecord): string;
+/**
+ * `m:d`: a `\begin{pmatrix}`-style environment, `\begin{cases}` or `\binom`
+ * when the delimiters and sole child match, otherwise `\left ... \right`.
+ */
+export declare function delimiterToLatex(emit: LatexEmitter, node: XmlRecord): string;
+//# sourceMappingURL=omml-to-latex-layout.d.ts.map

package/dist/math/omml-to-latex-layout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"omml-to-latex-layout.d.ts","sourceRoot":"","sources":["../../src/math/omml-to-latex-layout.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAW5D,yDAAyD;AACzD,MAAM,WAAW,YAAY;IAC5B,8DAA8D;IAC9D,QAAQ,CAAC,IAAI,EAAE,SAAS,GAAG,SAAS,GAAG,MAAM,CAAC;IAC9C,4DAA4D;IAC5D,GAAG,CAAC,IAAI,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC;CAC1C;AAMD,wBAAgB,WAAW,CAAC,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,SAAS,GAAG,MAAM,CAgBvE;AA0BD,wBAAgB,WAAW,CAAC,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,SAAS,EAAE,GAAG,MAAM,CAEzE;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAOtF;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,SAAS,GAAG,MAAM,CAExE;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,SAAS,GAAG,MAAM,CA4B5E"}

package/dist/math/omml-to-latex.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Reverse-convert an OMML node back to LaTeX for editing. Accepts the object at
+ * the `m:oMathPara` level, at `m:oMath`, or a bare content container.
+ */
+export declare function convertOmmlToLatex(omml: Record<string, unknown>): string;
+//# sourceMappingURL=omml-to-latex.d.ts.map

package/dist/math/omml-to-latex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"omml-to-latex.d.ts","sourceRoot":"","sources":["../../src/math/omml-to-latex.ts"],"names":[],"mappings":"AA6NA;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAgBxE"}

package/dist/math/omml-to-mathml.d.ts

@@ -0,0 +1,21 @@
+/** Pure OMML to MathML conversion, with no browser or document-format dependency. */
+import type { OmmlNode } from './omml-node.js';
+export type { OmmlNode } from './omml-node.js';
+/**
+ * Convert an OMML XML node (from fast-xml-parser) into a MathML string.
+ *
+ * Accepts the object at the `<a14:m>` / `<m:oMathPara>` level or directly at
+ * `<m:oMath>`. Returns a `<math>` element string, or empty string if the input
+ * is empty / unparseable.
+ */
+export declare function convertOmmlToMathMl(ommlNode: OmmlNode): string;
+/**
+ * Convenience alias used by the Vue viewer: `ommlToMathml(omml)`.
+ *
+ * Accepts the parsed OMML object (the shape stored on
+ * {@link TextSegment.equationXml}) or a raw OMML markup string. String inputs
+ * are not re-parsed here (no XML parser dependency in this pure module) : they
+ * are returned wrapped so callers can still surface raw markup if needed.
+ */
+export declare function ommlToMathml(omml: OmmlNode | string): string;
+//# sourceMappingURL=omml-to-mathml.d.ts.map

package/dist/math/omml-to-mathml.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"omml-to-mathml.d.ts","sourceRoot":"","sources":["../../src/math/omml-to-mathml.ts"],"names":[],"mappings":"AAAA,qFAAqF;AACrF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAI/C,YAAY,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AA4H/C;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAqB9D;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG,MAAM,CAO5D"}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ooxml-core",
-	"version": "0.4.0",
+	"version": "0.5.0",
 	"description": "Shared OOXML logic for the Word, PowerPoint and Excel viewers: everything except the UI",
 	"keywords": [
 		"charts",
@@ -140,6 +140,11 @@
 			"types": "./dist/pptx/signature-node/index.d.ts",
 			"import": "./dist/pptx/signature-node/index.mjs",
 			"require": "./dist/pptx/signature-node/index.cjs"
+		},
+		"./math": {
+			"types": "./dist/math/index.d.ts",
+			"import": "./dist/math/index.mjs",
+			"require": "./dist/math/index.cjs"
 		}
 	},
 	"publishConfig": {