documents.js 2.2.0 → 2.3.1

package/dist/latex/lint.js

@@ -0,0 +1,81 @@
+import { reduceRational } from "./rational.js";
+import { lowerLatex } from "./lower.js";
+//#region src/latex/lint.ts
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function canonical(value) {
+	if (Array.isArray(value)) return value.map(canonical);
+	if (!isRecord(value)) return value;
+	if (value.kind === "num" && typeof value.numerator === "string" && typeof value.denominator === "string") return {
+		kind: "num",
+		...reduceRational(BigInt(value.numerator), BigInt(value.denominator))
+	};
+	const entries = Object.entries(value).map(([key, element]) => [key, canonical(element)]);
+	entries.sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0);
+	return Object.fromEntries(entries);
+}
+function expressionsAgree(left, right) {
+	return JSON.stringify(canonical(left)) === JSON.stringify(canonical(right));
+}
+function isUnparsedRoot(expression) {
+	return expression.kind === "unparsed";
+}
+function lintFormula(formula, locate, symbolEntries, warnings) {
+	const presentation = formula.presentation;
+	const content = formula.content;
+	if (presentation === void 0 || content === void 0) return;
+	const provenance = formula.provenance === void 0 ? void 0 : [formula.provenance.source, ...formula.provenance.editTrail].join(" -> ");
+	const relowered = lowerLatex(presentation.latex, { symbolEntries });
+	const detail = `${locate}: ${presentation.latex}`;
+	if (relowered.diagnostics.some((diagnostic) => diagnostic.code === "latex/parse-error")) {
+		if (!isUnparsedRoot(content)) warnings.push({
+			code: "math/coherence-unparseable-presentation",
+			severity: "warning",
+			...provenance === void 0 ? {} : { provenance },
+			detail
+		});
+		return;
+	}
+	if (!expressionsAgree(relowered.expression, content)) warnings.push({
+		code: "math/coherence-divergence",
+		severity: "warning",
+		...provenance === void 0 ? {} : { provenance },
+		detail
+	});
+}
+function collectBlockFormulas(blocks, locate, formulas) {
+	for (const [index, block] of blocks.entries()) {
+		if (block.kind === "embeddedObject" && block.objectKind === "formula" && block.document.kind === "formula") {
+			formulas.push({
+				formula: block.document.formula,
+				locate: `${locate}/blocks[${String(index)}]`
+			});
+			continue;
+		}
+		if (block.kind === "table") for (const [rowIndex, row] of block.rows.entries()) for (const [cellIndex, cell] of row.cells.entries()) collectBlockFormulas(cell.blocks, `${locate}/rows[${String(rowIndex)}].cells[${String(cellIndex)}]`, formulas);
+	}
+}
+function lintMathCoherence(pkg) {
+	const warnings = [];
+	const symbolEntries = pkg.content.symbolTable?.symbols;
+	const found = [];
+	const content = pkg.content;
+	if (content.kind === "formula") found.push({
+		formula: content.formula,
+		locate: "formula"
+	});
+	else if (content.kind === "wordprocessing") for (const [index, section] of content.sections.entries()) collectBlockFormulas(section.blocks, `sections[${String(index)}]`, found);
+	else if (content.kind === "presentation") for (const [slideIndex, slide] of content.slides.entries()) for (const [shapeIndex, shape] of slide.shapes.entries()) collectBlockFormulas(shape.blocks, `slides[${String(slideIndex)}].shapes[${String(shapeIndex)}]`, found);
+	else if (content.kind === "drawing") for (const [pageIndex, page] of content.pages.entries()) for (const [shapeIndex, shape] of page.shapes.entries()) collectBlockFormulas(shape.blocks, `pages[${String(pageIndex)}].shapes[${String(shapeIndex)}]`, found);
+	else if (content.kind === "spreadsheet") {
+		for (const [sheetIndex, sheet] of content.sheets.entries()) for (const [objectIndex, object] of (sheet.embeddedObjects ?? []).entries()) if (object.objectKind === "formula" && object.document.kind === "formula") found.push({
+			formula: object.document.formula,
+			locate: `sheets[${String(sheetIndex)}].embeddedObjects[${String(objectIndex)}]`
+		});
+	}
+	for (const { formula, locate } of found) lintFormula(formula, locate, symbolEntries, warnings);
+	return warnings;
+}
+//#endregion
+export { lintMathCoherence };

