odf.js 0.0.0 → 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Joseph Mearman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.cjs

@@ -0,0 +1,356 @@
+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(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(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(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(entries) {
+	const data = {};
+	for (const [path, entry] of entries) if (entry.stored === true) data[path] = [entry.bytes, { level: 0 }];
+	else data[path] = entry.bytes;
+	return (0, fflate.zipSync)(data);
+}
+//#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
+const MIMETYPE_PART = "mimetype";
+const MANIFEST_PART = "META-INF/manifest.xml";
+function serializePackage(pkg) {
+	const remaining = new Map(Object.entries(pkg.parts));
+	const entries = [];
+	const mimetype = remaining.get(MIMETYPE_PART);
+	if (mimetype !== void 0) {
+		entries.push([MIMETYPE_PART, {
+			bytes: partToBytes(mimetype),
+			stored: true
+		}]);
+		remaining.delete(MIMETYPE_PART);
+	}
+	const manifest = remaining.get(MANIFEST_PART);
+	if (manifest !== void 0) {
+		entries.push([MANIFEST_PART, { bytes: partToBytes(manifest) }]);
+		remaining.delete(MANIFEST_PART);
+	}
+	for (const [path, part] of remaining) entries.push([path, { bytes: 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
+exports.AttributeSchema = AttributeSchema;
+exports.BinaryPartSchema = BinaryPartSchema;
+exports.PackageSchema = PackageSchema;
+exports.PartSchema = PartSchema;
+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.decodePackage = decodePackage;
+exports.encodePackage = encodePackage;
+exports.isXmlNode = isXmlNode;
+exports.packageCodec = packageCodec;
+exports.parsePackage = parsePackage;
+exports.parseXml = parseXml;
+exports.serializePackage = serializePackage;
+exports.unzipPackage = unzipPackage;
+exports.xmlCodec = xmlCodec;
+exports.zipPackage = zipPackage;

package/dist/index.d.cts

@@ -0,0 +1,286 @@
+import { z } from "zod";
+//#region src/model/node.d.ts
+declare const AttributeSchema: z.ZodObject<{
+  name: z.ZodString;
+  value: z.ZodString;
+}, z.core.$strip>;
+type Attribute = z.infer<typeof AttributeSchema>;
+declare const XmlTextSchema: z.ZodObject<{
+  type: z.ZodLiteral<"text">;
+  value: z.ZodString;
+}, z.core.$strip>;
+type XmlText = z.infer<typeof XmlTextSchema>;
+declare const XmlCdataSchema: z.ZodObject<{
+  type: z.ZodLiteral<"cdata">;
+  value: z.ZodString;
+}, z.core.$strip>;
+type XmlCdata = z.infer<typeof XmlCdataSchema>;
+declare const XmlCommentSchema: z.ZodObject<{
+  type: z.ZodLiteral<"comment">;
+  value: z.ZodString;
+}, z.core.$strip>;
+type XmlComment = z.infer<typeof XmlCommentSchema>;
+declare const XmlDeclarationSchema: z.ZodObject<{
+  type: z.ZodLiteral<"declaration">;
+  attributes: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    value: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type XmlDeclaration = z.infer<typeof XmlDeclarationSchema>;
+declare const XmlPiSchema: z.ZodObject<{
+  type: z.ZodLiteral<"pi">;
+  target: z.ZodString;
+  content: z.ZodString;
+}, z.core.$strip>;
+type XmlPi = z.infer<typeof XmlPiSchema>;
+interface XmlElement {
+  type: 'element';
+  tag: string;
+  attributes: Attribute[];
+  children: XmlNode[];
+}
+type XmlNode = XmlText | XmlCdata | XmlComment | XmlDeclaration | XmlPi | XmlElement;
+declare function isXmlNode(value: unknown): value is XmlNode;
+declare const XmlElementSchema: z.ZodObject<{
+  type: z.ZodLiteral<"element">;
+  tag: z.ZodString;
+  attributes: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    value: z.ZodString;
+  }, z.core.$strip>>;
+  children: z.ZodArray<z.ZodCustom<XmlNode, XmlNode>>;
+}, z.core.$strip>;
+declare const XmlNodeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  type: z.ZodLiteral<"text">;
+  value: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"cdata">;
+  value: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"comment">;
+  value: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"declaration">;
+  attributes: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    value: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"pi">;
+  target: z.ZodString;
+  content: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"element">;
+  tag: z.ZodString;
+  attributes: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    value: z.ZodString;
+  }, z.core.$strip>>;
+  children: z.ZodArray<z.ZodCustom<XmlNode, XmlNode>>;
+}, z.core.$strip>], "type">;
+//#endregion
+//#region src/model/package.d.ts
+declare const XmlPartSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"xml">;
+  nodes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    value: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"cdata">;
+    value: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"comment">;
+    value: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"declaration">;
+    attributes: z.ZodArray<z.ZodObject<{
+      name: z.ZodString;
+      value: z.ZodString;
+    }, z.core.$strip>>;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"pi">;
+    target: z.ZodString;
+    content: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"element">;
+    tag: z.ZodString;
+    attributes: z.ZodArray<z.ZodObject<{
+      name: z.ZodString;
+      value: z.ZodString;
+    }, z.core.$strip>>;
+    children: z.ZodArray<z.ZodCustom<XmlNode, XmlNode>>;
+  }, z.core.$strip>], "type">>;
+}, z.core.$strip>;
+type XmlPart = z.infer<typeof XmlPartSchema>;
+declare const BinaryPartSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"binary">;
+  base64: z.ZodString;
+}, z.core.$strip>;
+type BinaryPart = z.infer<typeof BinaryPartSchema>;
+declare const PartSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  kind: z.ZodLiteral<"xml">;
+  nodes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    value: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"cdata">;
+    value: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"comment">;
+    value: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"declaration">;
+    attributes: z.ZodArray<z.ZodObject<{
+      name: z.ZodString;
+      value: z.ZodString;
+    }, z.core.$strip>>;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"pi">;
+    target: z.ZodString;
+    content: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"element">;
+    tag: z.ZodString;
+    attributes: z.ZodArray<z.ZodObject<{
+      name: z.ZodString;
+      value: z.ZodString;
+    }, z.core.$strip>>;
+    children: z.ZodArray<z.ZodCustom<XmlNode, XmlNode>>;
+  }, z.core.$strip>], "type">>;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"binary">;
+  base64: z.ZodString;
+}, z.core.$strip>], "kind">;
+type Part = z.infer<typeof PartSchema>;
+declare const PackageSchema: z.ZodObject<{
+  parts: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"xml">;
+    nodes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+      type: z.ZodLiteral<"text">;
+      value: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"cdata">;
+      value: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"comment">;
+      value: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"declaration">;
+      attributes: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        value: z.ZodString;
+      }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"pi">;
+      target: z.ZodString;
+      content: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"element">;
+      tag: z.ZodString;
+      attributes: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        value: z.ZodString;
+      }, z.core.$strip>>;
+      children: z.ZodArray<z.ZodCustom<XmlNode, XmlNode>>;
+    }, z.core.$strip>], "type">>;
+  }, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"binary">;
+    base64: z.ZodString;
+  }, z.core.$strip>], "kind">>;
+}, z.core.$strip>;
+type Package = z.infer<typeof PackageSchema>;
+//#endregion
+//#region src/codec.d.ts
+declare const xmlCodec: z.ZodCodec<z.ZodString, z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+  type: z.ZodLiteral<"text">;
+  value: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"cdata">;
+  value: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"comment">;
+  value: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"declaration">;
+  attributes: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    value: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"pi">;
+  target: z.ZodString;
+  content: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"element">;
+  tag: z.ZodString;
+  attributes: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    value: z.ZodString;
+  }, z.core.$strip>>;
+  children: z.ZodArray<z.ZodCustom<XmlNode, XmlNode>>;
+}, z.core.$strip>], "type">>>;
+declare const packageCodec: z.ZodCodec<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>, z.ZodObject<{
+  parts: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"xml">;
+    nodes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+      type: z.ZodLiteral<"text">;
+      value: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"cdata">;
+      value: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"comment">;
+      value: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"declaration">;
+      attributes: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        value: z.ZodString;
+      }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"pi">;
+      target: z.ZodString;
+      content: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"element">;
+      tag: z.ZodString;
+      attributes: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        value: z.ZodString;
+      }, z.core.$strip>>;
+      children: z.ZodArray<z.ZodCustom<XmlNode, XmlNode>>;
+    }, z.core.$strip>], "type">>;
+  }, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"binary">;
+    base64: z.ZodString;
+  }, z.core.$strip>], "kind">>;
+}, z.core.$strip>>;
+declare function decodePackage(bytes: Uint8Array<ArrayBuffer>): Package;
+declare function encodePackage(pkg: Package): Uint8Array<ArrayBuffer>;
+//#endregion
+//#region src/package-io/read.d.ts
+declare function parsePackage(bytes: Uint8Array<ArrayBuffer>): Package;
+//#endregion
+//#region src/package-io/write.d.ts
+declare function serializePackage(pkg: Package): Uint8Array<ArrayBuffer>;
+//#endregion
+//#region src/xml/parse.d.ts
+declare function parseXml(xml: string): XmlNode[];
+//#endregion
+//#region src/xml/build.d.ts
+declare function buildXml(nodes: XmlNode[]): string;
+//#endregion
+//#region src/zip.d.ts
+interface ZipEntry {
+  readonly bytes: Uint8Array<ArrayBuffer>;
+  readonly stored?: boolean;
+}
+declare function unzipPackage(bytes: Uint8Array<ArrayBuffer>): Record<string, Uint8Array<ArrayBuffer>>;
+declare function zipPackage(entries: readonly (readonly [string, ZipEntry])[]): Uint8Array<ArrayBuffer>;
+//#endregion
+//#region src/util/base64.d.ts
+declare function bytesToBase64(bytes: Uint8Array<ArrayBuffer>): string;
+declare function base64ToBytes(b64: string): Uint8Array<ArrayBuffer>;
+//#endregion
+export { type Attribute, AttributeSchema, type BinaryPart, BinaryPartSchema, type Package, PackageSchema, type Part, PartSchema, type XmlCdata, XmlCdataSchema, type XmlComment, XmlCommentSchema, type XmlDeclaration, XmlDeclarationSchema, type XmlElement, XmlElementSchema, type XmlNode, XmlNodeSchema, type XmlPart, XmlPartSchema, type XmlPi, XmlPiSchema, type XmlText, XmlTextSchema, type ZipEntry, base64ToBytes, buildXml, bytesToBase64, decodePackage, encodePackage, isXmlNode, packageCodec, parsePackage, parseXml, serializePackage, unzipPackage, xmlCodec, zipPackage };

