documents.js 1.60.3 → 1.62.0

package/dist/omml/write.cjs

@@ -0,0 +1,258 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_xml_fragment = require("../xml/fragment.cjs");
+const require_mathml_length = require("../mathml/length.cjs");
+const require_mathml_nodes = require("../mathml/nodes.cjs");
+const require_mathml_operators = require("../mathml/operators.cjs");
+const require_mathml_variant = require("../mathml/variant.cjs");
+const require_xml_entities = require("../xml/entities.cjs");
+//#region src/omml/write.ts
+const OMML_NS = "http://schemas.openxmlformats.org/officeDocument/2006/math";
+const VARIANT_RUN_PROPERTIES = {
+	normal: { sty: "p" },
+	bold: { sty: "b" },
+	italic: { sty: "i" },
+	"bold-italic": { sty: "bi" },
+	"double-struck": {
+		scr: "double-struck",
+		sty: "p"
+	},
+	script: {
+		scr: "script",
+		sty: "p"
+	},
+	"bold-script": {
+		scr: "script",
+		sty: "b"
+	},
+	fraktur: {
+		scr: "fraktur",
+		sty: "p"
+	},
+	"bold-fraktur": {
+		scr: "fraktur",
+		sty: "b"
+	},
+	"sans-serif": {
+		scr: "sans-serif",
+		sty: "p"
+	},
+	"bold-sans-serif": {
+		scr: "sans-serif",
+		sty: "b"
+	},
+	"sans-serif-italic": {
+		scr: "sans-serif",
+		sty: "i"
+	},
+	"sans-serif-bold-italic": {
+		scr: "sans-serif",
+		sty: "bi"
+	},
+	monospace: {
+		scr: "monospace",
+		sty: "p"
+	}
+};
+function columnJustification(align) {
+	return align === "left" || align === "right" || align === "center" ? align : "center";
+}
+function diagnose(ctx, kind, element) {
+	ctx.diagnostics.push({
+		kind,
+		detail: require_mathml_nodes.elementLocalName(element)
+	});
+}
+function mathRun(text, properties) {
+	const tAttrs = require_xml_entities.needsSpacePreserve(text) ? { "xml:space": "preserve" } : {};
+	const children = [];
+	if (properties !== void 0) children.push(properties);
+	children.push(require_xml_fragment.el("m:t", tAttrs, [require_xml_fragment.txt(require_xml_entities.encodeXmlText(text))]));
+	return require_xml_fragment.el("m:r", {}, children);
+}
+function variantRunProperties(variant) {
+	const mapped = VARIANT_RUN_PROPERTIES[variant];
+	const children = [];
+	if (mapped.scr !== void 0) children.push(require_xml_fragment.el("m:scr", { "m:val": mapped.scr }));
+	children.push(require_xml_fragment.el("m:sty", { "m:val": mapped.sty }));
+	return require_xml_fragment.el("m:rPr", {}, children);
+}
+function miIntrinsicDefault(content) {
+	return [...content].length === 1 ? "italic" : "normal";
+}
+function tokenVariant(element, intrinsicDefault, ctx) {
+	const attr = require_mathml_nodes.attrValue(element, "mathvariant");
+	if (attr !== void 0 && require_mathml_variant.isMathVariant(attr)) return attr;
+	return ctx.inheritedVariant ?? intrinsicDefault;
+}
+function tokenRun(element, rawText, intrinsicDefault, ctx, normalText) {
+	if (rawText.length === 0) return [];
+	if (normalText && require_mathml_nodes.attrValue(element, "mathvariant") === void 0) return [mathRun(rawText, require_xml_fragment.el("m:rPr", {}, [require_xml_fragment.el("m:nor")]))];
+	return [mathRun(rawText, variantRunProperties(tokenVariant(element, intrinsicDefault, ctx)))];
+}
+function argSlot(tag, child, ctx) {
+	return require_xml_fragment.el(tag, {}, child === void 0 ? [] : convertElement(child, ctx));
+}
+function argSlotFromChildren(tag, children, ctx) {
+	return require_xml_fragment.el(tag, {}, children.flatMap((child) => convertElement(child, ctx)));
+}
+function convertFraction(element, ctx) {
+	const children = require_mathml_nodes.elementChildren(element);
+	const lineThickness = require_mathml_nodes.attrValue(element, "linethickness");
+	const barless = lineThickness !== void 0 && require_mathml_length.parseMathLength(lineThickness, 1) === 0;
+	const parts = [];
+	if (barless) parts.push(require_xml_fragment.el("m:fPr", {}, [require_xml_fragment.el("m:type", { "m:val": "noBar" })]));
+	parts.push(argSlot("m:num", children[0], ctx), argSlot("m:den", children[1], ctx));
+	return require_xml_fragment.el("m:f", {}, parts);
+}
+function convertRadical(element, kind, ctx) {
+	const children = require_mathml_nodes.elementChildren(element);
+	if (kind === "msqrt") return require_xml_fragment.el("m:rad", {}, [
+		require_xml_fragment.el("m:radPr", {}, [require_xml_fragment.el("m:degHide", { "m:val": "1" })]),
+		require_xml_fragment.el("m:deg"),
+		argSlotFromChildren("m:e", children, ctx)
+	]);
+	return require_xml_fragment.el("m:rad", {}, [argSlot("m:deg", children[1], ctx), argSlot("m:e", children[0], ctx)]);
+}
+function convertScripts(element, kind, ctx) {
+	const children = require_mathml_nodes.elementChildren(element);
+	const base = argSlot("m:e", children[0], ctx);
+	if (kind === "msub") return require_xml_fragment.el("m:sSub", {}, [base, argSlot("m:sub", children[1], ctx)]);
+	if (kind === "msup") return require_xml_fragment.el("m:sSup", {}, [base, argSlot("m:sup", children[1], ctx)]);
+	return require_xml_fragment.el("m:sSubSup", {}, [
+		base,
+		argSlot("m:sub", children[1], ctx),
+		argSlot("m:sup", children[2], ctx)
+	]);
+}
+function isMovableLimitsOperator(element) {
+	return element !== void 0 && require_mathml_nodes.elementLocalName(element) === "mo" && require_mathml_operators.operatorProperties(require_mathml_nodes.textContent(element).trim()).movablelimits;
+}
+function convertUnderOver(element, kind, ctx) {
+	const children = require_mathml_nodes.elementChildren(element);
+	if (!ctx.displayStyle && isMovableLimitsOperator(children[0])) return convertScripts(element, kind === "munder" ? "msub" : kind === "mover" ? "msup" : "msubsup", ctx);
+	if (kind === "munder") return require_xml_fragment.el("m:limLow", {}, [argSlot("m:e", children[0], ctx), argSlot("m:lim", children[1], ctx)]);
+	if (kind === "mover") return require_xml_fragment.el("m:limUpp", {}, [argSlot("m:e", children[0], ctx), argSlot("m:lim", children[1], ctx)]);
+	const lower = require_xml_fragment.el("m:limLow", {}, [argSlot("m:e", children[0], ctx), argSlot("m:lim", children[1], ctx)]);
+	return require_xml_fragment.el("m:limUpp", {}, [require_xml_fragment.el("m:e", {}, [lower]), argSlot("m:lim", children[2], ctx)]);
+}
+function convertTable(element, ctx) {
+	const rows = require_mathml_nodes.elementChildren(element).filter((child) => require_mathml_nodes.elementLocalName(child) === "mtr");
+	const columnAligns = (require_mathml_nodes.attrValue(element, "columnalign") ?? "").trim().split(/\s+/).filter((token) => token.length > 0);
+	const rowCells = rows.map((row) => require_mathml_nodes.elementChildren(row).filter((child) => require_mathml_nodes.elementLocalName(child) === "mtd"));
+	const columnCount = rowCells.reduce((max, cells) => Math.max(max, cells.length), 0);
+	const children = [];
+	if (columnCount > 0) {
+		const columns = [];
+		for (let column = 0; column < columnCount; column++) {
+			const align = columnJustification(columnAligns[column] ?? columnAligns[columnAligns.length - 1]);
+			columns.push(require_xml_fragment.el("m:mc", {}, [require_xml_fragment.el("m:mcPr", {}, [require_xml_fragment.el("m:count", { "m:val": "1" }), require_xml_fragment.el("m:mcJc", { "m:val": align })])]));
+		}
+		children.push(require_xml_fragment.el("m:mPr", {}, [require_xml_fragment.el("m:mcs", {}, columns)]));
+	}
+	for (const cells of rowCells) {
+		const slots = cells.map((cell) => argSlotFromChildren("m:e", require_mathml_nodes.elementChildren(cell), ctx));
+		children.push(require_xml_fragment.el("m:mr", {}, slots.length === 0 ? [require_xml_fragment.el("m:e")] : slots));
+	}
+	return require_xml_fragment.el("m:m", {}, children);
+}
+function convertSpace(element, ctx) {
+	const width = require_mathml_nodes.attrValue(element, "width");
+	const widthValue = width === void 0 ? void 0 : require_mathml_length.parseMathLength(width, 1);
+	if (widthValue === void 0 || widthValue <= 0) return [];
+	diagnose(ctx, "approximated-element", element);
+	return [mathRun(" ", require_xml_fragment.el("m:rPr", {}, [require_xml_fragment.el("m:nor")]))];
+}
+function convertSemantics(element, ctx) {
+	const content = require_mathml_nodes.elementChildren(element).find((child) => {
+		const name = require_mathml_nodes.elementLocalName(child);
+		return name !== "annotation" && name !== "annotation-xml";
+	});
+	return content === void 0 ? [] : convertElement(content, ctx);
+}
+function mstyleContext(element, ctx) {
+	let next = ctx;
+	const displayAttr = require_mathml_nodes.attrValue(element, "displaystyle");
+	if (displayAttr === "true" || displayAttr === "false") next = {
+		...next,
+		displayStyle: displayAttr === "true"
+	};
+	const variantAttr = require_mathml_nodes.attrValue(element, "mathvariant");
+	if (variantAttr !== void 0 && require_mathml_variant.isMathVariant(variantAttr)) next = {
+		...next,
+		inheritedVariant: variantAttr
+	};
+	return next;
+}
+function convertElement(node, ctx) {
+	const name = require_mathml_nodes.elementLocalName(node);
+	switch (name) {
+		case "mrow": return convertNodes(node.children, ctx);
+		case "mstyle": return convertNodes(node.children, mstyleContext(node, ctx));
+		case "semantics": return convertSemantics(node, ctx);
+		case "mi": {
+			const text = require_mathml_nodes.textContent(node);
+			return tokenRun(node, text, miIntrinsicDefault(text), ctx, false);
+		}
+		case "mn": return tokenRun(node, require_mathml_nodes.textContent(node), "normal", ctx, false);
+		case "mo": return tokenRun(node, require_mathml_nodes.textContent(node).trim(), "normal", ctx, false);
+		case "mtext": return tokenRun(node, require_mathml_nodes.textContent(node), "normal", ctx, true);
+		case "mspace": return convertSpace(node, ctx);
+		case "mfrac": return [convertFraction(node, ctx)];
+		case "msqrt": return [convertRadical(node, "msqrt", ctx)];
+		case "mroot": return [convertRadical(node, "mroot", ctx)];
+		case "msub":
+		case "msup":
+		case "msubsup": return [convertScripts(node, name, ctx)];
+		case "munder":
+		case "mover":
+		case "munderover": return [convertUnderOver(node, name, ctx)];
+		case "mtable": return [convertTable(node, ctx)];
+		case "mtr":
+		case "mtd": return convertNodes(node.children, ctx);
+		default:
+			diagnose(ctx, "unsupported-element", node);
+			return tokenRun(node, require_mathml_nodes.textContent(node), "normal", ctx, true);
+	}
+}
+function convertNodes(nodes, ctx) {
+	const out = [];
+	for (const node of nodes) {
+		if (!require_mathml_nodes.isMathMlElement(node)) continue;
+		out.push(...convertElement(node, ctx));
+	}
+	return out;
+}
+function rootContext(diagnostics) {
+	return {
+		inheritedVariant: void 0,
+		displayStyle: true,
+		diagnostics
+	};
+}
+function buildOfficeMath(mathml) {
+	const diagnostics = [];
+	const children = convertNodes(mathml, rootContext(diagnostics));
+	if (children.length === 0) return {
+		element: void 0,
+		diagnostics
+	};
+	return {
+		element: require_xml_fragment.el("m:oMath", { "xmlns:m": OMML_NS }, children),
+		diagnostics
+	};
+}
+function buildOfficeMathParagraph(mathml) {
+	const diagnostics = [];
+	const children = convertNodes(mathml, rootContext(diagnostics));
+	if (children.length === 0) return {
+		element: void 0,
+		diagnostics
+	};
+	return {
+		element: require_xml_fragment.el("m:oMathPara", { "xmlns:m": OMML_NS }, [require_xml_fragment.el("m:oMath", {}, children)]),
+		diagnostics
+	};
+}
+//#endregion
+exports.buildOfficeMath = buildOfficeMath;
+exports.buildOfficeMathParagraph = buildOfficeMathParagraph;

