js.documents 2.2.0 → 2.3.0

package/dist/latex/symbols.cjs

@@ -0,0 +1,128 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/latex/symbols.ts
+const COMMAND_GLYPHS = {
+	"\\alpha": "α",
+	"\\beta": "β",
+	"\\gamma": "γ",
+	"\\delta": "δ",
+	"\\epsilon": "ε",
+	"\\varepsilon": "ε",
+	"\\zeta": "ζ",
+	"\\eta": "η",
+	"\\theta": "θ",
+	"\\vartheta": "ϑ",
+	"\\iota": "ι",
+	"\\kappa": "κ",
+	"\\lambda": "λ",
+	"\\mu": "μ",
+	"\\nu": "ν",
+	"\\xi": "ξ",
+	"\\pi": "π",
+	"\\varpi": "ϖ",
+	"\\rho": "ρ",
+	"\\varrho": "ϱ",
+	"\\sigma": "σ",
+	"\\varsigma": "ς",
+	"\\tau": "τ",
+	"\\upsilon": "υ",
+	"\\phi": "φ",
+	"\\varphi": "φ",
+	"\\chi": "χ",
+	"\\psi": "ψ",
+	"\\omega": "ω",
+	"\\Gamma": "Γ",
+	"\\Delta": "Δ",
+	"\\Theta": "Θ",
+	"\\Lambda": "Λ",
+	"\\Xi": "Ξ",
+	"\\Pi": "Π",
+	"\\Sigma": "Σ",
+	"\\Upsilon": "Υ",
+	"\\Phi": "Φ",
+	"\\Psi": "Ψ",
+	"\\Omega": "Ω",
+	"\\infty": "∞",
+	"\\partial": "∂",
+	"\\nabla": "∇",
+	"\\ell": "ℓ",
+	"\\hbar": "ℏ",
+	"\\Re": "ℜ",
+	"\\Im": "ℑ",
+	"\\aleph": "ℵ"
+};
+function glyphOfSymbolText(text) {
+	if (!text.startsWith("\\")) return text;
+	return COMMAND_GLYPHS[text];
+}
+function mintedSymbolId(glyph) {
+	return `symbols:${glyph}`;
+}
+var SymbolResolver = class {
+	curated = /* @__PURE__ */ new Map();
+	minted = /* @__PURE__ */ new Map();
+	constructor(entries) {
+		for (const entry of entries) if (!this.curated.has(entry.glyph)) this.curated.set(entry.glyph, entry.id);
+	}
+	isCurated(glyph) {
+		return this.curated.has(glyph);
+	}
+	resolve(glyph) {
+		const curatedId = this.curated.get(glyph);
+		if (curatedId !== void 0) return curatedId;
+		const existing = this.minted.get(glyph);
+		if (existing !== void 0) return existing.id;
+		const id = mintedSymbolId(glyph);
+		this.minted.set(glyph, {
+			glyph,
+			scope: "document",
+			id
+		});
+		return id;
+	}
+	mintedEntries() {
+		return [...this.minted.values()];
+	}
+};
+const PROSE_SYMBOL_PATTERN = /[A-Za-zΑ-ω](?:_[A-Za-z0-9]+)?/;
+const PROSE_DEFINITION_PATTERNS = [/\bwhere\s+([^\s,.;:]+)\s+(?:is|are|denotes?|represents?|stands\s+for)\b/i, /\blet\s+([^\s,.;:]+)\s+(?:be|denote|represent|stand\s+for)\b/i];
+function sentencesOf(text) {
+	return text.split(/(?<=[.!?])\s+/).map((sentence) => sentence.trim()).filter((sentence) => sentence.length > 0);
+}
+function extractSymbolDefinitionsFromProse(document, sink) {
+	if (document.kind !== "wordprocessing") return [];
+	const entries = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const section of document.sections) for (const block of section.blocks) {
+		if (block.kind !== "paragraph") continue;
+		const text = block.runs.map((run) => run.text).join("");
+		for (const sentence of sentencesOf(text)) {
+			const entry = proseDefinitionIn(sentence);
+			if (entry === void 0 || seen.has(entry.glyph)) continue;
+			seen.add(entry.glyph);
+			entries.push(entry);
+			sink?.({
+				code: "symbols/prose-definition-found",
+				detail: `"${entry.glyph}" from: ${sentence}`
+			});
+		}
+	}
+	return entries;
+}
+function proseDefinitionIn(sentence) {
+	for (const pattern of PROSE_DEFINITION_PATTERNS) {
+		const candidate = pattern.exec(sentence)?.[1];
+		if (candidate === void 0) continue;
+		if (PROSE_SYMBOL_PATTERN.exec(candidate)?.[0] !== candidate) continue;
+		return {
+			glyph: candidate,
+			scope: "document",
+			id: mintedSymbolId(candidate),
+			definitionSource: sentence
+		};
+	}
+}
+//#endregion
+exports.SymbolResolver = SymbolResolver;
+exports.extractSymbolDefinitionsFromProse = extractSymbolDefinitionsFromProse;
+exports.glyphOfSymbolText = glyphOfSymbolText;
+exports.mintedSymbolId = mintedSymbolId;

