odf.js 1.12.0 → 1.13.0

package/dist/mimetype.cjs

@@ -0,0 +1,19 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_util_base64 = require("./util/base64.cjs");
+const require_package_io_write = require("./package-io/write.cjs");
+//#region src/mimetype.ts
+function readMimetype(pkg) {
+	const part = pkg.parts[require_package_io_write.MIMETYPE_PART];
+	if (part?.kind !== "binary") return;
+	return new TextDecoder("utf-8").decode(require_util_base64.base64ToBytes(part.base64));
+}
+function writeMimetype(pkg, mediaType) {
+	pkg.parts[require_package_io_write.MIMETYPE_PART] = {
+		kind: "binary",
+		base64: require_util_base64.bytesToBase64(new TextEncoder().encode(mediaType))
+	};
+}
+//#endregion
+exports.MIMETYPE_PART = require_package_io_write.MIMETYPE_PART;
+exports.readMimetype = readMimetype;
+exports.writeMimetype = writeMimetype;

package/dist/mimetype.d.cts

@@ -0,0 +1,7 @@
+import { Package } from "./model/package.cjs";
+import { MIMETYPE_PART } from "./package-io/write.cjs";
+//#region src/mimetype.d.ts
+declare function readMimetype(pkg: Package): string | undefined;
+declare function writeMimetype(pkg: Package, mediaType: string): void;
+//#endregion
+export { MIMETYPE_PART, readMimetype, writeMimetype };

package/dist/mimetype.d.ts

@@ -0,0 +1,7 @@
+import { Package } from "./model/package.js";
+import { MIMETYPE_PART } from "./package-io/write.js";
+//#region src/mimetype.d.ts
+declare function readMimetype(pkg: Package): string | undefined;
+declare function writeMimetype(pkg: Package, mediaType: string): void;
+//#endregion
+export { MIMETYPE_PART, readMimetype, writeMimetype };

package/dist/mimetype.js

@@ -0,0 +1,16 @@
+import { base64ToBytes, bytesToBase64 } from "./util/base64.js";
+import { MIMETYPE_PART } from "./package-io/write.js";
+//#region src/mimetype.ts
+function readMimetype(pkg) {
+	const part = pkg.parts[MIMETYPE_PART];
+	if (part?.kind !== "binary") return;
+	return new TextDecoder("utf-8").decode(base64ToBytes(part.base64));
+}
+function writeMimetype(pkg, mediaType) {
+	pkg.parts[MIMETYPE_PART] = {
+		kind: "binary",
+		base64: bytesToBase64(new TextEncoder().encode(mediaType))
+	};
+}
+//#endregion
+export { MIMETYPE_PART, readMimetype, writeMimetype };

package/dist/model/node.cjs