package/dist/latex/lower.cjs

@@ -0,0 +1,550 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_latex_temml = require("./temml.cjs");
+const require_latex_symbols = require("./symbols.cjs");
+const require_latex_rational = require("./rational.cjs");
+//#region src/latex/lower.ts
+const BINARY_ATOM_OPERATORS = {
+	"+": "math:add",
+	"-": "math:subtract",
+	"\\cdot": "math:multiply",
+	"\\times": "math:multiply",
+	"\\div": "math:divide"
+};
+const RELATION_ATOM_OPERATORS = {
+	"=": "math:eq",
+	"\\neq": "math:neq",
+	"\\ne": "math:neq",
+	"<": "math:lt",
+	"\\leq": "math:leq",
+	"\\le": "math:leq",
+	">": "math:gt",
+	"\\geq": "math:geq",
+	"\\ge": "math:geq"
+};
+const SUBTRACT_OPERATOR = "math:subtract";
+const UNARY_MINUS_OPERATOR = "math:negate";
+const NAMED_FUNCTION_OPERATORS = {
+	"\\sin": "math:sin",
+	"\\cos": "math:cos",
+	"\\tan": "math:tan",
+	"\\cot": "math:cot",
+	"\\sec": "math:sec",
+	"\\csc": "math:csc",
+	"\\arcsin": "math:arcsin",
+	"\\arccos": "math:arccos",
+	"\\arctan": "math:arctan",
+	"\\sinh": "math:sinh",
+	"\\cosh": "math:cosh",
+	"\\tanh": "math:tanh",
+	"\\exp": "math:exp",
+	"\\log": "math:log",
+	"\\ln": "math:ln"
+};
+const PRESENTATION_ONLY_TYPES = /* @__PURE__ */ new Set([
+	"spacing",
+	"rule",
+	"kern"
+]);
+const WRAPPER_TYPES = /* @__PURE__ */ new Set(["styling", "color"]);
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function nodeText(node) {
+	return typeof node.text === "string" ? node.text : void 0;
+}
+function glyphOfNode(node) {
+	const text = nodeText(node);
+	return text === void 0 ? void 0 : require_latex_symbols.glyphOfSymbolText(text);
+}
+function numericText(text) {
+	return text.length === 1 && text >= "0" && text <= "9";
+}
+function diagnose(context, code, detail) {
+	context.diagnostics.push({
+		code,
+		...detail === void 0 ? {} : { detail }
+	});
+	context.sink?.({
+		code,
+		...detail === void 0 ? {} : { detail }
+	});
+}
+function unparsed(latex) {
+	return {
+		kind: "unparsed",
+		latex
+	};
+}
+function app(operator, args) {
+	return {
+		kind: "app",
+		operator,
+		args: [...args]
+	};
+}
+function spanOfNodes(context, nodes) {
+	let start;
+	let end;
+	const visit = (node) => {
+		const loc = node.loc;
+		if (isRecord(loc) && typeof loc.start === "number" && typeof loc.end === "number") {
+			if (start === void 0 || loc.start < start) start = loc.start;
+			if (end === void 0 || loc.end > end) end = loc.end;
+		}
+		for (const value of Object.values(node)) if (require_latex_temml.isTemmlNode(value)) visit(value);
+		else if (Array.isArray(value)) {
+			for (const element of value) if (require_latex_temml.isTemmlNode(element)) visit(element);
+		}
+	};
+	for (const node of nodes) visit(node);
+	return start === void 0 || end === void 0 ? "" : context.input.slice(start, end);
+}
+function nodesOfScript(script) {
+	if (!require_latex_temml.isTemmlNode(script)) return;
+	if (script.type === "ordgroup" || WRAPPER_TYPES.has(script.type)) {
+		const body = script.body;
+		return Array.isArray(body) && body.every(require_latex_temml.isTemmlNode) ? body : void 0;
+	}
+	return [script];
+}
+function lowerNodeList(nodes, context) {
+	const present = nodes.filter((node) => !PRESENTATION_ONLY_TYPES.has(node.type));
+	const segments = [];
+	const operators = [];
+	let current = [];
+	let unmappable;
+	for (const node of present) {
+		const operator = operatorOfNode(node);
+		if (operator !== void 0) {
+			segments.push(current);
+			operators.push(operator);
+			current = [];
+			continue;
+		}
+		if (isOperatorAtom(node)) {
+			unmappable = unmappable ?? nodeText(node) ?? node.type;
+			continue;
+		}
+		current.push(node);
+	}
+	segments.push(current);
+	if (unmappable !== void 0) {
+		const detail = spanOfNodes(context, present) || unmappable;
+		diagnose(context, "latex/operator-unmapped", detail);
+		return unparsed(detail);
+	}
+	const [firstSegment = [], ...restSegments] = segments;
+	if (operators.length === 0) return lowerTerm(firstSegment, context);
+	const detail = spanOfNodes(context, present);
+	if (firstSegment.length === 0) {
+		const leading = operators[0];
+		const secondSegment = restSegments[0] ?? [];
+		if (leading !== SUBTRACT_OPERATOR || secondSegment.length === 0) {
+			diagnose(context, "latex/operator-placement-unparsed", detail);
+			return unparsed(detail);
+		}
+		return fold(app(UNARY_MINUS_OPERATOR, [lowerTerm(secondSegment, context)]), operators.slice(1), restSegments.slice(1), context, detail);
+	}
+	return fold(lowerTerm(firstSegment, context), operators, restSegments, context, detail);
+}
+function isOperatorAtom(node) {
+	return node.type === "atom" && (node.family === "bin" || node.family === "rel");
+}
+function operatorOfNode(node) {
+	if (node.type === "atom") {
+		const text = nodeText(node);
+		if (text === void 0) return;
+		return BINARY_ATOM_OPERATORS[text] ?? RELATION_ATOM_OPERATORS[text];
+	}
+	if (node.type === "textord" && nodeText(node) === "/") return "math:divide";
+}
+function fold(first, operators, segments, context, detail) {
+	let folded = first;
+	for (let index = 0; index < operators.length; index += 1) {
+		const operator = operators[index];
+		const segmentNodes = segments[index];
+		if (operator === void 0 || segmentNodes === void 0) throw new Error("operator and segment lists diverged while folding a lowered sequence");
+		if (segmentNodes.length === 0) {
+			diagnose(context, "latex/operator-placement-unparsed", detail);
+			return unparsed(detail);
+		}
+		folded = app(operator, [folded, lowerTerm(segmentNodes, context)]);
+	}
+	return folded;
+}
+function lowerTerm(nodes, context) {
+	return lowerTermItems(termItems(nodes), context);
+}
+function lowerTermItems(items, context) {
+	const first = items[0];
+	if (first === void 0) {
+		diagnose(context, "latex/construct-unparsed");
+		return unparsed("");
+	}
+	if (first.kind === "node") {
+		const binder = readBinder(first.node, context);
+		if (binder.status === "binder") {
+			const rest = items.slice(1);
+			const body = rest.length === 0 ? implicitArgument(context) : lowerTermItems(rest, {
+				...context,
+				binders: [binder.binder, ...context.binders]
+			});
+			return {
+				kind: binder.kind,
+				binder: binder.binder,
+				lower: binder.lower,
+				upper: binder.upper,
+				body
+			};
+		}
+		if (binder.status === "degraded") return unparsed(binder.detail);
+		const namedFunction = namedFunctionOfOp(first.node);
+		if (namedFunction !== void 0) {
+			const rest = items.slice(1);
+			return app(namedFunction, [rest.length === 0 ? implicitArgument(context) : lowerTermItems(rest, context)]);
+		}
+	}
+	const lowered = lowerTermItem(first, context);
+	if (items.length > 1) {
+		const detail = spanOfNodes(context, nodesOfItems(items));
+		diagnose(context, "latex/juxtaposition-unparsed", detail);
+		return unparsed(detail);
+	}
+	return lowered;
+}
+function nodesOfItems(items) {
+	const nodes = [];
+	for (const item of items) if (item.kind === "node") nodes.push(item.node);
+	else nodes.push(...item.nodes);
+	return nodes;
+}
+function implicitArgument(context) {
+	diagnose(context, "latex/construct-unparsed");
+	return unparsed("");
+}
+function termItems(nodes) {
+	const items = [];
+	let digits = [];
+	let digitNodes = [];
+	const flushDigits = () => {
+		if (digits.length > 0) {
+			items.push({
+				kind: "number",
+				literal: digits.join(""),
+				nodes: digitNodes
+			});
+			digits = [];
+			digitNodes = [];
+		}
+	};
+	for (const node of nodes) {
+		const text = nodeText(node);
+		if (node.type === "textord" && text !== void 0 && (numericText(text) || text === ".")) {
+			digits.push(text);
+			digitNodes.push(node);
+			continue;
+		}
+		flushDigits();
+		items.push({
+			kind: "node",
+			node
+		});
+	}
+	flushDigits();
+	return items;
+}
+function lowerTermItem(item, context) {
+	if (item.kind === "number") {
+		const rational = require_latex_rational.decimalToRational(item.literal);
+		if (rational === void 0) {
+			diagnose(context, "latex/construct-unparsed", item.literal);
+			return unparsed(item.literal);
+		}
+		return {
+			kind: "num",
+			numerator: rational.numerator,
+			denominator: rational.denominator
+		};
+	}
+	return lowerNode(item.node, context);
+}
+function lowerNode(node, context) {
+	switch (node.type) {
+		case "mathord": {
+			const glyph = glyphOfNode(node);
+			return glyph === void 0 ? degradeNode(node, context) : symbolExpression(glyph, context);
+		}
+		case "textord": {
+			const text = nodeText(node);
+			if (text === void 0) return degradeNode(node, context);
+			if (/^[0-9]$/.test(text)) return {
+				kind: "num",
+				numerator: text,
+				denominator: "1"
+			};
+			const glyph = require_latex_symbols.glyphOfSymbolText(text);
+			return glyph === void 0 ? degradeNode(node, context) : symbolExpression(glyph, context);
+		}
+		case "atom": return degradeNode(node, context);
+		case "genfrac": return lowerGenfrac(node, context);
+		case "sqrt": return lowerSqrt(node, context);
+		case "supsub": return lowerSupsub(node, context);
+		case "op": return degradeNode(node, context);
+		case "ordgroup":
+		case "styling":
+		case "color": {
+			const body = node.body;
+			if (!Array.isArray(body) || !body.every(require_latex_temml.isTemmlNode)) return degradeNode(node, context);
+			return lowerNodeList(body, context);
+		}
+		case "delimiter":
+		case "leftright": return lowerGrouping(node, context);
+		case "array": return lowerArray(node, context);
+		case "text": {
+			const detail = spanOfNodes(context, [node]);
+			diagnose(context, "latex/text-unparsed", detail);
+			return unparsed(detail);
+		}
+		default: return degradeNode(node, context);
+	}
+}
+function degradeNode(node, context) {
+	const span = spanOfNodes(context, [node]);
+	const detail = span !== "" ? span : nodeText(node) ?? node.type;
+	diagnose(context, "latex/construct-unparsed", detail);
+	return unparsed(detail);
+}
+function symbolExpression(glyph, context) {
+	if (context.binders.includes(glyph)) return {
+		kind: "sym",
+		id: glyph
+	};
+	return {
+		kind: "sym",
+		id: context.resolver.resolve(glyph)
+	};
+}
+function lowerGenfrac(node, context) {
+	const hasBar = node.hasBarLine !== false;
+	const delimited = node.leftDelim !== null && node.leftDelim !== void 0 || node.rightDelim !== null && node.rightDelim !== void 0;
+	if (!hasBar || delimited || !require_latex_temml.isTemmlNode(node.numer) || !require_latex_temml.isTemmlNode(node.denom)) {
+		const detail = spanOfNodes(context, [node]);
+		diagnose(context, "latex/genfrac-unparsed", detail);
+		return unparsed(detail);
+	}
+	return app("math:divide", [lowerNode(node.numer, context), lowerNode(node.denom, context)]);
+}
+function lowerSqrt(node, context) {
+	const index = node.index === null ? void 0 : node.index;
+	if (!require_latex_temml.isTemmlNode(node.body) || index !== void 0 && !require_latex_temml.isTemmlNode(index)) return degradeNode(node, context);
+	const body = lowerNode(node.body, context);
+	if (index === void 0) return app("math:sqrt", [body]);
+	return app("math:pow", [body, app("math:divide", [{
+		kind: "num",
+		numerator: "1",
+		denominator: "1"
+	}, lowerNode(index, context)])]);
+}
+function lowerGrouping(node, context) {
+	const body = node.body;
+	if (!Array.isArray(body) || !body.every(require_latex_temml.isTemmlNode)) return degradeNode(node, context);
+	if (body.length === 1) {
+		const only = body[0];
+		if (only?.type === "array") return lowerArray(only, context);
+	}
+	return lowerNodeList(body, context);
+}
+function lowerArray(node, context) {
+	const separated = Array.isArray(node.cols) && node.cols.some((col) => !require_latex_temml.isTemmlNode(col) || col.type === "separator");
+	const body = node.body;
+	const envClasses = node.envClasses;
+	const layoutEnvironment = Array.isArray(envClasses) && envClasses.length > 0;
+	if (layoutEnvironment || separated || !Array.isArray(body)) {
+		const detail = spanOfNodes(context, [node]);
+		diagnose(context, layoutEnvironment ? "latex/array-environment-unparsed" : "latex/construct-unparsed", detail);
+		return unparsed(detail);
+	}
+	const rows = [];
+	for (const row of body) {
+		if (!Array.isArray(row) || !row.every(require_latex_temml.isTemmlNode)) return degradeNode(node, context);
+		rows.push(row.map((cell) => lowerNode(cell, context)));
+	}
+	if (rows.length > 0 && new Set(rows.map((row) => row.length)).size > 1) {
+		const detail = spanOfNodes(context, [node]);
+		diagnose(context, "latex/construct-unparsed", detail);
+		return unparsed(detail);
+	}
+	return {
+		kind: "matrix",
+		rows
+	};
+}
+function lowerSupsub(node, context) {
+	const binder = readBinder(node, context);
+	if (binder.status === "binder") return {
+		kind: binder.kind,
+		binder: binder.binder,
+		lower: binder.lower,
+		upper: binder.upper,
+		body: implicitArgument(context)
+	};
+	if (binder.status === "degraded") return unparsed(binder.detail);
+	const detail = spanOfNodes(context, [node]);
+	const base = require_latex_temml.isTemmlNode(node.base) ? node.base : void 0;
+	const sub = node.sub === void 0 ? void 0 : nodesOfScript(node.sub);
+	const sup = node.sup === void 0 ? void 0 : nodesOfScript(node.sup);
+	if (sub !== void 0) {
+		const subWritten = simpleScriptGlyph(sub);
+		const baseGlyph = base !== void 0 && (base.type === "mathord" || base.type === "textord") ? glyphOfNode(base) : void 0;
+		if (baseGlyph === void 0 || subWritten === void 0) {
+			diagnose(context, "latex/subscript-unparsed", detail);
+			return unparsed(detail);
+		}
+		const subscriptedGlyph = `${baseGlyph}_${subWritten}`;
+		if (sup === void 0) return symbolExpression(subscriptedGlyph, context);
+		const tripleGlyph = `${subscriptedGlyph}^${scriptWrittenForm(sup, context)}`;
+		if (context.resolver.isCurated(tripleGlyph)) return symbolExpression(tripleGlyph, context);
+		return app("math:pow", [symbolExpression(subscriptedGlyph, context), lowerNodeList(sup, context)]);
+	}
+	if (sup === void 0) return degradeNode(node, context);
+	const exponent = lowerNodeList(sup, context);
+	if (base === void 0) return degradeNode(node, context);
+	if (base.type !== "mathord" && base.type !== "textord") {
+		const loweredBase = lowerNode(base, context);
+		if (loweredBase.kind === "unparsed") {
+			diagnose(context, "latex/script-base-unparsed", detail);
+			return unparsed(detail);
+		}
+		return app("math:pow", [loweredBase, exponent]);
+	}
+	const baseGlyph = glyphOfNode(base);
+	if (baseGlyph === void 0) return degradeNode(node, context);
+	const scriptedGlyph = `${baseGlyph}^${scriptWrittenForm(sup, context)}`;
+	if (context.resolver.isCurated(scriptedGlyph)) return symbolExpression(scriptedGlyph, context);
+	return app("math:pow", [symbolExpression(baseGlyph, context), exponent]);
+}
+function scriptWrittenForm(nodes, context) {
+	const span = spanOfNodes(context, nodes);
+	if (span !== "") return span;
+	return nodes.map((node) => glyphOfNode(node) ?? nodeText(node) ?? "").join("");
+}
+function simpleScriptGlyph(nodes) {
+	const parts = [];
+	for (const node of nodes) {
+		const text = nodeText(node);
+		if (node.type === "mathord") {
+			const glyph = glyphOfNode(node);
+			if (glyph === void 0) return;
+			parts.push(glyph);
+			continue;
+		}
+		if (node.type === "textord" && text !== void 0 && /^[0-9A-Za-z]$/.test(text)) {
+			parts.push(text);
+			continue;
+		}
+		return;
+	}
+	return parts.length === 0 ? void 0 : parts.join("");
+}
+function readBinder(node, context) {
+	if (node.type !== "supsub") return { status: "not-a-binder" };
+	const base = require_latex_temml.isTemmlNode(node.base) ? node.base : void 0;
+	if (base?.type !== "op" || base?.symbol !== true || typeof base?.name !== "string") return { status: "not-a-binder" };
+	if (base.name !== "\\sum" && base.name !== "\\prod") return { status: "not-a-binder" };
+	const kind = base.name === "\\sum" ? "sum" : "prod";
+	const detail = spanOfNodes(context, [node]);
+	const sub = node.sub === void 0 ? void 0 : nodesOfScript(node.sub);
+	const sup = node.sup === void 0 ? void 0 : nodesOfScript(node.sup);
+	const upper = sup === void 0 ? implicitBound(context) : lowerNodeList(sup, context);
+	if ((sub?.length ?? 0) >= 3) {
+		const first = sub?.[0];
+		const relation = sub?.[1];
+		const rest = sub?.slice(2) ?? [];
+		const firstGlyph = first?.type === "mathord" ? glyphOfNode(first) : void 0;
+		if (firstGlyph !== void 0 && relation?.type === "atom" && nodeText(relation) === "=") return {
+			status: "binder",
+			kind,
+			binder: firstGlyph,
+			lower: lowerNodeList(rest, context),
+			upper
+		};
+	}
+	if ((sub?.length ?? 0) === 1 && sub !== void 0) {
+		const singleGlyph = simpleScriptGlyph(sub);
+		if (singleGlyph !== void 0) {
+			diagnose(context, "latex/binder-bound-implicit", detail);
+			return {
+				status: "binder",
+				kind,
+				binder: singleGlyph,
+				lower: unparsed(""),
+				upper
+			};
+		}
+	}
+	diagnose(context, "latex/binder-bound-unreadable", detail);
+	return {
+		status: "degraded",
+		detail
+	};
+}
+function implicitBound(context) {
+	diagnose(context, "latex/binder-bound-implicit");
+	return unparsed("");
+}
+function namedFunctionOfOp(node) {
+	if (node.type !== "op" || node.symbol === true) return;
+	const name = typeof node.name === "string" ? node.name : void 0;
+	return name === void 0 ? void 0 : NAMED_FUNCTION_OPERATORS[name];
+}
+function lowerLatex(latex, options) {
+	return lowerParsed(latex, require_latex_temml.parseLatex(latex), options);
+}
+function lowerParsed(latex, parsed, options) {
+	if (latex.trim() === "") return {
+		expression: unparsed(""),
+		diagnostics: [],
+		mintedSymbols: []
+	};
+	const resolver = new require_latex_symbols.SymbolResolver(options?.symbolEntries ?? []);
+	const context = {
+		input: latex,
+		resolver,
+		binders: [],
+		diagnostics: [],
+		sink: options?.sink
+	};
+	if (parsed.status === "unparseable") {
+		diagnose(context, "latex/parse-error", parsed.message);
+		return {
+			expression: unparsed(latex),
+			diagnostics: context.diagnostics,
+			mintedSymbols: resolver.mintedEntries()
+		};
+	}
+	return {
+		expression: lowerNodeList(parsed.nodes, context),
+		diagnostics: context.diagnostics,
+		mintedSymbols: resolver.mintedEntries()
+	};
+}
+function latexToFormula(latex, options) {
+	const parsed = require_latex_temml.parseLatex(latex);
+	const lowering = lowerParsed(latex, parsed, options);
+	return {
+		formula: {
+			mathml: parsed.status === "parsed" ? [...parsed.mathml] : [],
+			presentation: { latex },
+			content: lowering.expression,
+			provenance: {
+				source: options?.source ?? "lowered:latex",
+				editTrail: []
+			}
+		},
+		diagnostics: lowering.diagnostics,
+		mintedSymbols: lowering.mintedSymbols
+	};
+}
+//#endregion
+exports.latexToFormula = latexToFormula;
+exports.lowerLatex = lowerLatex;

