js.documents 14.4.56 → 14.4.57

package/dist/lower-DzOb13w4.cjs

@@ -0,0 +1,701 @@
+const require_latex_temml = require("./latex/temml.cjs");
+const require_latex_symbols = require("./latex/symbols.cjs");
+const require_latex_rational = require("./latex/rational.cjs");
+//#region src/latex/lower-fold.ts
+function normaliseUnaryMinus(operators, segments) {
+	const outOperators = [];
+	const outSegments = [];
+	let pendingNegate = false;
+	let skipOperator = false;
+	for (const [index, segment] of segments.entries()) {
+		if (index > 0 && !skipOperator) {
+			const operator = operators[index - 1];
+			if (operator !== void 0) outOperators.push(operator);
+		}
+		skipOperator = false;
+		if (segment.nodes.length === 0 && operators[index] === "math:subtract") {
+			pendingNegate = !pendingNegate;
+			skipOperator = true;
+			continue;
+		}
+		outSegments.push({
+			nodes: segment.nodes,
+			negated: pendingNegate
+		});
+		pendingNegate = false;
+	}
+	return {
+		operators: outOperators,
+		segments: outSegments
+	};
+}
+function fold(first, operators, segments, context, detail) {
+	let runFirst = first;
+	let runOperators = [];
+	let runSegments = [];
+	const operands = [];
+	const relations = [];
+	for (let index = 0; index < operators.length; index += 1) {
+		const operator = operators[index];
+		const segment = segments[index];
+		if (operator === void 0 || segment === void 0) throw new Error("operator and segment lists diverged while folding a lowered sequence");
+		if (segment.nodes.length === 0) {
+			diagnose(context, "latex/operator-placement-unparsed", detail);
+			return unparsed(detail);
+		}
+		if (RELATION_OPERATORS.has(operator)) {
+			operands.push(foldArithmetic(runFirst, runOperators, runSegments, context));
+			relations.push(operator);
+			runFirst = lowerFoldSegment(segment, context);
+			runOperators = [];
+			runSegments = [];
+			continue;
+		}
+		runOperators.push(operator);
+		runSegments.push(segment);
+	}
+	operands.push(foldArithmetic(runFirst, runOperators, runSegments, context));
+	let folded = operands[0];
+	if (folded === void 0) throw new Error("fold produced no operand for a non-empty operator list");
+	for (let index = 0; index < relations.length; index += 1) {
+		const relation = relations[index];
+		const operand = operands[index + 1];
+		if (relation === void 0 || operand === void 0) throw new Error("relation and operand lists diverged while folding a lowered sequence");
+		folded = app(relation, [folded, operand]);
+	}
+	return folded;
+}
+function foldArithmetic(first, operators, segments, context) {
+	let folded = first;
+	for (let index = 0; index < operators.length; index += 1) {
+		const operator = operators[index];
+		const segment = segments[index];
+		if (operator === void 0 || segment === void 0) throw new Error("operator and segment lists diverged while folding an arithmetic run");
+		folded = app(operator, [folded, lowerFoldSegment(segment, context)]);
+	}
+	return folded;
+}
+function lowerFoldSegment(segment, context) {
+	const folded = lowerTerm(segment.nodes, context);
+	return segment.negated ? app(UNARY_MINUS_OPERATOR, [folded]) : folded;
+}
+//#endregion
+//#region src/latex/lower.ts
+const RELATION_SUBSCRIPT_MIN_NODES = 3;
+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 RELATION_OPERATORS = new Set(Object.values(RELATION_ATOM_OPERATORS));
+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 normalised = normaliseUnaryMinus(operators, segments.map((segmentNodes) => ({
+		nodes: segmentNodes,
+		negated: false
+	})));
+	const [firstSegment, ...restSegments] = normalised.segments;
+	if (firstSegment === void 0) {
+		diagnose(context, "latex/operator-placement-unparsed", spanOfNodes(context, present));
+		return unparsed(spanOfNodes(context, present));
+	}
+	if (normalised.operators.length === 0) return lowerFoldSegment(firstSegment, context);
+	const detail = spanOfNodes(context, present);
+	if (firstSegment.nodes.length === 0) {
+		diagnose(context, "latex/operator-placement-unparsed", detail);
+		return unparsed(detail);
+	}
+	return fold(lowerFoldSegment(firstSegment, context), normalised.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 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 = nodesOfScript(node.sub);
+	const sup = 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 = nodesOfScript(node.sub);
+	const sup = nodesOfScript(node.sup);
+	const upper = sup === void 0 ? implicitBound(context) : lowerNodeList(sup, context);
+	if ((sub?.length ?? 0) >= RELATION_SUBSCRIPT_MIN_NODES) {
+		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 === 1) {
+		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
+Object.defineProperty(exports, "RELATION_ATOM_OPERATORS", {
+	enumerable: true,
+	get: function() {
+		return RELATION_ATOM_OPERATORS;
+	}
+});
+Object.defineProperty(exports, "RELATION_OPERATORS", {
+	enumerable: true,
+	get: function() {
+		return RELATION_OPERATORS;
+	}
+});
+Object.defineProperty(exports, "SUBTRACT_OPERATOR", {
+	enumerable: true,
+	get: function() {
+		return SUBTRACT_OPERATOR;
+	}
+});
+Object.defineProperty(exports, "UNARY_MINUS_OPERATOR", {
+	enumerable: true,
+	get: function() {
+		return UNARY_MINUS_OPERATOR;
+	}
+});
+Object.defineProperty(exports, "app", {
+	enumerable: true,
+	get: function() {
+		return app;
+	}
+});
+Object.defineProperty(exports, "diagnose", {
+	enumerable: true,
+	get: function() {
+		return diagnose;
+	}
+});
+Object.defineProperty(exports, "fold", {
+	enumerable: true,
+	get: function() {
+		return fold;
+	}
+});
+Object.defineProperty(exports, "foldArithmetic", {
+	enumerable: true,
+	get: function() {
+		return foldArithmetic;
+	}
+});
+Object.defineProperty(exports, "latexToFormula", {
+	enumerable: true,
+	get: function() {
+		return latexToFormula;
+	}
+});
+Object.defineProperty(exports, "lowerFoldSegment", {
+	enumerable: true,
+	get: function() {
+		return lowerFoldSegment;
+	}
+});
+Object.defineProperty(exports, "lowerLatex", {
+	enumerable: true,
+	get: function() {
+		return lowerLatex;
+	}
+});
+Object.defineProperty(exports, "lowerTerm", {
+	enumerable: true,
+	get: function() {
+		return lowerTerm;
+	}
+});
+Object.defineProperty(exports, "normaliseUnaryMinus", {
+	enumerable: true,
+	get: function() {
+		return normaliseUnaryMinus;
+	}
+});
+Object.defineProperty(exports, "unparsed", {
+	enumerable: true,
+	get: function() {
+		return unparsed;
+	}
+});