odf.js 1.2.0 → 1.3.0

package/dist/index.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { XMLBuilder, XMLParser } from "fast-xml-parser";
 import { unzipSync, zipSync } from "fflate";
-import { AlignmentSchema, ColorSchema, colorToRgbHex, rgbHexToColor } from "document-content-model";
+import { AlignmentSchema, AlignmentSchema as AlignmentSchema$1, ColorSchema, colorToRgbHex, rgbHexToColor } from "document-content-model";
 //#region src/model/node.ts
 const AttributeSchema = z.object({
 	name: z.string(),
@@ -448,6 +448,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 = z.object({
@@ -471,26 +482,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$1(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$1(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$1(child, "manifest:full-path");
-		const mediaType = attrValue$1(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$1(child, "manifest:version");
+		const entryVersion = attrValue$2(child, "manifest:version");
 		entries.push(entryVersion === void 0 ? {
 			fullPath,
 			mediaType
@@ -600,7 +611,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 +660,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$1(child, "manifest:full-path");
+		const fullPath = attrValue$2(child, "manifest:full-path");
 		if (fullPath === void 0) continue;
 		problems.push({
 			severity: "warning",
@@ -681,6 +692,48 @@ 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 rgbHexToColor(value);
+}
+function formatOdfColor(color) {
+	return `#${colorToRgbHex(color)}`;
+}
+//#endregion
 //#region src/styles/properties.ts
 const StylePropertiesSchema = z.object({
 	bold: z.boolean().optional(),
@@ -690,7 +743,7 @@ const StylePropertiesSchema = z.object({
 	fontFamily: z.string().optional(),
 	sizePt: z.number().optional(),
 	color: ColorSchema.optional(),
-	alignment: AlignmentSchema.optional(),
+	alignment: AlignmentSchema$1.optional(),
 	spacingBeforePt: z.number().optional(),
 	spacingAfterPt: z.number().optional(),
 	lineSpacing: z.number().optional(),
@@ -740,30 +793,9 @@ function attributeMap(element) {
 	for (const attribute of element.attributes) map.set(attribute.name, attribute.value);
 	return map;
 }
-const LENGTH_PATTERN = /^(-?(?:\d+(?:\.\d+)?|\.\d+))(cm|mm|in|pt|pc|px)$/;
-function unitToPtFactor(unit) {
-	switch (unit) {
-		case "pt": return 1;
-		case "in": return 72;
-		case "cm": return 72 / 2.54;
-		case "mm": return 72 / 25.4;
-		case "pc": return 12;
-		case "px": return .75;
-	}
-}
-function isLengthUnit(value) {
-	return value === "cm" || value === "mm" || value === "in" || value === "pt" || value === "pc" || value === "px";
-}
-function parseLength(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);
-}
+const parseLength = parseOdfLength;
 function formatPt(valuePt) {
-	return `${valuePt}pt`;
+	return formatOdfLength(valuePt, "pt");
 }
 const PERCENTAGE_PATTERN = /^(-?(?:\d+(?:\.\d+)?|\.\d+))%$/;
 function parsePercentageMultiplier(value) {
@@ -776,14 +808,8 @@ function parsePercentageMultiplier(value) {
 function formatPercentageMultiplier(multiplier) {
 	return `${multiplier * 100}%`;
 }
-const COLOR_PATTERN = /^#[0-9a-fA-F]{6}$/;
-function parseColor(value) {
-	if (!COLOR_PATTERN.test(value)) return;
-	return rgbHexToColor(value);
-}
-function formatColor(color) {
-	return `#${colorToRgbHex(color)}`;
-}
+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;
@@ -1048,7 +1074,7 @@ function emptyFamilySets() {
 		graphic: /* @__PURE__ */ new Set()
 	};
 }
-function attrValue(element, name) {
+function attrValue$1(element, name) {
 	return element.attributes.find((attribute) => attribute.name === name)?.value;
 }
 function findDirectChild(nodes, tag) {
@@ -1076,8 +1102,8 @@ function ensureAutomaticStyles(root) {
 function reserveStyleNames(container, reserved) {
 	for (const child of container.children) {
 		if (child.type !== "element" || child.tag !== "style:style") continue;
-		const name = attrValue(child, "style:name");
-		const family = attrValue(child, "style:family");
+		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);
 	}
@@ -1123,14 +1149,14 @@ var StyleRegistry = class StyleRegistry {
 		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(child, "style:name");
-			const family = attrValue(child, "style:family");
+			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(child, "style:parent-style-name");
+				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);
@@ -1204,10 +1230,62 @@ var StyleRegistry = class StyleRegistry {
 	}
 };
 //#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 = sumLength(paragraph.children);
+	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);
@@ -1239,29 +1317,9 @@ function setStyleName(span, styleName) {
 		value: encoded
 	});
 }
-function getSpaceCount(spaceElement) {
-	const raw = spaceElement.attributes.find((attribute) => attribute.name === "text:c")?.value;
-	if (raw === void 0) return 1;
-	const parsed = Number.parseInt(raw, 10);
-	if (!Number.isInteger(parsed) || parsed < 0 || String(parsed) !== raw) throw new Error(`ensureSpan: text:s has a malformed text:c attribute: "${raw}"`);
-	return parsed;
-}
 function buildSpaceRun(count) {
 	return count === 1 ? el("text:s") : el("text:s", { "text:c": String(count) });
 }
-function measureLength(node) {
-	if (node.type === "text") return node.value.length;
-	if (node.type !== "element") return 0;
-	if (node.tag === "text:s") return getSpaceCount(node);
-	if (node.tag === "text:tab" || node.tag === "text:line-break") return 1;
-	if (node.tag === "text:span") return sumLength(node.children);
-	return 0;
-}
-function sumLength(nodes) {
-	let total = 0;
-	for (const node of nodes) total += measureLength(node);
-	return total;
-}
 function splitNode(node, offset) {
 	if (node.type === "text") return {
 		left: {
@@ -1274,7 +1332,7 @@ function splitNode(node, offset) {
 		}
 	};
 	if (node.type === "element" && node.tag === "text:s") {
-		const count = getSpaceCount(node);
+		const count = getOdfSpaceCount(node);
 		return {
 			left: buildSpaceRun(offset),
 			right: buildSpaceRun(count - offset)
@@ -1311,7 +1369,7 @@ function splitChildrenAt(children, offset) {
 			after: children.slice(index)
 		};
 		const node = children[index];
-		const length = measureLength(node);
+		const length = measureOdfNodeLength(node);
 		if (remaining >= length) {
 			before.push(node);
 			remaining -= length;
@@ -1333,4 +1391,215 @@ function splitChildrenAt(children, offset) {
 	};
 }
 //#endregion
-export { AttributeSchema, BinaryPartSchema, MANIFEST_PART, MIMETYPE_PART, ManifestEntrySchema, ManifestProblemSchema, ManifestSchema, ODF_MEDIA_TYPES, ODF_NAMESPACES, PackageSchema, PartSchema, STYLE_FAMILIES, StylePropertiesSchema, StyleRegistry, XmlCdataSchema, XmlCommentSchema, XmlDeclarationSchema, XmlElementSchema, XmlNodeSchema, XmlPartSchema, XmlPiSchema, XmlTextSchema, base64ToBytes, buildManifest, buildStylePropertyElements, buildXml, bytesToBase64, canonicalPropertiesString, decodePackage, el, encodePackage, encodeXmlText, ensureSpan, formatPercentageMultiplier, formatPt, isXmlNode, mediaTypeForExtension, packageCodec, paragraphPropertiesToAttributes, parseLength, parsePackage, parseParagraphProperties, parseStyleElementProperties, parseTextProperties, parseXml, readManifest, readMimetype, serializePackage, setDocumentMediaType, sniffImageFormat, syncManifest, textPropertiesToAttributes, txt, unzipPackage, validateManifest, writeManifest, writeMimetype, xmlCodec, xmlnsAttributes, zipPackage };
+//#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
+export { AlignmentSchema, AttributeSchema, BinaryPartSchema, MANIFEST_PART, META_PART, MIMETYPE_PART, ManifestEntrySchema, ManifestProblemSchema, ManifestSchema, ODF_MEDIA_TYPES, ODF_NAMESPACES, PackageSchema, PartSchema, STYLE_FAMILIES, StylePropertiesSchema, StyleRegistry, TableCursor, XmlCdataSchema, XmlCommentSchema, XmlDeclarationSchema, XmlElementSchema, XmlNodeSchema, XmlPartSchema, XmlPiSchema, XmlTextSchema, attrValue, base64ToBytes, buildManifest, buildStylePropertyElements, buildXml, bytesToBase64, canonicalPropertiesString, cellReference, childrenWithTag, columnIndexToLetters, decodeOdfText, decodePackage, decodeXmlText, el, encodePackage, encodeXmlText, ensureSpan, findChildElement, formatOdfColor, formatOdfLength, formatPercentageMultiplier, formatPt, getOdfSpaceCount, isStyleFamily, isXmlNode, measureOdfNodeLength, mediaTypeForExtension, packageCodec, paragraphPropertiesToAttributes, parseBox, parseLength, parseMargins, parseOdfColor, parseOdfLength, parsePackage, parsePageSize, parseParagraphProperties, parseStyleElementProperties, parseTextProperties, parseXml, readManifest, readMimetype, readOdfMetadata, resolveStyle, rootElement, serializePackage, setDocumentMediaType, sniffImageFormat, sumOdfNodeLength, syncManifest, textPropertiesToAttributes, txt, unzipPackage, validateManifest, writeManifest, writeMimetype, xmlCodec, xmlnsAttributes, zipPackage };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "odf.js",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Type-safe, lossless round-trip conversion between OpenDocument Format packages (odt, ods, odp) and JSON, hand-written and dependency-minimal, built on Zod 4 codecs.",
   "type": "module",
   "repository": {