@pie-players/pie-assessment-toolkit 0.3.44 → 0.3.45

package/dist/services/tts/math-alignment/mathml-tokenizer.js

@@ -0,0 +1,317 @@
+const OPERATOR_ALIASES = new Map([
+    ["+", ["plus"]],
+    ["-", ["minus", "negative"]],
+    ["−", ["minus", "negative"]],
+    ["×", ["times", "multiplied by"]],
+    ["÷", ["divided by"]],
+    ["=", ["equals", "equal to"]],
+    ["≠", ["is not equal to", "not equal to"]],
+    ["≈", ["approximately equals"]],
+    ["≤", ["less than or equal to"]],
+    ["≥", ["greater than or equal to"]],
+    ["<", ["less than"]],
+    [">", ["greater than"]],
+    ["∠", ["angle"]],
+    ["△", ["triangle"]],
+    ["□", ["box"]],
+    ["○", ["circle"]],
+    ["°", ["degrees", "degree"]],
+    ["%", ["percent"]],
+    ["'", ["prime"]],
+    ["′", ["prime"]],
+    ["•", ["times"]],
+    ["·", ["times"]],
+    ["\u2062", ["times", "multiplied by"]],
+]);
+// Invisible operators (no glyph). A TTS engine usually does not voice them, so
+// they are tokenized as OPTIONAL — they only consume a spoken token when one
+// happens to match (e.g. an invisible-times read aloud as "times"). Marking
+// them required would force a coarse fallback for any function call (sin, f(x))
+// or implicit product.
+const INVISIBLE_OPERATOR_ROLES = new Map([
+    ["\u2061", "function-application"],
+    ["\u2062", "implicit-multiply"],
+    ["\u2063", "invisible-separator"],
+    ["\u2064", "invisible-plus"],
+]);
+// Exponents a TTS engine reliably reads as a single power word. Other exponents
+// (variables, 4 and up, nested) are voiced in ways we cannot anchor, so they
+// recurse and let the all-or-nothing cover check fall back to the expression.
+const SUPERSCRIPT_ALIASES = new Map([
+    ["2", ["squared"]],
+    ["3", ["cubed"]],
+]);
+// 2D / scripted containers we do not attempt to track per token. Each becomes a
+// single opaque, unmatchable structure token so any expression containing one
+// degrades to a coarse whole-expression highlight rather than risking a
+// misaligned per-glyph highlight from flattened inner tokens.
+const OPAQUE_STRUCTURE_ROLES = new Map([
+    ["msqrt", "radical"],
+    ["mroot", "radical"],
+    ["msub", "subscript"],
+    ["msubsup", "subsupscript"],
+    ["munder", "underscript"],
+    ["mover", "overscript"],
+    ["munderover", "underoverscript"],
+    ["mmultiscripts", "multiscript"],
+    ["menclose", "enclosure"],
+]);
+const normalizeWhitespace = (value) => value.replace(/\s+/g, " ").trim();
+const localNameOf = (element) => (element.localName || element.tagName || "").toLowerCase();
+const isElement = (node) => node.nodeType === Node.ELEMENT_NODE;
+const elementChildren = (element) => Array.from(element.childNodes).filter(isElement);
+const textContentOf = (element) => normalizeWhitespace(element.textContent || "");
+const elementTarget = (element, quality) => ({
+    type: "element-range",
+    quality,
+    element,
+});
+const tokenKindFor = (tagName) => {
+    switch (tagName) {
+        case "mi":
+            return "identifier";
+        case "mn":
+            return "number";
+        case "mo":
+            return "operator";
+        case "mtext":
+        case "ms":
+            return "text";
+        case "mspace":
+            return "space";
+        default:
+            return "unknown";
+    }
+};
+const normalizeToken = (text, kind) => {
+    if (kind === "operator") {
+        if (text === "−")
+            return "-";
+        return text;
+    }
+    return text.toLowerCase();
+};
+const aliasesFor = (text, kind, role) => {
+    if (role === "fraction")
+        return ["over", "divided by"];
+    if (role === "superscript")
+        return SUPERSCRIPT_ALIASES.get(text) ?? [];
+    if (text === "|")
+        return ["absolute value"];
+    if (kind === "operator")
+        return OPERATOR_ALIASES.get(text) || [];
+    return [];
+};
+const createToken = (args) => {
+    const normalized = args.normalized ?? normalizeToken(args.text, args.kind || "unknown");
+    return {
+        id: `math-token-${args.state.nextId++}`,
+        kind: args.kind,
+        role: args.role,
+        text: args.text,
+        normalized,
+        spokenAliases: aliasesFor(args.text, args.kind, args.role),
+        sourceElement: args.sourceElement,
+        path: args.path,
+        target: args.target || elementTarget(args.sourceElement, "element-range"),
+        optional: args.optional,
+    };
+};
+const pushToken = (state, token, collection = "tokens") => {
+    state[collection].push(token);
+};
+const visitChildren = (element, state, path) => {
+    elementChildren(element).forEach((child, index) => visitElement(child, state, `${path}/${localNameOf(child)}[${index}]`));
+};
+const visitFraction = (element, state, path) => {
+    const children = elementChildren(element);
+    if (children[0])
+        visitElement(children[0], state, `${path}/numerator`);
+    pushToken(state, createToken({
+        state,
+        kind: "structure",
+        role: "fraction",
+        text: "/",
+        sourceElement: element,
+        path,
+        target: elementTarget(element, "element-range"),
+    }));
+    if (children[1])
+        visitElement(children[1], state, `${path}/denominator`);
+};
+const visitFenced = (element, state, path) => {
+    const open = element.getAttribute("open") || "(";
+    const close = element.getAttribute("close") || ")";
+    pushToken(state, createToken({
+        state,
+        kind: "operator",
+        role: open === "|" ? "absolute-value-fence" : "open-fence",
+        text: open,
+        sourceElement: element,
+        path: `${path}/open`,
+        target: elementTarget(element, "element-range"),
+    }));
+    visitChildren(element, state, path);
+    pushToken(state, createToken({
+        state,
+        kind: "operator",
+        role: close === "|" ? "absolute-value-fence" : "close-fence",
+        text: close,
+        sourceElement: element,
+        path: `${path}/close`,
+        target: elementTarget(element, "element-range"),
+    }));
+};
+const visitSuperscript = (element, state, path) => {
+    const children = elementChildren(element);
+    if (children[0])
+        visitElement(children[0], state, `${path}/base`);
+    const exponent = children[1];
+    if (!exponent)
+        return;
+    const exponentText = textContentOf(exponent);
+    if (SUPERSCRIPT_ALIASES.has(exponentText)) {
+        // One token aliased to the power word ("squared" / "cubed"), targeting the
+        // whole superscript so the spoken power word highlights the base-and-
+        // exponent unit.
+        pushToken(state, createToken({
+            state,
+            kind: "structure",
+            role: "superscript",
+            text: exponentText,
+            normalized: exponentText,
+            sourceElement: exponent,
+            path: `${path}/exponent`,
+            target: elementTarget(element, "element-range"),
+        }));
+        return;
+    }
+    visitElement(exponent, state, `${path}/exponent`);
+};
+const visitOpaqueStructure = (element, state, path, role) => {
+    // A single required, unmatchable token. The NUL-prefixed normalized value can
+    // never equal a spoken token, so the cover check always falls back to the
+    // whole-expression target when this structure is present — no per-glyph
+    // guessing inside fractions-under-radicals, subscripts, accents, etc.
+    pushToken(state, createToken({
+        state,
+        kind: "structure",
+        role,
+        text: textContentOf(element) || role,
+        normalized: `\u0000${role}`,
+        sourceElement: element,
+        path,
+        target: elementTarget(element, "element-range"),
+    }));
+};
+const visitTable = (element, state, path) => {
+    let rowNumber = 0;
+    for (const child of elementChildren(element)) {
+        if (localNameOf(child) === "mtr" || localNameOf(child) === "mlabeledtr") {
+            rowNumber++;
+            pushToken(state, createToken({
+                state,
+                kind: "layout",
+                role: "table-row",
+                text: `row-${rowNumber}`,
+                normalized: `row-${rowNumber}`,
+                sourceElement: child,
+                path: `${path}/row[${rowNumber}]`,
+                target: elementTarget(child, "region-fallback"),
+            }), "layoutTargets");
+        }
+        visitElement(child, state, `${path}/${localNameOf(child)}[${rowNumber}]`);
+    }
+};
+const visitTokenElement = (element, state, path) => {
+    const text = textContentOf(element);
+    if (!text)
+        return;
+    const kind = tokenKindFor(localNameOf(element));
+    const invisibleRole = kind === "operator" ? INVISIBLE_OPERATOR_ROLES.get(text) : undefined;
+    const role = invisibleRole ??
+        (kind === "operator" && (text === "(" || text === ")")
+            ? "grouping-fence"
+            : kind);
+    pushToken(state, createToken({
+        state,
+        kind,
+        role,
+        text,
+        sourceElement: element,
+        path,
+        target: invisibleRole && element.parentElement
+            ? elementTarget(element.parentElement, "region-fallback")
+            : undefined,
+        optional: Boolean(invisibleRole) || role === "grouping-fence",
+    }));
+};
+const visitElement = (element, state, path) => {
+    const tagName = localNameOf(element);
+    switch (tagName) {
+        case "annotation":
+        case "annotation-xml":
+            return;
+        case "semantics": {
+            const presentation = elementChildren(element).find((child) => {
+                const childName = localNameOf(child);
+                return childName !== "annotation" && childName !== "annotation-xml";
+            });
+            if (presentation)
+                visitElement(presentation, state, `${path}/presentation`);
+            return;
+        }
+        case "mi":
+        case "mn":
+        case "mo":
+        case "mtext":
+        case "ms":
+        case "mspace":
+            visitTokenElement(element, state, path);
+            return;
+        case "mfrac":
+            visitFraction(element, state, path);
+            return;
+        case "msup":
+            visitSuperscript(element, state, path);
+            return;
+        case "mfenced":
+            visitFenced(element, state, path);
+            return;
+        case "mtable":
+            visitTable(element, state, path);
+            return;
+        case "mphantom":
+            // Invisible spacing content — must not become spoken tokens.
+            return;
+        case "maction": {
+            // Only the shown alternative (first child) is rendered/spoken.
+            const shown = elementChildren(element)[0];
+            if (shown)
+                visitElement(shown, state, `${path}/action`);
+            return;
+        }
+        default: {
+            const opaqueRole = OPAQUE_STRUCTURE_ROLES.get(tagName);
+            if (opaqueRole) {
+                visitOpaqueStructure(element, state, path, opaqueRole);
+                return;
+            }
+            visitChildren(element, state, path);
+        }
+    }
+};
+export const tokenizeMathML = (mathElement) => {
+    const state = {
+        tokens: [],
+        layoutTargets: [],
+        nextId: 0,
+    };
+    visitElement(mathElement, state, "/math");
+    return {
+        tokens: state.tokens,
+        layoutTargets: state.layoutTargets,
+        expressionTarget: elementTarget(mathElement, "region-fallback"),
+    };
+};
+//# sourceMappingURL=mathml-tokenizer.js.map