package/dist/latex/symbols.d.cts

@@ -0,0 +1,16 @@
+import { n as LatexDiagnostic } from "../diagnostics-C5-bG09J.cjs";
+import { ContentDocument, MathSymbolEntry } from "document-schema.js";
+//#region src/latex/symbols.d.ts
+declare function glyphOfSymbolText(text: string): string | undefined;
+declare function mintedSymbolId(glyph: string): string;
+declare class SymbolResolver {
+  private readonly curated;
+  private readonly minted;
+  constructor(entries: readonly MathSymbolEntry[]);
+  isCurated(glyph: string): boolean;
+  resolve(glyph: string): string;
+  mintedEntries(): readonly MathSymbolEntry[];
+}
+declare function extractSymbolDefinitionsFromProse(document: ContentDocument, sink?: (diagnostic: LatexDiagnostic) => void): MathSymbolEntry[];
+//#endregion
+export { SymbolResolver, extractSymbolDefinitionsFromProse, glyphOfSymbolText, mintedSymbolId };

package/dist/latex/symbols.d.ts

@@ -0,0 +1,16 @@
+import { n as LatexDiagnostic } from "../diagnostics-C5-bG09J.js";
+import { ContentDocument, MathSymbolEntry } from "document-schema.js";
+//#region src/latex/symbols.d.ts
+declare function glyphOfSymbolText(text: string): string | undefined;
+declare function mintedSymbolId(glyph: string): string;
+declare class SymbolResolver {
+  private readonly curated;
+  private readonly minted;
+  constructor(entries: readonly MathSymbolEntry[]);
+  isCurated(glyph: string): boolean;
+  resolve(glyph: string): string;
+  mintedEntries(): readonly MathSymbolEntry[];
+}
+declare function extractSymbolDefinitionsFromProse(document: ContentDocument, sink?: (diagnostic: LatexDiagnostic) => void): MathSymbolEntry[];
+//#endregion
+export { SymbolResolver, extractSymbolDefinitionsFromProse, glyphOfSymbolText, mintedSymbolId };

package/dist/latex/symbols.js

