odf.js 1.1.0 → 1.3.0

package/dist/index.cjs

@@ -2,6 +2,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 let zod = require("zod");
 let fast_xml_parser = require("fast-xml-parser");
 let fflate = require("fflate");
+let document_content_model = require("document-content-model");
 //#region src/model/node.ts
 const AttributeSchema = zod.z.object({
 	name: zod.z.string(),
@@ -448,6 +449,17 @@ function txt(value) {
 function encodeXmlText(value) {
 	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
 }
+const XML_ENTITY_PATTERN = /&(?:amp|lt|gt|quot|apos);/g;
+const XML_ENTITY_DECODE = {
+	"&amp;": "&",
+	"&lt;": "<",
+	"&gt;": ">",
+	"&quot;": "\"",
+	"&apos;": "'"
+};
+function decodeXmlText(value) {
+	return value.replace(XML_ENTITY_PATTERN, (entity) => XML_ENTITY_DECODE[entity]);
+}
 //#endregion
 //#region src/manifest.ts
 const ManifestEntrySchema = zod.z.object({
@@ -471,26 +483,26 @@ const STANDARD_XML_PART_NAMES = /* @__PURE__ */ new Set([
 	"meta.xml",
 	"settings.xml"
 ]);
-function findChildElement(nodes, tag) {
+function findChildElement$1(nodes, tag) {
 	for (const node of nodes) if (node.type === "element" && node.tag === tag) return node;
 }
-function attrValue(element, name) {
+function attrValue$2(element, name) {
 	return element.attributes.find((attribute) => attribute.name === name)?.value;
 }
 function readManifest(pkg) {
 	const part = pkg.parts[MANIFEST_PART];
 	if (part?.kind !== "xml") throw new Error(`package has no ${MANIFEST_PART} XML part to read`);
-	const root = findChildElement(part.nodes, "manifest:manifest");
+	const root = findChildElement$1(part.nodes, "manifest:manifest");
 	if (root === void 0) throw new Error(`${MANIFEST_PART} has no manifest:manifest root element`);
-	const version = attrValue(root, "manifest:version");
+	const version = attrValue$2(root, "manifest:version");
 	if (version === void 0) throw new Error(`${MANIFEST_PART}'s manifest:manifest root is missing the required manifest:version attribute`);
 	const entries = [];
 	for (const child of root.children) {
 		if (child.type !== "element" || child.tag !== "manifest:file-entry") continue;
-		const fullPath = attrValue(child, "manifest:full-path");
-		const mediaType = attrValue(child, "manifest:media-type");
+		const fullPath = attrValue$2(child, "manifest:full-path");
+		const mediaType = attrValue$2(child, "manifest:media-type");
 		if (fullPath === void 0 || mediaType === void 0) throw new Error(`${MANIFEST_PART} has a manifest:file-entry missing manifest:full-path or manifest:media-type`);
-		const entryVersion = attrValue(child, "manifest:version");
+		const entryVersion = attrValue$2(child, "manifest:version");
 		entries.push(entryVersion === void 0 ? {
 			fullPath,
 			mediaType
@@ -600,7 +612,7 @@ function validateManifest(pkg) {
 		});
 		return problems;
 	}
-	const root = findChildElement(manifestPart.nodes, "manifest:manifest");
+	const root = findChildElement$1(manifestPart.nodes, "manifest:manifest");
 	if (root === void 0) {
 		problems.push({
 			severity: "error",
@@ -649,7 +661,7 @@ function validateManifest(pkg) {
 	for (const child of root.children) {
 		if (child.type !== "element" || child.tag !== "manifest:file-entry") continue;
 		if (!child.children.some((grandchild) => grandchild.type === "element" && grandchild.tag === "manifest:encryption-data")) continue;
-		const fullPath = attrValue(child, "manifest:full-path");
+		const fullPath = attrValue$2(child, "manifest:full-path");
 		if (fullPath === void 0) continue;
 		problems.push({
 			severity: "warning",
@@ -681,9 +693,926 @@ function setDocumentMediaType(pkg, mediaType, version = DEFAULT_MANIFEST_VERSION
 	});
 }
 //#endregion
+//#region src/typed/shared/units.ts
+const LENGTH_PATTERN = /^(-?(?:\d+(?:\.\d+)?|\.\d+))(cm|mm|in|pt|pc|px)$/;
+const POINTS_PER_INCH = 72;
+const POINTS_PER_PICA = 12;
+const CM_PER_INCH = 2.54;
+const MM_PER_INCH = 25.4;
+const CSS_REFERENCE_PIXELS_PER_INCH = 96;
+function unitToPtFactor(unit) {
+	switch (unit) {
+		case "pt": return 1;
+		case "in": return POINTS_PER_INCH;
+		case "cm": return POINTS_PER_INCH / CM_PER_INCH;
+		case "mm": return POINTS_PER_INCH / MM_PER_INCH;
+		case "pc": return POINTS_PER_PICA;
+		case "px": return POINTS_PER_INCH / CSS_REFERENCE_PIXELS_PER_INCH;
+	}
+}
+function isLengthUnit(value) {
+	return value === "cm" || value === "mm" || value === "in" || value === "pt" || value === "pc" || value === "px";
+}
+function parseOdfLength(value) {
+	const match = LENGTH_PATTERN.exec(value);
+	if (match === null) return;
+	const numeric = match[1];
+	const unit = match[2];
+	if (numeric === void 0 || unit === void 0 || !isLengthUnit(unit)) return;
+	return Number(numeric) * unitToPtFactor(unit);
+}
+function formatOdfLength(pt, unit = "pt") {
+	return `${pt / unitToPtFactor(unit)}${unit}`;
+}
+//#endregion
+//#region src/typed/shared/color.ts
+const ODF_COLOR_PATTERN = /^#[0-9a-fA-F]{6}$/;
+function parseOdfColor(value) {
+	if (!ODF_COLOR_PATTERN.test(value)) return;
+	return (0, document_content_model.rgbHexToColor)(value);
+}
+function formatOdfColor(color) {
+	return `#${(0, document_content_model.colorToRgbHex)(color)}`;
+}
+//#endregion
+//#region src/styles/properties.ts
+const StylePropertiesSchema = zod.z.object({
+	bold: zod.z.boolean().optional(),
+	italic: zod.z.boolean().optional(),
+	underline: zod.z.boolean().optional(),
+	strike: zod.z.boolean().optional(),
+	fontFamily: zod.z.string().optional(),
+	sizePt: zod.z.number().optional(),
+	color: document_content_model.ColorSchema.optional(),
+	alignment: document_content_model.AlignmentSchema.optional(),
+	spacingBeforePt: zod.z.number().optional(),
+	spacingAfterPt: zod.z.number().optional(),
+	lineSpacing: zod.z.number().optional(),
+	indentLeftPt: zod.z.number().optional(),
+	indentFirstLinePt: zod.z.number().optional()
+});
+const ATTR = {
+	fontWeight: "fo:font-weight",
+	fontStyle: "fo:font-style",
+	underlineStyle: "style:text-underline-style",
+	underlineWidth: "style:text-underline-width",
+	underlineColor: "style:text-underline-color",
+	lineThroughStyle: "style:text-line-through-style",
+	lineThroughType: "style:text-line-through-type",
+	fontFamily: "fo:font-family",
+	fontSize: "fo:font-size",
+	color: "fo:color",
+	textAlign: "fo:text-align",
+	marginTop: "fo:margin-top",
+	marginBottom: "fo:margin-bottom",
+	lineHeight: "fo:line-height",
+	marginLeft: "fo:margin-left",
+	textIndent: "fo:text-indent"
+};
+const TEXT_ATTR_NAMES = /* @__PURE__ */ new Set([
+	ATTR.fontWeight,
+	ATTR.fontStyle,
+	ATTR.underlineStyle,
+	ATTR.underlineWidth,
+	ATTR.underlineColor,
+	ATTR.lineThroughStyle,
+	ATTR.lineThroughType,
+	ATTR.fontFamily,
+	ATTR.fontSize,
+	ATTR.color
+]);
+const PARAGRAPH_ATTR_NAMES = /* @__PURE__ */ new Set([
+	ATTR.textAlign,
+	ATTR.marginTop,
+	ATTR.marginBottom,
+	ATTR.lineHeight,
+	ATTR.marginLeft,
+	ATTR.textIndent
+]);
+function attributeMap(element) {
+	const map = /* @__PURE__ */ new Map();
+	for (const attribute of element.attributes) map.set(attribute.name, attribute.value);
+	return map;
+}
+const parseLength = parseOdfLength;
+function formatPt(valuePt) {
+	return formatOdfLength(valuePt, "pt");
+}
+const PERCENTAGE_PATTERN = /^(-?(?:\d+(?:\.\d+)?|\.\d+))%$/;
+function parsePercentageMultiplier(value) {
+	const match = PERCENTAGE_PATTERN.exec(value);
+	if (match === null) return;
+	const numeric = match[1];
+	if (numeric === void 0) return;
+	return Number(numeric) / 100;
+}
+function formatPercentageMultiplier(multiplier) {
+	return `${multiplier * 100}%`;
+}
+const parseColor = parseOdfColor;
+const formatColor = formatOdfColor;
+function parseLineDecoration(style, companionA, companionAOnValue, companionB, companionBOnValue) {
+	if (style === void 0 && companionA === void 0 && companionB === void 0) return;
+	if (style === "solid" && (companionA === void 0 || companionA === companionAOnValue) && (companionB === void 0 || companionB === companionBOnValue)) return true;
+	if (style === "none" && companionA === void 0 && companionB === void 0) return false;
+	return "unknown";
+}
+const RISKY_STYLE_ELEMENT_ATTRS = /* @__PURE__ */ new Set(["style:master-page-name", "style:next-style-name"]);
+function parseTextProperties(element) {
+	const attrs = attributeMap(element);
+	const properties = {};
+	let hasUnknown = false;
+	for (const name of attrs.keys()) if (!TEXT_ATTR_NAMES.has(name)) hasUnknown = true;
+	const fontWeight = attrs.get(ATTR.fontWeight);
+	if (fontWeight === "bold") properties.bold = true;
+	else if (fontWeight === "normal") properties.bold = false;
+	else if (fontWeight !== void 0) hasUnknown = true;
+	const fontStyle = attrs.get(ATTR.fontStyle);
+	if (fontStyle === "italic") properties.italic = true;
+	else if (fontStyle === "normal") properties.italic = false;
+	else if (fontStyle !== void 0) hasUnknown = true;
+	const underline = parseLineDecoration(attrs.get(ATTR.underlineStyle), attrs.get(ATTR.underlineWidth), "auto", attrs.get(ATTR.underlineColor), "font-color");
+	if (underline === "unknown") hasUnknown = true;
+	else if (underline !== void 0) properties.underline = underline;
+	const strike = parseLineDecoration(attrs.get(ATTR.lineThroughStyle), attrs.get(ATTR.lineThroughType), "single", void 0, "");
+	if (strike === "unknown") hasUnknown = true;
+	else if (strike !== void 0) properties.strike = strike;
+	const fontFamily = attrs.get(ATTR.fontFamily);
+	if (fontFamily !== void 0) properties.fontFamily = fontFamily;
+	const fontSize = attrs.get(ATTR.fontSize);
+	if (fontSize !== void 0) {
+		const pt = parseLength(fontSize);
+		if (pt === void 0) hasUnknown = true;
+		else properties.sizePt = pt;
+	}
+	const color = attrs.get(ATTR.color);
+	if (color !== void 0) {
+		const parsed = parseColor(color);
+		if (parsed === void 0) hasUnknown = true;
+		else properties.color = parsed;
+	}
+	return {
+		properties,
+		hasUnknown
+	};
+}
+function parseParagraphProperties(element) {
+	const attrs = attributeMap(element);
+	const properties = {};
+	let hasUnknown = false;
+	for (const name of attrs.keys()) if (!PARAGRAPH_ATTR_NAMES.has(name)) hasUnknown = true;
+	const textAlign = attrs.get(ATTR.textAlign);
+	if (textAlign === "left" || textAlign === "center" || textAlign === "right" || textAlign === "justify") properties.alignment = textAlign;
+	else if (textAlign !== void 0) hasUnknown = true;
+	const marginTop = attrs.get(ATTR.marginTop);
+	if (marginTop !== void 0) {
+		const pt = parseLength(marginTop);
+		if (pt === void 0) hasUnknown = true;
+		else properties.spacingBeforePt = pt;
+	}
+	const marginBottom = attrs.get(ATTR.marginBottom);
+	if (marginBottom !== void 0) {
+		const pt = parseLength(marginBottom);
+		if (pt === void 0) hasUnknown = true;
+		else properties.spacingAfterPt = pt;
+	}
+	const marginLeft = attrs.get(ATTR.marginLeft);
+	if (marginLeft !== void 0) {
+		const pt = parseLength(marginLeft);
+		if (pt === void 0) hasUnknown = true;
+		else properties.indentLeftPt = pt;
+	}
+	const textIndent = attrs.get(ATTR.textIndent);
+	if (textIndent !== void 0) {
+		const pt = parseLength(textIndent);
+		if (pt === void 0) hasUnknown = true;
+		else properties.indentFirstLinePt = pt;
+	}
+	const lineHeight = attrs.get(ATTR.lineHeight);
+	if (lineHeight !== void 0) {
+		const multiplier = parsePercentageMultiplier(lineHeight);
+		if (multiplier === void 0) hasUnknown = true;
+		else properties.lineSpacing = multiplier;
+	}
+	return {
+		properties,
+		hasUnknown
+	};
+}
+function parseStyleElementProperties(styleElement) {
+	let properties = {};
+	let hasUnknown = false;
+	for (const attribute of styleElement.attributes) if (RISKY_STYLE_ELEMENT_ATTRS.has(attribute.name)) hasUnknown = true;
+	for (const child of styleElement.children) {
+		if (child.type !== "element") continue;
+		if (child.tag === "style:text-properties") {
+			const result = parseTextProperties(child);
+			properties = {
+				...properties,
+				...result.properties
+			};
+			if (result.hasUnknown) hasUnknown = true;
+		} else if (child.tag === "style:paragraph-properties") {
+			const result = parseParagraphProperties(child);
+			properties = {
+				...properties,
+				...result.properties
+			};
+			if (result.hasUnknown) hasUnknown = true;
+		} else hasUnknown = true;
+	}
+	return {
+		properties,
+		hasUnknown
+	};
+}
+function textPropertiesToAttributes(properties) {
+	const attributes = [];
+	if (properties.bold !== void 0) attributes.push({
+		name: ATTR.fontWeight,
+		value: properties.bold ? "bold" : "normal"
+	});
+	if (properties.italic !== void 0) attributes.push({
+		name: ATTR.fontStyle,
+		value: properties.italic ? "italic" : "normal"
+	});
+	if (properties.underline !== void 0) if (properties.underline) {
+		attributes.push({
+			name: ATTR.underlineStyle,
+			value: "solid"
+		});
+		attributes.push({
+			name: ATTR.underlineWidth,
+			value: "auto"
+		});
+		attributes.push({
+			name: ATTR.underlineColor,
+			value: "font-color"
+		});
+	} else attributes.push({
+		name: ATTR.underlineStyle,
+		value: "none"
+	});
+	if (properties.strike !== void 0) if (properties.strike) {
+		attributes.push({
+			name: ATTR.lineThroughStyle,
+			value: "solid"
+		});
+		attributes.push({
+			name: ATTR.lineThroughType,
+			value: "single"
+		});
+	} else attributes.push({
+		name: ATTR.lineThroughStyle,
+		value: "none"
+	});
+	if (properties.fontFamily !== void 0) attributes.push({
+		name: ATTR.fontFamily,
+		value: encodeXmlText(properties.fontFamily)
+	});
+	if (properties.sizePt !== void 0) attributes.push({
+		name: ATTR.fontSize,
+		value: formatPt(properties.sizePt)
+	});
+	if (properties.color !== void 0) attributes.push({
+		name: ATTR.color,
+		value: formatColor(properties.color)
+	});
+	return attributes;
+}
+function paragraphPropertiesToAttributes(properties) {
+	const attributes = [];
+	if (properties.alignment !== void 0) attributes.push({
+		name: ATTR.textAlign,
+		value: properties.alignment
+	});
+	if (properties.spacingBeforePt !== void 0) attributes.push({
+		name: ATTR.marginTop,
+		value: formatPt(properties.spacingBeforePt)
+	});
+	if (properties.spacingAfterPt !== void 0) attributes.push({
+		name: ATTR.marginBottom,
+		value: formatPt(properties.spacingAfterPt)
+	});
+	if (properties.lineSpacing !== void 0) attributes.push({
+		name: ATTR.lineHeight,
+		value: formatPercentageMultiplier(properties.lineSpacing)
+	});
+	if (properties.indentLeftPt !== void 0) attributes.push({
+		name: ATTR.marginLeft,
+		value: formatPt(properties.indentLeftPt)
+	});
+	if (properties.indentFirstLinePt !== void 0) attributes.push({
+		name: ATTR.textIndent,
+		value: formatPt(properties.indentFirstLinePt)
+	});
+	return attributes;
+}
+//#endregion
+//#region src/styles/serialize.ts
+function attributesToRecord(attributes) {
+	const record = {};
+	for (const attribute of attributes) record[attribute.name] = attribute.value;
+	return record;
+}
+function buildStylePropertyElements(properties) {
+	const elements = [];
+	const paragraphAttributes = paragraphPropertiesToAttributes(properties);
+	if (paragraphAttributes.length > 0) elements.push(el("style:paragraph-properties", attributesToRecord(paragraphAttributes)));
+	const textAttributes = textPropertiesToAttributes(properties);
+	if (textAttributes.length > 0) elements.push(el("style:text-properties", attributesToRecord(textAttributes)));
+	return elements;
+}
+function canonicalPropertiesString(properties) {
+	return [...paragraphPropertiesToAttributes(properties), ...textPropertiesToAttributes(properties)].map((attribute) => `${attribute.name}=${attribute.value}`).join("|");
+}
+//#endregion
+//#region src/styles/registry.ts
+const STYLE_FAMILIES = [
+	"paragraph",
+	"text",
+	"table",
+	"table-column",
+	"table-row",
+	"table-cell",
+	"graphic"
+];
+function isStyleFamily(value) {
+	return value === "paragraph" || value === "text" || value === "table" || value === "table-column" || value === "table-row" || value === "table-cell" || value === "graphic";
+}
+const CONTENT_PREFIXES = {
+	paragraph: "P",
+	text: "T",
+	table: "ta",
+	"table-column": "co",
+	"table-row": "ro",
+	"table-cell": "ce",
+	graphic: "fr"
+};
+const STYLES_PREFIXES = {
+	paragraph: "PS",
+	text: "TS",
+	table: "taS",
+	"table-column": "coS",
+	"table-row": "roS",
+	"table-cell": "ceS",
+	graphic: "frS"
+};
+function prefixesForPart(partPath) {
+	const baseName = partPath.slice(partPath.lastIndexOf("/") + 1);
+	if (baseName === "content.xml") return CONTENT_PREFIXES;
+	if (baseName === "styles.xml") return STYLES_PREFIXES;
+	throw new Error(`StyleRegistry.forPart: expected a part named "content.xml" or "styles.xml" (by base name), got "${partPath}"`);
+}
+function emptyFamilySets() {
+	return {
+		paragraph: /* @__PURE__ */ new Set(),
+		text: /* @__PURE__ */ new Set(),
+		table: /* @__PURE__ */ new Set(),
+		"table-column": /* @__PURE__ */ new Set(),
+		"table-row": /* @__PURE__ */ new Set(),
+		"table-cell": /* @__PURE__ */ new Set(),
+		graphic: /* @__PURE__ */ new Set()
+	};
+}
+function attrValue$1(element, name) {
+	return element.attributes.find((attribute) => attribute.name === name)?.value;
+}
+function findDirectChild(nodes, tag) {
+	for (const node of nodes) if (node.type === "element" && node.tag === tag) return node;
+}
+function findRootElement(nodes) {
+	const root = nodes.find((node) => node.type === "element");
+	if (root === void 0) throw new Error("StyleRegistry: part has no root XML element -- construct the part's minimal root (office:document-content/office:document-styles) before building a StyleRegistry for it");
+	return root;
+}
+function ensureAutomaticStyles(root) {
+	const existing = findDirectChild(root.children, "office:automatic-styles");
+	if (existing !== void 0) return existing;
+	const created = el("office:automatic-styles");
+	const insertBeforeTags = /* @__PURE__ */ new Set([
+		"office:body",
+		"office:master-styles",
+		"office:settings"
+	]);
+	const insertIndex = root.children.findIndex((node) => node.type === "element" && insertBeforeTags.has(node.tag));
+	if (insertIndex === -1) root.children.push(created);
+	else root.children.splice(insertIndex, 0, created);
+	return created;
+}
+function reserveStyleNames(container, reserved) {
+	for (const child of container.children) {
+		if (child.type !== "element" || child.tag !== "style:style") continue;
+		const name = attrValue$1(child, "style:name");
+		const family = attrValue$1(child, "style:family");
+		if (name === void 0 || family === void 0 || !isStyleFamily(family)) continue;
+		reserved[family].add(name);
+	}
+}
+const FINGERPRINT_SEPARATOR = "\0";
+const NO_PARENT_SENTINEL = "
";
+function computeFingerprint(family, properties, parentStyleName) {
+	const parentComponent = parentStyleName ?? NO_PARENT_SENTINEL;
+	return [
+		family,
+		canonicalPropertiesString(properties),
+		parentComponent
+	].join(FINGERPRINT_SEPARATOR);
+}
+var StyleRegistry = class StyleRegistry {
+	automaticStyles;
+	prefixes;
+	reservedByFamily;
+	knownStyles = /* @__PURE__ */ new Map();
+	fingerprintToName = /* @__PURE__ */ new Map();
+	nameToFingerprint = /* @__PURE__ */ new Map();
+	familyCounters = {
+		paragraph: 1,
+		text: 1,
+		table: 1,
+		"table-column": 1,
+		"table-row": 1,
+		"table-cell": 1,
+		graphic: 1
+	};
+	constructor(automaticStyles, prefixes, reservedByFamily) {
+		this.automaticStyles = automaticStyles;
+		this.prefixes = prefixes;
+		this.reservedByFamily = reservedByFamily;
+	}
+	static forPart(pkg, partPath, options = {}) {
+		const part = pkg.parts[partPath];
+		if (part?.kind !== "xml") throw new Error(`StyleRegistry.forPart: "${partPath}" is not an XML part of the given package`);
+		const prefixes = prefixesForPart(partPath);
+		const root = findRootElement(part.nodes);
+		const automaticStyles = ensureAutomaticStyles(root);
+		const reservedByFamily = emptyFamilySets();
+		const registry = new StyleRegistry(automaticStyles, prefixes, reservedByFamily);
+		for (const child of automaticStyles.children) {
+			if (child.type !== "element" || child.tag !== "style:style") continue;
+			const name = attrValue$1(child, "style:name");
+			const family = attrValue$1(child, "style:family");
+			if (name === void 0 || family === void 0 || !isStyleFamily(family)) continue;
+			registry.knownStyles.set(name, child);
+			reservedByFamily[family].add(name);
+			const parsed = parseStyleElementProperties(child);
+			if (!parsed.hasUnknown) {
+				const parentStyleName = attrValue$1(child, "style:parent-style-name");
+				const fingerprint = computeFingerprint(family, parsed.properties, parentStyleName);
+				if (!registry.fingerprintToName.has(fingerprint)) {
+					registry.fingerprintToName.set(fingerprint, name);
+					registry.nameToFingerprint.set(name, fingerprint);
+				}
+			}
+		}
+		const ownStyles = findDirectChild(root.children, "office:styles");
+		if (ownStyles !== void 0) reserveStyleNames(ownStyles, reservedByFamily);
+		if (options.otherPart !== void 0) {
+			const otherPart = options.otherPart.pkg.parts[options.otherPart.partPath];
+			if (otherPart?.kind === "xml") {
+				const otherRoot = findRootElement(otherPart.nodes);
+				const otherAutomatic = findDirectChild(otherRoot.children, "office:automatic-styles");
+				if (otherAutomatic !== void 0) reserveStyleNames(otherAutomatic, reservedByFamily);
+				const otherStyles = findDirectChild(otherRoot.children, "office:styles");
+				if (otherStyles !== void 0) reserveStyleNames(otherStyles, reservedByFamily);
+			}
+		}
+		if (options.additionalReservedNames !== void 0) for (const family of STYLE_FAMILIES) for (const name of options.additionalReservedNames) reservedByFamily[family].add(name);
+		return registry;
+	}
+	fingerprint(request) {
+		return computeFingerprint(request.family, request.properties, request.parentStyleName);
+	}
+	intern(request) {
+		const fingerprint = this.fingerprint(request);
+		const existingName = this.fingerprintToName.get(fingerprint);
+		if (existingName !== void 0) return existingName;
+		const name = this.mintName(request.family);
+		const attributes = {
+			"style:name": name,
+			"style:family": request.family
+		};
+		if (request.parentStyleName !== void 0) attributes["style:parent-style-name"] = encodeXmlText(request.parentStyleName);
+		const styleElement = el("style:style", attributes, buildStylePropertyElements(request.properties));
+		this.automaticStyles.children.push(styleElement);
+		this.knownStyles.set(name, styleElement);
+		this.reservedByFamily[request.family].add(name);
+		this.fingerprintToName.set(fingerprint, name);
+		this.nameToFingerprint.set(name, fingerprint);
+		return name;
+	}
+	mintName(family) {
+		const prefix = this.prefixes[family];
+		const reserved = this.reservedByFamily[family];
+		let counter = this.familyCounters[family];
+		while (reserved.has(`${prefix}${counter}`)) counter += 1;
+		const name = `${prefix}${counter}`;
+		this.familyCounters[family] = counter + 1;
+		return name;
+	}
+	names() {
+		return [...this.knownStyles.keys()];
+	}
+	gc(referenced) {
+		let removed = 0;
+		for (const [name, element] of [...this.knownStyles]) {
+			if (referenced.has(name)) continue;
+			const index = this.automaticStyles.children.indexOf(element);
+			if (index !== -1) this.automaticStyles.children.splice(index, 1);
+			this.knownStyles.delete(name);
+			const fingerprint = this.nameToFingerprint.get(name);
+			if (fingerprint !== void 0) {
+				this.fingerprintToName.delete(fingerprint);
+				this.nameToFingerprint.delete(name);
+			}
+			removed += 1;
+		}
+		return removed;
+	}
+};
+//#endregion
+//#region src/xml/query.ts
+function rootElement(nodes) {
+	for (const node of nodes) if (node.type === "element") return node;
+}
+function findChildElement(nodes, tag) {
+	for (const node of nodes) if (node.type === "element" && node.tag === tag) return node;
+}
+function childrenWithTag(element, tag) {
+	const out = [];
+	for (const child of element.children) if (child.type === "element" && child.tag === tag) out.push(child);
+	return out;
+}
+function attrValue(element, name) {
+	return element.attributes.find((attribute) => attribute.name === name)?.value;
+}
+//#endregion
+//#region src/typed/shared/text.ts
+function getOdfSpaceCount(element) {
+	const raw = attrValue(element, "text:c");
+	if (raw === void 0) return 1;
+	const parsed = Number.parseInt(raw, 10);
+	if (!Number.isInteger(parsed) || parsed < 0 || String(parsed) !== raw) throw new Error(`getOdfSpaceCount: text:s has a malformed text:c attribute: "${raw}"`);
+	return parsed;
+}
+function measureOdfNodeLength(node) {
+	if (node.type === "text") return node.value.length;
+	if (node.type !== "element") return 0;
+	if (node.tag === "text:s") return getOdfSpaceCount(node);
+	if (node.tag === "text:tab" || node.tag === "text:line-break") return 1;
+	if (node.tag === "text:span") return sumOdfNodeLength(node.children);
+	return 0;
+}
+function sumOdfNodeLength(nodes) {
+	let total = 0;
+	for (const node of nodes) total += measureOdfNodeLength(node);
+	return total;
+}
+function decodeOdfNode(node) {
+	if (node.type === "text") return decodeXmlText(node.value);
+	if (node.type !== "element") return "";
+	if (node.tag === "text:s") return " ".repeat(getOdfSpaceCount(node));
+	if (node.tag === "text:tab") return "	";
+	if (node.tag === "text:line-break") return "\n";
+	if (node.tag === "text:span") return decodeOdfText(node);
+	return "";
+}
+function decodeOdfText(container) {
+	let text = "";
+	for (const child of container.children) text += decodeOdfNode(child);
+	return text;
+}
+//#endregion
+//#region src/styles/span.ts
+function ensureSpan(paragraph, start, end, styleName) {
+	if (!Number.isInteger(start) || !Number.isInteger(end) || start < 0 || end < start) throw new Error(`ensureSpan: invalid range [${start}, ${end})`);
+	const total = sumOdfNodeLength(paragraph.children);
+	if (end > total) throw new Error(`ensureSpan: range end ${end} exceeds the container's total character length ${total}`);
+	const { before, after: rest } = splitChildrenAt(paragraph.children, start);
+	const { before: middle, after } = splitChildrenAt(rest, end - start);
+	let span;
+	const soleChild = middle.length === 1 ? middle[0] : void 0;
+	if (soleChild?.type === "element" && soleChild.tag === "text:span") {
+		span = soleChild;
+		setStyleName(span, styleName);
+	} else span = el("text:span", { "text:style-name": encodeXmlText(styleName) }, middle);
+	paragraph.children = [
+		...before,
+		span,
+		...after
+	];
+	return span;
+}
+function cloneAttributes(attributes) {
+	return attributes.map((attribute) => ({ ...attribute }));
+}
+function setStyleName(span, styleName) {
+	const encoded = encodeXmlText(styleName);
+	const existing = span.attributes.find((attribute) => attribute.name === "text:style-name");
+	if (existing !== void 0) {
+		existing.value = encoded;
+		return;
+	}
+	span.attributes.push({
+		name: "text:style-name",
+		value: encoded
+	});
+}
+function buildSpaceRun(count) {
+	return count === 1 ? el("text:s") : el("text:s", { "text:c": String(count) });
+}
+function splitNode(node, offset) {
+	if (node.type === "text") return {
+		left: {
+			type: "text",
+			value: node.value.slice(0, offset)
+		},
+		right: {
+			type: "text",
+			value: node.value.slice(offset)
+		}
+	};
+	if (node.type === "element" && node.tag === "text:s") {
+		const count = getOdfSpaceCount(node);
+		return {
+			left: buildSpaceRun(offset),
+			right: buildSpaceRun(count - offset)
+		};
+	}
+	if (node.type === "element" && node.tag === "text:span") {
+		const inner = splitChildrenAt(node.children, offset);
+		return {
+			left: inner.before.length === 0 ? void 0 : {
+				...node,
+				attributes: cloneAttributes(node.attributes),
+				children: inner.before
+			},
+			right: inner.after.length === 0 ? void 0 : {
+				...node,
+				attributes: cloneAttributes(node.attributes),
+				children: inner.after
+			}
+		};
+	}
+	const label = node.type === "element" ? node.tag : node.type;
+	throw new Error(`ensureSpan: cannot split "${label}" at a fractional offset -- this indicates a character-length computation bug, since every node type with length 1 or 0 should never reach this branch`);
+}
+function splitChildrenAt(children, offset) {
+	if (offset <= 0) return {
+		before: [],
+		after: [...children]
+	};
+	const before = [];
+	let remaining = offset;
+	for (let index = 0; index < children.length; index += 1) {
+		if (remaining === 0) return {
+			before,
+			after: children.slice(index)
+		};
+		const node = children[index];
+		const length = measureOdfNodeLength(node);
+		if (remaining >= length) {
+			before.push(node);
+			remaining -= length;
+			continue;
+		}
+		const { left, right } = splitNode(node, remaining);
+		const after = [];
+		if (left !== void 0) before.push(left);
+		if (right !== void 0) after.push(right);
+		after.push(...children.slice(index + 1));
+		return {
+			before,
+			after
+		};
+	}
+	return {
+		before,
+		after: []
+	};
+}
+//#endregion
+//#region src/typed/shared/a1.ts
+const ALPHABET_SIZE = 26;
+const ALPHABET_START_CODE = "A".charCodeAt(0);
+function columnIndexToLetters(index) {
+	if (!Number.isInteger(index) || index < 0) throw new Error(`columnIndexToLetters: index must be a non-negative integer, got ${index}`);
+	let remaining = index + 1;
+	let letters = "";
+	while (remaining > 0) {
+		const digit = (remaining - 1) % ALPHABET_SIZE;
+		letters = String.fromCharCode(ALPHABET_START_CODE + digit) + letters;
+		remaining = Math.floor((remaining - 1) / ALPHABET_SIZE);
+	}
+	return letters;
+}
+function cellReference(columnIndex, rowIndex) {
+	if (!Number.isInteger(rowIndex) || rowIndex < 0) throw new Error(`cellReference: rowIndex must be a non-negative integer, got ${rowIndex}`);
+	return `${columnIndexToLetters(columnIndex)}${rowIndex + 1}`;
+}
+function validateRepeatCount(repeatCount, caller) {
+	if (!Number.isInteger(repeatCount) || repeatCount < 1) throw new Error(`${caller}: repeatCount must be a positive integer, got ${repeatCount}`);
+}
+var TableCursor = class {
+	columnCursor = 0;
+	rowCursor = 0;
+	get columnIndex() {
+		return this.columnCursor;
+	}
+	get rowIndex() {
+		return this.rowCursor;
+	}
+	nextCell(repeatCount = 1) {
+		validateRepeatCount(repeatCount, "TableCursor.nextCell");
+		const reference = cellReference(this.columnCursor, this.rowCursor);
+		this.columnCursor += repeatCount;
+		return reference;
+	}
+	nextRow(repeatCount = 1) {
+		validateRepeatCount(repeatCount, "TableCursor.nextRow");
+		this.rowCursor += repeatCount;
+		this.columnCursor = 0;
+	}
+};
+//#endregion
+//#region src/typed/shared/geometry.ts
+function parsePageSize(pageLayoutProperties) {
+	const widthValue = attrValue(pageLayoutProperties, "fo:page-width");
+	const heightValue = attrValue(pageLayoutProperties, "fo:page-height");
+	if (widthValue === void 0 || heightValue === void 0) return;
+	const widthPt = parseOdfLength(widthValue);
+	const heightPt = parseOdfLength(heightValue);
+	if (widthPt === void 0 || heightPt === void 0) return;
+	return {
+		widthPt,
+		heightPt
+	};
+}
+function parseMargins(pageLayoutProperties) {
+	const topValue = attrValue(pageLayoutProperties, "fo:margin-top");
+	const rightValue = attrValue(pageLayoutProperties, "fo:margin-right");
+	const bottomValue = attrValue(pageLayoutProperties, "fo:margin-bottom");
+	const leftValue = attrValue(pageLayoutProperties, "fo:margin-left");
+	if (topValue === void 0 || rightValue === void 0 || bottomValue === void 0 || leftValue === void 0) return;
+	const topPt = parseOdfLength(topValue);
+	const rightPt = parseOdfLength(rightValue);
+	const bottomPt = parseOdfLength(bottomValue);
+	const leftPt = parseOdfLength(leftValue);
+	if (topPt === void 0 || rightPt === void 0 || bottomPt === void 0 || leftPt === void 0) return;
+	return {
+		topPt,
+		rightPt,
+		bottomPt,
+		leftPt
+	};
+}
+function parseBox(element) {
+	const xValue = attrValue(element, "svg:x");
+	const yValue = attrValue(element, "svg:y");
+	const widthValue = attrValue(element, "svg:width");
+	const heightValue = attrValue(element, "svg:height");
+	if (xValue === void 0 || yValue === void 0 || widthValue === void 0 || heightValue === void 0) return;
+	const xPt = parseOdfLength(xValue);
+	const yPt = parseOdfLength(yValue);
+	const widthPt = parseOdfLength(widthValue);
+	const heightPt = parseOdfLength(heightValue);
+	if (xPt === void 0 || yPt === void 0 || widthPt === void 0 || heightPt === void 0) return;
+	return {
+		xPt,
+		yPt,
+		widthPt,
+		heightPt
+	};
+}
+//#endregion
+//#region src/typed/shared/cascade.ts
+const STYLE_PARTS = ["content.xml", "styles.xml"];
+const NAME_KEY_SEPARATOR = "\0";
+function nameKey(family, name) {
+	return `${family}${NAME_KEY_SEPARATOR}${name}`;
+}
+function collectStyles(pkg) {
+	const byName = /* @__PURE__ */ new Map();
+	const defaultByFamily = /* @__PURE__ */ new Map();
+	for (const partPath of STYLE_PARTS) {
+		const part = pkg.parts[partPath];
+		if (part?.kind !== "xml") continue;
+		const root = rootElement(part.nodes);
+		if (root === void 0) continue;
+		for (const containerTag of ["office:automatic-styles", "office:styles"]) {
+			const container = findChildElement(root.children, containerTag);
+			if (container === void 0) continue;
+			for (const child of container.children) {
+				if (child.type !== "element") continue;
+				if (child.tag === "style:style") {
+					const name = attrValue(child, "style:name");
+					const family = attrValue(child, "style:family");
+					if (name === void 0 || family === void 0 || !isStyleFamily(family)) continue;
+					byName.set(nameKey(family, name), child);
+				} else if (child.tag === "style:default-style") {
+					const family = attrValue(child, "style:family");
+					if (family === void 0 || !isStyleFamily(family)) continue;
+					if (!defaultByFamily.has(family)) defaultByFamily.set(family, child);
+				}
+			}
+		}
+	}
+	return {
+		byName,
+		defaultByFamily
+	};
+}
+function resolveStyle(styleName, family, pkg) {
+	const { byName, defaultByFamily } = collectStyles(pkg);
+	const diagnostics = [];
+	const defaultElement = defaultByFamily.get(family);
+	let properties = defaultElement === void 0 ? {} : parseStyleElementProperties(defaultElement).properties;
+	if (styleName === void 0) return {
+		properties,
+		diagnostics
+	};
+	const chain = [];
+	const visited = /* @__PURE__ */ new Set();
+	let currentName = styleName;
+	while (currentName !== void 0) {
+		const key = nameKey(family, currentName);
+		if (visited.has(key)) {
+			diagnostics.push({
+				severity: "warning",
+				message: `cyclic style:parent-style-name chain detected at style "${currentName}" (family "${family}") -- breaking the cycle and stopping cascade resolution at this point`
+			});
+			break;
+		}
+		visited.add(key);
+		const element = byName.get(key);
+		if (element === void 0) {
+			diagnostics.push({
+				severity: "warning",
+				message: `style "${currentName}" (family "${family}") was not found in content.xml or styles.xml -- stopping cascade resolution at this point`
+			});
+			break;
+		}
+		chain.push(element);
+		currentName = attrValue(element, "style:parent-style-name");
+	}
+	chain.reverse();
+	for (const element of chain) properties = {
+		...properties,
+		...parseStyleElementProperties(element).properties
+	};
+	return {
+		properties,
+		diagnostics
+	};
+}
+//#endregion
+//#region src/typed/shared/metadata.ts
+const META_PART = "meta.xml";
+function elementText(element) {
+	let text = "";
+	for (const child of element.children) if (child.type === "text") text += decodeXmlText(child.value);
+	return text;
+}
+function firstElementText(container, tag) {
+	const element = childrenWithTag(container, tag)[0];
+	if (element === void 0) return;
+	const text = elementText(element);
+	return text.length > 0 ? text : void 0;
+}
+function readOdfMetadata(pkg) {
+	const part = pkg.parts[META_PART];
+	if (part?.kind !== "xml") return {};
+	const root = rootElement(part.nodes);
+	const meta = root === void 0 ? void 0 : findChildElement(root.children, "office:meta");
+	if (meta === void 0) return {};
+	const metadata = {};
+	const title = firstElementText(meta, "dc:title");
+	if (title !== void 0) metadata.title = title;
+	const author = firstElementText(meta, "meta:initial-creator");
+	if (author !== void 0) metadata.author = author;
+	const subject = firstElementText(meta, "dc:subject");
+	if (subject !== void 0) metadata.subject = subject;
+	const keywords = childrenWithTag(meta, "meta:keyword").map(elementText).filter((keyword) => keyword.length > 0);
+	if (keywords.length > 0) metadata.keywords = keywords;
+	const creator = firstElementText(meta, "meta:generator");
+	if (creator !== void 0) metadata.creator = creator;
+	const createdIso = firstElementText(meta, "meta:creation-date");
+	if (createdIso !== void 0) metadata.createdIso = createdIso;
+	const modifiedIso = firstElementText(meta, "dc:date");
+	if (modifiedIso !== void 0) metadata.modifiedIso = modifiedIso;
+	return metadata;
+}
+//#endregion
+Object.defineProperty(exports, "AlignmentSchema", {
+	enumerable: true,
+	get: function() {
+		return document_content_model.AlignmentSchema;
+	}
+});
 exports.AttributeSchema = AttributeSchema;
 exports.BinaryPartSchema = BinaryPartSchema;
 exports.MANIFEST_PART = MANIFEST_PART;
+exports.META_PART = META_PART;
 exports.MIMETYPE_PART = MIMETYPE_PART;
 exports.ManifestEntrySchema = ManifestEntrySchema;
 exports.ManifestProblemSchema = ManifestProblemSchema;
@@ -692,6 +1621,10 @@ exports.ODF_MEDIA_TYPES = ODF_MEDIA_TYPES;
 exports.ODF_NAMESPACES = ODF_NAMESPACES;
 exports.PackageSchema = PackageSchema;
 exports.PartSchema = PartSchema;
+exports.STYLE_FAMILIES = STYLE_FAMILIES;
+exports.StylePropertiesSchema = StylePropertiesSchema;
+exports.StyleRegistry = StyleRegistry;
+exports.TableCursor = TableCursor;
 exports.XmlCdataSchema = XmlCdataSchema;
 exports.XmlCommentSchema = XmlCommentSchema;
 exports.XmlDeclarationSchema = XmlDeclarationSchema;
@@ -700,25 +1633,57 @@ exports.XmlNodeSchema = XmlNodeSchema;
 exports.XmlPartSchema = XmlPartSchema;
 exports.XmlPiSchema = XmlPiSchema;
 exports.XmlTextSchema = XmlTextSchema;
+exports.attrValue = attrValue;
 exports.base64ToBytes = base64ToBytes;
 exports.buildManifest = buildManifest;
+exports.buildStylePropertyElements = buildStylePropertyElements;
 exports.buildXml = buildXml;
 exports.bytesToBase64 = bytesToBase64;
+exports.canonicalPropertiesString = canonicalPropertiesString;
+exports.cellReference = cellReference;
+exports.childrenWithTag = childrenWithTag;
+exports.columnIndexToLetters = columnIndexToLetters;
+exports.decodeOdfText = decodeOdfText;
 exports.decodePackage = decodePackage;
+exports.decodeXmlText = decodeXmlText;
 exports.el = el;
 exports.encodePackage = encodePackage;
 exports.encodeXmlText = encodeXmlText;
+exports.ensureSpan = ensureSpan;
+exports.findChildElement = findChildElement;
+exports.formatOdfColor = formatOdfColor;
+exports.formatOdfLength = formatOdfLength;
+exports.formatPercentageMultiplier = formatPercentageMultiplier;
+exports.formatPt = formatPt;
+exports.getOdfSpaceCount = getOdfSpaceCount;
+exports.isStyleFamily = isStyleFamily;
 exports.isXmlNode = isXmlNode;
+exports.measureOdfNodeLength = measureOdfNodeLength;
 exports.mediaTypeForExtension = mediaTypeForExtension;
 exports.packageCodec = packageCodec;
+exports.paragraphPropertiesToAttributes = paragraphPropertiesToAttributes;
+exports.parseBox = parseBox;
+exports.parseLength = parseLength;
+exports.parseMargins = parseMargins;
+exports.parseOdfColor = parseOdfColor;
+exports.parseOdfLength = parseOdfLength;
 exports.parsePackage = parsePackage;
+exports.parsePageSize = parsePageSize;
+exports.parseParagraphProperties = parseParagraphProperties;
+exports.parseStyleElementProperties = parseStyleElementProperties;
+exports.parseTextProperties = parseTextProperties;
 exports.parseXml = parseXml;
 exports.readManifest = readManifest;
 exports.readMimetype = readMimetype;
+exports.readOdfMetadata = readOdfMetadata;
+exports.resolveStyle = resolveStyle;
+exports.rootElement = rootElement;
 exports.serializePackage = serializePackage;
 exports.setDocumentMediaType = setDocumentMediaType;
 exports.sniffImageFormat = sniffImageFormat;
+exports.sumOdfNodeLength = sumOdfNodeLength;
 exports.syncManifest = syncManifest;
+exports.textPropertiesToAttributes = textPropertiesToAttributes;
 exports.txt = txt;
 exports.unzipPackage = unzipPackage;
 exports.validateManifest = validateManifest;