ooxml.js 2.4.0 → 2.5.0

package/README.md

@@ -6,6 +6,35 @@
 
 An OOXML file is a ZIP archive of parts (an OPC "package"): `[Content_Types].xml`, relationships (`*.rels`), XML content parts, and binary parts (images, embedded objects). `ooxml.js` decodes the **whole package** into a faithful JSON model and encodes it back — part for part — so `encode(decode(file))` reproduces the original content.
 
+```mermaid
+graph TD
+    schema("document-schema.js")
+    ooxml("ooxml.js")
+    odf("odf.js")
+    pdfcodec("pdf-codec")
+    documents("documents.js")
+    cli("document-cli")
+
+    schema --> ooxml
+    schema --> odf
+    schema --> pdfcodec
+    schema --> documents
+    ooxml --> documents
+    odf --> documents
+    pdfcodec --> documents
+    documents --> cli
+    odf --> cli
+
+    click schema "https://github.com/ExaDev/document-schema.js" "document-schema.js"
+    click ooxml "https://github.com/ExaDev/ooxml.js" "ooxml.js"
+    click odf "https://github.com/ExaDev/odf.js" "odf.js"
+    click pdfcodec "https://github.com/ExaDev/pdf-codec" "pdf-codec"
+    click documents "https://github.com/ExaDev/documents.js" "documents.js"
+    click cli "https://github.com/ExaDev/document-cli" "document-cli"
+
+    style ooxml fill:#f9a825,stroke:#333,stroke-width:3px
+```
+
 ## Why
 
 Semantic, typed document models are lossy and one-directional: they cannot round-trip. True round-trip requires capturing every part, relationship, and binary byte-for-byte at the content level. `ooxml.js` provides that lossless generic foundation, with ergonomic typed reading views (`Document`, `Presentation`, `Workbook`) layered on top for convenient access.
@@ -69,6 +98,13 @@ const content = readXlsxContent(decodePackage(bytes)); // ContentDocument, kind:
 const pkg = buildXlsxPackage(content); // a fresh Package built from scratch, not a write-back into `pkg`
 ```
 
+Every module under `src/` is also importable directly, by the same path it has relative to `src/`, without going through the barrel — useful for a caller that only needs one small piece and wants to avoid pulling in the rest:
+
+```ts
+import { bytesToBase64, base64ToBytes } from 'ooxml.js/util/base64';
+import { readXlsxContent } from 'ooxml.js/typed/xlsx/content';
+```
+
 ## The ooxml.js format
 
 The verbose `Package` JSON is faithful but repetitive: every node repeats its `type`/`tag`/`attributes`/`children` keys, and tag and namespace strings recur thousands of times across a real document. **The ooxml.js format** is a compact, still-plain-JSON alternative — tuple-encoded nodes plus a single interned string table — that composes on top of `packageCodec` without changing what it guarantees:
@@ -152,7 +188,7 @@ const out = encodeCompactPackage(compact); // CompactPackage -> OOXML bytes dire
 ## Build, test, and lint
 
 ```sh
-pnpm build          # tsdown -> dist/ (ESM + CJS + .d.ts, via tsdown.config.ts)
+pnpm build          # tsdown -> dist/ (one ESM + CJS + .d.ts set per source module, via tsdown.config.ts)
 pnpm lint           # eslint . --max-warnings 0
 pnpm typecheck      # tsc --noEmit
 pnpm test           # vitest run
@@ -162,7 +198,9 @@ pnpm test:smoke     # builds dist/, then runs test/smoke.test.mjs to verify the
 
 `pnpm prepublishOnly` runs `lint`, `typecheck`, `tsdown`, `publint`, and `@arethetypeswrong/cli` (`attw --pack`) — the full publish-readiness check — before a release.
 
-`test/smoke.test.mjs` loads the actual built `dist/index.js` (ESM) and `dist/index.cjs` (CJS) artifacts and checks they load and behave identically — a check none of `vitest`'s normal run, `tsc`, `publint`, or `attw` can do, since those either run against source or statically analyse package metadata without executing the compiled output. `vitest.config.ts` defines it as its own `smoke` project (vitest's `test.projects`), separate from the `unit` project (`src/**/*.test.ts`); `pnpm test`/`test:watch` pass `--project unit` and `pnpm test:smoke` passes `--project smoke` after `tsdown` rebuilds `dist/`, so neither run touches the other project's files.
+`test/smoke.test.mjs` loads the actual built `dist/index.js` (ESM) and `dist/index.cjs` (CJS) barrel artifacts and checks they load and behave identically — a check none of `vitest`'s normal run, `tsc`, `publint`, or `attw` can do, since those either run against source or statically analyse package metadata without executing the compiled output. `vitest.config.ts` defines it as its own `smoke` project (vitest's `test.projects`), separate from the `unit` project (`src/**/*.test.ts`); `pnpm test`/`test:watch` pass `--project unit` and `pnpm test:smoke` passes `--project smoke` after `tsdown` rebuilds `dist/`, so neither run touches the other project's files.
+
+`tsdown.config.ts`'s `entry` is a glob (`src/**/*.ts`, excluding tests and `.d.ts` files) rather than a single `src/index.ts` bundle, so `dist/` holds one ESM/CJS/`.d.ts`/`.d.cts` set per source module, laid out under `dist/` at the same relative path each module has under `src/` (pinned via the sibling `root: 'src'` option). `dist/index.js`/`dist/index.cjs` are just the file `tsdown` produces for `src/index.ts`, matched by that same glob — they still re-export everything the barrel always has. `package.json`'s `exports` map adds a `"./*"` wildcard alongside `"."`, so any module is importable by its own path, not only through the barrel.
 
 To run a single test file: `pnpm vitest run src/typed/docx.test.ts`.
 

