odf.js 1.1.0 → 1.2.0

package/dist/index.js

@@ -1,6 +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";
 //#region src/model/node.ts
 const AttributeSchema = z.object({
 	name: z.string(),
@@ -473,7 +474,7 @@ const STANDARD_XML_PART_NAMES = /* @__PURE__ */ new Set([
 function findChildElement(nodes, tag) {
 	for (const node of nodes) if (node.type === "element" && node.tag === tag) return node;
 }
-function attrValue(element, name) {
+function attrValue$1(element, name) {
 	return element.attributes.find((attribute) => attribute.name === name)?.value;
 }
 function readManifest(pkg) {
@@ -481,15 +482,15 @@ function readManifest(pkg) {
 	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(root, "manifest:version");
+	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(child, "manifest:full-path");
-		const mediaType = attrValue(child, "manifest:media-type");
+		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(child, "manifest:version");
+		const entryVersion = attrValue$1(child, "manifest:version");
 		entries.push(entryVersion === void 0 ? {
 			fullPath,
 			mediaType
@@ -648,7 +649,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$1(child, "manifest:full-path");
 		if (fullPath === void 0) continue;
 		problems.push({
 			severity: "warning",
@@ -680,4 +681,656 @@ function setDocumentMediaType(pkg, mediaType, version = DEFAULT_MANIFEST_VERSION
 	});
 }
 //#endregion
-export { AttributeSchema, BinaryPartSchema, MANIFEST_PART, MIMETYPE_PART, ManifestEntrySchema, ManifestProblemSchema, ManifestSchema, ODF_MEDIA_TYPES, ODF_NAMESPACES, PackageSchema, PartSchema, XmlCdataSchema, XmlCommentSchema, XmlDeclarationSchema, XmlElementSchema, XmlNodeSchema, XmlPartSchema, XmlPiSchema, XmlTextSchema, base64ToBytes, buildManifest, buildXml, bytesToBase64, decodePackage, el, encodePackage, encodeXmlText, isXmlNode, mediaTypeForExtension, packageCodec, parsePackage, parseXml, readManifest, readMimetype, serializePackage, setDocumentMediaType, sniffImageFormat, syncManifest, txt, unzipPackage, validateManifest, writeManifest, writeMimetype, xmlCodec, xmlnsAttributes, zipPackage };
+//#region src/styles/properties.ts
+const StylePropertiesSchema = z.object({
+	bold: z.boolean().optional(),
+	italic: z.boolean().optional(),
+	underline: z.boolean().optional(),
+	strike: z.boolean().optional(),
+	fontFamily: z.string().optional(),
+	sizePt: z.number().optional(),
+	color: ColorSchema.optional(),
+	alignment: AlignmentSchema.optional(),
+	spacingBeforePt: z.number().optional(),
+	spacingAfterPt: z.number().optional(),
+	lineSpacing: z.number().optional(),
+	indentLeftPt: z.number().optional(),
+	indentFirstLinePt: 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 rgbHexToColor(value);
+}
+function formatColor(color) {
+	return `#${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
+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 };