@lowlighter/xml 6.0.0 → 8.0.0

package/deno.lock

@@ -1,112 +1,32 @@
 {
-  "version": "4",
+  "version": "5",
   "specifiers": {
-    "jsr:@libs/logger@2": "2.1.4",
-    "jsr:@libs/run@2": "2.0.5",
-    "jsr:@libs/testing@3": "3.0.0",
-    "jsr:@libs/typing@2": "2.9.0",
-    "jsr:@libs/typing@3": "3.0.0",
-    "jsr:@std/assert@1": "1.0.6",
-    "jsr:@std/assert@^1.0.6": "1.0.6",
-    "jsr:@std/async@1": "1.0.5",
-    "jsr:@std/bytes@^1.0.2": "1.0.2",
-    "jsr:@std/expect@1": "1.0.4",
-    "jsr:@std/fmt@1": "1.0.2",
-    "jsr:@std/fs@1": "1.0.4",
-    "jsr:@std/html@1": "1.0.3",
-    "jsr:@std/http@1": "1.0.7",
-    "jsr:@std/internal@^1.0.4": "1.0.4",
-    "jsr:@std/path@1": "1.0.6",
-    "jsr:@std/streams@1": "1.0.6",
-    "npm:highlight.js@11": "11.10.0"
+    "jsr:@std/internal@^1.0.14": "1.0.14",
+    "jsr:@std/path@^1.1.4": "1.1.6",
+    "jsr:@std/xml@~0.1.3": "0.1.3"
   },
   "jsr": {
-    "@libs/logger@2.1.4": {
-      "integrity": "47d100412f9c16b5752d670d7fb182a2dce2cda26a72896e0f69d3a2de35fa1f"
+    "@std/internal@1.0.14": {
+      "integrity": "291516b3d4c35024d6ffbc0a9df5bf4c64116e05b50012cf846710152d2ffdf7"
     },
-    "@libs/run@2.0.5": {
-      "integrity": "6da09b6d9458a7f8134a113f7a70186742e6f759423a60f7037ca1001bbf1b78",
+    "@std/path@1.1.6": {
+      "integrity": "c68485c2a4dfbb5ae3cc74fae4e8c4e5d874cf8a8ed12927917235c758b46cbe",
       "dependencies": [
-        "jsr:@libs/logger",
-        "jsr:@libs/typing@2",
-        "jsr:@std/async",
-        "jsr:@std/streams"
-      ]
-    },
-    "@libs/testing@3.0.0": {
-      "integrity": "514547988fadac36890692ccafc932546d9e27680df1b736dd7674ad2e7c9625",
-      "dependencies": [
-        "jsr:@libs/run",
-        "jsr:@libs/typing@2",
-        "jsr:@std/assert@1",
-        "jsr:@std/expect",
-        "jsr:@std/fmt",
-        "jsr:@std/html",
-        "jsr:@std/http",
-        "npm:highlight.js"
-      ]
-    },
-    "@libs/typing@2.9.0": {
-      "integrity": "ddf35ea652b807cd9b19b4f3f163fb5d76d57299053753fbd01ba8b02d9306ad"
-    },
-    "@libs/typing@3.0.0": {
-      "integrity": "f84ffbbdcbb6a02e6a527911b1399dc79f6ad213aec4ad0a86c95df4b353738f"
-    },
-    "@std/assert@1.0.6": {
-      "integrity": "1904c05806a25d94fe791d6d883b685c9e2dcd60e4f9fc30f4fc5cf010c72207",
-      "dependencies": [
-        "jsr:@std/internal"
-      ]
-    },
-    "@std/async@1.0.5": {
-      "integrity": "31d68214bfbb31bd4c6022401d484e3964147c76c9220098baa703a39b6c2da6"
-    },
-    "@std/bytes@1.0.2": {
-      "integrity": "fbdee322bbd8c599a6af186a1603b3355e59a5fb1baa139f8f4c3c9a1b3e3d57"
-    },
-    "@std/expect@1.0.4": {
-      "integrity": "97f68a445a9de0d9670200d2b7a19a7505a01b2cb390a983ba8d97d90ce30c4f",
-      "dependencies": [
-        "jsr:@std/assert@^1.0.6",
         "jsr:@std/internal"
       ]
     },
-    "@std/fmt@1.0.2": {
-      "integrity": "87e9dfcdd3ca7c066e0c3c657c1f987c82888eb8103a3a3baa62684ffeb0f7a7"
-    },
-    "@std/fs@1.0.4": {
-      "integrity": "2907d32d8d1d9e540588fd5fe0ec21ee638134bd51df327ad4e443aaef07123c"
-    },
-    "@std/html@1.0.3": {
-      "integrity": "7a0ac35e050431fb49d44e61c8b8aac1ebd55937e0dc9ec6409aa4bab39a7988"
-    },
-    "@std/http@1.0.7": {
-      "integrity": "9b904fc256678a5c9759f1a53a24a3fdcc59d83dc62099bb472683b6f819194c"
-    },
-    "@std/internal@1.0.4": {
-      "integrity": "62e8e4911527e5e4f307741a795c0b0a9e6958d0b3790716ae71ce085f755422"
-    },
-    "@std/path@1.0.6": {
-      "integrity": "ab2c55f902b380cf28e0eec501b4906e4c1960d13f00e11cfbcd21de15f18fed"
-    },
-    "@std/streams@1.0.6": {
-      "integrity": "022ed94e380d06b4d91c49eb70241b7289ab78b8c2b4c4bbb7eb265e4997c25c",
-      "dependencies": [
-        "jsr:@std/bytes"
-      ]
-    }
-  },
-  "npm": {
-    "highlight.js@11.10.0": {
-      "integrity": "sha512-SYVnVFswQER+zu1laSya563s+F8VDGt7o35d4utbamowvUNLLMovFqwCLSocpZTz3MgaSRA1IbqRWZv97dtErQ=="
+    "@std/xml@0.1.3": {
+      "integrity": "afb7750d09f9f521046b27119d0e63f7aaad6eeb3d74e5f41fc04a9958014811"
     }
   },
   "workspace": {
     "dependencies": [
-      "jsr:@libs/testing@3",
-      "jsr:@libs/typing@3",
-      "jsr:@std/fs@1",
-      "jsr:@std/path@1"
-    ]
+      "jsr:@std/path@^1.1.4"
+    ],
+    "packageJson": {
+      "dependencies": [
+        "npm:@jsr/std__path@^1.1.4"
+      ]
+    }
   }
 }

package/mod.d.ts

@@ -0,0 +1,3 @@
+export * from "./parse.js";
+export * from "./stringify.js";
+export type * from "./_types.js";

package/mod.js

@@ -0,0 +1,3 @@
+export * from "./parse.js";
+export * from "./stringify.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImZpbGU6Ly8vaG9tZS9ydW5uZXIvd29yay9saWJzL2xpYnMvQGxpYnMveG1sL21vZC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9wYXJzZS5qc1wiXG5leHBvcnQgKiBmcm9tIFwiLi9zdHJpbmdpZnkuanNcIlxuZXhwb3J0IHR5cGUgKiBmcm9tIFwiLi9fdHlwZXMuanNcIlxuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsYUFBWTtBQUMxQixjQUFjLGlCQUFnQiJ9

package/package.json

@@ -1,28 +1,32 @@
 {
   "name": "@lowlighter/xml",
-  "version": "6.0.0",
+  "version": "8.0.0",
   "type": "module",
-  "scripts": {},
-  "dependencies": {},
-  "devDependencies": {},
-  "description": "XML parser/stringifier with no dependencies.",
-  "keywords": [
-    "xml",
-    "parser",
-    "stringifier",
-    "esm"
-  ],
-  "license": "MIT",
-  "author": "lowlighter (Simon Lecoq)",
-  "homepage": "https://github.com/lowlighter/libs",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/lowlighter/libs.git"
-  },
-  "funding": "https://github.com/sponsors/lowlighter",
+  "main": "./mod.js",
+  "types": "./mod.d.ts",
   "exports": {
-    ".": "./mod.mjs",
-    "./parse": "./parse.mjs",
-    "./stringify": "./stringify.mjs"
+    ".": {
+      "types": "./mod.d.ts",
+      "import": "./mod.js",
+      "default": "./mod.js"
+    },
+    "./parse": {
+      "types": "./parse.d.ts",
+      "import": "./parse.js",
+      "default": "./parse.js"
+    },
+    "./stringify": {
+      "types": "./stringify.d.ts",
+      "import": "./stringify.js",
+      "default": "./stringify.js"
+    },
+    "./wasm/parse": {
+      "types": "./wasm/parse.d.ts",
+      "import": "./wasm/parse.js",
+      "default": "./wasm/parse.js"
+    }
+  },
+  "dependencies": {
+    "@jsr/std__xml": "^0.1.3"
   }
-}
+}