package/dist/services/tts/math-alignment/mathml-tokenizer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mathml-tokenizer.js","sourceRoot":"","sources":["../../../../src/services/tts/math-alignment/mathml-tokenizer.ts"],"names":[],"mappings":"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","sourcesContent":["import type {\n\tHighlightTarget,\n\tMathAlignmentToken,\n\tMathAlignmentTokenKind,\n\tMathMLTokenizationResult,\n} from \"./types.js\";\n\nconst OPERATOR_ALIASES = new Map<string, string[]>([\n\t[\"+\", [\"plus\"]],\n\t[\"-\", [\"minus\", \"negative\"]],\n\t[\"−\", [\"minus\", \"negative\"]],\n\t[\"×\", [\"times\", \"multiplied by\"]],\n\t[\"÷\", [\"divided by\"]],\n\t[\"=\", [\"equals\", \"equal to\"]],\n\t[\"≠\", [\"is not equal to\", \"not equal to\"]],\n\t[\"≈\", [\"approximately equals\"]],\n\t[\"≤\", [\"less than or equal to\"]],\n\t[\"≥\", [\"greater than or equal to\"]],\n\t[\"<\", [\"less than\"]],\n\t[\">\", [\"greater than\"]],\n\t[\"∠\", [\"angle\"]],\n\t[\"△\", [\"triangle\"]],\n\t[\"□\", [\"box\"]],\n\t[\"○\", [\"circle\"]],\n\t[\"°\", [\"degrees\", \"degree\"]],\n\t[\"%\", [\"percent\"]],\n\t[\"'\", [\"prime\"]],\n\t[\"′\", [\"prime\"]],\n\t[\"•\", [\"times\"]],\n\t[\"·\", [\"times\"]],\n\t[\"\\u2062\", [\"times\", \"multiplied by\"]],\n]);\n\n// Invisible operators (no glyph). A TTS engine usually does not voice them, so\n// they are tokenized as OPTIONAL — they only consume a spoken token when one\n// happens to match (e.g. an invisible-times read aloud as \"times\"). Marking\n// them required would force a coarse fallback for any function call (sin, f(x))\n// or implicit product.\nconst INVISIBLE_OPERATOR_ROLES = new Map<string, string>([\n\t[\"\\u2061\", \"function-application\"],\n\t[\"\\u2062\", \"implicit-multiply\"],\n\t[\"\\u2063\", \"invisible-separator\"],\n\t[\"\\u2064\", \"invisible-plus\"],\n]);\n\n// Exponents a TTS engine reliably reads as a single power word. Other exponents\n// (variables, 4 and up, nested) are voiced in ways we cannot anchor, so they\n// recurse and let the all-or-nothing cover check fall back to the expression.\nconst SUPERSCRIPT_ALIASES = new Map<string, string[]>([\n\t[\"2\", [\"squared\"]],\n\t[\"3\", [\"cubed\"]],\n]);\n\n// 2D / scripted containers we do not attempt to track per token. Each becomes a\n// single opaque, unmatchable structure token so any expression containing one\n// degrades to a coarse whole-expression highlight rather than risking a\n// misaligned per-glyph highlight from flattened inner tokens.\nconst OPAQUE_STRUCTURE_ROLES = new Map<string, string>([\n\t[\"msqrt\", \"radical\"],\n\t[\"mroot\", \"radical\"],\n\t[\"msub\", \"subscript\"],\n\t[\"msubsup\", \"subsupscript\"],\n\t[\"munder\", \"underscript\"],\n\t[\"mover\", \"overscript\"],\n\t[\"munderover\", \"underoverscript\"],\n\t[\"mmultiscripts\", \"multiscript\"],\n\t[\"menclose\", \"enclosure\"],\n]);\n\nconst normalizeWhitespace = (value: string): string =>\n\tvalue.replace(/\\s+/g, \" \").trim();\n\nconst localNameOf = (element: Element): string =>\n\t(element.localName || element.tagName || \"\").toLowerCase();\n\nconst isElement = (node: Node): node is Element =>\n\tnode.nodeType === Node.ELEMENT_NODE;\n\nconst elementChildren = (element: Element): Element[] =>\n\tArray.from(element.childNodes).filter(isElement);\n\nconst textContentOf = (element: Element): string =>\n\tnormalizeWhitespace(element.textContent || \"\");\n\nconst elementTarget = (\n\telement: Element,\n\tquality: \"element-range\" | \"region-fallback\",\n): HighlightTarget => ({\n\ttype: \"element-range\",\n\tquality,\n\telement,\n});\n\nconst tokenKindFor = (tagName: string): MathAlignmentTokenKind => {\n\tswitch (tagName) {\n\t\tcase \"mi\":\n\t\t\treturn \"identifier\";\n\t\tcase \"mn\":\n\t\t\treturn \"number\";\n\t\tcase \"mo\":\n\t\t\treturn \"operator\";\n\t\tcase \"mtext\":\n\t\tcase \"ms\":\n\t\t\treturn \"text\";\n\t\tcase \"mspace\":\n\t\t\treturn \"space\";\n\t\tdefault:\n\t\t\treturn \"unknown\";\n\t}\n};\n\nconst normalizeToken = (text: string, kind: MathAlignmentTokenKind): string => {\n\tif (kind === \"operator\") {\n\t\tif (text === \"−\") return \"-\";\n\t\treturn text;\n\t}\n\treturn text.toLowerCase();\n};\n\nconst aliasesFor = (\n\ttext: string,\n\tkind: MathAlignmentTokenKind,\n\trole: string,\n): string[] => {\n\tif (role === \"fraction\") return [\"over\", \"divided by\"];\n\tif (role === \"superscript\") return SUPERSCRIPT_ALIASES.get(text) ?? [];\n\tif (text === \"|\") return [\"absolute value\"];\n\tif (kind === \"operator\") return OPERATOR_ALIASES.get(text) || [];\n\treturn [];\n};\n\ninterface TokenizerState {\n\ttokens: MathAlignmentToken[];\n\tlayoutTargets: MathAlignmentToken[];\n\tnextId: number;\n}\n\nconst createToken = (args: {\n\tstate: TokenizerState;\n\tkind: MathAlignmentTokenKind;\n\trole: string;\n\ttext: string;\n\tnormalized?: string;\n\tsourceElement: Element;\n\tpath: string;\n\ttarget?: HighlightTarget;\n\toptional?: boolean;\n}): MathAlignmentToken => {\n\tconst normalized =\n\t\targs.normalized ?? normalizeToken(args.text, args.kind || \"unknown\");\n\treturn {\n\t\tid: `math-token-${args.state.nextId++}`,\n\t\tkind: args.kind,\n\t\trole: args.role,\n\t\ttext: args.text,\n\t\tnormalized,\n\t\tspokenAliases: aliasesFor(args.text, args.kind, args.role),\n\t\tsourceElement: args.sourceElement,\n\t\tpath: args.path,\n\t\ttarget: args.target || elementTarget(args.sourceElement, \"element-range\"),\n\t\toptional: args.optional,\n\t};\n};\n\nconst pushToken = (\n\tstate: TokenizerState,\n\ttoken: MathAlignmentToken,\n\tcollection: \"tokens\" | \"layoutTargets\" = \"tokens\",\n): void => {\n\tstate[collection].push(token);\n};\n\nconst visitChildren = (\n\telement: Element,\n\tstate: TokenizerState,\n\tpath: string,\n): void => {\n\telementChildren(element).forEach((child, index) =>\n\t\tvisitElement(child, state, `${path}/${localNameOf(child)}[${index}]`),\n\t);\n};\n\nconst visitFraction = (\n\telement: Element,\n\tstate: TokenizerState,\n\tpath: string,\n): void => {\n\tconst children = elementChildren(element);\n\tif (children[0]) visitElement(children[0], state, `${path}/numerator`);\n\tpushToken(\n\t\tstate,\n\t\tcreateToken({\n\t\t\tstate,\n\t\t\tkind: \"structure\",\n\t\t\trole: \"fraction\",\n\t\t\ttext: \"/\",\n\t\t\tsourceElement: element,\n\t\t\tpath,\n\t\t\ttarget: elementTarget(element, \"element-range\"),\n\t\t}),\n\t);\n\tif (children[1]) visitElement(children[1], state, `${path}/denominator`);\n};\n\nconst visitFenced = (\n\telement: Element,\n\tstate: TokenizerState,\n\tpath: string,\n): void => {\n\tconst open = element.getAttribute(\"open\") || \"(\";\n\tconst close = element.getAttribute(\"close\") || \")\";\n\tpushToken(\n\t\tstate,\n\t\tcreateToken({\n\t\t\tstate,\n\t\t\tkind: \"operator\",\n\t\t\trole: open === \"|\" ? \"absolute-value-fence\" : \"open-fence\",\n\t\t\ttext: open,\n\t\t\tsourceElement: element,\n\t\t\tpath: `${path}/open`,\n\t\t\ttarget: elementTarget(element, \"element-range\"),\n\t\t}),\n\t);\n\tvisitChildren(element, state, path);\n\tpushToken(\n\t\tstate,\n\t\tcreateToken({\n\t\t\tstate,\n\t\t\tkind: \"operator\",\n\t\t\trole: close === \"|\" ? \"absolute-value-fence\" : \"close-fence\",\n\t\t\ttext: close,\n\t\t\tsourceElement: element,\n\t\t\tpath: `${path}/close`,\n\t\t\ttarget: elementTarget(element, \"element-range\"),\n\t\t}),\n\t);\n};\n\nconst visitSuperscript = (\n\telement: Element,\n\tstate: TokenizerState,\n\tpath: string,\n): void => {\n\tconst children = elementChildren(element);\n\tif (children[0]) visitElement(children[0], state, `${path}/base`);\n\tconst exponent = children[1];\n\tif (!exponent) return;\n\tconst exponentText = textContentOf(exponent);\n\tif (SUPERSCRIPT_ALIASES.has(exponentText)) {\n\t\t// One token aliased to the power word (\"squared\" / \"cubed\"), targeting the\n\t\t// whole superscript so the spoken power word highlights the base-and-\n\t\t// exponent unit.\n\t\tpushToken(\n\t\t\tstate,\n\t\t\tcreateToken({\n\t\t\t\tstate,\n\t\t\t\tkind: \"structure\",\n\t\t\t\trole: \"superscript\",\n\t\t\t\ttext: exponentText,\n\t\t\t\tnormalized: exponentText,\n\t\t\t\tsourceElement: exponent,\n\t\t\t\tpath: `${path}/exponent`,\n\t\t\t\ttarget: elementTarget(element, \"element-range\"),\n\t\t\t}),\n\t\t);\n\t\treturn;\n\t}\n\tvisitElement(exponent, state, `${path}/exponent`);\n};\n\nconst visitOpaqueStructure = (\n\telement: Element,\n\tstate: TokenizerState,\n\tpath: string,\n\trole: string,\n): void => {\n\t// A single required, unmatchable token. The NUL-prefixed normalized value can\n\t// never equal a spoken token, so the cover check always falls back to the\n\t// whole-expression target when this structure is present — no per-glyph\n\t// guessing inside fractions-under-radicals, subscripts, accents, etc.\n\tpushToken(\n\t\tstate,\n\t\tcreateToken({\n\t\t\tstate,\n\t\t\tkind: \"structure\",\n\t\t\trole,\n\t\t\ttext: textContentOf(element) || role,\n\t\t\tnormalized: `\\u0000${role}`,\n\t\t\tsourceElement: element,\n\t\t\tpath,\n\t\t\ttarget: elementTarget(element, \"element-range\"),\n\t\t}),\n\t);\n};\n\nconst visitTable = (\n\telement: Element,\n\tstate: TokenizerState,\n\tpath: string,\n): void => {\n\tlet rowNumber = 0;\n\tfor (const child of elementChildren(element)) {\n\t\tif (localNameOf(child) === \"mtr\" || localNameOf(child) === \"mlabeledtr\") {\n\t\t\trowNumber++;\n\t\t\tpushToken(\n\t\t\t\tstate,\n\t\t\t\tcreateToken({\n\t\t\t\t\tstate,\n\t\t\t\t\tkind: \"layout\",\n\t\t\t\t\trole: \"table-row\",\n\t\t\t\t\ttext: `row-${rowNumber}`,\n\t\t\t\t\tnormalized: `row-${rowNumber}`,\n\t\t\t\t\tsourceElement: child,\n\t\t\t\t\tpath: `${path}/row[${rowNumber}]`,\n\t\t\t\t\ttarget: elementTarget(child, \"region-fallback\"),\n\t\t\t\t}),\n\t\t\t\t\"layoutTargets\",\n\t\t\t);\n\t\t}\n\t\tvisitElement(child, state, `${path}/${localNameOf(child)}[${rowNumber}]`);\n\t}\n};\n\nconst visitTokenElement = (\n\telement: Element,\n\tstate: TokenizerState,\n\tpath: string,\n): void => {\n\tconst text = textContentOf(element);\n\tif (!text) return;\n\tconst kind = tokenKindFor(localNameOf(element));\n\tconst invisibleRole =\n\t\tkind === \"operator\" ? INVISIBLE_OPERATOR_ROLES.get(text) : undefined;\n\tconst role =\n\t\tinvisibleRole ??\n\t\t(kind === \"operator\" && (text === \"(\" || text === \")\")\n\t\t\t? \"grouping-fence\"\n\t\t\t: kind);\n\tpushToken(\n\t\tstate,\n\t\tcreateToken({\n\t\t\tstate,\n\t\t\tkind,\n\t\t\trole,\n\t\t\ttext,\n\t\t\tsourceElement: element,\n\t\t\tpath,\n\t\t\ttarget:\n\t\t\t\tinvisibleRole && element.parentElement\n\t\t\t\t\t? elementTarget(element.parentElement, \"region-fallback\")\n\t\t\t\t\t: undefined,\n\t\t\toptional: Boolean(invisibleRole) || role === \"grouping-fence\",\n\t\t}),\n\t);\n};\n\nconst visitElement = (\n\telement: Element,\n\tstate: TokenizerState,\n\tpath: string,\n): void => {\n\tconst tagName = localNameOf(element);\n\tswitch (tagName) {\n\t\tcase \"annotation\":\n\t\tcase \"annotation-xml\":\n\t\t\treturn;\n\t\tcase \"semantics\": {\n\t\t\tconst presentation = elementChildren(element).find((child) => {\n\t\t\t\tconst childName = localNameOf(child);\n\t\t\t\treturn childName !== \"annotation\" && childName !== \"annotation-xml\";\n\t\t\t});\n\t\t\tif (presentation) visitElement(presentation, state, `${path}/presentation`);\n\t\t\treturn;\n\t\t}\n\t\tcase \"mi\":\n\t\tcase \"mn\":\n\t\tcase \"mo\":\n\t\tcase \"mtext\":\n\t\tcase \"ms\":\n\t\tcase \"mspace\":\n\t\t\tvisitTokenElement(element, state, path);\n\t\t\treturn;\n\t\tcase \"mfrac\":\n\t\t\tvisitFraction(element, state, path);\n\t\t\treturn;\n\t\tcase \"msup\":\n\t\t\tvisitSuperscript(element, state, path);\n\t\t\treturn;\n\t\tcase \"mfenced\":\n\t\t\tvisitFenced(element, state, path);\n\t\t\treturn;\n\t\tcase \"mtable\":\n\t\t\tvisitTable(element, state, path);\n\t\t\treturn;\n\t\tcase \"mphantom\":\n\t\t\t// Invisible spacing content — must not become spoken tokens.\n\t\t\treturn;\n\t\tcase \"maction\": {\n\t\t\t// Only the shown alternative (first child) is rendered/spoken.\n\t\t\tconst shown = elementChildren(element)[0];\n\t\t\tif (shown) visitElement(shown, state, `${path}/action`);\n\t\t\treturn;\n\t\t}\n\t\tdefault: {\n\t\t\tconst opaqueRole = OPAQUE_STRUCTURE_ROLES.get(tagName);\n\t\t\tif (opaqueRole) {\n\t\t\t\tvisitOpaqueStructure(element, state, path, opaqueRole);\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tvisitChildren(element, state, path);\n\t\t}\n\t}\n};\n\nexport const tokenizeMathML = (mathElement: Element): MathMLTokenizationResult => {\n\tconst state: TokenizerState = {\n\t\ttokens: [],\n\t\tlayoutTargets: [],\n\t\tnextId: 0,\n\t};\n\tvisitElement(mathElement, state, \"/math\");\n\n\treturn {\n\t\ttokens: state.tokens,\n\t\tlayoutTargets: state.layoutTargets,\n\t\texpressionTarget: elementTarget(mathElement, \"region-fallback\"),\n\t};\n};\n"]}