package/dist/latex/lower.d.cts

@@ -0,0 +1,24 @@
+import { i as LatexDiagnosticSink, n as LatexDiagnostic } from "../diagnostics-C5-bG09J.cjs";
+import { ContentFormula, MathExpression, MathSymbolEntry } from "document-schema.js";
+//#region src/latex/lower.d.ts
+interface LowerLatexOptions {
+  readonly symbolEntries?: readonly MathSymbolEntry[];
+  readonly sink?: LatexDiagnosticSink;
+}
+interface LatexLoweringResult {
+  readonly expression: MathExpression;
+  readonly diagnostics: readonly LatexDiagnostic[];
+  readonly mintedSymbols: readonly MathSymbolEntry[];
+}
+declare function lowerLatex(latex: string, options?: LowerLatexOptions): LatexLoweringResult;
+interface LatexFormulaOptions extends LowerLatexOptions {
+  readonly source?: string;
+}
+interface LatexFormulaResult {
+  readonly formula: ContentFormula;
+  readonly diagnostics: readonly LatexDiagnostic[];
+  readonly mintedSymbols: readonly MathSymbolEntry[];
+}
+declare function latexToFormula(latex: string, options?: LatexFormulaOptions): LatexFormulaResult;
+//#endregion
+export { LatexFormulaOptions, LatexFormulaResult, LatexLoweringResult, LowerLatexOptions, latexToFormula, lowerLatex };