package/dist/omml/write.d.cts

@@ -0,0 +1,2 @@
+import { a as buildOfficeMathParagraph, i as buildOfficeMath, n as OmmlDiagnosticKind, r as OmmlWriteResult, t as OmmlDiagnostic } from "../write-DuyfnbL_.cjs";
+export { OmmlDiagnostic, OmmlDiagnosticKind, OmmlWriteResult, buildOfficeMath, buildOfficeMathParagraph };

package/dist/omml/write.d.ts

@@ -0,0 +1,2 @@
+import { a as buildOfficeMathParagraph, i as buildOfficeMath, n as OmmlDiagnosticKind, r as OmmlWriteResult, t as OmmlDiagnostic } from "../write-Zqwx6pka.js";
+export { OmmlDiagnostic, OmmlDiagnosticKind, OmmlWriteResult, buildOfficeMath, buildOfficeMathParagraph };

package/dist/omml/write.js

@@ -0,0 +1,256 @@
+import { el, txt } from "../xml/fragment.js";
+import { parseMathLength } from "../mathml/length.js";
+import { attrValue, elementChildren, elementLocalName, isMathMlElement, textContent } from "../mathml/nodes.js";
+import { operatorProperties } from "../mathml/operators.js";
+import { isMathVariant } from "../mathml/variant.js";
+import { encodeXmlText, needsSpacePreserve } from "../xml/entities.js";
+//#region src/omml/write.ts
+const OMML_NS = "http://schemas.openxmlformats.org/officeDocument/2006/math";
+const VARIANT_RUN_PROPERTIES = {
+	normal: { sty: "p" },
+	bold: { sty: "b" },
+	italic: { sty: "i" },
+	"bold-italic": { sty: "bi" },
+	"double-struck": {
+		scr: "double-struck",
+		sty: "p"
+	},
+	script: {
+		scr: "script",
+		sty: "p"
+	},
+	"bold-script": {
+		scr: "script",
+		sty: "b"
+	},
+	fraktur: {
+		scr: "fraktur",
+		sty: "p"
+	},
+	"bold-fraktur": {
+		scr: "fraktur",
+		sty: "b"
+	},
+	"sans-serif": {
+		scr: "sans-serif",
+		sty: "p"
+	},
+	"bold-sans-serif": {
+		scr: "sans-serif",
+		sty: "b"
+	},
+	"sans-serif-italic": {
+		scr: "sans-serif",
+		sty: "i"
+	},
+	"sans-serif-bold-italic": {
+		scr: "sans-serif",
+		sty: "bi"
+	},
+	monospace: {
+		scr: "monospace",
+		sty: "p"
+	}
+};
+function columnJustification(align) {
+	return align === "left" || align === "right" || align === "center" ? align : "center";
+}
+function diagnose(ctx, kind, element) {
+	ctx.diagnostics.push({
+		kind,
+		detail: elementLocalName(element)
+	});
+}
+function mathRun(text, properties) {
+	const tAttrs = needsSpacePreserve(text) ? { "xml:space": "preserve" } : {};
+	const children = [];
+	if (properties !== void 0) children.push(properties);
+	children.push(el("m:t", tAttrs, [txt(encodeXmlText(text))]));
+	return el("m:r", {}, children);
+}
+function variantRunProperties(variant) {
+	const mapped = VARIANT_RUN_PROPERTIES[variant];
+	const children = [];
+	if (mapped.scr !== void 0) children.push(el("m:scr", { "m:val": mapped.scr }));
+	children.push(el("m:sty", { "m:val": mapped.sty }));
+	return el("m:rPr", {}, children);
+}
+function miIntrinsicDefault(content) {
+	return [...content].length === 1 ? "italic" : "normal";
+}
+function tokenVariant(element, intrinsicDefault, ctx) {
+	const attr = attrValue(element, "mathvariant");
+	if (attr !== void 0 && isMathVariant(attr)) return attr;
+	return ctx.inheritedVariant ?? intrinsicDefault;
+}
+function tokenRun(element, rawText, intrinsicDefault, ctx, normalText) {
+	if (rawText.length === 0) return [];
+	if (normalText && attrValue(element, "mathvariant") === void 0) return [mathRun(rawText, el("m:rPr", {}, [el("m:nor")]))];
+	return [mathRun(rawText, variantRunProperties(tokenVariant(element, intrinsicDefault, ctx)))];
+}
+function argSlot(tag, child, ctx) {
+	return el(tag, {}, child === void 0 ? [] : convertElement(child, ctx));
+}
+function argSlotFromChildren(tag, children, ctx) {
+	return el(tag, {}, children.flatMap((child) => convertElement(child, ctx)));
+}
+function convertFraction(element, ctx) {
+	const children = elementChildren(element);
+	const lineThickness = attrValue(element, "linethickness");
+	const barless = lineThickness !== void 0 && parseMathLength(lineThickness, 1) === 0;
+	const parts = [];
+	if (barless) parts.push(el("m:fPr", {}, [el("m:type", { "m:val": "noBar" })]));
+	parts.push(argSlot("m:num", children[0], ctx), argSlot("m:den", children[1], ctx));
+	return el("m:f", {}, parts);
+}
+function convertRadical(element, kind, ctx) {
+	const children = elementChildren(element);
+	if (kind === "msqrt") return el("m:rad", {}, [
+		el("m:radPr", {}, [el("m:degHide", { "m:val": "1" })]),
+		el("m:deg"),
+		argSlotFromChildren("m:e", children, ctx)
+	]);
+	return el("m:rad", {}, [argSlot("m:deg", children[1], ctx), argSlot("m:e", children[0], ctx)]);
+}
+function convertScripts(element, kind, ctx) {
+	const children = elementChildren(element);
+	const base = argSlot("m:e", children[0], ctx);
+	if (kind === "msub") return el("m:sSub", {}, [base, argSlot("m:sub", children[1], ctx)]);
+	if (kind === "msup") return el("m:sSup", {}, [base, argSlot("m:sup", children[1], ctx)]);
+	return el("m:sSubSup", {}, [
+		base,
+		argSlot("m:sub", children[1], ctx),
+		argSlot("m:sup", children[2], ctx)
+	]);
+}
+function isMovableLimitsOperator(element) {
+	return element !== void 0 && elementLocalName(element) === "mo" && operatorProperties(textContent(element).trim()).movablelimits;
+}
+function convertUnderOver(element, kind, ctx) {
+	const children = elementChildren(element);
+	if (!ctx.displayStyle && isMovableLimitsOperator(children[0])) return convertScripts(element, kind === "munder" ? "msub" : kind === "mover" ? "msup" : "msubsup", ctx);
+	if (kind === "munder") return el("m:limLow", {}, [argSlot("m:e", children[0], ctx), argSlot("m:lim", children[1], ctx)]);
+	if (kind === "mover") return el("m:limUpp", {}, [argSlot("m:e", children[0], ctx), argSlot("m:lim", children[1], ctx)]);
+	const lower = el("m:limLow", {}, [argSlot("m:e", children[0], ctx), argSlot("m:lim", children[1], ctx)]);
+	return el("m:limUpp", {}, [el("m:e", {}, [lower]), argSlot("m:lim", children[2], ctx)]);
+}
+function convertTable(element, ctx) {
+	const rows = elementChildren(element).filter((child) => elementLocalName(child) === "mtr");
+	const columnAligns = (attrValue(element, "columnalign") ?? "").trim().split(/\s+/).filter((token) => token.length > 0);
+	const rowCells = rows.map((row) => elementChildren(row).filter((child) => elementLocalName(child) === "mtd"));
+	const columnCount = rowCells.reduce((max, cells) => Math.max(max, cells.length), 0);
+	const children = [];
+	if (columnCount > 0) {
+		const columns = [];
+		for (let column = 0; column < columnCount; column++) {
+			const align = columnJustification(columnAligns[column] ?? columnAligns[columnAligns.length - 1]);
+			columns.push(el("m:mc", {}, [el("m:mcPr", {}, [el("m:count", { "m:val": "1" }), el("m:mcJc", { "m:val": align })])]));
+		}
+		children.push(el("m:mPr", {}, [el("m:mcs", {}, columns)]));
+	}
+	for (const cells of rowCells) {
+		const slots = cells.map((cell) => argSlotFromChildren("m:e", elementChildren(cell), ctx));
+		children.push(el("m:mr", {}, slots.length === 0 ? [el("m:e")] : slots));
+	}
+	return el("m:m", {}, children);
+}
+function convertSpace(element, ctx) {
+	const width = attrValue(element, "width");
+	const widthValue = width === void 0 ? void 0 : parseMathLength(width, 1);
+	if (widthValue === void 0 || widthValue <= 0) return [];
+	diagnose(ctx, "approximated-element", element);
+	return [mathRun(" ", el("m:rPr", {}, [el("m:nor")]))];
+}
+function convertSemantics(element, ctx) {
+	const content = elementChildren(element).find((child) => {
+		const name = elementLocalName(child);
+		return name !== "annotation" && name !== "annotation-xml";
+	});
+	return content === void 0 ? [] : convertElement(content, ctx);
+}
+function mstyleContext(element, ctx) {
+	let next = ctx;
+	const displayAttr = attrValue(element, "displaystyle");
+	if (displayAttr === "true" || displayAttr === "false") next = {
+		...next,
+		displayStyle: displayAttr === "true"
+	};
+	const variantAttr = attrValue(element, "mathvariant");
+	if (variantAttr !== void 0 && isMathVariant(variantAttr)) next = {
+		...next,
+		inheritedVariant: variantAttr
+	};
+	return next;
+}
+function convertElement(node, ctx) {
+	const name = elementLocalName(node);
+	switch (name) {
+		case "mrow": return convertNodes(node.children, ctx);
+		case "mstyle": return convertNodes(node.children, mstyleContext(node, ctx));
+		case "semantics": return convertSemantics(node, ctx);
+		case "mi": {
+			const text = textContent(node);
+			return tokenRun(node, text, miIntrinsicDefault(text), ctx, false);
+		}
+		case "mn": return tokenRun(node, textContent(node), "normal", ctx, false);
+		case "mo": return tokenRun(node, textContent(node).trim(), "normal", ctx, false);
+		case "mtext": return tokenRun(node, textContent(node), "normal", ctx, true);
+		case "mspace": return convertSpace(node, ctx);
+		case "mfrac": return [convertFraction(node, ctx)];
+		case "msqrt": return [convertRadical(node, "msqrt", ctx)];
+		case "mroot": return [convertRadical(node, "mroot", ctx)];
+		case "msub":
+		case "msup":
+		case "msubsup": return [convertScripts(node, name, ctx)];
+		case "munder":
+		case "mover":
+		case "munderover": return [convertUnderOver(node, name, ctx)];
+		case "mtable": return [convertTable(node, ctx)];
+		case "mtr":
+		case "mtd": return convertNodes(node.children, ctx);
+		default:
+			diagnose(ctx, "unsupported-element", node);
+			return tokenRun(node, textContent(node), "normal", ctx, true);
+	}
+}
+function convertNodes(nodes, ctx) {
+	const out = [];
+	for (const node of nodes) {
+		if (!isMathMlElement(node)) continue;
+		out.push(...convertElement(node, ctx));
+	}
+	return out;
+}
+function rootContext(diagnostics) {
+	return {
+		inheritedVariant: void 0,
+		displayStyle: true,
+		diagnostics
+	};
+}
+function buildOfficeMath(mathml) {
+	const diagnostics = [];
+	const children = convertNodes(mathml, rootContext(diagnostics));
+	if (children.length === 0) return {
+		element: void 0,
+		diagnostics
+	};
+	return {
+		element: el("m:oMath", { "xmlns:m": OMML_NS }, children),
+		diagnostics
+	};
+}
+function buildOfficeMathParagraph(mathml) {
+	const diagnostics = [];
+	const children = convertNodes(mathml, rootContext(diagnostics));
+	if (children.length === 0) return {
+		element: void 0,
+		diagnostics
+	};
+	return {
+		element: el("m:oMathPara", { "xmlns:m": OMML_NS }, [el("m:oMath", {}, children)]),
+		diagnostics
+	};
+}
+//#endregion
+export { buildOfficeMath, buildOfficeMathParagraph };