package/dist/services/tts/math-alignment/range-resolver.d.ts

@@ -0,0 +1,10 @@
+import type { AlignmentResult, HighlightTarget } from "./types.js";
+import type { ResolvedSpeechBoundary } from "./speech-tokenizer.js";
+export declare const resolveHighlightTargetForBoundary: (args: {
+    alignment: AlignmentResult;
+    boundary: ResolvedSpeechBoundary | null;
+}) => HighlightTarget;
+export declare const resolveMatchedHighlightTargetForBoundary: (args: {
+    alignment: AlignmentResult;
+    boundary: ResolvedSpeechBoundary | null;
+}) => HighlightTarget | null;

package/dist/services/tts/math-alignment/range-resolver.js

@@ -0,0 +1,13 @@
+export const resolveHighlightTargetForBoundary = (args) => {
+    if (!args.boundary)
+        return args.alignment.fallbackTarget;
+    const segment = args.alignment.segments.find((candidate) => candidate.speechTokenIds.includes(args.boundary.token.id));
+    return segment?.target || args.alignment.fallbackTarget;
+};
+export const resolveMatchedHighlightTargetForBoundary = (args) => {
+    if (!args.boundary)
+        return null;
+    const segment = args.alignment.segments.find((candidate) => candidate.speechTokenIds.includes(args.boundary.token.id));
+    return segment?.target || null;
+};
+//# sourceMappingURL=range-resolver.js.map