package/dist/codec.cjs

@@ -0,0 +1,28 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_model_node = require("./model/node.cjs");
+const require_model_package = require("./model/package.cjs");
+const require_xml_parse = require("./xml/parse.cjs");
+const require_package_io_read = require("./package-io/read.cjs");
+const require_xml_build = require("./xml/build.cjs");
+const require_package_io_write = require("./package-io/write.cjs");
+let zod = require("zod");
+//#region src/codec.ts
+const xmlCodec = zod.z.codec(zod.z.string(), zod.z.array(require_model_node.XmlNodeSchema), {
+	decode: (xml) => require_xml_parse.parseXml(xml),
+	encode: (nodes) => require_xml_build.buildXml(nodes)
+});
+const packageCodec = zod.z.codec(zod.z.instanceof(Uint8Array), require_model_package.PackageSchema, {
+	decode: (bytes) => require_package_io_read.parsePackage(bytes),
+	encode: (pkg) => require_package_io_write.serializePackage(pkg)
+});
+function decodePackage(bytes) {
+	return zod.z.decode(packageCodec, bytes);
+}
+function encodePackage(pkg) {
+	return zod.z.encode(packageCodec, pkg);
+}
+//#endregion
+exports.decodePackage = decodePackage;
+exports.encodePackage = encodePackage;
+exports.packageCodec = packageCodec;
+exports.xmlCodec = xmlCodec;

package/dist/codec.d.cts

@@ -0,0 +1,72 @@
+import { d as XmlNode } from "./node-CkBWRjNR.cjs";
+import { r as Package } from "./package-L24lkba-.cjs";
+import { z } from "zod";
+//#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
+export { type XmlNode, decodePackage, encodePackage, packageCodec, xmlCodec };

package/dist/codec.d.ts

@@ -0,0 +1,72 @@
+import { d as XmlNode } from "./node-CkBWRjNR.js";
+import { r as Package } from "./package-BUojjTXf.js";
+import { z } from "zod";
+//#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
+export { type XmlNode, decodePackage, encodePackage, packageCodec, xmlCodec };

package/dist/codec.js

@@ -0,0 +1,24 @@
+import { XmlNodeSchema } from "./model/node.js";
+import { PackageSchema } from "./model/package.js";
+import { parseXml } from "./xml/parse.js";
+import { parsePackage } from "./package-io/read.js";
+import { buildXml } from "./xml/build.js";
+import { serializePackage } from "./package-io/write.js";
+import { z } from "zod";
+//#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 { decodePackage, encodePackage, packageCodec, xmlCodec };

package/dist/compact.cjs

@@ -0,0 +1,162 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_model_package = require("./model/package.cjs");
+const require_codec = require("./codec.cjs");
+let zod = require("zod");
+//#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(require_model_package.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(require_codec.decodePackage(bytes)),
+	encode: (cpkg) => require_codec.encodePackage(fromCompact(cpkg))
+});
+function decodeCompactPackage(bytes) {
+	return zod.z.decode(compactPackageCodec, bytes);
+}
+function encodeCompactPackage(cpkg) {
+	return zod.z.encode(compactPackageCodec, cpkg);
+}
+//#endregion
+exports.CompactPackageSchema = CompactPackageSchema;
+exports.CompactPartSchema = CompactPartSchema;
+exports.CompactXmlNodeSchema = CompactXmlNodeSchema;
+exports.compactCodec = compactCodec;
+exports.compactPackageCodec = compactPackageCodec;
+exports.decodeCompactPackage = decodeCompactPackage;
+exports.encodeCompactPackage = encodeCompactPackage;
+exports.fromCompact = fromCompact;
+exports.isCompactXmlNode = isCompactXmlNode;
+exports.toCompact = toCompact;

package/dist/compact.d.cts