package/parse.d.ts

@@ -0,0 +1,81 @@
+import { type CleanOptions, type FlattenOptions, type ReviveOptions } from "./_parser.js";
+import type { XmlDocument } from "./_types.js";
+export type * from "./_types.js";
+export type { CleanOptions, FlattenOptions, ReviveOptions, Reviver } from "./_parser.js";
+/** XML parser options. */ export type ParseOptions = {
+  /** Remove elements from result. */ clean?: CleanOptions;
+  /** Flatten result depending on node content. */ flatten?: FlattenOptions;
+  /** Revive result. */ revive?: ReviveOptions;
+  /**
+   * Parsing mode.
+   * Using `html` is more permissive and will not throw on some invalid XML syntax.
+   * Mainly unquoted attributes will be supported and not properly closed tags will be accepted.
+   *
+   * > Note: `html` mode is currently not supported, use the WASM backend (`@libs/xml/wasm/parse`) instead.
+   * > Tracking issue: https://github.com/denoland/std/issues/7212
+   */ mode?: "xml";
+};
+/**
+ * Parse a XML string into an object.
+ *
+ * Output (cleaning, flattening, reviving, etc.) can be customized using the {@link ParseOptions} parameter.
+ *
+ * Unless flattened, output nodes will contain the following non-enumerable properties (which mean they're not "visible" when iterating over, but are still explicitely accessible):
+ * - General properties
+ *   - `readonly ["~name"]: string`: tag name
+ *   - `readonly ["~parent"]: Nullable<XmlNode>`: parent node
+ *   - `["#text"]?: string`: text content
+ * - Node properties
+ *   - `readonly ["~children"]: Array<XmlNode|XmlText>`: node children
+ *   - `readonly ["#comments"]?: Array<string>`: node comments
+ *   - `readonly ["#text"]?: string`: concatenated children text content, this property becomes enumerable if at least one non-empty text node is present
+ * - XML document properties
+ *  - `["#doctype"]?: XmlNode`: XML doctype
+ *  - `["#instructions"]?: { [key:string]: Arrayable<XmlNode> }`: XML processing instructions
+ *
+ * Attributes are prefixed with an arobase (`@`).
+ *
+ * ```ts
+ * console.log(parse(
+ * `
+ *   <root>
+ *     <!-- This is a comment -->
+ *     <text>hello</text>
+ *     <array>world</array>
+ *     <array>monde</array>
+ *     <array>世界</array>
+ *     <array>🌏</array>
+ *     <number>42</number>
+ *     <boolean>true</boolean>
+ *     <complex attribute="value">content</complex>
+ *   </root>
+ * `))
+ * ```
+ */ export declare function parse(content: string, options?: ParseOptions): XmlDocument;
+/**
+ * Parse a XML string into an object.
+ *
+ * Output (cleaning, flattening, reviving, etc.) can be customized using the {@link ParseOptions} parameter.
+ *
+ * Unless flattened, output nodes will contain the following non-enumerable properties (which mean they're not "visible" when iterating over, but are still explicitely accessible):
+ * - General properties
+ *   - `readonly ["~name"]: string`: tag name
+ *   - `readonly ["~parent"]: Nullable<XmlNode>`: parent node
+ *   - `["#text"]?: string`: text content
+ * - Node properties
+ *   - `readonly ["~children"]: Array<XmlNode|XmlText>`: node children
+ *   - `readonly ["#comments"]?: Array<string>`: node comments
+ *   - `readonly ["#text"]?: string`: concatenated children text content, this property becomes enumerable if at least one non-empty text node is present
+ * - XML document properties
+ *  - `["#doctype"]?: XmlNode`: XML doctype
+ *  - `["#instructions"]?: { [key:string]: Arrayable<XmlNode> }`: XML processing instructions
+ *
+ * Attributes are prefixed with an arobase (`@`).
+ *
+ * ```ts
+ * import { fromFileUrl } from "@std/path"
+ *
+ * const file = await Deno.open(fromFileUrl(import.meta.resolve("./bench/assets/small.xml")))
+ * console.log(await parse(file.readable))
+ * ```
+ */ export declare function parse(content: ReadableStream<Uint8Array>, options?: ParseOptions): Promise<XmlDocument>;