package/dist/services/tts/math-alignment/range-resolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"range-resolver.js","sourceRoot":"","sources":["../../../../src/services/tts/math-alignment/range-resolver.ts"],"names":[],"mappings":"AAGA,MAAM,CAAC,MAAM,iCAAiC,GAAG,CAAC,IAGjD,EAAmB,EAAE;IACrB,IAAI,CAAC,IAAI,CAAC,QAAQ;QAAE,OAAO,IAAI,CAAC,SAAS,CAAC,cAAc,CAAC;IACzD,MAAM,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,EAAE,CAC1D,SAAS,CAAC,cAAc,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAS,CAAC,KAAK,CAAC,EAAE,CAAC,CAC1D,CAAC;IACF,OAAO,OAAO,EAAE,MAAM,IAAI,IAAI,CAAC,SAAS,CAAC,cAAc,CAAC;AACzD,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,wCAAwC,GAAG,CAAC,IAGxD,EAA0B,EAAE;IAC5B,IAAI,CAAC,IAAI,CAAC,QAAQ;QAAE,OAAO,IAAI,CAAC;IAChC,MAAM,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,EAAE,CAC1D,SAAS,CAAC,cAAc,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAS,CAAC,KAAK,CAAC,EAAE,CAAC,CAC1D,CAAC;IACF,OAAO,OAAO,EAAE,MAAM,IAAI,IAAI,CAAC;AAChC,CAAC,CAAC","sourcesContent":["import type { AlignmentResult, HighlightTarget } from \"./types.js\";\nimport type { ResolvedSpeechBoundary } from \"./speech-tokenizer.js\";\n\nexport const resolveHighlightTargetForBoundary = (args: {\n\talignment: AlignmentResult;\n\tboundary: ResolvedSpeechBoundary | null;\n}): HighlightTarget => {\n\tif (!args.boundary) return args.alignment.fallbackTarget;\n\tconst segment = args.alignment.segments.find((candidate) =>\n\t\tcandidate.speechTokenIds.includes(args.boundary!.token.id),\n\t);\n\treturn segment?.target || args.alignment.fallbackTarget;\n};\n\nexport const resolveMatchedHighlightTargetForBoundary = (args: {\n\talignment: AlignmentResult;\n\tboundary: ResolvedSpeechBoundary | null;\n}): HighlightTarget | null => {\n\tif (!args.boundary) return null;\n\tconst segment = args.alignment.segments.find((candidate) =>\n\t\tcandidate.speechTokenIds.includes(args.boundary!.token.id),\n\t);\n\treturn segment?.target || null;\n};\n"]}

