epub-codec 0.0.0 → 1.0.0

package/dist/xhtml/write.js

@@ -0,0 +1,182 @@
+import { EpubDiagnosticCodes } from "../diagnostics.js";
+import { encodeEntities } from "../xml/entities.js";
+import { base64ToBytes } from "../util/base64.js";
+import "./style-constants.js";
+import { parseListNumId } from "./list-id.js";
+import { isHeadingGroupNode, isListGroupNode, isSectionConstructGroupNode, isTreeBlockLeaf } from "document-schema.js";
+import { decomposeSection } from "document-schema.js/decompose";
+//#region src/xhtml/write.ts
+function element(tag, attrs = {}, children = []) {
+	return {
+		type: "element",
+		tag,
+		attributes: Object.entries(attrs).map(([name, value]) => ({
+			name,
+			value
+		})),
+		children
+	};
+}
+function text(value) {
+	return {
+		type: "text",
+		value: encodeEntities(value)
+	};
+}
+function writeXhtmlBody(blocks, context) {
+	const { children } = decomposeSection({
+		pageSize: {
+			widthPt: 1,
+			heightPt: 1
+		},
+		margins: {
+			topPt: 0,
+			rightPt: 0,
+			bottomPt: 0,
+			leftPt: 0
+		},
+		blocks: [...blocks]
+	});
+	return element("body", {}, writeSectionChildren(children, context));
+}
+function writeSectionChildren(children, context) {
+	const out = [];
+	let index = 0;
+	while (index < children.length) {
+		const child = children[index];
+		if (child === void 0) break;
+		if (isListGroupNode(child)) {
+			let end = index;
+			while (end < children.length && isListGroupNode(children[end])) end += 1;
+			const items = children.slice(index, end);
+			out.push(writeList(items, context));
+			index = end;
+			continue;
+		}
+		out.push(...writeSectionChild(child, context));
+		index += 1;
+	}
+	return out;
+}
+function writeSectionChild(child, context) {
+	if (isHeadingGroupNode(child)) return [writeHeading(child), ...writeSectionChildren(child.children, context)];
+	if (isListGroupNode(child)) return [writeList([child], context)];
+	if (isSectionConstructGroupNode(child)) return writeSectionConstructGroup(child, context);
+	return writeLeafBlock(child, context);
+}
+function writeHeading(group) {
+	const level = Math.min(6, Math.max(1, group.node.headingLevel));
+	return element(`h${String(level)}`, {}, writeRunsToNodes(group.node.runs, group.node.constructs));
+}
+function writeList(items, context) {
+	const numId = items[0]?.node.list.numId;
+	const info = numId === void 0 ? void 0 : parseListNumId(numId);
+	return element(info?.type === "ordered" ? "ol" : "ul", info?.type === "ordered" && info.start !== void 0 ? { start: String(info.start) } : {}, items.map((item) => {
+		const paragraph = item.node;
+		const anchorNodes = writeRunsToNodes(paragraph.runs, paragraph.constructs);
+		const nested = writeSectionChildren(item.children, context);
+		return element("li", {}, [...anchorNodes, ...nested]);
+	}));
+}
+function writeSectionConstructGroup(group, context) {
+	const descriptor = group.node;
+	if (descriptor.kind === "division") return [element("blockquote", {}, writeSectionChildren(group.children, context))];
+	if (descriptor.kind === "anchor" && descriptor.anchorType === "footnote") return [element("aside", {
+		"epub:type": "footnote",
+		id: descriptor.name
+	}, writeSectionChildren(group.children, context))];
+	context.sink({
+		code: EpubDiagnosticCodes.CONSTRUCT_UNREPRESENTED,
+		severity: "info",
+		message: `a '${descriptor.kind}' construct has no XHTML spelling in this package's writer; its extent is written, the construct itself is not`,
+		href: context.sourceHref
+	});
+	return writeSectionChildren(group.children, context);
+}
+function writeLeafBlock(block, context) {
+	switch (block.kind) {
+		case "paragraph": return [writeParagraph(block)];
+		case "table": return [writeTable(block, context)];
+		case "image": return [writeImage(block, context)];
+		case "pageBreak": return [];
+		case "embeddedObject":
+			context.sink({
+				code: EpubDiagnosticCodes.ELEMENT_UNMAPPED,
+				severity: "warning",
+				message: "an embedded object has no XHTML representation in this package's writer and was dropped",
+				href: context.sourceHref
+			});
+			return [];
+	}
+}
+function isPreBlockParagraph(paragraph) {
+	if (paragraph.codeLanguage !== void 0) return true;
+	return paragraph.runs.length === 1 && paragraph.runs[0]?.fontFamily === "Courier New" && paragraph.runs[0].text.includes("\n");
+}
+function writeParagraph(paragraph) {
+	if (paragraph.styleId === "HorizontalRule" && paragraph.runs.length === 0) return element("hr");
+	if (isPreBlockParagraph(paragraph)) return element("pre", {}, [element("code", paragraph.codeLanguage === void 0 ? {} : { class: `language-${paragraph.codeLanguage}` }, [text(paragraph.runs.map((run) => run.text).join(""))])]);
+	return element("p", {}, writeRunsToNodes(paragraph.runs, paragraph.constructs));
+}
+function isFootnoteExtent(construct) {
+	return construct.descriptor.kind === "anchor" && construct.descriptor.anchorType === "footnote";
+}
+function writeRunsToNodes(runs, constructs) {
+	const footnoteExtents = (constructs ?? []).filter(isFootnoteExtent);
+	const out = [];
+	let index = 0;
+	while (index < runs.length) {
+		const extent = footnoteExtents.find((e) => e.startRun === index);
+		if (extent !== void 0) {
+			const inner = runs.slice(extent.startRun, extent.endRun).flatMap((run) => writeRunNodes(run));
+			out.push(element("a", {
+				"epub:type": "noteref",
+				href: `#${extent.descriptor.name}`
+			}, inner));
+			index = Math.max(extent.endRun, index + 1);
+			continue;
+		}
+		const run = runs[index];
+		if (run !== void 0) out.push(...writeRunNodes(run));
+		index += 1;
+	}
+	return out;
+}
+function writeRunNodes(run) {
+	const segments = run.text.split("\n");
+	let nodes = [];
+	segments.forEach((segment, i) => {
+		if (i > 0) nodes.push(element("br"));
+		if (segment.length > 0) nodes.push(text(segment));
+	});
+	if (nodes.length === 0) nodes = [text("")];
+	if (run.fontFamily === "Courier New") nodes = [element("code", {}, nodes)];
+	if (run.bold === true) nodes = [element("strong", {}, nodes)];
+	if (run.italic === true) nodes = [element("em", {}, nodes)];
+	if (run.underline === true) nodes = [element("u", {}, nodes)];
+	if (run.strike === true) nodes = [element("s", {}, nodes)];
+	if (run.hyperlink !== void 0) nodes = [element("a", { href: run.hyperlink }, nodes)];
+	return nodes;
+}
+function writeTable(table, context) {
+	return element("table", {}, table.rows.map((row) => element("tr", {}, row.cells.map((cell) => {
+		const attrs = {};
+		if (cell.colSpan !== void 0) attrs.colspan = String(cell.colSpan);
+		if (cell.rowSpan !== void 0) attrs.rowspan = String(cell.rowSpan);
+		for (const block of cell.blocks) if (!isTreeBlockLeaf(block)) context.sink({
+			code: EpubDiagnosticCodes.ELEMENT_UNMAPPED,
+			severity: "info",
+			message: "a construct-boundary marker inside a table cell has no XHTML representation in this package's writer and was dropped",
+			href: context.sourceHref
+		});
+		return element("td", attrs, cell.blocks.filter(isTreeBlockLeaf).flatMap((block) => writeLeafBlock(block, context)));
+	}))));
+}
+function writeImage(image, context) {
+	const bytes = base64ToBytes(image.base64);
+	const attrs = { src: context.registerImage(bytes, image.format) };
+	attrs.alt = image.altText ?? "";
+	return element("img", attrs);
+}
+//#endregion
+export { writeXhtmlBody };