@@ -0,0 +1,67 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let zod = require("zod");
+//#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(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isAttribute(value) {
+	return isRecord(value) && typeof value.name === "string" && typeof value.value === "string";
+}
+function isXmlNode(value) {
+	if (!isRecord(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
+exports.AttributeSchema = AttributeSchema;
+exports.XmlCdataSchema = XmlCdataSchema;
+exports.XmlCommentSchema = XmlCommentSchema;
+exports.XmlDeclarationSchema = XmlDeclarationSchema;
+exports.XmlElementSchema = XmlElementSchema;
+exports.XmlNodeSchema = XmlNodeSchema;
+exports.XmlPiSchema = XmlPiSchema;
+exports.XmlTextSchema = XmlTextSchema;
+exports.isXmlNode = isXmlNode;

package/dist/model/node.d.cts

@@ -0,0 +1,2 @@
+import { _ as isXmlNode, a as XmlComment, c as XmlDeclarationSchema, d as XmlNode, f as XmlNodeSchema, g as XmlTextSchema, h as XmlText, i as XmlCdataSchema, l as XmlElement, m as XmlPiSchema, n as AttributeSchema, o as XmlCommentSchema, p as XmlPi, r as XmlCdata, s as XmlDeclaration, t as Attribute, u as XmlElementSchema } from "../node-CkBWRjNR.cjs";
+export { Attribute, AttributeSchema, XmlCdata, XmlCdataSchema, XmlComment, XmlCommentSchema, XmlDeclaration, XmlDeclarationSchema, XmlElement, XmlElementSchema, XmlNode, XmlNodeSchema, XmlPi, XmlPiSchema, XmlText, XmlTextSchema, isXmlNode };

package/dist/model/node.d.ts

@@ -0,0 +1,2 @@
+import { _ as isXmlNode, a as XmlComment, c as XmlDeclarationSchema, d as XmlNode, f as XmlNodeSchema, g as XmlTextSchema, h as XmlText, i as XmlCdataSchema, l as XmlElement, m as XmlPiSchema, n as AttributeSchema, o as XmlCommentSchema, p as XmlPi, r as XmlCdata, s as XmlDeclaration, t as Attribute, u as XmlElementSchema } from "../node-CkBWRjNR.js";
+export { Attribute, AttributeSchema, XmlCdata, XmlCdataSchema, XmlComment, XmlCommentSchema, XmlDeclaration, XmlDeclarationSchema, XmlElement, XmlElementSchema, XmlNode, XmlNodeSchema, XmlPi, XmlPiSchema, XmlText, XmlTextSchema, isXmlNode };

package/dist/model/node.js

@@ -0,0 +1,58 @@
+import { z } from "zod";
+//#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(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isAttribute(value) {
+	return isRecord(value) && typeof value.name === "string" && typeof value.value === "string";
+}
+function isXmlNode(value) {
+	if (!isRecord(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
+export { AttributeSchema, XmlCdataSchema, XmlCommentSchema, XmlDeclarationSchema, XmlElementSchema, XmlNodeSchema, XmlPiSchema, XmlTextSchema, isXmlNode };

package/dist/model/package.cjs

@@ -0,0 +1,19 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_model_node = require("./node.cjs");
+let zod = require("zod");
+//#region src/model/package.ts
+const XmlPartSchema = zod.z.object({
+	kind: zod.z.literal("xml"),
+	nodes: zod.z.array(require_model_node.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
+exports.BinaryPartSchema = BinaryPartSchema;
+exports.PackageSchema = PackageSchema;
+exports.PartSchema = PartSchema;
+exports.XmlPartSchema = XmlPartSchema;

package/dist/model/package.d.cts

@@ -0,0 +1,114 @@
+import { d as XmlNode } from "../node-CkBWRjNR.cjs";
+import { z } from "zod";
+//#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
+export { BinaryPart, BinaryPartSchema, Package, PackageSchema, Part, PartSchema, XmlPart, XmlPartSchema };

package/dist/model/package.d.ts

@@ -0,0 +1,114 @@
+import { d as XmlNode } from "../node-CkBWRjNR.js";
+import { z } from "zod";
+//#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
+export { BinaryPart, BinaryPartSchema, Package, PackageSchema, Part, PartSchema, XmlPart, XmlPartSchema };

package/dist/model/package.js

@@ -0,0 +1,15 @@
+import { XmlNodeSchema } from "./node.js";
+import { z } from "zod";
+//#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
+export { BinaryPartSchema, PackageSchema, PartSchema, XmlPartSchema };

package/dist/node-CkBWRjNR.d.cts

@@ -0,0 +1,83 @@
+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
+export { isXmlNode as _, XmlComment as a, XmlDeclarationSchema as c, XmlNode as d, XmlNodeSchema as f, XmlTextSchema as g, XmlText as h, XmlCdataSchema as i, XmlElement as l, XmlPiSchema as m, AttributeSchema as n, XmlCommentSchema as o, XmlPi as p, XmlCdata as r, XmlDeclaration as s, Attribute as t, XmlElementSchema as u };

package/dist/node-CkBWRjNR.d.ts

@@ -0,0 +1,83 @@
+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
+export { isXmlNode as _, XmlComment as a, XmlDeclarationSchema as c, XmlNode as d, XmlNodeSchema as f, XmlTextSchema as g, XmlText as h, XmlCdataSchema as i, XmlElement as l, XmlPiSchema as m, AttributeSchema as n, XmlCommentSchema as o, XmlPi as p, XmlCdata as r, XmlDeclaration as s, Attribute as t, XmlElementSchema as u };

package/dist/ns.cjs

@@ -0,0 +1,37 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/ns.ts
+const ODF_NAMESPACES = Object.freeze({
+	office: "urn:oasis:names:tc:opendocument:xmlns:office:1.0",
+	style: "urn:oasis:names:tc:opendocument:xmlns:style:1.0",
+	text: "urn:oasis:names:tc:opendocument:xmlns:text:1.0",
+	table: "urn:oasis:names:tc:opendocument:xmlns:table:1.0",
+	draw: "urn:oasis:names:tc:opendocument:xmlns:drawing:1.0",
+	fo: "urn:oasis:names:tc:opendocument:xmlns:xsl-fo-compatible:1.0",
+	svg: "urn:oasis:names:tc:opendocument:xmlns:svg-compatible:1.0",
+	xlink: "http://www.w3.org/1999/xlink",
+	dc: "http://purl.org/dc/elements/1.1/",
+	meta: "urn:oasis:names:tc:opendocument:xmlns:meta:1.0",
+	number: "urn:oasis:names:tc:opendocument:xmlns:datastyle:1.0",
+	chart: "urn:oasis:names:tc:opendocument:xmlns:chart:1.0",
+	dr3d: "urn:oasis:names:tc:opendocument:xmlns:dr3d:1.0",
+	math: "http://www.w3.org/1998/Math/MathML",
+	form: "urn:oasis:names:tc:opendocument:xmlns:form:1.0",
+	script: "urn:oasis:names:tc:opendocument:xmlns:script:1.0",
+	config: "urn:oasis:names:tc:opendocument:xmlns:config:1.0",
+	presentation: "urn:oasis:names:tc:opendocument:xmlns:presentation:1.0",
+	smil: "urn:oasis:names:tc:opendocument:xmlns:smil-compatible:1.0",
+	anim: "urn:oasis:names:tc:opendocument:xmlns:animation:1.0",
+	xforms: "http://www.w3.org/2002/xforms",
+	xsd: "http://www.w3.org/2001/XMLSchema",
+	xsi: "http://www.w3.org/2001/XMLSchema-instance",
+	manifest: "urn:oasis:names:tc:opendocument:xmlns:manifest:1.0",
+	db: "urn:oasis:names:tc:opendocument:xmlns:database:1.0"
+});
+function xmlnsAttributes(prefixes) {
+	const attrs = {};
+	for (const prefix of prefixes) attrs[`xmlns:${prefix}`] = ODF_NAMESPACES[prefix];
+	return attrs;
+}
+//#endregion
+exports.ODF_NAMESPACES = ODF_NAMESPACES;
+exports.xmlnsAttributes = xmlnsAttributes;