package/dist/services/tts/math-alignment/sequence-aligner.d.ts

@@ -0,0 +1,7 @@
+import type { AlignmentResult, MathMLTokenizationResult } from "./types.js";
+import type { SpeechSourceTokenization } from "./speech-tokenizer.js";
+export declare const alignSpeechToMath: (args: {
+    speech: SpeechSourceTokenization;
+    math: MathMLTokenizationResult;
+    minExactWordConfidence?: number;
+}) => AlignmentResult;

package/dist/services/tts/math-alignment/sequence-aligner.js

@@ -0,0 +1,119 @@
+const MIN_EXACT_WORD_CONFIDENCE = 0.95;
+// Candidate spoken forms for a math token: its own normalized value plus every
+// spoken alias, each split into the sequence of words a TTS engine emits (e.g.
+// "÷" → ["divided", "by"], "≤" → ["less", "than", "or", "equal", "to"]). This is
+// what lets multi-word operator names match — a single speech token can never
+// equal "divided by". Speech tokens are already number-word normalized by the
+// speech tokenizer (two → 2), so no numeric mapping is repeated here.
+const candidatePhrasesFor = (math) => {
+    const phrases = [];
+    const seen = new Set();
+    const add = (value) => {
+        const words = value.toLowerCase().trim().split(/\s+/).filter(Boolean);
+        if (words.length === 0)
+            return;
+        const key = words.join(" ");
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        phrases.push(words);
+    };
+    add(math.normalized);
+    for (const alias of math.spokenAliases)
+        add(alias);
+    return phrases;
+};
+// Length (in speech tokens) of the longest candidate phrase that matches the
+// run of speech tokens starting at `startIndex`, or 0 if none match. Longest
+// match wins so a multi-word alias is preferred over a coincidental one-word
+// prefix.
+const matchPhraseLengthAt = (speechTokens, startIndex, phrases) => {
+    let best = 0;
+    for (const phrase of phrases) {
+        if (phrase.length <= best)
+            continue;
+        let matched = true;
+        for (let i = 0; i < phrase.length; i++) {
+            const token = speechTokens[startIndex + i];
+            if (!token || token.normalized.toLowerCase() !== phrase[i]) {
+                matched = false;
+                break;
+            }
+        }
+        if (matched)
+            best = phrase.length;
+    }
+    return best;
+};
+// Greedy forward (monotonic) pass: each math token consumes the next run of
+// speech tokens that spells one of its candidate phrases. Optional math tokens
+// (invisible operators, grouping fences) are consumed only when present.
+// Unmatched speech tokens are skipped, which the perfect-cover check below then
+// treats as a miss.
+const computeMonotonicMatches = (speechTokens, mathTokens) => {
+    const matches = [];
+    let speechIndex = 0;
+    for (const math of mathTokens) {
+        const phrases = candidatePhrasesFor(math);
+        if (math.optional) {
+            const consumed = matchPhraseLengthAt(speechTokens, speechIndex, phrases);
+            if (consumed > 0) {
+                matches.push({
+                    speechTokens: speechTokens.slice(speechIndex, speechIndex + consumed),
+                    math,
+                });
+                speechIndex += consumed;
+            }
+            continue;
+        }
+        while (speechIndex < speechTokens.length) {
+            const consumed = matchPhraseLengthAt(speechTokens, speechIndex, phrases);
+            if (consumed > 0) {
+                matches.push({
+                    speechTokens: speechTokens.slice(speechIndex, speechIndex + consumed),
+                    math,
+                });
+                speechIndex += consumed;
+                break;
+            }
+            speechIndex++;
+        }
+    }
+    return matches;
+};
+// Word-level highlighting is all-or-nothing: it is emitted only when every
+// required math token AND every spoken token is accounted for. Anything less
+// falls back to a coarse whole-expression highlight, because "false positives
+// are worse than coarse highlighting" — a partial alignment risks underlining
+// the wrong glyph.
+const isPerfectCover = (matches, speechTokens, mathTokens) => {
+    const requiredTokenCount = mathTokens.filter((token) => !token.optional).length;
+    const requiredMatched = matches.filter((match) => !match.math.optional).length;
+    const consumedSpeech = matches.reduce((total, match) => total + match.speechTokens.length, 0);
+    return (requiredTokenCount > 0 &&
+        requiredMatched === requiredTokenCount &&
+        consumedSpeech === speechTokens.length);
+};
+const createSegments = (matches) => matches.map(({ speechTokens, math }) => ({
+    // Every spoken word that spells this math token maps back to it, so a
+    // boundary on any of those words ("divided" or "by") resolves to the
+    // same glyph.
+    speechTokenIds: speechTokens.map((token) => token.id),
+    mathTokenIds: [math.id],
+    score: 1,
+    confidence: 1,
+    target: math.target,
+}));
+export const alignSpeechToMath = (args) => {
+    const minConfidence = args.minExactWordConfidence ?? MIN_EXACT_WORD_CONFIDENCE;
+    const matches = computeMonotonicMatches(args.speech.tokens, args.math.tokens);
+    const confidence = isPerfectCover(matches, args.speech.tokens, args.math.tokens)
+        ? 1
+        : 0;
+    return {
+        segments: confidence >= minConfidence ? createSegments(matches) : [],
+        confidence,
+        fallbackTarget: args.math.expressionTarget,
+    };
+};
+//# sourceMappingURL=sequence-aligner.js.map