package/dist/xml/build.cjs

@@ -0,0 +1,46 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/xml/build.ts
+const BUILDER = new (require("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
+exports.buildXml = buildXml;

package/dist/xml/build.d.cts

@@ -0,0 +1,5 @@
+import { XmlNode } from "./node.cjs";
+//#region src/xml/build.d.ts
+declare function buildXml(nodes: XmlNode[]): string;
+//#endregion
+export { buildXml };

package/dist/xml/build.d.ts

@@ -0,0 +1,5 @@
+import { XmlNode } from "./node.js";
+//#region src/xml/build.d.ts
+declare function buildXml(nodes: XmlNode[]): string;
+//#endregion
+export { buildXml };

package/dist/xml/build.js

@@ -0,0 +1,46 @@
+import { XMLBuilder } from "fast-xml-parser";
+//#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
+export { buildXml };

package/dist/xml/entities.cjs

@@ -0,0 +1,20 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/xml/entities.ts
+function decodeEntities(value) {
+	return value.replace(/&(?:amp|lt|gt|quot|apos);/g, (entity) => {
+		switch (entity) {
+			case "&": return "&";
+			case "&lt;": return "<";
+			case "&gt;": return ">";
+			case "&quot;": return "\"";
+			case "&apos;": return "'";
+			default: return entity;
+		}
+	});
+}
+function encodeEntities(value) {
+	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+//#endregion
+exports.decodeEntities = decodeEntities;
+exports.encodeEntities = encodeEntities;

package/dist/xml/entities.d.cts

@@ -0,0 +1,5 @@
+//#region src/xml/entities.d.ts
+declare function decodeEntities(value: string): string;
+declare function encodeEntities(value: string): string;
+//#endregion
+export { decodeEntities, encodeEntities };

package/dist/xml/entities.d.ts

@@ -0,0 +1,5 @@
+//#region src/xml/entities.d.ts
+declare function decodeEntities(value: string): string;
+declare function encodeEntities(value: string): string;
+//#endregion
+export { decodeEntities, encodeEntities };

package/dist/xml/entities.js

@@ -0,0 +1,18 @@
+//#region src/xml/entities.ts
+function decodeEntities(value) {
+	return value.replace(/&(?:amp|lt|gt|quot|apos);/g, (entity) => {
+		switch (entity) {
+			case "&": return "&";
+			case "&lt;": return "<";
+			case "&gt;": return ">";
+			case "&quot;": return "\"";
+			case "&apos;": return "'";
+			default: return entity;
+		}
+	});
+}
+function encodeEntities(value) {
+	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+//#endregion
+export { decodeEntities, encodeEntities };

package/dist/xml/node.cjs

@@ -0,0 +1,67 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let zod = require("zod");
+//#region src/xml/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/xml/node.d.cts

@@ -0,0 +1,83 @@
+import { z } from "zod";
+//#region src/xml/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 { Attribute, AttributeSchema, XmlCdata, XmlCdataSchema, XmlComment, XmlCommentSchema, XmlDeclaration, XmlDeclarationSchema, XmlElement, XmlElementSchema, XmlNode, XmlNodeSchema, XmlPi, XmlPiSchema, XmlText, XmlTextSchema, isXmlNode };

package/dist/xml/node.d.ts

@@ -0,0 +1,83 @@
+import { z } from "zod";
+//#region src/xml/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 { Attribute, AttributeSchema, XmlCdata, XmlCdataSchema, XmlComment, XmlCommentSchema, XmlDeclaration, XmlDeclarationSchema, XmlElement, XmlElementSchema, XmlNode, XmlNodeSchema, XmlPi, XmlPiSchema, XmlText, XmlTextSchema, isXmlNode };

package/dist/xml/node.js

@@ -0,0 +1,58 @@
+import { z } from "zod";
+//#region src/xml/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 };