package/dist/rowformat-Cl2exlEh.d.cts

@@ -0,0 +1,25 @@
+import { ContentCellValue } from "document-schema.js";
+//#region src/hsqldb/rowformat.d.ts
+declare class HsqldbRowFormatError extends Error {
+  constructor(message: string);
+}
+declare function resolveHsqldbTypeCode(declaredType: string): number;
+declare class HsqldbDataCursor {
+  private readonly bytes;
+  private readonly view;
+  position: number;
+  constructor(bytes: Uint8Array<ArrayBuffer>, offset?: number);
+  readUint8(): number;
+  readInt16(): number;
+  readInt32(): number;
+  readBigInt64(): bigint;
+  readFloat64(): number;
+  readBytes(length: number): Uint8Array<ArrayBuffer>;
+}
+declare function readModifiedUtf8(bytes: Uint8Array<ArrayBuffer>): string;
+interface HsqldbDecodeOptions {
+  readonly timeZone?: string;
+}
+declare function readHsqldbColumnValue(cursor: HsqldbDataCursor, typeCode: number, options?: HsqldbDecodeOptions): ContentCellValue;
+//#endregion
+export { readModifiedUtf8 as a, readHsqldbColumnValue as i, HsqldbDecodeOptions as n, resolveHsqldbTypeCode as o, HsqldbRowFormatError as r, HsqldbDataCursor as t };