@@ -0,0 +1,70 @@
+import { d as XmlNode } from "./node-CkBWRjNR.cjs";
+import { r as Package } from "./package-L24lkba-.cjs";
+import { z } from "zod";
+//#region src/compact.d.ts
+type CompactAttrPairs = number[];
+type CompactElement = [0, number, CompactAttrPairs, CompactXmlNode[]];
+type CompactText = [1, number];
+type CompactCdata = [2, number];
+type CompactComment = [3, number];
+type CompactDeclaration = [4, CompactAttrPairs];
+type CompactPi = [5, number, number];
+type CompactXmlNode = CompactElement | CompactText | CompactCdata | CompactComment | CompactDeclaration | CompactPi;
+declare function isCompactXmlNode(value: unknown): value is CompactXmlNode;
+declare const CompactXmlNodeSchema: z.ZodCustom<CompactXmlNode, CompactXmlNode>;
+declare const CompactPartSchema: z.ZodUnion<readonly [z.ZodArray<z.ZodCustom<CompactXmlNode, CompactXmlNode>>, z.ZodNumber]>;
+type CompactPart = z.infer<typeof CompactPartSchema>;
+declare const CompactPackageSchema: z.ZodObject<{
+  s: z.ZodArray<z.ZodString>;
+  p: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodArray<z.ZodCustom<CompactXmlNode, CompactXmlNode>>, z.ZodNumber]>>;
+}, z.core.$strip>;
+type CompactPackage = z.infer<typeof CompactPackageSchema>;
+declare const compactCodec: z.ZodCodec<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>, z.ZodObject<{
+  s: z.ZodArray<z.ZodString>;
+  p: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodArray<z.ZodCustom<CompactXmlNode, CompactXmlNode>>, z.ZodNumber]>>;
+}, z.core.$strip>>;
+declare function toCompact(pkg: Package): CompactPackage;
+declare function fromCompact(cpkg: CompactPackage): Package;
+declare const compactPackageCodec: z.ZodCodec<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>, z.ZodObject<{
+  s: z.ZodArray<z.ZodString>;
+  p: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodArray<z.ZodCustom<CompactXmlNode, CompactXmlNode>>, z.ZodNumber]>>;
+}, z.core.$strip>>;
+declare function decodeCompactPackage(bytes: Uint8Array<ArrayBuffer>): CompactPackage;
+declare function encodeCompactPackage(cpkg: CompactPackage): Uint8Array<ArrayBuffer>;
+//#endregion
+export { CompactAttrPairs, CompactCdata, CompactComment, CompactDeclaration, CompactElement, CompactPackage, CompactPackageSchema, CompactPart, CompactPartSchema, CompactPi, CompactText, CompactXmlNode, CompactXmlNodeSchema, compactCodec, compactPackageCodec, decodeCompactPackage, encodeCompactPackage, fromCompact, isCompactXmlNode, toCompact };

package/dist/compact.d.ts

@@ -0,0 +1,70 @@
+import { d as XmlNode } from "./node-CkBWRjNR.js";
+import { r as Package } from "./package-BUojjTXf.js";
+import { z } from "zod";
+//#region src/compact.d.ts
+type CompactAttrPairs = number[];
+type CompactElement = [0, number, CompactAttrPairs, CompactXmlNode[]];
+type CompactText = [1, number];
+type CompactCdata = [2, number];
+type CompactComment = [3, number];
+type CompactDeclaration = [4, CompactAttrPairs];
+type CompactPi = [5, number, number];
+type CompactXmlNode = CompactElement | CompactText | CompactCdata | CompactComment | CompactDeclaration | CompactPi;
+declare function isCompactXmlNode(value: unknown): value is CompactXmlNode;
+declare const CompactXmlNodeSchema: z.ZodCustom<CompactXmlNode, CompactXmlNode>;
+declare const CompactPartSchema: z.ZodUnion<readonly [z.ZodArray<z.ZodCustom<CompactXmlNode, CompactXmlNode>>, z.ZodNumber]>;
+type CompactPart = z.infer<typeof CompactPartSchema>;
+declare const CompactPackageSchema: z.ZodObject<{
+  s: z.ZodArray<z.ZodString>;
+  p: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodArray<z.ZodCustom<CompactXmlNode, CompactXmlNode>>, z.ZodNumber]>>;
+}, z.core.$strip>;
+type CompactPackage = z.infer<typeof CompactPackageSchema>;
+declare const compactCodec: z.ZodCodec<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>, z.ZodObject<{
+  s: z.ZodArray<z.ZodString>;
+  p: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodArray<z.ZodCustom<CompactXmlNode, CompactXmlNode>>, z.ZodNumber]>>;
+}, z.core.$strip>>;
+declare function toCompact(pkg: Package): CompactPackage;
+declare function fromCompact(cpkg: CompactPackage): Package;
+declare const compactPackageCodec: z.ZodCodec<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>, z.ZodObject<{
+  s: z.ZodArray<z.ZodString>;
+  p: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodArray<z.ZodCustom<CompactXmlNode, CompactXmlNode>>, z.ZodNumber]>>;
+}, z.core.$strip>>;
+declare function decodeCompactPackage(bytes: Uint8Array<ArrayBuffer>): CompactPackage;
+declare function encodeCompactPackage(cpkg: CompactPackage): Uint8Array<ArrayBuffer>;
+//#endregion
+export { CompactAttrPairs, CompactCdata, CompactComment, CompactDeclaration, CompactElement, CompactPackage, CompactPackageSchema, CompactPart, CompactPartSchema, CompactPi, CompactText, CompactXmlNode, CompactXmlNodeSchema, compactCodec, compactPackageCodec, decodeCompactPackage, encodeCompactPackage, fromCompact, isCompactXmlNode, toCompact };