package/dist/latex/lower.d.ts

@@ -0,0 +1,24 @@
+import { i as LatexDiagnosticSink, n as LatexDiagnostic } from "../diagnostics-C5-bG09J.js";
+import { ContentFormula, MathExpression, MathSymbolEntry } from "document-schema.js";
+//#region src/latex/lower.d.ts
+interface LowerLatexOptions {
+  readonly symbolEntries?: readonly MathSymbolEntry[];
+  readonly sink?: LatexDiagnosticSink;
+}
+interface LatexLoweringResult {
+  readonly expression: MathExpression;
+  readonly diagnostics: readonly LatexDiagnostic[];
+  readonly mintedSymbols: readonly MathSymbolEntry[];
+}
+declare function lowerLatex(latex: string, options?: LowerLatexOptions): LatexLoweringResult;
+interface LatexFormulaOptions extends LowerLatexOptions {
+  readonly source?: string;
+}
+interface LatexFormulaResult {
+  readonly formula: ContentFormula;
+  readonly diagnostics: readonly LatexDiagnostic[];
+  readonly mintedSymbols: readonly MathSymbolEntry[];
+}
+declare function latexToFormula(latex: string, options?: LatexFormulaOptions): LatexFormulaResult;
+//#endregion
+export { LatexFormulaOptions, LatexFormulaResult, LatexLoweringResult, LowerLatexOptions, latexToFormula, lowerLatex };