package/dist/rowformat-Cl2exlEh.d.ts

@@ -0,0 +1,25 @@
+import { ContentCellValue } from "document-schema.js";
+//#region src/hsqldb/rowformat.d.ts
+declare class HsqldbRowFormatError extends Error {
+  constructor(message: string);
+}
+declare function resolveHsqldbTypeCode(declaredType: string): number;
+declare class HsqldbDataCursor {
+  private readonly bytes;
+  private readonly view;
+  position: number;
+  constructor(bytes: Uint8Array<ArrayBuffer>, offset?: number);
+  readUint8(): number;
+  readInt16(): number;
+  readInt32(): number;
+  readBigInt64(): bigint;
+  readFloat64(): number;
+  readBytes(length: number): Uint8Array<ArrayBuffer>;
+}
+declare function readModifiedUtf8(bytes: Uint8Array<ArrayBuffer>): string;
+interface HsqldbDecodeOptions {
+  readonly timeZone?: string;
+}
+declare function readHsqldbColumnValue(cursor: HsqldbDataCursor, typeCode: number, options?: HsqldbDecodeOptions): ContentCellValue;
+//#endregion
+export { readModifiedUtf8 as a, readHsqldbColumnValue as i, HsqldbDecodeOptions as n, resolveHsqldbTypeCode as o, HsqldbRowFormatError as r, HsqldbDataCursor as t };