@@ -0,0 +1,124 @@
+//#region src/latex/symbols.ts
+const COMMAND_GLYPHS = {
+	"\\alpha": "α",
+	"\\beta": "β",
+	"\\gamma": "γ",
+	"\\delta": "δ",
+	"\\epsilon": "ε",
+	"\\varepsilon": "ε",
+	"\\zeta": "ζ",
+	"\\eta": "η",
+	"\\theta": "θ",
+	"\\vartheta": "ϑ",
+	"\\iota": "ι",
+	"\\kappa": "κ",
+	"\\lambda": "λ",
+	"\\mu": "μ",
+	"\\nu": "ν",
+	"\\xi": "ξ",
+	"\\pi": "π",
+	"\\varpi": "ϖ",
+	"\\rho": "ρ",
+	"\\varrho": "ϱ",
+	"\\sigma": "σ",
+	"\\varsigma": "ς",
+	"\\tau": "τ",
+	"\\upsilon": "υ",
+	"\\phi": "φ",
+	"\\varphi": "φ",
+	"\\chi": "χ",
+	"\\psi": "ψ",
+	"\\omega": "ω",
+	"\\Gamma": "Γ",
+	"\\Delta": "Δ",
+	"\\Theta": "Θ",
+	"\\Lambda": "Λ",
+	"\\Xi": "Ξ",
+	"\\Pi": "Π",
+	"\\Sigma": "Σ",
+	"\\Upsilon": "Υ",
+	"\\Phi": "Φ",
+	"\\Psi": "Ψ",
+	"\\Omega": "Ω",
+	"\\infty": "∞",
+	"\\partial": "∂",
+	"\\nabla": "∇",
+	"\\ell": "ℓ",
+	"\\hbar": "ℏ",
+	"\\Re": "ℜ",
+	"\\Im": "ℑ",
+	"\\aleph": "ℵ"
+};
+function glyphOfSymbolText(text) {
+	if (!text.startsWith("\\")) return text;
+	return COMMAND_GLYPHS[text];
+}
+function mintedSymbolId(glyph) {
+	return `symbols:${glyph}`;
+}
+var SymbolResolver = class {
+	curated = /* @__PURE__ */ new Map();
+	minted = /* @__PURE__ */ new Map();
+	constructor(entries) {
+		for (const entry of entries) if (!this.curated.has(entry.glyph)) this.curated.set(entry.glyph, entry.id);
+	}
+	isCurated(glyph) {
+		return this.curated.has(glyph);
+	}
+	resolve(glyph) {
+		const curatedId = this.curated.get(glyph);
+		if (curatedId !== void 0) return curatedId;
+		const existing = this.minted.get(glyph);
+		if (existing !== void 0) return existing.id;
+		const id = mintedSymbolId(glyph);
+		this.minted.set(glyph, {
+			glyph,
+			scope: "document",
+			id
+		});
+		return id;
+	}
+	mintedEntries() {
+		return [...this.minted.values()];
+	}
+};
+const PROSE_SYMBOL_PATTERN = /[A-Za-zΑ-ω](?:_[A-Za-z0-9]+)?/;
+const PROSE_DEFINITION_PATTERNS = [/\bwhere\s+([^\s,.;:]+)\s+(?:is|are|denotes?|represents?|stands\s+for)\b/i, /\blet\s+([^\s,.;:]+)\s+(?:be|denote|represent|stand\s+for)\b/i];
+function sentencesOf(text) {
+	return text.split(/(?<=[.!?])\s+/).map((sentence) => sentence.trim()).filter((sentence) => sentence.length > 0);
+}
+function extractSymbolDefinitionsFromProse(document, sink) {
+	if (document.kind !== "wordprocessing") return [];
+	const entries = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const section of document.sections) for (const block of section.blocks) {
+		if (block.kind !== "paragraph") continue;
+		const text = block.runs.map((run) => run.text).join("");
+		for (const sentence of sentencesOf(text)) {
+			const entry = proseDefinitionIn(sentence);
+			if (entry === void 0 || seen.has(entry.glyph)) continue;
+			seen.add(entry.glyph);
+			entries.push(entry);
+			sink?.({
+				code: "symbols/prose-definition-found",
+				detail: `"${entry.glyph}" from: ${sentence}`
+			});
+		}
+	}
+	return entries;
+}
+function proseDefinitionIn(sentence) {
+	for (const pattern of PROSE_DEFINITION_PATTERNS) {
+		const candidate = pattern.exec(sentence)?.[1];
+		if (candidate === void 0) continue;
+		if (PROSE_SYMBOL_PATTERN.exec(candidate)?.[0] !== candidate) continue;
+		return {
+			glyph: candidate,
+			scope: "document",
+			id: mintedSymbolId(candidate),
+			definitionSource: sentence
+		};
+	}
+}
+//#endregion
+export { SymbolResolver, extractSymbolDefinitionsFromProse, glyphOfSymbolText, mintedSymbolId };

package/dist/latex/temml.cjs