package/dist/index.d.ts

@@ -0,0 +1,286 @@
+import { z } from "zod";
+//#region src/model/node.d.ts
+declare const AttributeSchema: z.ZodObject<{
+  name: z.ZodString;
+  value: z.ZodString;
+}, z.core.$strip>;
+type Attribute = z.infer<typeof AttributeSchema>;
+declare const XmlTextSchema: z.ZodObject<{
+  type: z.ZodLiteral<"text">;
+  value: z.ZodString;
+}, z.core.$strip>;
+type XmlText = z.infer<typeof XmlTextSchema>;
+declare const XmlCdataSchema: z.ZodObject<{
+  type: z.ZodLiteral<"cdata">;
+  value: z.ZodString;
+}, z.core.$strip>;
+type XmlCdata = z.infer<typeof XmlCdataSchema>;
+declare const XmlCommentSchema: z.ZodObject<{
+  type: z.ZodLiteral<"comment">;
+  value: z.ZodString;
+}, z.core.$strip>;
+type XmlComment = z.infer<typeof XmlCommentSchema>;
+declare const XmlDeclarationSchema: z.ZodObject<{
+  type: z.ZodLiteral<"declaration">;
+  attributes: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    value: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type XmlDeclaration = z.infer<typeof XmlDeclarationSchema>;
+declare const XmlPiSchema: z.ZodObject<{
+  type: z.ZodLiteral<"pi">;
+  target: z.ZodString;
+  content: z.ZodString;
+}, z.core.$strip>;
+type XmlPi = z.infer<typeof XmlPiSchema>;
+interface XmlElement {
+  type: 'element';
+  tag: string;
+  attributes: Attribute[];
+  children: XmlNode[];
+}
+type XmlNode = XmlText | XmlCdata | XmlComment | XmlDeclaration | XmlPi | XmlElement;
+declare function isXmlNode(value: unknown): value is XmlNode;
+declare const XmlElementSchema: z.ZodObject<{
+  type: z.ZodLiteral<"element">;
+  tag: z.ZodString;
+  attributes: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    value: z.ZodString;
+  }, z.core.$strip>>;
+  children: z.ZodArray<z.ZodCustom<XmlNode, XmlNode>>;
+}, z.core.$strip>;
+declare const XmlNodeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  type: z.ZodLiteral<"text">;
+  value: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"cdata">;
+  value: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"comment">;
+  value: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"declaration">;
+  attributes: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    value: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"pi">;
+  target: z.ZodString;
+  content: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"element">;
+  tag: z.ZodString;
+  attributes: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    value: z.ZodString;
+  }, z.core.$strip>>;
+  children: z.ZodArray<z.ZodCustom<XmlNode, XmlNode>>;
+}, z.core.$strip>], "type">;
+//#endregion
+//#region src/model/package.d.ts
+declare const XmlPartSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"xml">;
+  nodes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    value: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"cdata">;
+    value: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"comment">;
+    value: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"declaration">;
+    attributes: z.ZodArray<z.ZodObject<{
+      name: z.ZodString;
+      value: z.ZodString;
+    }, z.core.$strip>>;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"pi">;
+    target: z.ZodString;
+    content: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"element">;
+    tag: z.ZodString;
+    attributes: z.ZodArray<z.ZodObject<{
+      name: z.ZodString;
+      value: z.ZodString;
+    }, z.core.$strip>>;
+    children: z.ZodArray<z.ZodCustom<XmlNode, XmlNode>>;
+  }, z.core.$strip>], "type">>;
+}, z.core.$strip>;
+type XmlPart = z.infer<typeof XmlPartSchema>;
+declare const BinaryPartSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"binary">;
+  base64: z.ZodString;
+}, z.core.$strip>;
+type BinaryPart = z.infer<typeof BinaryPartSchema>;
+declare const PartSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  kind: z.ZodLiteral<"xml">;
+  nodes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    value: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"cdata">;
+    value: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"comment">;
+    value: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"declaration">;
+    attributes: z.ZodArray<z.ZodObject<{
+      name: z.ZodString;
+      value: z.ZodString;
+    }, z.core.$strip>>;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"pi">;
+    target: z.ZodString;
+    content: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"element">;
+    tag: z.ZodString;
+    attributes: z.ZodArray<z.ZodObject<{
+      name: z.ZodString;
+      value: z.ZodString;
+    }, z.core.$strip>>;
+    children: z.ZodArray<z.ZodCustom<XmlNode, XmlNode>>;
+  }, z.core.$strip>], "type">>;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"binary">;
+  base64: z.ZodString;
+}, z.core.$strip>], "kind">;
+type Part = z.infer<typeof PartSchema>;
+declare const PackageSchema: z.ZodObject<{
+  parts: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"xml">;
+    nodes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+      type: z.ZodLiteral<"text">;
+      value: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"cdata">;
+      value: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"comment">;
+      value: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"declaration">;
+      attributes: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        value: z.ZodString;
+      }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"pi">;
+      target: z.ZodString;
+      content: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"element">;
+      tag: z.ZodString;
+      attributes: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        value: z.ZodString;
+      }, z.core.$strip>>;
+      children: z.ZodArray<z.ZodCustom<XmlNode, XmlNode>>;
+    }, z.core.$strip>], "type">>;
+  }, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"binary">;
+    base64: z.ZodString;
+  }, z.core.$strip>], "kind">>;
+}, z.core.$strip>;
+type Package = z.infer<typeof PackageSchema>;
+//#endregion
+//#region src/codec.d.ts
+declare const xmlCodec: z.ZodCodec<z.ZodString, z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+  type: z.ZodLiteral<"text">;
+  value: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"cdata">;
+  value: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"comment">;
+  value: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"declaration">;
+  attributes: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    value: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"pi">;
+  target: z.ZodString;
+  content: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"element">;
+  tag: z.ZodString;
+  attributes: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    value: z.ZodString;
+  }, z.core.$strip>>;
+  children: z.ZodArray<z.ZodCustom<XmlNode, XmlNode>>;
+}, z.core.$strip>], "type">>>;
+declare const packageCodec: z.ZodCodec<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>, z.ZodObject<{
+  parts: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"xml">;
+    nodes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+      type: z.ZodLiteral<"text">;
+      value: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"cdata">;
+      value: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"comment">;
+      value: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"declaration">;
+      attributes: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        value: z.ZodString;
+      }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"pi">;
+      target: z.ZodString;
+      content: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"element">;
+      tag: z.ZodString;
+      attributes: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        value: z.ZodString;
+      }, z.core.$strip>>;
+      children: z.ZodArray<z.ZodCustom<XmlNode, XmlNode>>;
+    }, z.core.$strip>], "type">>;
+  }, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"binary">;
+    base64: z.ZodString;
+  }, z.core.$strip>], "kind">>;
+}, z.core.$strip>>;
+declare function decodePackage(bytes: Uint8Array<ArrayBuffer>): Package;
+declare function encodePackage(pkg: Package): Uint8Array<ArrayBuffer>;
+//#endregion
+//#region src/package-io/read.d.ts
+declare function parsePackage(bytes: Uint8Array<ArrayBuffer>): Package;
+//#endregion
+//#region src/package-io/write.d.ts
+declare function serializePackage(pkg: Package): Uint8Array<ArrayBuffer>;
+//#endregion
+//#region src/xml/parse.d.ts
+declare function parseXml(xml: string): XmlNode[];
+//#endregion
+//#region src/xml/build.d.ts
+declare function buildXml(nodes: XmlNode[]): string;
+//#endregion
+//#region src/zip.d.ts
+interface ZipEntry {
+  readonly bytes: Uint8Array<ArrayBuffer>;
+  readonly stored?: boolean;
+}
+declare function unzipPackage(bytes: Uint8Array<ArrayBuffer>): Record<string, Uint8Array<ArrayBuffer>>;
+declare function zipPackage(entries: readonly (readonly [string, ZipEntry])[]): Uint8Array<ArrayBuffer>;
+//#endregion
+//#region src/util/base64.d.ts
+declare function bytesToBase64(bytes: Uint8Array<ArrayBuffer>): string;
+declare function base64ToBytes(b64: string): Uint8Array<ArrayBuffer>;
+//#endregion
+export { type Attribute, AttributeSchema, type BinaryPart, BinaryPartSchema, type Package, PackageSchema, type Part, PartSchema, type XmlCdata, XmlCdataSchema, type XmlComment, XmlCommentSchema, type XmlDeclaration, XmlDeclarationSchema, type XmlElement, XmlElementSchema, type XmlNode, XmlNodeSchema, type XmlPart, XmlPartSchema, type XmlPi, XmlPiSchema, type XmlText, XmlTextSchema, type ZipEntry, base64ToBytes, buildXml, bytesToBase64, decodePackage, encodePackage, isXmlNode, packageCodec, parsePackage, parseXml, serializePackage, unzipPackage, xmlCodec, zipPackage };

