odf.js 1.0.0 → 1.2.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(),
@@ -329,10 +330,1024 @@ function encodePackage(pkg) {
 	return zod.z.encode(packageCodec, pkg);
 }
 //#endregion
+//#region src/ns.ts
+const ODF_NAMESPACES = Object.freeze({
+	office: "urn:oasis:names:tc:opendocument:xmlns:office:1.0",
+	style: "urn:oasis:names:tc:opendocument:xmlns:style:1.0",
+	text: "urn:oasis:names:tc:opendocument:xmlns:text:1.0",
+	table: "urn:oasis:names:tc:opendocument:xmlns:table:1.0",
+	draw: "urn:oasis:names:tc:opendocument:xmlns:drawing:1.0",
+	fo: "urn:oasis:names:tc:opendocument:xmlns:xsl-fo-compatible:1.0",
+	svg: "urn:oasis:names:tc:opendocument:xmlns:svg-compatible:1.0",
+	xlink: "http://www.w3.org/1999/xlink",
+	dc: "http://purl.org/dc/elements/1.1/",
+	meta: "urn:oasis:names:tc:opendocument:xmlns:meta:1.0",
+	number: "urn:oasis:names:tc:opendocument:xmlns:datastyle:1.0",
+	chart: "urn:oasis:names:tc:opendocument:xmlns:chart:1.0",
+	dr3d: "urn:oasis:names:tc:opendocument:xmlns:dr3d:1.0",
+	math: "http://www.w3.org/1998/Math/MathML",
+	form: "urn:oasis:names:tc:opendocument:xmlns:form:1.0",
+	script: "urn:oasis:names:tc:opendocument:xmlns:script:1.0",
+	config: "urn:oasis:names:tc:opendocument:xmlns:config:1.0",
+	presentation: "urn:oasis:names:tc:opendocument:xmlns:presentation:1.0",
+	smil: "urn:oasis:names:tc:opendocument:xmlns:smil-compatible:1.0",
+	anim: "urn:oasis:names:tc:opendocument:xmlns:animation:1.0",
+	xforms: "http://www.w3.org/2002/xforms",
+	xsd: "http://www.w3.org/2001/XMLSchema",
+	xsi: "http://www.w3.org/2001/XMLSchema-instance",
+	manifest: "urn:oasis:names:tc:opendocument:xmlns:manifest:1.0"
+});
+function xmlnsAttributes(prefixes) {
+	const attrs = {};
+	for (const prefix of prefixes) attrs[`xmlns:${prefix}`] = ODF_NAMESPACES[prefix];
+	return attrs;
+}
+//#endregion
+//#region src/media-type.ts
+const ODF_MEDIA_TYPES = Object.freeze({
+	odt: "application/vnd.oasis.opendocument.text",
+	ott: "application/vnd.oasis.opendocument.text-template",
+	ods: "application/vnd.oasis.opendocument.spreadsheet",
+	ots: "application/vnd.oasis.opendocument.spreadsheet-template",
+	odp: "application/vnd.oasis.opendocument.presentation",
+	otp: "application/vnd.oasis.opendocument.presentation-template",
+	odg: "application/vnd.oasis.opendocument.graphics",
+	otg: "application/vnd.oasis.opendocument.graphics-template",
+	odf: "application/vnd.oasis.opendocument.formula",
+	otf: "application/vnd.oasis.opendocument.formula-template",
+	odm: "application/vnd.oasis.opendocument.text-master",
+	otm: "application/vnd.oasis.opendocument.text-master-template",
+	odb: "application/vnd.oasis.opendocument.base"
+});
+function isOdfExtension(extension) {
+	return Object.hasOwn(ODF_MEDIA_TYPES, extension);
+}
+function mediaTypeForExtension(extension) {
+	const lower = extension.toLowerCase();
+	return isOdfExtension(lower) ? ODF_MEDIA_TYPES[lower] : void 0;
+}
+//#endregion
+//#region src/image/sniff.ts
+const PNG_SIGNATURE = [
+	137,
+	80,
+	78,
+	71,
+	13,
+	10,
+	26,
+	10
+];
+const JPEG_SIGNATURE = [
+	255,
+	216,
+	255
+];
+function startsWith(bytes, signature) {
+	if (bytes.length < signature.length) return false;
+	for (let i = 0; i < signature.length; i++) if (bytes[i] !== signature[i]) return false;
+	return true;
+}
+function sniffImageFormat(bytes) {
+	if (startsWith(bytes, PNG_SIGNATURE)) return "png";
+	if (startsWith(bytes, JPEG_SIGNATURE)) return "jpeg";
+}
+//#endregion
+//#region src/mimetype.ts
+function readMimetype(pkg) {
+	const part = pkg.parts[MIMETYPE_PART];
+	if (part?.kind !== "binary") return;
+	return new TextDecoder("utf-8").decode(base64ToBytes(part.base64));
+}
+function writeMimetype(pkg, mediaType) {
+	pkg.parts[MIMETYPE_PART] = {
+		kind: "binary",
+		base64: bytesToBase64(new TextEncoder().encode(mediaType))
+	};
+}
+//#endregion
+//#region src/xml/fragment.ts
+function el(tag, attrs = {}, children = []) {
+	return {
+		type: "element",
+		tag,
+		attributes: Object.entries(attrs).map(([name, value]) => ({
+			name,
+			value
+		})),
+		children
+	};
+}
+function txt(value) {
+	return {
+		type: "text",
+		value
+	};
+}
+//#endregion
+//#region src/xml/entities.ts
+function encodeXmlText(value) {
+	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+//#endregion
+//#region src/manifest.ts
+const ManifestEntrySchema = zod.z.object({
+	fullPath: zod.z.string(),
+	mediaType: zod.z.string(),
+	version: zod.z.string().optional()
+});
+const ManifestSchema = zod.z.object({
+	version: zod.z.string(),
+	entries: zod.z.array(ManifestEntrySchema)
+});
+const ManifestProblemSchema = zod.z.object({
+	severity: zod.z.enum(["error", "warning"]),
+	message: zod.z.string(),
+	path: zod.z.string().optional()
+});
+const DEFAULT_MANIFEST_VERSION = "1.3";
+const STANDARD_XML_PART_NAMES = /* @__PURE__ */ new Set([
+	"content.xml",
+	"styles.xml",
+	"meta.xml",
+	"settings.xml"
+]);
+function findChildElement(nodes, tag) {
+	for (const node of nodes) if (node.type === "element" && node.tag === tag) return node;
+}
+function attrValue$1(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");
+	if (root === void 0) throw new Error(`${MANIFEST_PART} has no manifest:manifest root element`);
+	const version = attrValue$1(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");
+		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");
+		entries.push(entryVersion === void 0 ? {
+			fullPath,
+			mediaType
+		} : {
+			fullPath,
+			mediaType,
+			version: entryVersion
+		});
+	}
+	return {
+		version,
+		entries
+	};
+}
+function subdocumentDirectories(partPaths) {
+	const dirs = [];
+	for (const path of partPaths) if (path.endsWith("/content.xml")) dirs.push(path.slice(0, path.length - 11));
+	return dirs;
+}
+function resolvePartMediaType(path, bytes, overrides) {
+	const override = overrides?.[path];
+	if (override !== void 0) return override;
+	const baseName = path.slice(path.lastIndexOf("/") + 1);
+	if (STANDARD_XML_PART_NAMES.has(baseName)) return "text/xml";
+	const dotIndex = baseName.lastIndexOf(".");
+	const extension = dotIndex === -1 ? "" : baseName.slice(dotIndex + 1);
+	const byExtension = extension === "" ? void 0 : mediaTypeForExtension(extension);
+	if (byExtension !== void 0) return byExtension;
+	if (bytes !== void 0) {
+		const sniffed = sniffImageFormat(bytes);
+		if (sniffed === "png") return "image/png";
+		if (sniffed === "jpeg") return "image/jpeg";
+	}
+	return "";
+}
+function buildManifest(pkg, options = {}) {
+	const version = options.version ?? DEFAULT_MANIFEST_VERSION;
+	const documentMediaType = options.documentMediaType ?? readMimetype(pkg);
+	if (documentMediaType === void 0) throw new Error("buildManifest: package has no \"mimetype\" part and no documentMediaType override was supplied -- the manifest root entry requires a known document media type");
+	const entries = [{
+		fullPath: "/",
+		mediaType: documentMediaType,
+		version
+	}];
+	const partPaths = Object.keys(pkg.parts);
+	for (const dir of new Set(subdocumentDirectories(partPaths))) entries.push({
+		fullPath: dir,
+		mediaType: resolvePartMediaType(dir, void 0, options.mediaTypeOverrides)
+	});
+	for (const [path, part] of Object.entries(pkg.parts)) {
+		if (path === "mimetype" || path === "META-INF/manifest.xml") continue;
+		const bytes = part.kind === "binary" ? base64ToBytes(part.base64) : void 0;
+		entries.push({
+			fullPath: path,
+			mediaType: resolvePartMediaType(path, bytes, options.mediaTypeOverrides)
+		});
+	}
+	return {
+		version,
+		entries
+	};
+}
+function buildManifestNodes(manifest) {
+	const fileEntries = manifest.entries.map((entry) => {
+		const attrs = { "manifest:full-path": encodeXmlText(entry.fullPath) };
+		if (entry.version !== void 0) attrs["manifest:version"] = encodeXmlText(entry.version);
+		attrs["manifest:media-type"] = encodeXmlText(entry.mediaType);
+		return el("manifest:file-entry", attrs);
+	});
+	return [{
+		type: "declaration",
+		attributes: [{
+			name: "version",
+			value: "1.0"
+		}, {
+			name: "encoding",
+			value: "UTF-8"
+		}]
+	}, el("manifest:manifest", {
+		...xmlnsAttributes(["manifest"]),
+		"manifest:version": encodeXmlText(manifest.version)
+	}, fileEntries)];
+}
+function writeManifest(pkg, manifest) {
+	pkg.parts[MANIFEST_PART] = {
+		kind: "xml",
+		nodes: buildManifestNodes(manifest)
+	};
+}
+function syncManifest(pkg, options) {
+	writeManifest(pkg, buildManifest(pkg, options));
+}
+function validateManifest(pkg) {
+	const problems = [];
+	const manifestPart = pkg.parts[MANIFEST_PART];
+	if (manifestPart === void 0) {
+		problems.push({
+			severity: "error",
+			message: `package has no ${MANIFEST_PART} part`
+		});
+		return problems;
+	}
+	if (manifestPart.kind !== "xml") {
+		problems.push({
+			severity: "error",
+			message: `${MANIFEST_PART} part is not XML`
+		});
+		return problems;
+	}
+	const root = findChildElement(manifestPart.nodes, "manifest:manifest");
+	if (root === void 0) {
+		problems.push({
+			severity: "error",
+			message: `${MANIFEST_PART} has no manifest:manifest root element`
+		});
+		return problems;
+	}
+	let manifest;
+	try {
+		manifest = readManifest(pkg);
+	} catch (error) {
+		problems.push({
+			severity: "error",
+			message: `failed to parse ${MANIFEST_PART}: ${error instanceof Error ? error.message : String(error)}`
+		});
+		return problems;
+	}
+	const rootEntry = manifest.entries.find((entry) => entry.fullPath === "/");
+	if (rootEntry === void 0) problems.push({
+		severity: "error",
+		message: "manifest has no root (\"/\") entry"
+	});
+	else {
+		const documentMediaType = readMimetype(pkg);
+		if (documentMediaType !== void 0 && documentMediaType !== rootEntry.mediaType) problems.push({
+			severity: "error",
+			message: `manifest root entry media type "${rootEntry.mediaType}" does not match the mimetype part's media type "${documentMediaType}"`,
+			path: "/"
+		});
+	}
+	const partPaths = new Set(Object.keys(pkg.parts).filter((path) => path !== "mimetype" && path !== "META-INF/manifest.xml"));
+	const manifestPaths = new Set(manifest.entries.map((entry) => entry.fullPath));
+	for (const entry of manifest.entries) {
+		if (entry.fullPath === "/" || entry.fullPath.endsWith("/")) continue;
+		if (!partPaths.has(entry.fullPath)) problems.push({
+			severity: "warning",
+			message: `manifest lists "${entry.fullPath}" but the package has no such part`,
+			path: entry.fullPath
+		});
+	}
+	for (const path of partPaths) if (!manifestPaths.has(path)) problems.push({
+		severity: "warning",
+		message: `package has part "${path}" not listed in the manifest`,
+		path
+	});
+	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");
+		if (fullPath === void 0) continue;
+		problems.push({
+			severity: "warning",
+			message: `entry "${fullPath}" carries manifest:encryption-data -- odf.js does not implement ODF encryption/decryption`,
+			path: fullPath
+		});
+	}
+	return problems;
+}
+function setDocumentMediaType(pkg, mediaType, version = DEFAULT_MANIFEST_VERSION) {
+	writeMimetype(pkg, mediaType);
+	const rootEntry = {
+		fullPath: "/",
+		mediaType,
+		version
+	};
+	if (pkg.parts["META-INF/manifest.xml"] === void 0) {
+		writeManifest(pkg, {
+			version,
+			entries: [rootEntry]
+		});
+		return;
+	}
+	const existing = readManifest(pkg);
+	const rootIndex = existing.entries.findIndex((entry) => entry.fullPath === "/");
+	writeManifest(pkg, {
+		version,
+		entries: rootIndex === -1 ? [rootEntry, ...existing.entries] : existing.entries.map((entry, index) => index === rootIndex ? rootEntry : entry)
+	});
+}
+//#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 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);
+}
+function formatPt(valuePt) {
+	return `${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 COLOR_PATTERN = /^#[0-9a-fA-F]{6}$/;
+function parseColor(value) {
+	if (!COLOR_PATTERN.test(value)) return;
+	return (0, document_content_model.rgbHexToColor)(value);
+}
+function formatColor(color) {
+	return `#${(0, document_content_model.colorToRgbHex)(color)}`;
+}
+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(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(child, "style:name");
+		const family = attrValue(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(child, "style:name");
+			const family = attrValue(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 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/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);
+	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 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: {
+			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 = getSpaceCount(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 = measureLength(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
 exports.AttributeSchema = AttributeSchema;
 exports.BinaryPartSchema = BinaryPartSchema;
+exports.MANIFEST_PART = MANIFEST_PART;
+exports.MIMETYPE_PART = MIMETYPE_PART;
+exports.ManifestEntrySchema = ManifestEntrySchema;
+exports.ManifestProblemSchema = ManifestProblemSchema;
+exports.ManifestSchema = ManifestSchema;
+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.XmlCdataSchema = XmlCdataSchema;
 exports.XmlCommentSchema = XmlCommentSchema;
 exports.XmlDeclarationSchema = XmlDeclarationSchema;
@@ -342,15 +1357,40 @@ exports.XmlPartSchema = XmlPartSchema;
 exports.XmlPiSchema = XmlPiSchema;
 exports.XmlTextSchema = XmlTextSchema;
 exports.base64ToBytes = base64ToBytes;
+exports.buildManifest = buildManifest;
+exports.buildStylePropertyElements = buildStylePropertyElements;
 exports.buildXml = buildXml;
 exports.bytesToBase64 = bytesToBase64;
+exports.canonicalPropertiesString = canonicalPropertiesString;
 exports.decodePackage = decodePackage;
+exports.el = el;
 exports.encodePackage = encodePackage;
+exports.encodeXmlText = encodeXmlText;
+exports.ensureSpan = ensureSpan;
+exports.formatPercentageMultiplier = formatPercentageMultiplier;
+exports.formatPt = formatPt;
 exports.isXmlNode = isXmlNode;
+exports.mediaTypeForExtension = mediaTypeForExtension;
 exports.packageCodec = packageCodec;
+exports.paragraphPropertiesToAttributes = paragraphPropertiesToAttributes;
+exports.parseLength = parseLength;
 exports.parsePackage = parsePackage;
+exports.parseParagraphProperties = parseParagraphProperties;
+exports.parseStyleElementProperties = parseStyleElementProperties;
+exports.parseTextProperties = parseTextProperties;
 exports.parseXml = parseXml;
+exports.readManifest = readManifest;
+exports.readMimetype = readMimetype;
 exports.serializePackage = serializePackage;
+exports.setDocumentMediaType = setDocumentMediaType;
+exports.sniffImageFormat = sniffImageFormat;
+exports.syncManifest = syncManifest;
+exports.textPropertiesToAttributes = textPropertiesToAttributes;
+exports.txt = txt;
 exports.unzipPackage = unzipPackage;
+exports.validateManifest = validateManifest;
+exports.writeManifest = writeManifest;
+exports.writeMimetype = writeMimetype;
 exports.xmlCodec = xmlCodec;
+exports.xmlnsAttributes = xmlnsAttributes;
 exports.zipPackage = zipPackage;