package/dist/services/tts/math-alignment/sequence-aligner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequence-aligner.js","sourceRoot":"","sources":["../../../../src/services/tts/math-alignment/sequence-aligner.ts"],"names":[],"mappings":"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","sourcesContent":["import type {\n\tAlignmentResult,\n\tAlignmentSegment,\n\tMathAlignmentToken,\n\tMathMLTokenizationResult,\n\tSpeechAlignmentToken,\n} from \"./types.js\";\nimport type { SpeechSourceTokenization } from \"./speech-tokenizer.js\";\n\nconst MIN_EXACT_WORD_CONFIDENCE = 0.95;\n\ninterface PhraseMatch {\n\tspeechTokens: SpeechAlignmentToken[];\n\tmath: MathAlignmentToken;\n}\n\n// Candidate spoken forms for a math token: its own normalized value plus every\n// spoken alias, each split into the sequence of words a TTS engine emits (e.g.\n// \"÷\" → [\"divided\", \"by\"], \"≤\" → [\"less\", \"than\", \"or\", \"equal\", \"to\"]). This is\n// what lets multi-word operator names match — a single speech token can never\n// equal \"divided by\". Speech tokens are already number-word normalized by the\n// speech tokenizer (two → 2), so no numeric mapping is repeated here.\nconst candidatePhrasesFor = (math: MathAlignmentToken): string[][] => {\n\tconst phrases: string[][] = [];\n\tconst seen = new Set<string>();\n\tconst add = (value: string): void => {\n\t\tconst words = value.toLowerCase().trim().split(/\\s+/).filter(Boolean);\n\t\tif (words.length === 0) return;\n\t\tconst key = words.join(\" \");\n\t\tif (seen.has(key)) return;\n\t\tseen.add(key);\n\t\tphrases.push(words);\n\t};\n\tadd(math.normalized);\n\tfor (const alias of math.spokenAliases) add(alias);\n\treturn phrases;\n};\n\n// Length (in speech tokens) of the longest candidate phrase that matches the\n// run of speech tokens starting at `startIndex`, or 0 if none match. Longest\n// match wins so a multi-word alias is preferred over a coincidental one-word\n// prefix.\nconst matchPhraseLengthAt = (\n\tspeechTokens: SpeechAlignmentToken[],\n\tstartIndex: number,\n\tphrases: string[][],\n): number => {\n\tlet best = 0;\n\tfor (const phrase of phrases) {\n\t\tif (phrase.length <= best) continue;\n\t\tlet matched = true;\n\t\tfor (let i = 0; i < phrase.length; i++) {\n\t\t\tconst token = speechTokens[startIndex + i];\n\t\t\tif (!token || token.normalized.toLowerCase() !== phrase[i]) {\n\t\t\t\tmatched = false;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t\tif (matched) best = phrase.length;\n\t}\n\treturn best;\n};\n\n// Greedy forward (monotonic) pass: each math token consumes the next run of\n// speech tokens that spells one of its candidate phrases. Optional math tokens\n// (invisible operators, grouping fences) are consumed only when present.\n// Unmatched speech tokens are skipped, which the perfect-cover check below then\n// treats as a miss.\nconst computeMonotonicMatches = (\n\tspeechTokens: SpeechAlignmentToken[],\n\tmathTokens: MathAlignmentToken[],\n): PhraseMatch[] => {\n\tconst matches: PhraseMatch[] = [];\n\tlet speechIndex = 0;\n\n\tfor (const math of mathTokens) {\n\t\tconst phrases = candidatePhrasesFor(math);\n\t\tif (math.optional) {\n\t\t\tconst consumed = matchPhraseLengthAt(speechTokens, speechIndex, phrases);\n\t\t\tif (consumed > 0) {\n\t\t\t\tmatches.push({\n\t\t\t\t\tspeechTokens: speechTokens.slice(\n\t\t\t\t\t\tspeechIndex,\n\t\t\t\t\t\tspeechIndex + consumed,\n\t\t\t\t\t),\n\t\t\t\t\tmath,\n\t\t\t\t});\n\t\t\t\tspeechIndex += consumed;\n\t\t\t}\n\t\t\tcontinue;\n\t\t}\n\t\twhile (speechIndex < speechTokens.length) {\n\t\t\tconst consumed = matchPhraseLengthAt(speechTokens, speechIndex, phrases);\n\t\t\tif (consumed > 0) {\n\t\t\t\tmatches.push({\n\t\t\t\t\tspeechTokens: speechTokens.slice(\n\t\t\t\t\t\tspeechIndex,\n\t\t\t\t\t\tspeechIndex + consumed,\n\t\t\t\t\t),\n\t\t\t\t\tmath,\n\t\t\t\t});\n\t\t\t\tspeechIndex += consumed;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tspeechIndex++;\n\t\t}\n\t}\n\n\treturn matches;\n};\n\n// Word-level highlighting is all-or-nothing: it is emitted only when every\n// required math token AND every spoken token is accounted for. Anything less\n// falls back to a coarse whole-expression highlight, because \"false positives\n// are worse than coarse highlighting\" — a partial alignment risks underlining\n// the wrong glyph.\nconst isPerfectCover = (\n\tmatches: PhraseMatch[],\n\tspeechTokens: SpeechAlignmentToken[],\n\tmathTokens: MathAlignmentToken[],\n): boolean => {\n\tconst requiredTokenCount = mathTokens.filter(\n\t\t(token) => !token.optional,\n\t).length;\n\tconst requiredMatched = matches.filter(\n\t\t(match) => !match.math.optional,\n\t).length;\n\tconst consumedSpeech = matches.reduce(\n\t\t(total, match) => total + match.speechTokens.length,\n\t\t0,\n\t);\n\treturn (\n\t\trequiredTokenCount > 0 &&\n\t\trequiredMatched === requiredTokenCount &&\n\t\tconsumedSpeech === speechTokens.length\n\t);\n};\n\nconst createSegments = (matches: PhraseMatch[]): AlignmentSegment[] =>\n\tmatches.map(({ speechTokens, math }) => ({\n\t\t// Every spoken word that spells this math token maps back to it, so a\n\t\t// boundary on any of those words (\"divided\" or \"by\") resolves to the\n\t\t// same glyph.\n\t\tspeechTokenIds: speechTokens.map((token) => token.id),\n\t\tmathTokenIds: [math.id],\n\t\tscore: 1,\n\t\tconfidence: 1,\n\t\ttarget: math.target,\n\t}));\n\nexport const alignSpeechToMath = (args: {\n\tspeech: SpeechSourceTokenization;\n\tmath: MathMLTokenizationResult;\n\tminExactWordConfidence?: number;\n}): AlignmentResult => {\n\tconst minConfidence =\n\t\targs.minExactWordConfidence ?? MIN_EXACT_WORD_CONFIDENCE;\n\tconst matches = computeMonotonicMatches(args.speech.tokens, args.math.tokens);\n\tconst confidence = isPerfectCover(\n\t\tmatches,\n\t\targs.speech.tokens,\n\t\targs.math.tokens,\n\t)\n\t\t? 1\n\t\t: 0;\n\n\treturn {\n\t\tsegments: confidence >= minConfidence ? createSegments(matches) : [],\n\t\tconfidence,\n\t\tfallbackTarget: args.math.expressionTarget,\n\t};\n};\n"]}

