@lowlighter/xml 6.0.1 → 8.0.0

package/README.md

@@ -28,7 +28,7 @@ console.log(parse(`
 
 // Parse a file
 using file = await Deno.open("bench/assets/small.xml")
-console.log(parse(file))
+console.log(await parse(file.readable))
 ```
 
 ### Stringifying objects to XML
@@ -51,7 +51,7 @@ console.log(stringify({
 
 ## ✨ Features
 
-- Based on the [quick-xml](https://github.com/tafia/quick-xml) Rust package (compiled to WASM).
+- Based on [`@std/xml`](https://jsr.io/@std/xml).
 - Support for `XML.parse` and `XML.stringify` in the style of the `JSON` global.
 - Support for `<!-- -->` comments.
 - Support for XML entities (`&amp;`, `&#38;`, `&#x26;`, …).
@@ -64,14 +64,75 @@ console.log(stringify({
   - Support for custom `reviver` and `replacer` functions
 - Support for metadata stored into non-enumerable properties (advanced usage).
 
+## 🕊️ Migrating from `7.x.x` to `8.x.x`
+
+### Using `@std/xml` instead of `quick-xml` as parser
+
+The parser is now backed by [`@std/xml`](https://jsr.io/@std/xml) instead of a WASM-compiled binding of the [quick-xml](https://github.com/tafia/quick-xml) Rust package.
+
+This change reduces the maintenance burden of the library while relying on a standardized parser.
+
+The WASM parser from `7.x.x` is still available in the `@libs/xml/wasm/parse` export. While the TypeScript layer will continue being updated, the underlying WASM module that serves quick-xml tokenization won't.
+
+### Exported types are now PascalCase
+
+```diff ts
+- import type { stringify_options, stringifyable, xml_document, xml_node, xml_text } from "jsr:@libs/xml@7/stringify"
++ import type { StringifyOptions, Stringifyable, XmlDocument, XmlNode, XmlText } from "jsr:@libs/xml@8/stringify"
+```
+
+### Unsupported options in the default export
+
+> Note: described options are still available in the legacy WASM backend from `@libs/xml/wasm/parse` export.
+
+The `revive.entities` option of `parse` has been removed, XML entities are now always decoded. If you need values in their escaped form, re-escape them with `escape` from [`@std/html/entities`](https://jsr.io/@std/html):
+
+```diff ts
+- const document = parse(text, { revive: { entities: false } })
++ import { escape } from "jsr:@std/html/entities"
++ const document = parse(text)
++ // Apply `escape()` on values where the escaped form is needed
+```
+
+The `mode: "html"` option of `parse` has been temporarily removed, as `@std/xml` only supports strict XML.
+
+```diff ts
+- import { parse } from "jsr:@libs/xml@8/parse"
++ import { parse } from "jsr:@libs/xml@8/wasm/parse"
+  const document = parse(text, { mode: "html" })
+```
+
+Passing a `ReaderSync` to `parse` is no longer supported. You can still pass a `Reader` to `parse` but the result is now asynchronous.
+
+```diff
+  using file = await Deno.open("bench/assets/small.xml")
+- console.log(parse(file))
++ console.log(await parse(file.readable))
+```
+
+## 🕊️ Migrating from `6.x.x` to `7.x.x`
+
+For both `stringify` and `parse`, the type `options` has been renamed and prefixed by their scope for more clarity.
+
+```diff ts
+- import type { options } from "jsr:@libs/xml@6/stringify"
++ import type { stringify_options } from "jsr:@libs/xml@7/stringify"
+```
+
+```diff ts
+- import type { options } from "jsr:@libs/xml@6/parse"
++ import type { parse_options } from "jsr:@libs/xml@7/parse"
+```
+
+If you didn't use these typings, no further changes are required.
+
 ## 🕊️ Migrating from `5.x.x` to `6.x.x`
 
 Version `6.x.x` and onwards require Deno `2.x.x` or later.
 
 ## 🕊️ Migrating from `4.x.x` to `5.x.x`
 
-Prior to version version `5.0.0`, this library was fully written in TypeScript.
-It now uses a WASM-compiled binding of the [quick-xml](https://github.com/tafia/quick-xml) Rust package, which provides better performance while allowing us to support more features.
+Prior to version version `5.0.0`, this library was fully written in TypeScript. It now uses a WASM-compiled binding of the [quick-xml](https://github.com/tafia/quick-xml) Rust package, which provides better performance while allowing us to support more features.
 
 ### Internal API changes
 
@@ -138,8 +199,7 @@ Processing instructions (like XML stylesheets) are now parsed the same way as re
 
 ### Mixed content support
 
-This breaks any existing code that was expecting mixed content to always be a string.
-Now, mixed content nodes will be parsed as usual, and the `#text` property will contain the "inner text" of the node.
+This breaks any existing code that was expecting mixed content to always be a string. Now, mixed content nodes will be parsed as usual, and the `#text` property will contain the "inner text" of the node.
 
 Note that `#text` is actually a getter that recursively gets the `#text` of children nodes (ignoring comment nodes), so it'll also handle nested mixed content correctly.
 
@@ -159,11 +219,9 @@ Note that `#text` is actually a getter that recursively gets the `#text` of chil
 
 ### Comments
 
-Comments have been moved into `"#comments"` property.
-Note that this property is now always an array, even if there is only one comment.
+Comments have been moved into `"#comments"` property. Note that this property is now always an array, even if there is only one comment.
 
-Additionally, you can find comments into the `~children` property by searching for nodes with `"~name": "~comment"`.
-If you call the `#text` getter on a parent node containing comments, it will return the inner text without comments.
+Additionally, you can find comments into the `~children` property by searching for nodes with `"~name": "~comment"`. If you call the `#text` getter on a parent node containing comments, it will return the inner text without comments.
 
 ```xml
 <root><!--some comment--></root>
@@ -189,8 +247,7 @@ Parsing options are categorized into 4 groups:
 - `revive`, which can `trim` content (unless `xml:space="preserve"`), unescape xml `entities`, revive `booleans` and `numbers`
   - You can also provide a `custom` reviver function (applied after other revivals) that will be called on each attribute and node
   - _Note that signature of the reviver function has changed_
-- `mode`, which can be either `xml` or `html`.
-  Choosing the latter will be more permissive than the former.
+- `mode`, which can be either `xml` or `html`. Choosing the latter will be more permissive than the former.
 
 ```diff js
   const options = {
@@ -212,7 +269,7 @@ Please refer to the [documentation](https://jsr.io/@libs/xml/doc) for more infor
 
 The `parse()` function supports any `ReaderSync`, which means you can pass directly a file reader for example.
 
-```ts
+```ts ignore
 import { parse } from "./parse.ts"
 parse(await Deno.readTextFile("example.xml"))
 ```
@@ -248,8 +305,7 @@ Please refer to the [documentation](https://jsr.io/@libs/xml/doc) for more infor
 
 ### Stringifying content
 
-Please refer to the above section about API changes.
-If you were handling XML document properties, using the `$XML` symbol or `#comment` property, or dealing with mixed nodes content, you'll most likely need to update your code.
+Please refer to the above section about API changes. If you were handling XML document properties, using the `$XML` symbol or `#comment` property, or dealing with mixed nodes content, you'll most likely need to update your code.
 
 Additionally, the library now provides `comment()` and `cdata()` helpers to respectively create comment and CDATA nodes:
 
@@ -287,27 +343,26 @@ stringify({
 </root>
 ```
 
-Note that while you can _theoretically_ use internal API properties, currently, we strongly advise against doing so.
-Supporting `~children` might be added in the future ([#57](https://github.com/lowlighter/libs/issues/57)) for mixed content, but its behavior is not yet well defined.
-Setting `~name` manually might lead to unexpected behaviors, especially if it differs from the parent key.
+Note that while you can _theoretically_ use internal API properties, currently, we strongly advise against doing so. Supporting `~children` might be added in the future ([#57](https://github.com/lowlighter/libs/issues/57)) for mixed content, but its behavior is not yet well
+defined. Setting `~name` manually might lead to unexpected behaviors, especially if it differs from the parent key.
 
 > [!TIP]
-> For more type-safety, write `satisfies Partial<xml_document>` after whatever you pass into `stringify`, like so:
+> For more type-safety, write `satisfies Partial<XmlDocument>` after whatever you pass into `stringify`, like so:
 >
 > <!-- TODO(lishaduck): Add ts highlighting once denoland/deno#24164 is resolved -->
 >
 > ```
-> import { stringify, type xml_document } from "./stringify.ts"
+> import { stringify, type XmlDocument } from "./stringify.ts"
 >
 > const ast = {
 >   "@version": "1.0",
 >   "@encoding": "UTF-8",
 >   "root": {},
-> } satisfies Partial<xml_document>
+> } satisfies Partial<XmlDocument>
 > const result = stringify(ast)
 > ```
 >
-> We expose lax typing, but `Partial<xml_document>` uses the stricter typing we use internally.
+> We expose lax typing, but `Partial<XmlDocument>` uses the stricter typing we use internally.
 
 ## 📜 License and credits
 

package/_parser.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Shared internals between the std-based ({@link ./parse.ts}) and WASM-based ({@link ./wasm/parse.ts}) XML parsers.
+ * @module
+ */ import type { Nullable, XmlNode } from "./_types.js";
+/** XML parser `clean` options. */ export type CleanOptions = {
+  /** Remove attributes from result. */ attributes?: boolean;
+  /** Remove comments from result. */ comments?: boolean;
+  /** Remove XML doctype from result. */ doctype?: boolean;
+  /** Remove XML processing instructions from result. */ instructions?: boolean;
+};
+/** XML parser `flatten` options. */ export type FlattenOptions = {
+  /** If node only contains attributes values (i.e. with key starting with `@`), it'll be flattened as a regular object without `@` prefixes. */ attributes?: boolean;
+  /** If node only contains a `#text` value, it'll be flattened as a string (defaults to `true`). */ text?: boolean;
+  /** If node does not contains any attribute or text, it'll be flattened to `null` (defaults to `true`). */ empty?: boolean;
+};
+/** XML parser `revive` options. */ export type ReviveOptions = {
+  /**
+   * Trim texts (this is applied before other revivals, defaults to `true`).
+   * It honors `xml:space="preserve"` attribute.
+   */ trim?: boolean;
+  /**
+   * Revive XML entities (defaults to `true`).
+   * Automatically unescape XML entities and replace common entities with their respective characters.
+   */ entities?: boolean;
+  /** Revive booleans (matching `/^(?:[Tt]rue|[Ff]alse)$/`).*/ booleans?: boolean;
+  /**
+   * Revive finite numbers.
+   * Note that the version of the XML prolog is always treated as a string to avoid breaking documents.
+   */ numbers?: boolean;
+  /**
+   * Custom reviver (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?: Reviver;
+};
+/**
+ * Custom XML parser reviver.
+ * It can be used to change the way some nodes are parsed.
+ */ export type Reviver = (args: {
+  name: string;
+  key: Nullable<string>;
+  value: Nullable<string>;
+  node: Readonly<XmlNode>;
+}) => unknown;

package/_parser.js

@@ -0,0 +1,266 @@
+/**
+ * Shared internals between the std-based ({@link ./parse.ts}) and WASM-based ({@link ./wasm/parse.ts}) XML parsers.
+ * @module
+ */ // Imports
+/** Apply parser option defaults and post-process the parsed document. */ export function finalize(xml, options) {
+  options ??= {};
+  options.revive ??= {};
+  options.revive.trim ??= true;
+  options.revive.entities ??= true;
+  options.flatten ??= {};
+  options.flatten.text ??= true;
+  options.flatten.empty ??= true;
+  if (!Object.keys(xml).length) throw new SyntaxError("Malformed XML document: empty document or no root node detected");
+  return postprocess(xml, options);
+}
+/** Attach a processing instruction under `#instructions` with array-grouping.  */ export function xml_instruction(xml, name, raw) {
+  const instruction = Object.assign(xml_node(name, {
+    parent: xml
+  }), xml_attributes(raw));
+  xml["#instructions"] ??= {};
+  switch(true){
+    case Array.isArray(xml["#instructions"][name]):
+      ;
+      xml["#instructions"][name].push(instruction);
+      break;
+    case name in xml["#instructions"]:
+      xml["#instructions"][name] = [
+        xml["#instructions"][name],
+        instruction
+      ];
+      break;
+    default:
+      xml["#instructions"][name] = instruction;
+  }
+}
+/** Parse xml attributes. */ export function xml_attributes(raw) {
+  const attributes = {};
+  for (const [_, name, __, value] of raw.matchAll(/(?<name>[A-Za-z_][-\w.:]*)=(["'])(?<value>(?:(?!\2).)*)(\2)/g))attributes[`@${name}`] = value;
+  return attributes;
+}
+/** Parse xml doctype. */ export function xml_doctype(raw) {
+  const node = {};
+  const { attributes: _attributes, elements: _elements = "" } = raw.match(/^(?<attributes>[^\[]*)(?:\[(?<elements>[\s\S]*)\])?/)?.groups;
+  // Parse attributes
+  raw = raw.replace(`[${_elements}]`, "");
+  for (const [match, __, name] of _attributes.matchAll(/(["'])(?<name>(?:(?!\1).)*)(\1)/g)){
+    node[`@${name}`] = "";
+    raw = raw.replace(match, "");
+  }
+  raw.split(/\s+/).filter(Boolean).forEach((name)=>node[`@${name}`] = "");
+  // Parse elements
+  for (const [_, name, value] of _elements.matchAll(/<!ELEMENT\s+(?<name>\w+)\s+\((?<value>[^\)]+)\)/g))node[name] = value;
+  return node;
+}
+/** Create a new text node. */ export function xml_text(value, { type = "~text", parent = null } = {}) {
+  const text = Object.defineProperties({}, {
+    ["~parent"]: {
+      enumerable: false,
+      writable: false,
+      value: parent
+    },
+    ["~name"]: {
+      enumerable: false,
+      writable: false,
+      value: type
+    }
+  });
+  text["#text"] = value;
+  if (parent) parent["~children"].push(text);
+  return text;
+}
+/** Create a new element node and attach it under its parent's enumerable key with array-grouping. */ export function xml_element(name, parent) {
+  const node = xml_node(name, {
+    parent
+  });
+  switch(true){
+    case Array.isArray(parent[node["~name"]]):
+      ;
+      parent[node["~name"]].push(node);
+      break;
+    case node["~name"] in parent:
+      parent[node["~name"]] = [
+        parent[node["~name"]],
+        node
+      ];
+      break;
+    default:
+      parent[node["~name"]] = node;
+  }
+  return node;
+}
+/** Create a new node. */ export function xml_node(name, { parent = null } = {}) {
+  const node = Object.defineProperties({}, {
+    ["~parent"]: {
+      enumerable: false,
+      writable: false,
+      value: parent
+    },
+    ["~name"]: {
+      enumerable: false,
+      writable: false,
+      value: name
+    },
+    ["~children"]: {
+      enumerable: false,
+      writable: true,
+      value: []
+    },
+    ["#text"]: {
+      enumerable: false,
+      configurable: true,
+      get () {
+        const children = this["~children"].filter((node)=>node["~name"] !== "~comment");
+        // If xml:space is not set to "preserve", concatenate text nodes and trim them while removing empty ones
+        if (this["@xml:space"] !== "preserve") return children.map((child)=>child["#text"]).filter(Boolean).join(" ");
+        // If xml:space is set to "preserve", concatenate text nodes without trimming them
+        // In case of mixed content, add a space between mixed nodes if needed
+        let text = "";
+        for(let i = 0; i < children.length; i++){
+          const spaced = i && +children[i - 1]["~name"].startsWith("~") ^ +children[i]["~name"].startsWith("~") && !children[i - 1]["#text"].endsWith(" ") && !children[i]["#text"].startsWith(" ");
+          text += `${spaced ? " " : ""}${children[i]["#text"]}`;
+        }
+        return text;
+      }
+    },
+    ["#comments"]: {
+      enumerable: false,
+      configurable: true,
+      get () {
+        return this["~children"].filter((node)=>node["~name"] === "~comment").map((node)=>node["#text"]);
+      }
+    }
+  });
+  if (parent) parent["~children"].push(node);
+  return node;
+}
+/** Post-process xml node. */ function postprocess(node, options) {
+  // Clean XML document if required
+  if (node["~name"] === "~xml") {
+    if (options?.clean?.doctype) delete node["#doctype"];
+    if (options?.clean?.instructions) {
+      ;
+      node["~children"] = node["~children"].filter((child)=>!(child["~name"] in (node["#instructions"] ?? {})));
+      delete node["#instructions"];
+    }
+  }
+  // Clean node and enable enumerable properties if required
+  if (node["~children"]) {
+    if (options?.clean?.comments) {
+      ;
+      node["~children"] = node["~children"].filter((child)=>child["~name"] !== "~comment");
+    }
+    if (options?.revive?.trim) node["~children"].forEach((child)=>/^~(?:text|cdata|comment)$/.test(child["~name"]) ? child["#text"] = revive(child, "#text", {
+        revive: {
+          trim: node["@xml:space"] !== "preserve"
+        }
+      }) : null);
+    if (node["~children"].some((child)=>/^~(?:text|cdata)$/.test(child["~name"]) && child["#text"].trim().length + (node["@xml:space"] === "preserve" ? 1 : 0) * child["#text"].length)) Object.defineProperty(node, "#text", {
+      enumerable: true,
+      configurable: true
+    });
+    if (node["~children"].some((child)=>child["~name"] === "~comment")) Object.defineProperty(node, "#comments", {
+      enumerable: true,
+      configurable: true
+    });
+  }
+  // Process child nodes
+  for (const [key, value] of Object.entries(node)){
+    // Skip comments
+    if (key === "#comments") continue;
+    // Clean attributes if required
+    if (options?.clean?.attributes && key.startsWith("@")) {
+      delete node[key];
+      continue;
+    }
+    // Revive attribute value if required
+    if (key.startsWith("@")) {
+      node[key] = revive(node, key, options);
+      if (node[key] === undefined) delete node[key];
+      continue;
+    }
+    // Handle other nodes
+    if (Array.isArray(value)) {
+      node[key] = Object.defineProperties(value.map((child)=>postprocess(child, options)), {
+        ["~parent"]: {
+          enumerable: false,
+          writable: false,
+          value: node
+        },
+        ["~name"]: {
+          enumerable: false,
+          writable: false,
+          value: key
+        }
+      });
+    } else if (typeof value === "object" && value) {
+      node[key] = postprocess(value, options);
+    }
+    if (node[key] === undefined) delete node[key];
+  }
+  // Revive text if required
+  const keys = Object.keys(node);
+  if (keys.includes("#text")) {
+    const _options = {
+      ...options,
+      revive: {
+        ...options?.revive,
+        trim: options?.revive?.trim && node["@xml:space"] !== "preserve"
+      }
+    };
+    Object.defineProperty(node, "#text", {
+      enumerable: true,
+      configurable: true,
+      value: revive(node, "#text", _options)
+    });
+  }
+  // Custom revival if required
+  if (options?.revive?.custom) {
+    if (options.revive.custom({
+      name: node["~name"],
+      key: null,
+      value: null,
+      node: node
+    }) === undefined) return undefined;
+  }
+  // Flatten object if required
+  if (options?.flatten?.text && keys.length === 1 && keys.includes("#text")) return node["#text"];
+  if (options?.flatten?.attributes && keys.length && keys.every((key)=>key.startsWith("@"))) {
+    for (const key of keys){
+      node[key.slice(1)] = node[key];
+      delete node[key];
+    }
+    return node;
+  }
+  if (!keys.length) return options?.flatten?.empty ? null : options?.flatten?.text ? "" : Object.defineProperty(node, "#text", {
+    enumerable: true,
+    configurable: true,
+    value: ""
+  });
+  return node;
+}
+/** Entities */ const entities = {
+  "&lt;": "<",
+  "&gt;": ">",
+  "&apos;": "'",
+  "&quot;": '"',
+  "&amp;": "&"
+};
+/** Revive value. */ function revive(node, key, options) {
+  let value = node[key];
+  if (options?.revive?.trim) value = value.trim();
+  if (options?.revive?.entities) {
+    value = value.replaceAll(/&#(?<hex>x?)(?<code>[A-Fa-f\d]+);/g, (_, hex, code)=>String.fromCharCode(Number.parseInt(code, hex ? 16 : 10)));
+    for (const [entity, character] of Object.entries(entities))value = value.replaceAll(entity, character);
+  }
+  if (options?.revive?.numbers && value.length && Number.isFinite(Number(value)) && !(node["~name"] === "~xml" && key === "@version")) value = Number(value);
+  if (options?.revive?.booleans && /^(?:[Tt]rue|[Ff]alse)$/.test(value)) value = /^[Tt]rue$/.test(value);
+  if (options?.revive?.custom) return options.revive.custom({
+    name: node["~name"],
+    key,
+    value,
+    node: node
+  });
+  return value;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/libs/libs/@libs/xml/_parser.ts"],"sourcesContent":["/**\n * Shared internals between the std-based ({@link ./parse.ts}) and WASM-based ({@link ./wasm/parse.ts}) XML parsers.\n * @module\n */\n\n// Imports\nimport type { Nullable, XmlDocument, XmlNode, XmlText } from \"./_types.js\"\n\n/** XML parser `clean` options. */\nexport type CleanOptions = {\n  /** Remove attributes from result. */\n  attributes?: boolean\n  /** Remove comments from result. */\n  comments?: boolean\n  /** Remove XML doctype from result. */\n  doctype?: boolean\n  /** Remove XML processing instructions from result. */\n  instructions?: boolean\n}\n\n/** XML parser `flatten` options. */\nexport type FlattenOptions = {\n  /** If node only contains attributes values (i.e. with key starting with `@`), it'll be flattened as a regular object without `@` prefixes. */\n  attributes?: boolean\n  /** If node only contains a `#text` value, it'll be flattened as a string (defaults to `true`). */\n  text?: boolean\n  /** If node does not contains any attribute or text, it'll be flattened to `null` (defaults to `true`). */\n  empty?: boolean\n}\n\n/** XML parser `revive` options. */\nexport type ReviveOptions = {\n  /**\n   * Trim texts (this is applied before other revivals, defaults to `true`).\n   * It honors `xml:space=\"preserve\"` attribute.\n   */\n  trim?: boolean\n  /**\n   * Revive XML entities (defaults to `true`).\n   * Automatically unescape XML entities and replace common entities with their respective characters.\n   */\n  entities?: boolean\n  /** Revive booleans (matching `/^(?:[Tt]rue|[Ff]alse)$/`).*/\n  booleans?: boolean\n  /**\n   * Revive finite numbers.\n   * Note that the version of the XML prolog is always treated as a string to avoid breaking documents.\n   */\n  numbers?: boolean\n  /**\n   * Custom reviver (this is applied after other revivals).\n   * When it is applied on an attribute, `key` and `value` will be given.\n   * When it is applied on a node, both `key` and `value` will be `null`.\n   * Return `undefined` to delete either the attribute or the tag.\n   */\n  custom?: Reviver\n}\n\n/**\n * Custom XML parser reviver.\n * It can be used to change the way some nodes are parsed.\n */\nexport type Reviver = (args: { name: string; key: Nullable<string>; value: Nullable<string>; node: Readonly<XmlNode> }) => unknown\n\n/** Backend-agnostic parser options (each backend extends it with its own supported `mode`). */\nexport type ParserOptions = {\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\n/** Apply parser option defaults and post-process the parsed document. */\nexport function finalize(xml: XmlDocument, options?: ParserOptions): XmlDocument {\n  options ??= {}\n  options.revive ??= {}\n  options.revive.trim ??= true\n  options.revive.entities ??= true\n  options.flatten ??= {}\n  options.flatten.text ??= true\n  options.flatten.empty ??= true\n  if (!Object.keys(xml).length)\n    throw new SyntaxError(\"Malformed XML document: empty document or no root node detected\")\n  return postprocess(xml, options) as XmlDocument\n}\n\n/** Attach a processing instruction under `#instructions` with array-grouping.  */\nexport function xml_instruction(xml: XmlDocument, name: string, raw: string): void {\n  const instruction = Object.assign(xml_node(name, { parent: xml }), xml_attributes(raw))\n  xml[\"#instructions\"] ??= {}\n  switch (true) {\n    case Array.isArray(xml[\"#instructions\"][name]):\n      ;(xml[\"#instructions\"][name] as Array<XmlNode>).push(instruction)\n      break\n    case name in xml[\"#instructions\"]:\n      xml[\"#instructions\"][name] = [xml[\"#instructions\"][name] as XmlNode, instruction]\n      break\n    default:\n      xml[\"#instructions\"][name] = instruction\n  }\n}\n\n/** Parse xml attributes. */\nexport function xml_attributes(raw: string): Record<PropertyKey, string> {\n  const attributes = {} as Record<PropertyKey, string>\n  for (const [_, name, __, value] of raw.matchAll(/(?<name>[A-Za-z_][-\\w.:]*)=([\"'])(?<value>(?:(?!\\2).)*)(\\2)/g))\n    attributes[`@${name}`] = value\n  return attributes\n}\n\n/** Parse xml doctype. */\nexport function xml_doctype(raw: string): XmlNode {\n  const node = {} as XmlNode\n  const { attributes: _attributes, elements: _elements = \"\" } = raw.match(/^(?<attributes>[^\\[]*)(?:\\[(?<elements>[\\s\\S]*)\\])?/)?.groups!\n  // Parse attributes\n  raw = raw.replace(`[${_elements}]`, \"\")\n  for (const [match, __, name] of _attributes.matchAll(/([\"'])(?<name>(?:(?!\\1).)*)(\\1)/g)) {\n    node[`@${name}`] = \"\"\n    raw = raw.replace(match, \"\")\n  }\n  raw.split(/\\s+/).filter(Boolean).forEach((name) => node[`@${name}`] = \"\")\n  // Parse elements\n  for (const [_, name, value] of _elements.matchAll(/<!ELEMENT\\s+(?<name>\\w+)\\s+\\((?<value>[^\\)]+)\\)/g))\n    node[name] = value\n  return node\n}\n\n/** Create a new text node. */\nexport function xml_text(value: string, { type = \"~text\" as \"~text\" | \"~cdata\" | \"~comment\", parent = null as Nullable<XmlNode> } = {}): XmlText {\n  const text = Object.defineProperties({}, {\n    [\"~parent\"]: { enumerable: false, writable: false, value: parent },\n    [\"~name\"]: { enumerable: false, writable: false, value: type },\n  }) as XmlText\n  text[\"#text\"] = value\n  if (parent)\n    parent[\"~children\"].push(text)\n  return text\n}\n\n/** Create a new element node and attach it under its parent's enumerable key with array-grouping. */\nexport function xml_element(name: string, parent: XmlNode): XmlNode {\n  const node = xml_node(name, { parent })\n  switch (true) {\n    case Array.isArray(parent[node[\"~name\"]]):\n      ;(parent[node[\"~name\"]] as Array<XmlNode>).push(node)\n      break\n    case node[\"~name\"] in parent:\n      parent[node[\"~name\"]] = [parent[node[\"~name\"]], node]\n      break\n    default:\n      parent[node[\"~name\"]] = node\n  }\n  return node\n}\n\n/** Create a new node. */\nexport function xml_node(name: string, { parent = null as Nullable<XmlNode> } = {}): XmlNode {\n  const node = Object.defineProperties({}, {\n    [\"~parent\"]: { enumerable: false, writable: false, value: parent },\n    [\"~name\"]: { enumerable: false, writable: false, value: name },\n    [\"~children\"]: { enumerable: false, writable: true, value: [] },\n    [\"#text\"]: {\n      enumerable: false,\n      configurable: true,\n      get(this: XmlNode) {\n        const children = this[\"~children\"].filter((node) => node[\"~name\"] !== \"~comment\")\n        // If xml:space is not set to \"preserve\", concatenate text nodes and trim them while removing empty ones\n        if (this[\"@xml:space\"] !== \"preserve\")\n          return children.map((child) => child[\"#text\"]).filter(Boolean).join(\" \")\n        // If xml:space is set to \"preserve\", concatenate text nodes without trimming them\n        // In case of mixed content, add a space between mixed nodes if needed\n        let text = \"\"\n        for (let i = 0; i < children.length; i++) {\n          const spaced = i && (+children[i - 1][\"~name\"].startsWith(\"~\") ^ +children[i][\"~name\"].startsWith(\"~\")) && (!children[i - 1][\"#text\"].endsWith(\" \")) && (!children[i][\"#text\"].startsWith(\" \"))\n          text += `${spaced ? \" \" : \"\"}${children[i][\"#text\"]}`\n        }\n        return text\n      },\n    },\n    [\"#comments\"]: {\n      enumerable: false,\n      configurable: true,\n      get(this: XmlNode) {\n        return this[\"~children\"].filter((node) => node[\"~name\"] === \"~comment\").map((node) => node[\"#text\"]!)\n      },\n    },\n  }) as XmlNode\n  if (parent)\n    parent[\"~children\"].push(node)\n  return node\n}\n\n/** Post-process xml node. */\nfunction postprocess(node: XmlNode, options: ParserOptions) {\n  // Clean XML document if required\n  if (node[\"~name\"] === \"~xml\") {\n    if (options?.clean?.doctype)\n      delete node[\"#doctype\"]\n    if (options?.clean?.instructions) {\n      ;(node as Record<PropertyKey, unknown>)[\"~children\"] = node[\"~children\"].filter((child) => !(child[\"~name\"] in ((node as XmlDocument)[\"#instructions\"] ?? {})))\n      delete node[\"#instructions\"]\n    }\n  }\n  // Clean node and enable enumerable properties if required\n  if (node[\"~children\"]) {\n    if (options?.clean?.comments) {\n      ;(node as Record<PropertyKey, unknown>)[\"~children\"] = node[\"~children\"].filter((child) => child[\"~name\"] !== \"~comment\")\n    }\n    if (options?.revive?.trim)\n      node[\"~children\"].forEach((child) => /^~(?:text|cdata|comment)$/.test(child[\"~name\"]) ? (child as Record<PropertyKey, unknown>)[\"#text\"] = revive(child, \"#text\", { revive: { trim: node[\"@xml:space\"] !== \"preserve\" } }) : null)\n    if (node[\"~children\"].some((child) => (/^~(?:text|cdata)$/.test(child[\"~name\"])) && (child[\"#text\"].trim().length + (node[\"@xml:space\"] === \"preserve\" ? 1 : 0) * child[\"#text\"].length)))\n      Object.defineProperty(node, \"#text\", { enumerable: true, configurable: true })\n    if (node[\"~children\"].some((child) => child[\"~name\"] === \"~comment\"))\n      Object.defineProperty(node, \"#comments\", { enumerable: true, configurable: true })\n  }\n  // Process child nodes\n  for (const [key, value] of Object.entries(node)) {\n    // Skip comments\n    if (key === \"#comments\")\n      continue\n    // Clean attributes if required\n    if ((options?.clean?.attributes) && (key.startsWith(\"@\"))) {\n      delete node[key]\n      continue\n    }\n    // Revive attribute value if required\n    if (key.startsWith(\"@\")) {\n      node[key] = revive(node, key, options)\n      if (node[key] === undefined)\n        delete node[key]\n      continue\n    }\n    // Handle other nodes\n    if (Array.isArray(value)) {\n      node[key] = Object.defineProperties(value.map((child) => postprocess(child, options)), {\n        [\"~parent\"]: { enumerable: false, writable: false, value: node },\n        [\"~name\"]: { enumerable: false, writable: false, value: key },\n      })\n    } else if ((typeof value === \"object\") && value) {\n      node[key] = postprocess(value as XmlNode, options)\n    }\n    if (node[key] === undefined)\n      delete node[key]\n  }\n  // Revive text if required\n  const keys = Object.keys(node)\n  if (keys.includes(\"#text\")) {\n    const _options = { ...options, revive: { ...options?.revive, trim: (options?.revive?.trim) && (node[\"@xml:space\"] !== \"preserve\") } }\n    Object.defineProperty(node, \"#text\", { enumerable: true, configurable: true, value: revive(node, \"#text\", _options) })\n  }\n  // Custom revival if required\n  if (options?.revive?.custom) {\n    if (options.revive.custom({ name: node[\"~name\"], key: null, value: null, node: node as XmlNode }) === undefined)\n      return undefined\n  }\n  // Flatten object if required\n  if ((options?.flatten?.text) && (keys.length === 1) && (keys.includes(\"#text\")))\n    return node[\"#text\"]\n  if ((options?.flatten?.attributes) && (keys.length) && (keys.every((key) => key.startsWith(\"@\")))) {\n    for (const key of keys) {\n      node[key.slice(1)] = node[key]\n      delete node[key]\n    }\n    return node\n  }\n  if (!keys.length)\n    return (options?.flatten?.empty) ? null : (options?.flatten?.text) ? \"\" : Object.defineProperty(node, \"#text\", { enumerable: true, configurable: true, value: \"\" })\n  return node\n}\n\n/** Entities */\nconst entities = {\n  \"&lt;\": \"<\",\n  \"&gt;\": \">\",\n  \"&apos;\": \"'\",\n  \"&quot;\": '\"',\n  \"&amp;\": \"&\", //Keep last\n} as const\n\n/** Revive value. */\nfunction revive(node: XmlNode | XmlText, key: string, options: ParserOptions) {\n  let value = (node as XmlNode)[key] as string\n  if (options?.revive?.trim)\n    value = value.trim()\n  if (options?.revive?.entities) {\n    value = value.replaceAll(/&#(?<hex>x?)(?<code>[A-Fa-f\\d]+);/g, (_, hex, code) => String.fromCharCode(Number.parseInt(code, hex ? 16 : 10)))\n    for (const [entity, character] of Object.entries(entities))\n      value = value.replaceAll(entity, character)\n  }\n  if ((options?.revive?.numbers) && (value.length) && (Number.isFinite(Number(value))) && (!((node[\"~name\"] === \"~xml\") && (key === \"@version\"))))\n    value = Number(value) as unknown as string\n  if ((options?.revive?.booleans) && (/^(?:[Tt]rue|[Ff]alse)$/.test(value)))\n    value = /^[Tt]rue$/.test(value) as unknown as string\n  if (options?.revive?.custom)\n    return options.revive.custom({ name: node[\"~name\"], key, value, node: node as XmlNode })\n  return value\n}\n"],"names":[],"mappings":"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"}

package/_types.d.ts

@@ -0,0 +1,29 @@
+/** Nullable type. */ export type Nullable<T> = T | null;
+/** XML text node. */ export type XmlText = {
+  /** Parent node. */ readonly ["~parent"]: XmlNode;
+  /** Tag name (`~text` for text nodes, `~cdata` for CDATA nodes and `~comment` for comment nodes). */ readonly ["~name"]: string;
+  /** Text content. */ ["#text"]: string;
+};
+/** XML node. */ export type XmlNode = {
+  /** Tag name (`~xml` for XML prolog, other nodes will be given their respective tag name). */ readonly ["~name"]: string;
+  /** Child nodes. */ readonly ["~children"]: Array<XmlNode | XmlText>;
+  /** Comments. */ readonly ["#comments"]?: Array<string>;
+  /** Text content. */ readonly ["#text"]: string;
+  [key: string]: unknown;
+};
+/** XML document. */ export type XmlDocument = XmlNode & {
+  /** XML version. */ ["@version"]?: `1.${number}`;
+  /** XML character encoding. */ ["@encoding"]?: string;
+  /** XML standalone. */ ["@standalone"]?: "yes" | "no";
+  /** XML doctype. */ ["#doctype"]?: XmlNode;
+  /** XML instructions. */ ["#instructions"]?: {
+    [key: string]: XmlNode | Array<XmlNode>;
+  };
+};
+/** Synchronous reader. */ export type ReaderSync = {
+  /** Read synchronously some data into a buffer and returns the number of bytes read. */ readSync(buffer: Uint8Array): Nullable<number>;
+};
+/** A laxer type for what can be stringified. We won’t ever create this, but we’ll accept it. */ export type Stringifyable = Partial<Omit<XmlDocument, "@version" | "@standalone"> & {
+  "@version": string;
+  "@standalone": string;
+}>;

package/_types.js

@@ -0,0 +1,2 @@
+/** Nullable type. */ 
+//# sourceMappingURL=data:application/json;base64,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

package/bench/assets/medium.xml

@@ -288,4 +288,4 @@
     <PRICE>$3.02</PRICE>
     <AVAILABILITY>022299</AVAILABILITY>
   </PLANT>
-</CATALOG>
+</CATALOG>

package/bench/assets/small.xml

@@ -4,4 +4,4 @@
   <from>Jani</from>
   <heading>Reminder</heading>
   <body>Don't forget me this weekend!</body>
-</note>
+</note>

package/bench/bench.ts

@@ -1,12 +1,16 @@
-import { expandGlob } from "@std/fs/expand-glob"
+// deno-lint-ignore-file no-external-import no-import-prefix
+import { expandGlob } from "jsr:@std/fs@1/expand-glob"
 import { parse } from "../mod.ts"
+import { parse as parseWasm } from "../wasm/parse.ts"
+import { parse as parse_v7 } from "jsr:@libs/xml@7.0.4/parse"
+import { parse as parse_v6 } from "jsr:@libs/xml@6.0.8/parse"
 import { parse as parse_v5 } from "jsr:@libs/xml@5.0.2/parse"
 import { parse as parse_v4 } from "https://deno.land/x/xml@4.0.0/parse.ts"
 import { parse as parse_v3 } from "https://deno.land/x/xml@3.0.2/parse.ts"
 
 for await (const { name, path } of expandGlob("**/!(x-)*.xml", { globstar: true })) {
   const { size } = await (await Deno.open(path)).stat()
-  for (const [func, f] of Object.entries({ parse, parse_v5, parse_v4, parse_v3 })) {
+  for (const [func, f] of Object.entries<(content: string) => unknown>({ parse, parseWasm, parse_v7, parse_v6, parse_v5, parse_v4, parse_v3 })) {
     Deno.bench(`${func}(): ${name}, ${size}b)`, async function (t) {
       const content = await Deno.readTextFile(path)
       t.start()