ooxml.js 0.0.0 → 1.1.0

package/dist/index.cjs

@@ -0,0 +1,944 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let zod = require("zod");
+let fast_xml_parser = require("fast-xml-parser");
+let fflate = require("fflate");
+//#region src/model/node.ts
+const AttributeSchema = zod.z.object({
+	name: zod.z.string(),
+	value: zod.z.string()
+});
+const XmlTextSchema = zod.z.object({
+	type: zod.z.literal("text"),
+	value: zod.z.string()
+});
+const XmlCdataSchema = zod.z.object({
+	type: zod.z.literal("cdata"),
+	value: zod.z.string()
+});
+const XmlCommentSchema = zod.z.object({
+	type: zod.z.literal("comment"),
+	value: zod.z.string()
+});
+const XmlDeclarationSchema = zod.z.object({
+	type: zod.z.literal("declaration"),
+	attributes: zod.z.array(AttributeSchema)
+});
+const XmlPiSchema = zod.z.object({
+	type: zod.z.literal("pi"),
+	target: zod.z.string(),
+	content: zod.z.string()
+});
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isAttribute(value) {
+	return isRecord$1(value) && typeof value.name === "string" && typeof value.value === "string";
+}
+function isXmlNode(value) {
+	if (!isRecord$1(value)) return false;
+	const t = value.type;
+	if (t === "text" || t === "cdata" || t === "comment") return typeof value.value === "string";
+	if (t === "declaration") return Array.isArray(value.attributes) && value.attributes.every(isAttribute);
+	if (t === "pi") return typeof value.target === "string" && typeof value.content === "string";
+	if (t === "element") return typeof value.tag === "string" && Array.isArray(value.attributes) && value.attributes.every(isAttribute) && Array.isArray(value.children) && value.children.every(isXmlNode);
+	return false;
+}
+const XmlElementSchema = zod.z.object({
+	type: zod.z.literal("element"),
+	tag: zod.z.string(),
+	attributes: zod.z.array(AttributeSchema),
+	children: zod.z.array(zod.z.custom(isXmlNode))
+});
+const XmlNodeSchema = zod.z.discriminatedUnion("type", [
+	XmlTextSchema,
+	XmlCdataSchema,
+	XmlCommentSchema,
+	XmlDeclarationSchema,
+	XmlPiSchema,
+	XmlElementSchema
+]);
+//#endregion
+//#region src/model/package.ts
+const XmlPartSchema = zod.z.object({
+	kind: zod.z.literal("xml"),
+	nodes: zod.z.array(XmlNodeSchema)
+});
+const BinaryPartSchema = zod.z.object({
+	kind: zod.z.literal("binary"),
+	base64: zod.z.string()
+});
+const PartSchema = zod.z.discriminatedUnion("kind", [XmlPartSchema, BinaryPartSchema]);
+const PackageSchema = zod.z.object({ parts: zod.z.record(zod.z.string(), PartSchema) });
+//#endregion
+//#region src/util/base64.ts
+const TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const DECODE = (() => {
+	const map = (/* @__PURE__ */ new Uint8Array(256)).fill(255);
+	for (let i = 0; i < 64; i = i + 1) map[TABLE.charCodeAt(i)] = i;
+	return map;
+})();
+function bytesToBase64(bytes) {
+	let out = "";
+	const len = bytes.length;
+	for (let i = 0; i < len; i = i + 3) {
+		const b0 = bytes[i];
+		const b1 = i + 1 < len ? bytes[i + 1] : 0;
+		const b2 = i + 2 < len ? bytes[i + 2] : 0;
+		out += TABLE[b0 >> 2];
+		out += TABLE[(b0 & 3) << 4 | b1 >> 4];
+		out += i + 1 < len ? TABLE[(b1 & 15) << 2 | b2 >> 6] : "=";
+		out += i + 2 < len ? TABLE[b2 & 63] : "=";
+	}
+	return out;
+}
+function base64ToBytes(b64) {
+	const clean = b64.replace(/[^A-Za-z0-9+/=]/g, "");
+	const len = clean.length;
+	const out = new Uint8Array(len * 3 / 4 | 0);
+	let p = 0;
+	for (let i = 0; i < len; i = i + 4) {
+		const c0 = DECODE[clean.charCodeAt(i)];
+		const c1 = DECODE[clean.charCodeAt(i + 1)];
+		const c2 = clean.charCodeAt(i + 2);
+		const c3 = clean.charCodeAt(i + 3);
+		if (c0 === 255 || c1 === 255) throw new Error("invalid base64 input");
+		out[p++] = c0 << 2 | c1 >> 4;
+		if (c2 !== 61) {
+			const d2 = DECODE[c2];
+			out[p++] = (c1 & 15) << 4 | d2 >> 2;
+			if (c3 !== 61) {
+				const d3 = DECODE[c3];
+				out[p++] = (d2 & 3) << 6 | d3;
+			}
+		}
+	}
+	return out.subarray(0, p);
+}
+//#endregion
+//#region src/xml/parse.ts
+const PARSER = new fast_xml_parser.XMLParser({
+	preserveOrder: true,
+	attributeNamePrefix: "@_",
+	ignoreAttributes: false,
+	textNodeName: "#text",
+	cdataPropName: "__cdata",
+	commentPropName: "__comment",
+	processEntities: false,
+	parseTagValue: false,
+	trimValues: false
+});
+function parseXml(xml) {
+	return parseNodes(PARSER.parse(xml));
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isUnknownArray$1(value) {
+	return Array.isArray(value);
+}
+function asString(value) {
+	if (typeof value !== "string") throw new Error(`expected string while parsing XML, got ${typeof value}`);
+	return value;
+}
+function parseNodes(raw) {
+	if (!isUnknownArray$1(raw)) throw new Error("fast-xml-parser output was not an ordered array");
+	return raw.map(parseNode);
+}
+function parseNode(raw) {
+	if (!isRecord(raw)) throw new Error("fast-xml-parser node was not an object");
+	let tagKey;
+	for (const key of Object.keys(raw)) if (key !== ":@") {
+		if (tagKey !== void 0) throw new Error("XML node had multiple tag keys");
+		tagKey = key;
+	}
+	if (tagKey === void 0) throw new Error("XML node had no tag key");
+	const attributes = parseAttributes(raw[":@"]);
+	if (tagKey === "#text") return {
+		type: "text",
+		value: asString(raw["#text"])
+	};
+	if (tagKey === "__comment") return {
+		type: "comment",
+		value: scalarText(raw.__comment)
+	};
+	if (tagKey === "__cdata") return {
+		type: "cdata",
+		value: scalarText(raw.__cdata)
+	};
+	if (tagKey === "?xml") return {
+		type: "declaration",
+		attributes
+	};
+	if (tagKey.startsWith("?")) return {
+		type: "pi",
+		target: tagKey.slice(1),
+		content: scalarText(raw[tagKey])
+	};
+	return {
+		type: "element",
+		tag: tagKey,
+		attributes,
+		children: parseNodes(raw[tagKey])
+	};
+}
+function parseAttributes(raw) {
+	if (raw === void 0) return [];
+	if (!isRecord(raw)) throw new Error("XML attributes were not an object");
+	const attrs = [];
+	for (const key of Object.keys(raw)) {
+		if (!key.startsWith("@_")) throw new Error(`unexpected attribute key without @_ prefix: ${key}`);
+		attrs.push({
+			name: key.slice(2),
+			value: asString(raw[key])
+		});
+	}
+	return attrs;
+}
+function scalarText(raw) {
+	if (!isUnknownArray$1(raw) || raw.length === 0) throw new Error("expected a scalar-text wrapper array");
+	const first = raw[0];
+	if (!isRecord(first)) throw new Error("scalar-text wrapper was not an object");
+	return asString(first["#text"]);
+}
+//#endregion
+//#region src/zip.ts
+function unzipPackage(bytes) {
+	return (0, fflate.unzipSync)(bytes);
+}
+function zipPackage(parts) {
+	return (0, fflate.zipSync)(parts);
+}
+//#endregion
+//#region src/package-io/read.ts
+function parsePackage(bytes) {
+	const entries = unzipPackage(bytes);
+	const parts = {};
+	for (const [path, partBytes] of Object.entries(entries)) if (looksLikeXml(partBytes)) parts[path] = {
+		kind: "xml",
+		nodes: parseXml(new TextDecoder("utf-8").decode(partBytes))
+	};
+	else parts[path] = {
+		kind: "binary",
+		base64: bytesToBase64(partBytes)
+	};
+	return { parts };
+}
+function looksLikeXml(bytes) {
+	let i = 0;
+	if (bytes.length >= 3 && bytes[0] === 239 && bytes[1] === 187 && bytes[2] === 191) i = 3;
+	while (i < bytes.length) {
+		const b = bytes[i];
+		if (b === 32 || b === 9 || b === 10 || b === 13) {
+			i = i + 1;
+			continue;
+		}
+		return b === 60;
+	}
+	return false;
+}
+//#endregion
+//#region src/xml/build.ts
+const BUILDER = new fast_xml_parser.XMLBuilder({
+	preserveOrder: true,
+	attributeNamePrefix: "@_",
+	ignoreAttributes: false,
+	textNodeName: "#text",
+	cdataPropName: "__cdata",
+	commentPropName: "__comment",
+	processEntities: false,
+	format: false,
+	suppressEmptyNode: false
+});
+function buildXml(nodes) {
+	const out = BUILDER.build(toOrdered(nodes));
+	if (typeof out !== "string") throw new Error("XMLBuilder did not return a string");
+	return out;
+}
+function toOrdered(nodes) {
+	return nodes.map(toOrderedNode);
+}
+function attrsObject(attributes) {
+	const obj = {};
+	for (const a of attributes) obj[`@_${a.name}`] = a.value;
+	return obj;
+}
+function toOrderedNode(node) {
+	switch (node.type) {
+		case "text": return { "#text": node.value };
+		case "comment": return { __comment: [{ "#text": node.value }] };
+		case "cdata": return { __cdata: [{ "#text": node.value }] };
+		case "pi": return { [`?${node.target}`]: [{ "#text": node.content }] };
+		case "declaration": return {
+			"?xml": [{ "#text": "" }],
+			":@": attrsObject(node.attributes)
+		};
+		case "element": {
+			const obj = { [node.tag]: toOrdered(node.children) };
+			const attrs = attrsObject(node.attributes);
+			if (Object.keys(attrs).length > 0) obj[":@"] = attrs;
+			return obj;
+		}
+	}
+}
+//#endregion
+//#region src/package-io/write.ts
+function serializePackage(pkg) {
+	const entries = {};
+	for (const [path, part] of Object.entries(pkg.parts)) entries[path] = partToBytes(part);
+	return zipPackage(entries);
+}
+function partToBytes(part) {
+	switch (part.kind) {
+		case "xml": return new TextEncoder().encode(buildXml(part.nodes));
+		case "binary": return base64ToBytes(part.base64);
+	}
+}
+//#endregion
+//#region src/codec.ts
+const xmlCodec = zod.z.codec(zod.z.string(), zod.z.array(XmlNodeSchema), {
+	decode: (xml) => parseXml(xml),
+	encode: (nodes) => buildXml(nodes)
+});
+const packageCodec = zod.z.codec(zod.z.instanceof(Uint8Array), PackageSchema, {
+	decode: (bytes) => parsePackage(bytes),
+	encode: (pkg) => serializePackage(pkg)
+});
+function decodePackage(bytes) {
+	return zod.z.decode(packageCodec, bytes);
+}
+function encodePackage(pkg) {
+	return zod.z.encode(packageCodec, pkg);
+}
+//#endregion
+//#region src/compact.ts
+function isUnknownArray(value) {
+	return Array.isArray(value);
+}
+function isCompactAttrPairs(value) {
+	return isUnknownArray(value) && value.every((v) => typeof v === "number");
+}
+function isCompactXmlNode(value) {
+	if (!isUnknownArray(value)) return false;
+	const code = value[0];
+	if (code === 1 || code === 2 || code === 3) return value.length === 2 && typeof value[1] === "number";
+	if (code === 4) return value.length === 2 && isCompactAttrPairs(value[1]);
+	if (code === 5) return value.length === 3 && typeof value[1] === "number" && typeof value[2] === "number";
+	if (code === 0) return value.length === 4 && typeof value[1] === "number" && isCompactAttrPairs(value[2]) && Array.isArray(value[3]) && value[3].every(isCompactXmlNode);
+	return false;
+}
+const CompactXmlNodeSchema = zod.z.custom(isCompactXmlNode);
+const CompactPartSchema = zod.z.union([zod.z.array(CompactXmlNodeSchema), zod.z.number()]);
+const CompactPackageSchema = zod.z.object({
+	s: zod.z.array(zod.z.string()),
+	p: zod.z.record(zod.z.string(), CompactPartSchema)
+});
+var StringTable = class {
+	indices = /* @__PURE__ */ new Map();
+	strings = [];
+	intern(value) {
+		const existing = this.indices.get(value);
+		if (existing !== void 0) return existing;
+		const index = this.strings.length;
+		this.indices.set(value, index);
+		this.strings.push(value);
+		return index;
+	}
+};
+function encodeAttrs(attributes, table) {
+	const pairs = [];
+	for (const attribute of attributes) pairs.push(table.intern(attribute.name), table.intern(attribute.value));
+	return pairs;
+}
+function encodeNode(node, table) {
+	switch (node.type) {
+		case "text": return [1, table.intern(node.value)];
+		case "cdata": return [2, table.intern(node.value)];
+		case "comment": return [3, table.intern(node.value)];
+		case "declaration": return [4, encodeAttrs(node.attributes, table)];
+		case "pi": return [
+			5,
+			table.intern(node.target),
+			table.intern(node.content)
+		];
+		case "element": return [
+			0,
+			table.intern(node.tag),
+			encodeAttrs(node.attributes, table),
+			node.children.map((child) => encodeNode(child, table))
+		];
+	}
+}
+function packageToCompact(pkg) {
+	const table = new StringTable();
+	const p = {};
+	for (const [path, part] of Object.entries(pkg.parts)) p[path] = part.kind === "binary" ? table.intern(part.base64) : part.nodes.map((node) => encodeNode(node, table));
+	return {
+		s: table.strings,
+		p
+	};
+}
+function stringAt(strings, index) {
+	const value = strings[index];
+	if (value === void 0) throw new Error(`fromCompact: string table index ${index} is out of range`);
+	return value;
+}
+function decodeAttrs(pairs, strings) {
+	const attributes = [];
+	for (let i = 0; i < pairs.length; i += 2) {
+		const nameIdx = pairs[i];
+		const valueIdx = pairs[i + 1];
+		if (nameIdx === void 0 || valueIdx === void 0) throw new Error("fromCompact: attribute index pairs array has odd length");
+		attributes.push({
+			name: stringAt(strings, nameIdx),
+			value: stringAt(strings, valueIdx)
+		});
+	}
+	return attributes;
+}
+function decodeNode(node, strings) {
+	switch (node[0]) {
+		case 1: return {
+			type: "text",
+			value: stringAt(strings, node[1])
+		};
+		case 2: return {
+			type: "cdata",
+			value: stringAt(strings, node[1])
+		};
+		case 3: return {
+			type: "comment",
+			value: stringAt(strings, node[1])
+		};
+		case 4: return {
+			type: "declaration",
+			attributes: decodeAttrs(node[1], strings)
+		};
+		case 5: return {
+			type: "pi",
+			target: stringAt(strings, node[1]),
+			content: stringAt(strings, node[2])
+		};
+		case 0: return {
+			type: "element",
+			tag: stringAt(strings, node[1]),
+			attributes: decodeAttrs(node[2], strings),
+			children: node[3].map((child) => decodeNode(child, strings))
+		};
+	}
+}
+function compactToPackage(cpkg) {
+	const parts = {};
+	for (const [path, part] of Object.entries(cpkg.p)) parts[path] = typeof part === "number" ? {
+		kind: "binary",
+		base64: stringAt(cpkg.s, part)
+	} : {
+		kind: "xml",
+		nodes: part.map((node) => decodeNode(node, cpkg.s))
+	};
+	return { parts };
+}
+const compactCodec = zod.z.codec(PackageSchema, CompactPackageSchema, {
+	decode: (pkg) => packageToCompact(pkg),
+	encode: (cpkg) => compactToPackage(cpkg)
+});
+function toCompact(pkg) {
+	return zod.z.decode(compactCodec, pkg);
+}
+function fromCompact(cpkg) {
+	return zod.z.encode(compactCodec, cpkg);
+}
+const compactPackageCodec = zod.z.codec(zod.z.instanceof(Uint8Array), CompactPackageSchema, {
+	decode: (bytes) => toCompact(decodePackage(bytes)),
+	encode: (cpkg) => encodePackage(fromCompact(cpkg))
+});
+function decodeCompactPackage(bytes) {
+	return zod.z.decode(compactPackageCodec, bytes);
+}
+function encodeCompactPackage(cpkg) {
+	return zod.z.encode(compactPackageCodec, cpkg);
+}
+//#endregion
+//#region src/typed/util.ts
+function* walk(nodes) {
+	for (const node of nodes) {
+		yield node;
+		if (node.type === "element") yield* walk(node.children);
+	}
+}
+function elementsWithTag(nodes, tag) {
+	const out = [];
+	for (const node of walk(nodes)) if (node.type === "element" && node.tag === tag) out.push(node);
+	return out;
+}
+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 attr(element, name) {
+	for (const a of element.attributes) if (a.name === name) return a.value;
+}
+function rootElement(part) {
+	if (part?.kind !== "xml") return;
+	for (const node of part.nodes) if (node.type === "element") return node;
+}
+function decodeEntities(value) {
+	return value.replace(/&(?:amp|lt|gt|quot|apos);/g, (entity) => {
+		switch (entity) {
+			case "&amp;": return "&";
+			case "&lt;": return "<";
+			case "&gt;": return ">";
+			case "&quot;": return "\"";
+			case "&apos;": return "'";
+			default: return entity;
+		}
+	});
+}
+function textContent(element) {
+	let text = "";
+	for (const node of walk(element.children)) if (node.type === "text" || node.type === "cdata") text += node.value;
+	return decodeEntities(text);
+}
+function relsPathFor(partPath) {
+	const lastSlash = partPath.lastIndexOf("/");
+	return `${lastSlash === -1 ? "" : partPath.slice(0, lastSlash)}/_rels/${lastSlash === -1 ? partPath : partPath.slice(lastSlash + 1)}.rels`;
+}
+function resolveRelTarget$1(partPath, target) {
+	if (target.startsWith("/")) return target.slice(1);
+	const lastSlash = partPath.lastIndexOf("/");
+	const baseDir = lastSlash === -1 ? "" : partPath.slice(0, lastSlash);
+	const resolved = [];
+	for (const segment of `${baseDir}/${target}`.split("/")) {
+		if (segment === "" || segment === ".") continue;
+		if (segment === "..") resolved.pop();
+		else resolved.push(segment);
+	}
+	return resolved.join("/");
+}
+function resolveRelationships(pkg, partPath) {
+	const map = /* @__PURE__ */ new Map();
+	const rels = rootElement(pkg.parts[relsPathFor(partPath)]);
+	if (rels === void 0) return map;
+	for (const rel of childrenWithTag(rels, "Relationship")) {
+		const id = attr(rel, "Id");
+		const type = attr(rel, "Type");
+		const target = attr(rel, "Target");
+		if (id === void 0 || type === void 0 || target === void 0) continue;
+		const targetMode = attr(rel, "TargetMode");
+		map.set(id, {
+			type,
+			target: targetMode === "External" ? target : resolveRelTarget$1(partPath, target),
+			targetMode
+		});
+	}
+	return map;
+}
+//#endregion
+//#region src/typed/docx.ts
+const RunSchema = zod.z.object({
+	text: zod.z.string(),
+	bold: zod.z.boolean().optional(),
+	italic: zod.z.boolean().optional()
+});
+const ListMembershipSchema = zod.z.object({
+	numId: zod.z.string(),
+	level: zod.z.number()
+});
+const ParagraphSchema = zod.z.object({
+	runs: zod.z.array(RunSchema),
+	list: ListMembershipSchema.optional()
+});
+const TableCellSchema = zod.z.object({ paragraphs: zod.z.array(ParagraphSchema) });
+const TableRowSchema = zod.z.object({ cells: zod.z.array(TableCellSchema) });
+const TableSchema = zod.z.object({ rows: zod.z.array(TableRowSchema) });
+const HyperlinkSchema = zod.z.object({
+	text: zod.z.string(),
+	target: zod.z.string()
+});
+const CommentSchema = zod.z.object({
+	author: zod.z.string().optional(),
+	text: zod.z.string()
+});
+const FootnoteSchema = zod.z.object({
+	type: zod.z.string().optional(),
+	text: zod.z.string()
+});
+const DocxDocumentSchema = zod.z.object({
+	paragraphs: zod.z.array(ParagraphSchema),
+	tables: zod.z.array(TableSchema),
+	hyperlinks: zod.z.array(HyperlinkSchema),
+	comments: zod.z.array(CommentSchema),
+	footnotes: zod.z.array(FootnoteSchema),
+	headers: zod.z.array(zod.z.string()),
+	footers: zod.z.array(zod.z.string())
+});
+function runPropertyOn(run, tag) {
+	const rPr = run.children.find((child) => child.type === "element" && child.tag === "w:rPr");
+	return rPr !== void 0 && elementsWithTag(rPr.children, tag).length > 0;
+}
+function readRun(run) {
+	const result = { text: elementsWithTag(run.children, "w:t").map(textContent).join("") };
+	if (runPropertyOn(run, "w:b")) result.bold = true;
+	if (runPropertyOn(run, "w:i")) result.italic = true;
+	return result;
+}
+function readListMembership(paragraph) {
+	const pPr = childrenWithTag(paragraph, "w:pPr")[0];
+	if (pPr === void 0) return;
+	const numPr = childrenWithTag(pPr, "w:numPr")[0];
+	if (numPr === void 0) return;
+	const numIdEl = childrenWithTag(numPr, "w:numId")[0];
+	const numId = numIdEl !== void 0 ? attr(numIdEl, "w:val") : void 0;
+	if (numId === void 0) return;
+	const ilvlEl = childrenWithTag(numPr, "w:ilvl")[0];
+	const ilvlVal = ilvlEl !== void 0 ? attr(ilvlEl, "w:val") : void 0;
+	return {
+		numId,
+		level: ilvlVal !== void 0 ? Number(ilvlVal) : 0
+	};
+}
+function readParagraph(paragraph) {
+	const result = { runs: elementsWithTag(paragraph.children, "w:r").map(readRun) };
+	const list = readListMembership(paragraph);
+	if (list !== void 0) result.list = list;
+	return result;
+}
+function readCell$1(cell) {
+	return { paragraphs: childrenWithTag(cell, "w:p").map(readParagraph) };
+}
+function readRow(row) {
+	return { cells: childrenWithTag(row, "w:tc").map(readCell$1) };
+}
+function readTable$1(table) {
+	return { rows: childrenWithTag(table, "w:tr").map(readRow) };
+}
+function readHyperlink(hyperlink, rels) {
+	const text = elementsWithTag(hyperlink.children, "w:t").map(textContent).join("");
+	const rid = attr(hyperlink, "r:id");
+	return {
+		text,
+		target: rid !== void 0 ? rels.get(rid)?.target ?? "" : ""
+	};
+}
+function readComment(comment) {
+	const author = attr(comment, "w:author");
+	const result = { text: elementsWithTag(comment.children, "w:t").map(textContent).join("") };
+	if (author !== void 0) result.author = author;
+	return result;
+}
+function readFootnote(footnote) {
+	const type = attr(footnote, "w:type");
+	const result = { text: elementsWithTag(footnote.children, "w:t").map(textContent).join("") };
+	if (type !== void 0) result.type = type;
+	return result;
+}
+function readComments(pkg) {
+	const root = rootElement(pkg.parts["word/comments.xml"]);
+	if (root === void 0) return [];
+	return childrenWithTag(root, "w:comment").map(readComment);
+}
+function readFootnotes(pkg) {
+	const root = rootElement(pkg.parts["word/footnotes.xml"]);
+	if (root === void 0) return [];
+	const out = [];
+	for (const fn of childrenWithTag(root, "w:footnote")) {
+		const type = attr(fn, "w:type");
+		if (type === "separator" || type === "continuationSeparator") continue;
+		out.push(readFootnote(fn));
+	}
+	return out;
+}
+function readHeaderFooterText(pkg, prefix) {
+	const out = [];
+	for (const path of Object.keys(pkg.parts)) {
+		if (!path.startsWith(prefix) || !path.endsWith(".xml")) continue;
+		const part = pkg.parts[path];
+		if (part?.kind !== "xml") continue;
+		out.push(elementsWithTag(part.nodes, "w:t").map(textContent).join(""));
+	}
+	return out;
+}
+function readDocx(pkg) {
+	const part = pkg.parts["word/document.xml"];
+	if (part === void 0) throw new Error("readDocx: package has no word/document.xml part");
+	if (part.kind !== "xml") throw new Error("readDocx: word/document.xml is not an XML part");
+	const rels = resolveRelationships(pkg, "word/document.xml");
+	return {
+		paragraphs: elementsWithTag(part.nodes, "w:p").map(readParagraph),
+		tables: elementsWithTag(part.nodes, "w:tbl").map(readTable$1),
+		hyperlinks: elementsWithTag(part.nodes, "w:hyperlink").map((h) => readHyperlink(h, rels)),
+		comments: readComments(pkg),
+		footnotes: readFootnotes(pkg),
+		headers: readHeaderFooterText(pkg, "word/header"),
+		footers: readHeaderFooterText(pkg, "word/footer")
+	};
+}
+//#endregion
+//#region src/typed/pptx.ts
+const ShapeSchema = zod.z.object({ text: zod.z.string() });
+const PptxTableCellSchema = zod.z.object({ text: zod.z.string() });
+const PptxTableRowSchema = zod.z.object({ cells: zod.z.array(PptxTableCellSchema) });
+const PptxTableSchema = zod.z.object({ rows: zod.z.array(PptxTableRowSchema) });
+const SlideSchema = zod.z.object({
+	index: zod.z.number().int(),
+	text: zod.z.string(),
+	shapes: zod.z.array(ShapeSchema),
+	tables: zod.z.array(PptxTableSchema),
+	notes: zod.z.string()
+});
+const PptxPresentationSchema = zod.z.object({ slides: zod.z.array(SlideSchema) });
+const SLIDE_PATH = /^ppt\/slides\/slide(\d+)\.xml$/;
+function txBodyText(parent, txBodyTag) {
+	const txBody = childrenWithTag(parent, txBodyTag)[0];
+	if (txBody === void 0) return "";
+	return elementsWithTag(txBody.children, "a:t").map(textContent).join("");
+}
+function readShape(shape) {
+	return { text: txBodyText(shape, "p:txBody") };
+}
+function readTableCell(cell) {
+	return { text: txBodyText(cell, "a:txBody") };
+}
+function readTableRow(row) {
+	return { cells: childrenWithTag(row, "a:tc").map(readTableCell) };
+}
+function readTable(table) {
+	return { rows: childrenWithTag(table, "a:tr").map(readTableRow) };
+}
+function readNotes(pkg, slidePath) {
+	const rels = resolveRelationships(pkg, slidePath);
+	let notesPath;
+	for (const rel of rels.values()) if (rel.type.endsWith("/notesSlide")) {
+		notesPath = rel.target;
+		break;
+	}
+	if (notesPath === void 0) return "";
+	const part = pkg.parts[notesPath];
+	if (part?.kind !== "xml") return "";
+	return elementsWithTag(part.nodes, "a:t").map(textContent).join("");
+}
+function readPptx(pkg) {
+	const found = [];
+	for (const [path, part] of Object.entries(pkg.parts)) {
+		const match = SLIDE_PATH.exec(path);
+		if (match === null) continue;
+		const captured = match[1];
+		if (captured === void 0) continue;
+		if (part.kind !== "xml") continue;
+		const index = Number(captured);
+		const text = elementsWithTag(part.nodes, "a:t").map(textContent).join("");
+		const shapes = elementsWithTag(part.nodes, "p:sp").map(readShape);
+		const tables = elementsWithTag(part.nodes, "a:tbl").map(readTable);
+		const notes = readNotes(pkg, path);
+		found.push({
+			index,
+			text,
+			shapes,
+			tables,
+			notes
+		});
+	}
+	found.sort((a, b) => a.index - b.index);
+	return { slides: found };
+}
+//#endregion
+//#region src/typed/xlsx.ts
+const XlsxCellSchema = zod.z.object({
+	reference: zod.z.string(),
+	value: zod.z.string(),
+	formula: zod.z.string().optional()
+});
+const XlsxSheetSchema = zod.z.object({
+	name: zod.z.string(),
+	cells: zod.z.array(XlsxCellSchema),
+	mergedRanges: zod.z.array(zod.z.string())
+});
+const DefinedNameSchema = zod.z.object({
+	name: zod.z.string(),
+	refersTo: zod.z.string()
+});
+const XlsxWorkbookSchema = zod.z.object({
+	sheets: zod.z.array(XlsxSheetSchema),
+	definedNames: zod.z.array(DefinedNameSchema)
+});
+const SHEET_PATH_RE = /^xl\/worksheets\/sheet(\d+)\.xml$/;
+function loadSharedStrings(pkg) {
+	const root = rootElement(pkg.parts["xl/sharedStrings.xml"]);
+	if (root === void 0) return [];
+	const strings = [];
+	for (const si of childrenWithTag(root, "si")) {
+		let value = "";
+		for (const t of elementsWithTag(si.children, "t")) value += textContent(t);
+		strings.push(value);
+	}
+	return strings;
+}
+function resolveRelTarget(target) {
+	if (target.startsWith("/")) return target.slice(1);
+	return `xl/${target}`;
+}
+function relTargets(pkg) {
+	const map = /* @__PURE__ */ new Map();
+	const rels = rootElement(pkg.parts["xl/_rels/workbook.xml.rels"]);
+	if (rels === void 0) return map;
+	for (const rel of childrenWithTag(rels, "Relationship")) {
+		const id = attr(rel, "Id");
+		const target = attr(rel, "Target");
+		if (id !== void 0 && target !== void 0) map.set(id, resolveRelTarget(target));
+	}
+	return map;
+}
+function resolveSheetNames(pkg) {
+	const names = /* @__PURE__ */ new Map();
+	const workbook = rootElement(pkg.parts["xl/workbook.xml"]);
+	if (workbook === void 0) return names;
+	const targets = relTargets(pkg);
+	for (const sheet of elementsWithTag(workbook.children, "sheet")) {
+		const name = attr(sheet, "name");
+		const rid = attr(sheet, "r:id");
+		if (name !== void 0 && rid !== void 0) {
+			const partName = targets.get(rid);
+			if (partName !== void 0) names.set(partName, name);
+		}
+	}
+	return names;
+}
+function readDefinedNames(pkg) {
+	const names = [];
+	const workbook = rootElement(pkg.parts["xl/workbook.xml"]);
+	if (workbook === void 0) return names;
+	for (const container of elementsWithTag(workbook.children, "definedNames")) for (const definedName of childrenWithTag(container, "definedName")) {
+		const name = attr(definedName, "name");
+		if (name === void 0) continue;
+		names.push({
+			name,
+			refersTo: textContent(definedName)
+		});
+	}
+	return names;
+}
+function sheetNumberOf(path) {
+	const match = SHEET_PATH_RE.exec(path);
+	const digits = match === null ? void 0 : match[1];
+	if (digits === void 0) return;
+	return Number.parseInt(digits, 10);
+}
+function readCell(cell, sharedStrings) {
+	const reference = attr(cell, "r");
+	if (reference === void 0) return;
+	const valueEl = childrenWithTag(cell, "v")[0];
+	if (valueEl === void 0) return;
+	const raw = textContent(valueEl);
+	let value;
+	if (attr(cell, "t") === "s") {
+		const index = Number.parseInt(raw, 10);
+		value = Number.isInteger(index) ? sharedStrings[index] : void 0;
+	} else value = raw;
+	if (value === void 0) return;
+	const projected = {
+		reference,
+		value
+	};
+	const formulaEl = childrenWithTag(cell, "f")[0];
+	if (formulaEl !== void 0) projected.formula = textContent(formulaEl);
+	return projected;
+}
+function readCells(worksheet, sharedStrings) {
+	const cells = [];
+	for (const row of elementsWithTag(worksheet.children, "row")) for (const cell of childrenWithTag(row, "c")) {
+		const projected = readCell(cell, sharedStrings);
+		if (projected !== void 0) cells.push(projected);
+	}
+	return cells;
+}
+function readMergedRanges(worksheet) {
+	const ranges = [];
+	for (const mergeCells of elementsWithTag(worksheet.children, "mergeCells")) for (const mergeCell of childrenWithTag(mergeCells, "mergeCell")) {
+		const ref = attr(mergeCell, "ref");
+		if (ref !== void 0) ranges.push(ref);
+	}
+	return ranges;
+}
+function readXlsx(pkg) {
+	const sharedStrings = loadSharedStrings(pkg);
+	const names = resolveSheetNames(pkg);
+	const definedNames = readDefinedNames(pkg);
+	const worksheets = Object.keys(pkg.parts).map((path) => ({
+		path,
+		number: sheetNumberOf(path)
+	})).filter((entry) => entry.number !== void 0).sort((a, b) => a.number - b.number);
+	const sheets = [];
+	for (const { path, number } of worksheets) {
+		const root = rootElement(pkg.parts[path]);
+		if (root === void 0) continue;
+		const name = names.get(path) ?? `Sheet${number}`;
+		sheets.push({
+			name,
+			cells: readCells(root, sharedStrings),
+			mergedRanges: readMergedRanges(root)
+		});
+	}
+	return {
+		sheets,
+		definedNames
+	};
+}
+//#endregion
+exports.AttributeSchema = AttributeSchema;
+exports.BinaryPartSchema = BinaryPartSchema;
+exports.CommentSchema = CommentSchema;
+exports.CompactPackageSchema = CompactPackageSchema;
+exports.CompactPartSchema = CompactPartSchema;
+exports.CompactXmlNodeSchema = CompactXmlNodeSchema;
+exports.DefinedNameSchema = DefinedNameSchema;
+exports.DocxDocumentSchema = DocxDocumentSchema;
+exports.FootnoteSchema = FootnoteSchema;
+exports.HyperlinkSchema = HyperlinkSchema;
+exports.ListMembershipSchema = ListMembershipSchema;
+exports.PackageSchema = PackageSchema;
+exports.ParagraphSchema = ParagraphSchema;
+exports.PartSchema = PartSchema;
+exports.PptxPresentationSchema = PptxPresentationSchema;
+exports.PptxTableCellSchema = PptxTableCellSchema;
+exports.PptxTableRowSchema = PptxTableRowSchema;
+exports.PptxTableSchema = PptxTableSchema;
+exports.RunSchema = RunSchema;
+exports.ShapeSchema = ShapeSchema;
+exports.SlideSchema = SlideSchema;
+exports.TableCellSchema = TableCellSchema;
+exports.TableRowSchema = TableRowSchema;
+exports.TableSchema = TableSchema;
+exports.XlsxCellSchema = XlsxCellSchema;
+exports.XlsxSheetSchema = XlsxSheetSchema;
+exports.XlsxWorkbookSchema = XlsxWorkbookSchema;
+exports.XmlCdataSchema = XmlCdataSchema;
+exports.XmlCommentSchema = XmlCommentSchema;
+exports.XmlDeclarationSchema = XmlDeclarationSchema;
+exports.XmlElementSchema = XmlElementSchema;
+exports.XmlNodeSchema = XmlNodeSchema;
+exports.XmlPartSchema = XmlPartSchema;
+exports.XmlPiSchema = XmlPiSchema;
+exports.XmlTextSchema = XmlTextSchema;
+exports.base64ToBytes = base64ToBytes;
+exports.buildXml = buildXml;
+exports.bytesToBase64 = bytesToBase64;
+exports.compactCodec = compactCodec;
+exports.compactPackageCodec = compactPackageCodec;
+exports.decodeCompactPackage = decodeCompactPackage;
+exports.decodePackage = decodePackage;
+exports.encodeCompactPackage = encodeCompactPackage;
+exports.encodePackage = encodePackage;
+exports.fromCompact = fromCompact;
+exports.isCompactXmlNode = isCompactXmlNode;
+exports.isXmlNode = isXmlNode;
+exports.packageCodec = packageCodec;
+exports.parsePackage = parsePackage;
+exports.parseXml = parseXml;
+exports.readDocx = readDocx;
+exports.readPptx = readPptx;
+exports.readXlsx = readXlsx;
+exports.serializePackage = serializePackage;
+exports.toCompact = toCompact;
+exports.unzipPackage = unzipPackage;
+exports.xmlCodec = xmlCodec;
+exports.zipPackage = zipPackage;