package/dist/services/tts/math-alignment/speech-tokenizer.d.ts

@@ -0,0 +1,31 @@
+import type { BoundaryOffsetSpace, SpeechAlignmentToken } from "./types.js";
+export interface SpeechSourceTokenization {
+    speechText: string;
+    spokenText: string;
+    tokens: SpeechAlignmentToken[];
+    rawToSpokenOffsetMap: Map<number, number>;
+    boundaryOffsetSpace: BoundaryOffsetSpace;
+    unsupportedSemantic: boolean;
+    hasMarkup: boolean;
+}
+export interface ResolvedSpeechBoundary {
+    token: SpeechAlignmentToken;
+    start: number;
+    length: number;
+    confidence: number;
+}
+export declare const tokenizeSpeechSource: (args: {
+    speechText: string;
+}) => SpeechSourceTokenization;
+export declare const resolveBoundaryToSpeechToken: (args: {
+    tokenization: SpeechSourceTokenization;
+    position: number;
+    length?: number;
+    boundaryWord?: string;
+}) => ResolvedSpeechBoundary | null;
+export declare const resolveSpokenOffsetToSpeechToken: (args: {
+    tokenization: SpeechSourceTokenization;
+    position: number;
+    length?: number;
+    boundaryWord?: string;
+}) => ResolvedSpeechBoundary | null;