package/dist/index.js

@@ -0,0 +1,331 @@
+import { z } from "zod";
+import { XMLBuilder, XMLParser } from "fast-xml-parser";
+import { unzipSync, zipSync } from "fflate";
+//#region src/model/node.ts
+const AttributeSchema = z.object({
+	name: z.string(),
+	value: z.string()
+});
+const XmlTextSchema = z.object({
+	type: z.literal("text"),
+	value: z.string()
+});
+const XmlCdataSchema = z.object({
+	type: z.literal("cdata"),
+	value: z.string()
+});
+const XmlCommentSchema = z.object({
+	type: z.literal("comment"),
+	value: z.string()
+});
+const XmlDeclarationSchema = z.object({
+	type: z.literal("declaration"),
+	attributes: z.array(AttributeSchema)
+});
+const XmlPiSchema = z.object({
+	type: z.literal("pi"),
+	target: z.string(),
+	content: 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 = z.object({
+	type: z.literal("element"),
+	tag: z.string(),
+	attributes: z.array(AttributeSchema),
+	children: z.array(z.custom(isXmlNode))
+});
+const XmlNodeSchema = z.discriminatedUnion("type", [
+	XmlTextSchema,
+	XmlCdataSchema,
+	XmlCommentSchema,
+	XmlDeclarationSchema,
+	XmlPiSchema,
+	XmlElementSchema
+]);
+//#endregion
+//#region src/model/package.ts
+const XmlPartSchema = z.object({
+	kind: z.literal("xml"),
+	nodes: z.array(XmlNodeSchema)
+});
+const BinaryPartSchema = z.object({
+	kind: z.literal("binary"),
+	base64: z.string()
+});
+const PartSchema = z.discriminatedUnion("kind", [XmlPartSchema, BinaryPartSchema]);
+const PackageSchema = z.object({ parts: z.record(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 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(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(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(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 unzipSync(bytes);
+}
+function zipPackage(entries) {
+	const data = {};
+	for (const [path, entry] of entries) if (entry.stored === true) data[path] = [entry.bytes, { level: 0 }];
+	else data[path] = entry.bytes;
+	return zipSync(data);
+}
+//#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 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
+const MIMETYPE_PART = "mimetype";
+const MANIFEST_PART = "META-INF/manifest.xml";
+function serializePackage(pkg) {
+	const remaining = new Map(Object.entries(pkg.parts));
+	const entries = [];
+	const mimetype = remaining.get(MIMETYPE_PART);
+	if (mimetype !== void 0) {
+		entries.push([MIMETYPE_PART, {
+			bytes: partToBytes(mimetype),
+			stored: true
+		}]);
+		remaining.delete(MIMETYPE_PART);
+	}
+	const manifest = remaining.get(MANIFEST_PART);
+	if (manifest !== void 0) {
+		entries.push([MANIFEST_PART, { bytes: partToBytes(manifest) }]);
+		remaining.delete(MANIFEST_PART);
+	}
+	for (const [path, part] of remaining) entries.push([path, { bytes: 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 = z.codec(z.string(), z.array(XmlNodeSchema), {
+	decode: (xml) => parseXml(xml),
+	encode: (nodes) => buildXml(nodes)
+});
+const packageCodec = z.codec(z.instanceof(Uint8Array), PackageSchema, {
+	decode: (bytes) => parsePackage(bytes),
+	encode: (pkg) => serializePackage(pkg)
+});
+function decodePackage(bytes) {
+	return z.decode(packageCodec, bytes);
+}
+function encodePackage(pkg) {
+	return z.encode(packageCodec, pkg);
+}
+//#endregion
+export { AttributeSchema, BinaryPartSchema, PackageSchema, PartSchema, XmlCdataSchema, XmlCommentSchema, XmlDeclarationSchema, XmlElementSchema, XmlNodeSchema, XmlPartSchema, XmlPiSchema, XmlTextSchema, base64ToBytes, buildXml, bytesToBase64, decodePackage, encodePackage, isXmlNode, packageCodec, parsePackage, parseXml, serializePackage, unzipPackage, xmlCodec, zipPackage };

package/package.json

@@ -1,5 +1,89 @@
 {
   "name": "odf.js",
-  "version": "0.0.0",
-  "private": false
+  "version": "1.0.0",
+  "description": "Type-safe, lossless round-trip conversion between OpenDocument Format packages (odt, ods, odp) and JSON, hand-written and dependency-minimal, built on Zod 4 codecs.",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ExaDev/odf.js.git"
+  },
+  "homepage": "https://github.com/ExaDev/odf.js#readme",
+  "bugs": {
+    "url": "https://github.com/ExaDev/odf.js/issues"
+  },
+  "exports": {
+    ".": {
+      "types": {
+        "import": "./dist/index.d.ts",
+        "require": "./dist/index.d.cts"
+      },
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true,
+    "registry": "https://registry.npmjs.org/"
+  },
+  "sideEffects": false,
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "prepublishOnly": "pnpm run lint && pnpm run typecheck && tsdown && publint && attw --pack",
+    "lint": "eslint . --max-warnings 0",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --project unit",
+    "test:watch": "vitest --project unit",
+    "test:coverage": "vitest run --project unit --coverage",
+    "test:smoke": "tsdown && vitest run --project smoke",
+    "prepare": "husky",
+    "release": "semantic-release"
+  },
+  "keywords": [
+    "odf",
+    "opendocument",
+    "odt",
+    "ods",
+    "odp",
+    "round-trip",
+    "zod",
+    "codec"
+  ],
+  "license": "MIT",
+  "packageManager": "pnpm@11.6.0",
+  "dependencies": {
+    "document-content-model": "^1.1.0",
+    "fast-xml-parser": "^5.10.1",
+    "fflate": "^0.8.3",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.18.5",
+    "@commitlint/cli": "^21.2.1",
+    "@commitlint/config-conventional": "^21.2.0",
+    "@eslint/js": "^10.0.1",
+    "@semantic-release/changelog": "^7.0.0",
+    "@semantic-release/git": "^11.0.1",
+    "@types/node": "^26.1.1",
+    "@vitest/coverage-v8": "^4.1.10",
+    "eslint": "^10.8.0",
+    "globals": "^17.8.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^17.2.0",
+    "publint": "^0.3.21",
+    "semantic-release": "^25.0.8",
+    "tsdown": "^0.22.13",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.65.0",
+    "vitest": "^4.1.10"
+  }
 }