@@ -0,0 +1,121 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let temml = require("temml");
+temml = __toESM(temml, 1);
+//#region src/latex/temml.ts
+const TEMML_OPTIONS = { throwOnError: true };
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isTemmlNode(value) {
+	return isRecord(value) && typeof value.type === "string";
+}
+function isTemmlNodeArray(value) {
+	return Array.isArray(value) && value.every(isTemmlNode);
+}
+function sourceSpanOf(node) {
+	const loc = node.loc;
+	if (!isRecord(loc)) return;
+	const start = loc.start;
+	const end = loc.end;
+	if (typeof start !== "number" || typeof end !== "number" || !Number.isInteger(start) || !Number.isInteger(end) || start < 0 || end < start) return;
+	return {
+		start,
+		end
+	};
+}
+function sourceSlice(input, span) {
+	if (span === void 0) return "";
+	return input.slice(span.start, span.end);
+}
+function parseLatex(latex) {
+	try {
+		const nodes = temml.default.__parse(latex, TEMML_OPTIONS);
+		if (!isTemmlNodeArray(nodes)) return {
+			status: "unparseable",
+			message: "parser returned a shape this package does not recognise"
+		};
+		return {
+			status: "parsed",
+			nodes,
+			mathml: mathmlOf(latex)
+		};
+	} catch (error) {
+		return {
+			status: "unparseable",
+			message: errorMessage(error)
+		};
+	}
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function mathmlOf(latex) {
+	let root;
+	try {
+		root = temml.default.__renderToMathMLTree(latex, TEMML_OPTIONS);
+	} catch {
+		return [];
+	}
+	return toMathMlNodes(root) ?? [];
+}
+function toMathMlNodes(value) {
+	if (!isRecord(value)) return;
+	if (typeof value.text === "string" && value.type === void 0) return [{
+		type: "text",
+		value: value.text
+	}];
+	if (!Array.isArray(value.children)) return;
+	const children = [];
+	for (const child of value.children) {
+		const converted = toMathMlNodes(child);
+		if (converted === void 0) return;
+		children.push(...converted);
+	}
+	if (value.type === void 0) return children;
+	if (typeof value.type !== "string") return;
+	const attributes = attributesOf(value.attributes);
+	if (attributes === void 0) return;
+	return [{
+		type: "element",
+		tag: value.type,
+		attributes,
+		children
+	}];
+}
+function attributesOf(value) {
+	if (!isRecord(value)) return;
+	const attributes = [];
+	for (const [name, attributeValue] of Object.entries(value)) if (typeof attributeValue === "string" || typeof attributeValue === "number" || typeof attributeValue === "boolean") attributes.push({
+		name,
+		value: String(attributeValue)
+	});
+	return attributes;
+}
+//#endregion
+exports.isTemmlNode = isTemmlNode;
+exports.isTemmlNodeArray = isTemmlNodeArray;
+exports.parseLatex = parseLatex;
+exports.sourceSlice = sourceSlice;
+exports.sourceSpanOf = sourceSpanOf;

package/dist/latex/temml.d.cts

@@ -0,0 +1,25 @@
+import { MathMlNode } from "document-schema.js";
+//#region src/latex/temml.d.ts
+interface TemmlNode {
+  readonly type: string;
+  readonly [field: string]: unknown;
+}
+declare function isTemmlNode(value: unknown): value is TemmlNode;
+declare function isTemmlNodeArray(value: unknown): value is TemmlNode[];
+interface TemmlSourceSpan {
+  readonly start: number;
+  readonly end: number;
+}
+declare function sourceSpanOf(node: TemmlNode): TemmlSourceSpan | undefined;
+declare function sourceSlice(input: string, span: TemmlSourceSpan | undefined): string;
+type LatexParseResult = {
+  readonly status: 'parsed';
+  readonly nodes: readonly TemmlNode[];
+  readonly mathml: readonly MathMlNode[];
+} | {
+  readonly status: 'unparseable';
+  readonly message: string;
+};
+declare function parseLatex(latex: string): LatexParseResult;
+//#endregion
+export { LatexParseResult, TemmlNode, TemmlSourceSpan, isTemmlNode, isTemmlNodeArray, parseLatex, sourceSlice, sourceSpanOf };

package/dist/latex/temml.d.ts

@@ -0,0 +1,25 @@
+import { MathMlNode } from "document-schema.js";
+//#region src/latex/temml.d.ts
+interface TemmlNode {
+  readonly type: string;
+  readonly [field: string]: unknown;
+}
+declare function isTemmlNode(value: unknown): value is TemmlNode;
+declare function isTemmlNodeArray(value: unknown): value is TemmlNode[];
+interface TemmlSourceSpan {
+  readonly start: number;
+  readonly end: number;
+}
+declare function sourceSpanOf(node: TemmlNode): TemmlSourceSpan | undefined;
+declare function sourceSlice(input: string, span: TemmlSourceSpan | undefined): string;
+type LatexParseResult = {
+  readonly status: 'parsed';
+  readonly nodes: readonly TemmlNode[];
+  readonly mathml: readonly MathMlNode[];
+} | {
+  readonly status: 'unparseable';
+  readonly message: string;
+};
+declare function parseLatex(latex: string): LatexParseResult;
+//#endregion
+export { LatexParseResult, TemmlNode, TemmlSourceSpan, isTemmlNode, isTemmlNodeArray, parseLatex, sourceSlice, sourceSpanOf };

package/dist/latex/temml.js

@@ -0,0 +1,93 @@
+import temml from "temml";
+//#region src/latex/temml.ts
+const TEMML_OPTIONS = { throwOnError: true };
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isTemmlNode(value) {
+	return isRecord(value) && typeof value.type === "string";
+}
+function isTemmlNodeArray(value) {
+	return Array.isArray(value) && value.every(isTemmlNode);
+}
+function sourceSpanOf(node) {
+	const loc = node.loc;
+	if (!isRecord(loc)) return;
+	const start = loc.start;
+	const end = loc.end;
+	if (typeof start !== "number" || typeof end !== "number" || !Number.isInteger(start) || !Number.isInteger(end) || start < 0 || end < start) return;
+	return {
+		start,
+		end
+	};
+}
+function sourceSlice(input, span) {
+	if (span === void 0) return "";
+	return input.slice(span.start, span.end);
+}
+function parseLatex(latex) {
+	try {
+		const nodes = temml.__parse(latex, TEMML_OPTIONS);
+		if (!isTemmlNodeArray(nodes)) return {
+			status: "unparseable",
+			message: "parser returned a shape this package does not recognise"
+		};
+		return {
+			status: "parsed",
+			nodes,
+			mathml: mathmlOf(latex)
+		};
+	} catch (error) {
+		return {
+			status: "unparseable",
+			message: errorMessage(error)
+		};
+	}
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function mathmlOf(latex) {
+	let root;
+	try {
+		root = temml.__renderToMathMLTree(latex, TEMML_OPTIONS);
+	} catch {
+		return [];
+	}
+	return toMathMlNodes(root) ?? [];
+}
+function toMathMlNodes(value) {
+	if (!isRecord(value)) return;
+	if (typeof value.text === "string" && value.type === void 0) return [{
+		type: "text",
+		value: value.text
+	}];
+	if (!Array.isArray(value.children)) return;
+	const children = [];
+	for (const child of value.children) {
+		const converted = toMathMlNodes(child);
+		if (converted === void 0) return;
+		children.push(...converted);
+	}
+	if (value.type === void 0) return children;
+	if (typeof value.type !== "string") return;
+	const attributes = attributesOf(value.attributes);
+	if (attributes === void 0) return;
+	return [{
+		type: "element",
+		tag: value.type,
+		attributes,
+		children
+	}];
+}
+function attributesOf(value) {
+	if (!isRecord(value)) return;
+	const attributes = [];
+	for (const [name, attributeValue] of Object.entries(value)) if (typeof attributeValue === "string" || typeof attributeValue === "number" || typeof attributeValue === "boolean") attributes.push({
+		name,
+		value: String(attributeValue)
+	});
+	return attributes;
+}
+//#endregion
+export { isTemmlNode, isTemmlNodeArray, parseLatex, sourceSlice, sourceSpanOf };

package/dist/markdown/math.cjs

@@ -0,0 +1,110 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_model_formula = require("../model/formula.cjs");
+const require_latex_symbols = require("../latex/symbols.cjs");
+const require_latex_lower = require("../latex/lower.cjs");
+//#region src/markdown/math.ts
+const MATH_BLOCK_STYLE_ID = "MathBlock";
+const MATH_INLINE_FONT_MARKER = "Cambria Math";
+const STAND_IN_FRAME = {
+	xPt: 0,
+	yPt: 0,
+	widthPt: 0,
+	heightPt: 22
+};
+const MATH_BLOCK_SOURCE = "markdown:math-block";
+const MATH_INLINE_SOURCE = "markdown:math-inline";
+function extractInlineMath(runs) {
+	const latexRuns = [];
+	const remainingRuns = [];
+	for (const run of runs) {
+		if (run.fontFamily === MATH_INLINE_FONT_MARKER && run.text.trim() !== "") {
+			latexRuns.push(run.text);
+			continue;
+		}
+		remainingRuns.push(run);
+	}
+	const consumed = latexRuns.length > 0 && remainingRuns.every((run) => run.text === "");
+	return {
+		latexRuns,
+		remainingRuns: consumed ? [] : remainingRuns,
+		consumed
+	};
+}
+function lowerMarkdownMath(document, options) {
+	if (document.kind !== "wordprocessing") return document;
+	const sink = options?.onDiagnostic;
+	const proseEntries = require_latex_symbols.extractSymbolDefinitionsFromProse(document, sink);
+	const known = new Map(proseEntries.map((entry) => [entry.glyph, entry]));
+	const minted = /* @__PURE__ */ new Map();
+	const lowerOne = (latex, source) => {
+		if (latex.trim() === "") return;
+		const result = require_latex_lower.latexToFormula(latex, {
+			symbolEntries: [...known.values()],
+			source
+		});
+		for (const diagnostic of result.diagnostics) sink?.(diagnostic);
+		for (const entry of result.mintedSymbols) if (!known.has(entry.glyph) && !minted.has(entry.glyph)) minted.set(entry.glyph, entry);
+		return require_model_formula.buildFormulaBlock(result.formula, STAND_IN_FRAME, source);
+	};
+	const lowerBlocks = (blocks) => {
+		const out = [];
+		for (const block of blocks) {
+			if (block.kind === "table") {
+				out.push({
+					...block,
+					rows: block.rows.map((row) => ({
+						...row,
+						cells: row.cells.map((cell) => ({
+							...cell,
+							blocks: lowerBlocks(cell.blocks)
+						}))
+					}))
+				});
+				continue;
+			}
+			if (block.kind !== "paragraph") {
+				out.push(block);
+				continue;
+			}
+			if (block.styleId === MATH_BLOCK_STYLE_ID) {
+				const latex = block.runs.map((run) => run.text).join("");
+				const formulaBlock = lowerOne(latex, MATH_BLOCK_SOURCE);
+				out.push(formulaBlock ?? block);
+				continue;
+			}
+			const extraction = extractInlineMath(block.runs);
+			if (extraction.latexRuns.length === 0) {
+				out.push(block);
+				continue;
+			}
+			if (!extraction.consumed) out.push({
+				...block,
+				runs: [...extraction.remainingRuns]
+			});
+			for (const latex of extraction.latexRuns) {
+				const formulaBlock = lowerOne(latex, MATH_INLINE_SOURCE);
+				if (formulaBlock !== void 0) out.push(formulaBlock);
+			}
+		}
+		return out;
+	};
+	const sections = document.sections.map((section) => ({
+		...section,
+		blocks: lowerBlocks(section.blocks)
+	}));
+	const symbols = [...known.values(), ...minted.values()];
+	if (symbols.length === 0) return {
+		...document,
+		sections
+	};
+	return {
+		...document,
+		sections,
+		symbolTable: {
+			symbols,
+			units: []
+		}
+	};
+}
+//#endregion
+exports.lowerMarkdownMath = lowerMarkdownMath;

package/dist/markdown/math.d.cts

@@ -0,0 +1,9 @@
+import { i as LatexDiagnosticSink } from "../diagnostics-C5-bG09J.cjs";
+import { ContentDocument } from "document-schema.js";
+//#region src/markdown/math.d.ts
+interface MarkdownMathLoweringOptions {
+  readonly onDiagnostic?: LatexDiagnosticSink;
+}
+declare function lowerMarkdownMath(document: ContentDocument, options?: MarkdownMathLoweringOptions): ContentDocument;
+//#endregion
+export { MarkdownMathLoweringOptions, lowerMarkdownMath };

package/dist/markdown/math.d.ts

@@ -0,0 +1,9 @@
+import { i as LatexDiagnosticSink } from "../diagnostics-C5-bG09J.js";
+import { ContentDocument } from "document-schema.js";
+//#region src/markdown/math.d.ts
+interface MarkdownMathLoweringOptions {
+  readonly onDiagnostic?: LatexDiagnosticSink;
+}
+declare function lowerMarkdownMath(document: ContentDocument, options?: MarkdownMathLoweringOptions): ContentDocument;
+//#endregion
+export { MarkdownMathLoweringOptions, lowerMarkdownMath };