package/dist/{schema-Acco3Ezi.d.cts → schema-BeR_KJ0X.d.cts}

@@ -1,5 +1,5 @@
 import { n as FirebirdBackupReader } from "./reader-DP0Mbaj4.cjs";
-import { E as FirebirdPhysicalType } from "./blr-types-CYYC3yYU.cjs";
+import { E as FirebirdPhysicalType } from "./blr-types-DVgO1DQ9.cjs";
 //#region src/firebird/schema.d.ts
 interface FirebirdField {
   readonly name: string;
@@ -7,6 +7,8 @@ interface FirebirdField {
   readonly lengthBytes: number;
   readonly scale: number;
   readonly characterLength: number | undefined;
+  readonly subType: number;
+  readonly fieldNumber: number | undefined;
   readonly typeLabel: string;
   readonly computed: boolean;
 }

package/dist/{schema-VkAA6pF5.d.ts → schema-CSKwSb_v.d.ts}

@@ -1,5 +1,5 @@
 import { n as FirebirdBackupReader } from "./reader-DP0Mbaj4.js";
-import { E as FirebirdPhysicalType } from "./blr-types-CYYC3yYU.js";
+import { E as FirebirdPhysicalType } from "./blr-types-DVgO1DQ9.js";
 //#region src/firebird/schema.d.ts
 interface FirebirdField {
   readonly name: string;
@@ -7,6 +7,8 @@ interface FirebirdField {
   readonly lengthBytes: number;
   readonly scale: number;
   readonly characterLength: number | undefined;
+  readonly subType: number;
+  readonly fieldNumber: number | undefined;
   readonly typeLabel: string;
   readonly computed: boolean;
 }

package/dist/{shape-BUfjw5eZ.d.cts → shape-BhkP6HB8.d.cts}

@@ -1,8 +1,9 @@
 import { n as LayoutColor } from "./color-71eoF1Up.cjs";
-import { t as Box } from "./geometry-DvwdrIij.cjs";
+import { t as Box } from "./geometry-DaJr8yQW.cjs";
 import { t as Alignment } from "./style-DkamR3aY.cjs";
 import { XmlElement, XmlNode } from "ooxml.js";
 //#region src/edit/pptx/shape.d.ts
+declare const ROTATION_UNITS_PER_DEGREE = 60000;
 declare class PptxShape {
   private readonly container;
   private readonly node;
@@ -12,6 +13,8 @@ declare class PptxShape {
   private spPrElement;
   get frame(): Box | undefined;
   set frame(value: Box);
+  get rotationDeg(): number | undefined;
+  set rotationDeg(value: number | undefined);
   get text(): string;
   set text(value: string);
   setParagraphs(paragraphs: readonly DrawingParagraphInit[]): void;
@@ -29,7 +32,8 @@ interface DrawingParagraphInit {
   readonly runs: readonly DrawingRunInit[];
   readonly alignment?: Alignment;
 }
+declare function buildDrawingParagraph(init: DrawingParagraphInit): XmlElement;
 declare function buildTextBoxShape(frame: Box, text: string, shapeId: number): XmlElement;
 declare function buildPictureShape(frame: Box, relationshipId: string, shapeId: number): XmlElement;
 //#endregion
-export { buildTextBoxShape as a, buildPictureShape as i, DrawingRunInit as n, PptxShape as r, DrawingParagraphInit as t };
+export { buildDrawingParagraph as a, ROTATION_UNITS_PER_DEGREE as i, DrawingRunInit as n, buildPictureShape as o, PptxShape as r, buildTextBoxShape as s, DrawingParagraphInit as t };

package/dist/{shape-CTkl6kt8.d.ts → shape-BkVcwPcf.d.ts}

@@ -1,8 +1,9 @@
 import { n as LayoutColor } from "./color-Bo228AY2.js";
-import { t as Box } from "./geometry-DvwdrIij.js";
+import { t as Box } from "./geometry-DaJr8yQW.js";
 import { t as Alignment } from "./style-DkamR3aY.js";
 import { XmlElement, XmlNode } from "ooxml.js";
 //#region src/edit/pptx/shape.d.ts
+declare const ROTATION_UNITS_PER_DEGREE = 60000;
 declare class PptxShape {
   private readonly container;
   private readonly node;
@@ -12,6 +13,8 @@ declare class PptxShape {
   private spPrElement;
   get frame(): Box | undefined;
   set frame(value: Box);
+  get rotationDeg(): number | undefined;
+  set rotationDeg(value: number | undefined);
   get text(): string;
   set text(value: string);
   setParagraphs(paragraphs: readonly DrawingParagraphInit[]): void;
@@ -29,7 +32,8 @@ interface DrawingParagraphInit {
   readonly runs: readonly DrawingRunInit[];
   readonly alignment?: Alignment;
 }
+declare function buildDrawingParagraph(init: DrawingParagraphInit): XmlElement;
 declare function buildTextBoxShape(frame: Box, text: string, shapeId: number): XmlElement;
 declare function buildPictureShape(frame: Box, relationshipId: string, shapeId: number): XmlElement;
 //#endregion
-export { buildTextBoxShape as a, buildPictureShape as i, DrawingRunInit as n, PptxShape as r, DrawingParagraphInit as t };
+export { buildDrawingParagraph as a, ROTATION_UNITS_PER_DEGREE as i, DrawingRunInit as n, buildPictureShape as o, PptxShape as r, buildTextBoxShape as s, DrawingParagraphInit as t };