package/parse.js

@@ -0,0 +1,227 @@
+/**
+ * Parse a XML string into an object.
+ * @module
+ */ // Imports
+import { parse as std_parse } from "@std/xml/parse";
+import { parseXmlStreamFromBytes } from "@std/xml/parse-stream";
+import { finalize, xml_doctype, xml_element, xml_instruction, xml_node, xml_text } from "./_parser.js";
+export function parse(content, options) {
+  if (typeof content !== "string") return parse_stream(content, options);
+  const xml = xml_node("~xml");
+  content = content.replace(/^\s+/, "");
+  // @std sync parser only exposes a DOM tree of {declaration, root}
+  // and is missing DOCTYPE and processing instructions (they are discarded)
+  // Prescan the content to recover them first
+  content = prescan(content, xml);
+  const doc = std_parse(content, {
+    disallowDoctype: false
+  });
+  // XML declaration
+  if (doc.declaration) {
+    if (doc.declaration.version) xml["@version"] = doc.declaration.version;
+    if (doc.declaration.encoding) xml["@encoding"] = doc.declaration.encoding;
+    if (doc.declaration.standalone) xml["@standalone"] = doc.declaration.standalone;
+  }
+  build(doc.root, xml);
+  return finalize(xml, options);
+}
+/**
+ * Parse a XML stream into an object.
+ * @std streaming parser events are mapped to the same document structure as the string version,
+ * and unlike the sync DOM they natively expose the doctype and processing instructions.
+ */ async function parse_stream(content, options) {
+  const xml = xml_node("~xml");
+  const stack = [
+    xml
+  ];
+  await parseXmlStreamFromBytes(content, {
+    // XML declaration
+    onDeclaration (version, encoding, standalone) {
+      if (version) xml["@version"] = version;
+      if (encoding) xml["@encoding"] = encoding;
+      if (standalone) xml["@standalone"] = standalone;
+    },
+    // XML doctype (only the name and public/system identifiers are exposed by @std events)
+    onDoctype (name, publicId, systemId) {
+      const doctype = xml_node("~doctype", {
+        parent: xml
+      });
+      [
+        name,
+        publicId,
+        systemId
+      ].filter((value)=>value !== undefined).forEach((value)=>doctype[`@${value}`] = "");
+      xml["#doctype"] = doctype;
+    },
+    // XML processing instruction
+    onProcessingInstruction (target, instruction) {
+      xml_instruction(xml, target, instruction.trim());
+    },
+    // XML tag opened
+    onStartElement (name, _colon, _uri, attributes, selfClosing) {
+      const node = xml_element(name, stack.at(-1));
+      for(let i = 0; i < attributes.count; i++)node[`@${attributes.getName(i)}`] = attributes.getValue(i);
+      if (!selfClosing) stack.push(node);
+    },
+    // XML tag closed
+    onEndElement () {
+      stack.pop();
+    },
+    // Text
+    onText (text) {
+      xml_text(text, {
+        type: "~text",
+        parent: stack.at(-1)
+      });
+    },
+    // CDATA
+    onCData (text) {
+      xml_text(text, {
+        type: "~cdata",
+        parent: stack.at(-1)
+      });
+    },
+    // Comment
+    onComment (text) {
+      xml_text(text, {
+        type: "~comment",
+        parent: stack.at(-1)
+      });
+    }
+  }, {
+    disallowDoctype: false
+  });
+  return finalize(xml, options);
+}
+/** Recover `#doctype` and `#instructions`. */ function prescan(content, xml) {
+  // Prolog: skip whitespace/comments, collect instructions and doctype until the root element opens
+  let i = 0;
+  prolog: while(i < content.length){
+    switch(true){
+      case /\s/.test(content[i]):
+        {
+          i++;
+          continue;
+        }
+      case content.startsWith("<!--", i):
+        {
+          const end = content.indexOf("-->", i + 4);
+          if (end < 0) break prolog;
+          i = end + 3;
+          continue;
+        }
+      case content.startsWith("<?", i):
+        {
+          const end = content.indexOf("?>", i + 2);
+          if (end < 0) break prolog;
+          const raw = content.slice(i + 2, end);
+          i = end + 2;
+          const target = raw.match(/^\S+/)?.[0] ?? "";
+          // The <?xml?> declaration is already handled through std's DOM
+          if (target !== "xml") xml_instruction(xml, target, raw.slice(target.length).trim());
+          continue;
+        }
+      case content.startsWith("<!DOCTYPE", i):
+        {
+          // Find the closing ">", skipping quoted literals and the internal subset "[...]"
+          let j = i + 9;
+          doctype: while(j < content.length){
+            switch(content[j]){
+              case '"':
+              case "'":
+                {
+                  const quote = content.indexOf(content[j], j + 1);
+                  if (quote < 0) break doctype;
+                  j = quote + 1;
+                  break;
+                }
+              case "[":
+                {
+                  const bracket = content.indexOf("]", j + 1);
+                  if (bracket < 0) break doctype;
+                  j = bracket + 1;
+                  break;
+                }
+              case ">":
+                break doctype;
+              default:
+                j++;
+            }
+          }
+          xml["#doctype"] = Object.assign(xml_node("~doctype", {
+            parent: xml
+          }), xml_doctype(content.slice(i + 9, j).trim()));
+          const end = Math.min(j + 1, content.length);
+          content = `${content.slice(0, i)}${" ".repeat(end - i)}${content.slice(end)}`;
+          i = end;
+          continue;
+        }
+      default:
+        break prolog;
+    }
+  }
+  // Epilog: only comments and instructions may follow the root element, scan them backwards
+  const instructions = [];
+  let tail = content.trimEnd();
+  epilog: while(true){
+    switch(true){
+      case tail.endsWith("-->"):
+        {
+          const start = tail.lastIndexOf("<!--");
+          if (start < 0) break epilog;
+          tail = tail.slice(0, start).trimEnd();
+          continue;
+        }
+      case tail.endsWith("?>"):
+        {
+          const start = tail.lastIndexOf("<?");
+          if (start < 0) break epilog;
+          const raw = tail.slice(start + 2, -2);
+          const target = raw.match(/^\S+/)?.[0] ?? "";
+          instructions.unshift([
+            target,
+            raw.slice(target.length).trim()
+          ]);
+          tail = tail.slice(0, start).trimEnd();
+          continue;
+        }
+      default:
+        break epilog;
+    }
+  }
+  instructions.forEach(([target, raw])=>xml_instruction(xml, target, raw));
+  return content;
+}
+/** Walk a std DOM element into the ergonomic ~children/@attr/#text structure. */ function build(element, parent) {
+  // Attach under the enumerable key with array-grouping
+  const node = xml_element(element.name.raw, parent);
+  // Attributes
+  for (const [name, value] of Object.entries(element.attributes))node[`@${name}`] = value;
+  // Children
+  for (const child of element.children){
+    switch(child.type){
+      case "element":
+        build(child, node);
+        break;
+      case "text":
+        xml_text(child.text, {
+          type: "~text",
+          parent: node
+        });
+        break;
+      case "cdata":
+        xml_text(child.text, {
+          type: "~cdata",
+          parent: node
+        });
+        break;
+      case "comment":
+        xml_text(child.text, {
+          type: "~comment",
+          parent: node
+        });
+        break;
+    }
+  }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/libs/libs/@libs/xml/parse.ts"],"sourcesContent":["/**\n * Parse a XML string into an object.\n * @module\n */\n\n// Imports\nimport { parse as std_parse } from \"@std/xml/parse\"\nimport { parseXmlStreamFromBytes } from \"@std/xml/parse-stream\"\nimport type { XmlDocument as StdDocument, XmlElement as StdElement, XmlNode as StdNode } from \"@std/xml/types\"\nimport { type CleanOptions, finalize, type FlattenOptions, type ReviveOptions, xml_doctype, xml_element, xml_instruction, xml_node, xml_text } from \"./_parser.js\"\nimport type { XmlDocument, XmlNode } from \"./_types.js\"\nexport type * from \"./_types.js\"\nexport type { CleanOptions, FlattenOptions, ReviveOptions, Reviver } from \"./_parser.js\"\n\n/** XML parser options. */\nexport type ParseOptions = {\n  /** Remove elements from result. */\n  clean?: CleanOptions\n  /** Flatten result depending on node content. */\n  flatten?: FlattenOptions\n  /** Revive result. */\n  revive?: ReviveOptions\n  /**\n   * Parsing mode.\n   * Using `html` is more permissive and will not throw on some invalid XML syntax.\n   * Mainly unquoted attributes will be supported and not properly closed tags will be accepted.\n   *\n   * > Note: `html` mode is currently not supported, use the WASM backend (`@libs/xml/wasm/parse`) instead.\n   * > Tracking issue: https://github.com/denoland/std/issues/7212\n   */\n  mode?: \"xml\"\n}\n\n/**\n * Parse a XML string into an object.\n *\n * Output (cleaning, flattening, reviving, etc.) can be customized using the {@link ParseOptions} parameter.\n *\n * Unless flattened, output nodes will contain the following non-enumerable properties (which mean they're not \"visible\" when iterating over, but are still explicitely accessible):\n * - General properties\n *   - `readonly [\"~name\"]: string`: tag name\n *   - `readonly [\"~parent\"]: Nullable<XmlNode>`: parent node\n *   - `[\"#text\"]?: string`: text content\n * - Node properties\n *   - `readonly [\"~children\"]: Array<XmlNode|XmlText>`: node children\n *   - `readonly [\"#comments\"]?: Array<string>`: node comments\n *   - `readonly [\"#text\"]?: string`: concatenated children text content, this property becomes enumerable if at least one non-empty text node is present\n * - XML document properties\n *  - `[\"#doctype\"]?: XmlNode`: XML doctype\n *  - `[\"#instructions\"]?: { [key:string]: Arrayable<XmlNode> }`: XML processing instructions\n *\n * Attributes are prefixed with an arobase (`@`).\n *\n * ```ts\n * console.log(parse(\n * `\n *   <root>\n *     <!-- This is a comment -->\n *     <text>hello</text>\n *     <array>world</array>\n *     <array>monde</array>\n *     <array>世界</array>\n *     <array>🌏</array>\n *     <number>42</number>\n *     <boolean>true</boolean>\n *     <complex attribute=\"value\">content</complex>\n *   </root>\n * `))\n * ```\n */\nexport function parse(content: string, options?: ParseOptions): XmlDocument\n\n/**\n * Parse a XML string into an object.\n *\n * Output (cleaning, flattening, reviving, etc.) can be customized using the {@link ParseOptions} parameter.\n *\n * Unless flattened, output nodes will contain the following non-enumerable properties (which mean they're not \"visible\" when iterating over, but are still explicitely accessible):\n * - General properties\n *   - `readonly [\"~name\"]: string`: tag name\n *   - `readonly [\"~parent\"]: Nullable<XmlNode>`: parent node\n *   - `[\"#text\"]?: string`: text content\n * - Node properties\n *   - `readonly [\"~children\"]: Array<XmlNode|XmlText>`: node children\n *   - `readonly [\"#comments\"]?: Array<string>`: node comments\n *   - `readonly [\"#text\"]?: string`: concatenated children text content, this property becomes enumerable if at least one non-empty text node is present\n * - XML document properties\n *  - `[\"#doctype\"]?: XmlNode`: XML doctype\n *  - `[\"#instructions\"]?: { [key:string]: Arrayable<XmlNode> }`: XML processing instructions\n *\n * Attributes are prefixed with an arobase (`@`).\n *\n * ```ts\n * import { fromFileUrl } from \"@std/path\"\n *\n * const file = await Deno.open(fromFileUrl(import.meta.resolve(\"./bench/assets/small.xml\")))\n * console.log(await parse(file.readable))\n * ```\n */\nexport function parse(content: ReadableStream<Uint8Array>, options?: ParseOptions): Promise<XmlDocument>\nexport function parse(content: string | ReadableStream<Uint8Array>, options?: ParseOptions): XmlDocument | Promise<XmlDocument> {\n  if (typeof content !== \"string\")\n    return parse_stream(content, options)\n  const xml = xml_node(\"~xml\") as XmlDocument\n  content = content.replace(/^\\s+/, \"\")\n  // @std sync parser only exposes a DOM tree of {declaration, root}\n  // and is missing DOCTYPE and processing instructions (they are discarded)\n  // Prescan the content to recover them first\n  content = prescan(content, xml)\n  const doc: StdDocument = std_parse(content, { disallowDoctype: false })\n\n  // XML declaration\n  if (doc.declaration) {\n    if (doc.declaration.version)\n      xml[\"@version\"] = doc.declaration.version as typeof xml[\"@version\"]\n    if (doc.declaration.encoding)\n      xml[\"@encoding\"] = doc.declaration.encoding\n    if (doc.declaration.standalone)\n      xml[\"@standalone\"] = doc.declaration.standalone\n  }\n\n  build(doc.root, xml)\n\n  return finalize(xml, options)\n}\n\n/**\n * Parse a XML stream into an object.\n * @std streaming parser events are mapped to the same document structure as the string version,\n * and unlike the sync DOM they natively expose the doctype and processing instructions.\n */\nasync function parse_stream(content: ReadableStream<Uint8Array>, options?: ParseOptions): Promise<XmlDocument> {\n  const xml = xml_node(\"~xml\") as XmlDocument\n  const stack = [xml] as Array<XmlNode>\n  await parseXmlStreamFromBytes(content, {\n    // XML declaration\n    onDeclaration(version, encoding, standalone) {\n      if (version)\n        xml[\"@version\"] = version as XmlDocument[\"@version\"]\n      if (encoding)\n        xml[\"@encoding\"] = encoding\n      if (standalone)\n        xml[\"@standalone\"] = standalone\n    },\n    // XML doctype (only the name and public/system identifiers are exposed by @std events)\n    onDoctype(name, publicId, systemId) {\n      const doctype = xml_node(\"~doctype\", { parent: xml })\n      ;[name, publicId, systemId].filter((value) => value !== undefined).forEach((value) => doctype[`@${value}`] = \"\")\n      xml[\"#doctype\"] = doctype\n    },\n    // XML processing instruction\n    onProcessingInstruction(target, instruction) {\n      xml_instruction(xml, target, instruction.trim())\n    },\n    // XML tag opened\n    onStartElement(name, _colon, _uri, attributes, selfClosing) {\n      const node = xml_element(name, stack.at(-1)!)\n      for (let i = 0; i < attributes.count; i++)\n        node[`@${attributes.getName(i)}`] = attributes.getValue(i)\n      if (!selfClosing)\n        stack.push(node)\n    },\n    // XML tag closed\n    onEndElement() {\n      stack.pop()\n    },\n    // Text\n    onText(text) {\n      xml_text(text, { type: \"~text\", parent: stack.at(-1)! })\n    },\n    // CDATA\n    onCData(text) {\n      xml_text(text, { type: \"~cdata\", parent: stack.at(-1)! })\n    },\n    // Comment\n    onComment(text) {\n      xml_text(text, { type: \"~comment\", parent: stack.at(-1)! })\n    },\n  }, { disallowDoctype: false })\n  return finalize(xml, options)\n}\n\n/** Recover `#doctype` and `#instructions`. */\nfunction prescan(content: string, xml: XmlDocument): string {\n  // Prolog: skip whitespace/comments, collect instructions and doctype until the root element opens\n  let i = 0\n  prolog: while (i < content.length) {\n    switch (true) {\n      case /\\s/.test(content[i]): {\n        i++\n        continue\n      }\n      case content.startsWith(\"<!--\", i): {\n        const end = content.indexOf(\"-->\", i + 4)\n        if (end < 0)\n          break prolog\n        i = end + 3\n        continue\n      }\n      case content.startsWith(\"<?\", i): {\n        const end = content.indexOf(\"?>\", i + 2)\n        if (end < 0)\n          break prolog\n        const raw = content.slice(i + 2, end)\n        i = end + 2\n        const target = raw.match(/^\\S+/)?.[0] ?? \"\"\n        // The <?xml?> declaration is already handled through std's DOM\n        if (target !== \"xml\")\n          xml_instruction(xml, target, raw.slice(target.length).trim())\n        continue\n      }\n      case content.startsWith(\"<!DOCTYPE\", i): {\n        // Find the closing \">\", skipping quoted literals and the internal subset \"[...]\"\n        let j = i + 9\n        doctype: while (j < content.length) {\n          switch (content[j]) {\n            case '\"':\n            case \"'\": {\n              const quote = content.indexOf(content[j], j + 1)\n              if (quote < 0)\n                break doctype\n              j = quote + 1\n              break\n            }\n            case \"[\": {\n              const bracket = content.indexOf(\"]\", j + 1)\n              if (bracket < 0)\n                break doctype\n              j = bracket + 1\n              break\n            }\n            case \">\":\n              break doctype\n            default:\n              j++\n          }\n        }\n        xml[\"#doctype\"] = Object.assign(xml_node(\"~doctype\", { parent: xml }), xml_doctype(content.slice(i + 9, j).trim()))\n        const end = Math.min(j + 1, content.length)\n        content = `${content.slice(0, i)}${\" \".repeat(end - i)}${content.slice(end)}`\n        i = end\n        continue\n      }\n      default:\n        break prolog\n    }\n  }\n  // Epilog: only comments and instructions may follow the root element, scan them backwards\n  const instructions = [] as Array<[string, string]>\n  let tail = content.trimEnd()\n  epilog: while (true) {\n    switch (true) {\n      case tail.endsWith(\"-->\"): {\n        const start = tail.lastIndexOf(\"<!--\")\n        if (start < 0)\n          break epilog\n        tail = tail.slice(0, start).trimEnd()\n        continue\n      }\n      case tail.endsWith(\"?>\"): {\n        const start = tail.lastIndexOf(\"<?\")\n        if (start < 0)\n          break epilog\n        const raw = tail.slice(start + 2, -2)\n        const target = raw.match(/^\\S+/)?.[0] ?? \"\"\n        instructions.unshift([target, raw.slice(target.length).trim()])\n        tail = tail.slice(0, start).trimEnd()\n        continue\n      }\n      default:\n        break epilog\n    }\n  }\n  instructions.forEach(([target, raw]) => xml_instruction(xml, target, raw))\n  return content\n}\n\n/** Walk a std DOM element into the ergonomic ~children/@attr/#text structure. */\nfunction build(element: StdElement, parent: XmlNode): void {\n  // Attach under the enumerable key with array-grouping\n  const node = xml_element(element.name.raw, parent)\n  // Attributes\n  for (const [name, value] of Object.entries(element.attributes))\n    node[`@${name}`] = value\n  // Children\n  for (const child of element.children as ReadonlyArray<StdNode>) {\n    switch (child.type) {\n      case \"element\":\n        build(child, node)\n        break\n      case \"text\":\n        xml_text(child.text, { type: \"~text\", parent: node })\n        break\n      case \"cdata\":\n        xml_text(child.text, { type: \"~cdata\", parent: node })\n        break\n      case \"comment\":\n        xml_text(child.text, { type: \"~comment\", parent: node })\n        break\n    }\n  }\n}\n"],"names":[],"mappings":"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"}

package/stringify.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Stringify an XML document object into a XML string.
+ * @module
+ */ import type { Nullable, Stringifyable, XmlNode, XmlText } from "./_types.js";
+export type * from "./_types.js";
+/** XML stringifier options. */ export type StringifyOptions = {
+  /** Format options. */ format?: FormatOptions;
+  /** Replace options. */ replace?: ReplaceOptions;
+};
+/** XML stringifier {@linkcode StringifyOptions}`.format` */ export type FormatOptions = {
+  /**
+   * Indent string (defaults to `"  "`).
+   * Set to empty string to disable indentation and enable minification.
+   */ indent?: string;
+  /** Break text node if its length is greater than this value (defaults to `128`). */ breakline?: number;
+};
+/** XML stringifier {@linkcode StringifyOptions}`.replace` */ export type ReplaceOptions = {
+  /**
+   * Force escape all XML entities.
+   * By default, only the ones that would break the XML structure are escaped.
+   */ entities?: boolean;
+  /**
+   * Custom replacer (this is applied after other revivals).
+   * When it is applied on an attribute, `key` and `value` will be given.
+   * When it is applied on a node, both `key` and `value` will be `null`.
+   * Return `undefined` to delete either the attribute or the tag.
+   */ custom?: Replacer;
+};
+/**
+ * Custom XML stringifier replacer.
+ * It can be used to change the way some nodes are stringified.
+ */ export type Replacer = (args: {
+  name: string;
+  key: Nullable<string>;
+  value: Nullable<string>;
+  node: Readonly<XmlNode>;
+}) => unknown;
+/**
+ * Stringify an {@link XmlDocument} object into a XML string.
+ *
+ * Output can be customized using the {@link options} parameter.
+ *
+ * ```ts
+ * import { stringify } from "./stringify.ts"
+ *
+ * console.log(stringify({
+ *   "@version": "1.0",
+ *   "@standalone": "yes",
+ *   root: {
+ *     text: "hello",
+ *     array: ["world", "monde", "世界", "🌏"],
+ *     number: 42,
+ *     boolean: true,
+ *     complex: {
+ *       "@attribute": "value",
+ *       "#text": "content",
+ *     },
+ *   }
+ * }))
+ * ```
+ */ export declare function stringify(document: Stringifyable, options?: StringifyOptions): string;
+/**
+ * Helper to create a CDATA node.
+ *
+ * ```ts
+ * import { stringify, cdata } from "./stringify.ts"
+ * stringify({ string: cdata(`hello <world>`) })
+ * // <string><![CDATA[hello <world>]]></string>
+ * ```
+ */ export declare function cdata(text: string): Omit<XmlText, "~parent">;
+/**
+ * Helper to create a comment node.
+ *
+ * ```ts
+ * import { stringify, comment } from "./stringify.ts"
+ * stringify({ string: comment(`hello world`) })
+ * // <string><!--hello world--></string>
+ * ```
+ */ export declare function comment(text: string): Omit<XmlText, "~parent">;