@lowlighter/xml 6.0.1 → 8.0.0

package/stringify.js

@@ -0,0 +1,263 @@
+/**
+ * Stringify an XML document object into a XML string.
+ * @module
+ */ // Imports
+/** Internal symbol to store properties without erasing user-provided ones. */ const internal = Symbol("internal");
+/**
+ * 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 function stringify(document, options) {
+  options ??= {};
+  options.format ??= {};
+  options.format.indent ??= "  ";
+  options.format.breakline ??= 128;
+  const _options = options;
+  let text = "";
+  document = clone(document);
+  // Add prolog
+  text += xml_prolog(document, _options);
+  // Add processing instructions
+  if (document["#instructions"]) {
+    for (const [name, nodes] of Object.entries(document["#instructions"])){
+      for (const node of [
+        nodes
+      ].flat()){
+        if (!("~name" in node)) Object.defineProperties(node, {
+          ["~name"]: {
+            enumerable: false,
+            writable: false,
+            value: name
+          }
+        });
+        text += xml_instruction(node, _options);
+      }
+    }
+  }
+  // Add doctype
+  if (document["#doctype"]) text += xml_doctype(document["#doctype"], _options);
+  // Add root node
+  const [root, ...garbage] = xml_children(document, _options);
+  if (!root) throw new SyntaxError("No root node detected");
+  if (garbage.length) throw new SyntaxError("Multiple root node detected");
+  text += xml_node(root, {
+    ..._options,
+    depth: 0
+  });
+  return text.trim();
+}
+/**
+ * Clone the provided user document so it {@linkcode stringify} can edit it in-place without affecting user.
+ *
+ * It copies all enumerable properties along non-enumerable one supported by `parse`
+ */ function clone(document) {
+  const cloned = Array.isArray(document) ? [] : {};
+  for(const property in document)cloned[property] = document[property] !== null && [
+    "object",
+    "function"
+  ].includes(typeof document[property]) ? clone(document[property]) : document[property];
+  [
+    "~name",
+    "~parent",
+    "#text",
+    "~children",
+    "#comments",
+    "#text",
+    "#doctype",
+    "#instructions",
+    internal
+  ].forEach((property)=>{
+    if (property in document) Object.defineProperty(cloned, property, Object.getOwnPropertyDescriptor(document, property));
+  });
+  return cloned;
+}
+/**
+ * Helper to create a CDATA node.
+ *
+ * ```ts
+ * import { stringify, cdata } from "./stringify.ts"
+ * stringify({ string: cdata(`hello <world>`) })
+ * // <string><![CDATA[hello <world>]]></string>
+ * ```
+ */ export function cdata(text) {
+  return {
+    "~name": "~cdata",
+    "#text": text
+  };
+}
+/**
+ * Helper to create a comment node.
+ *
+ * ```ts
+ * import { stringify, comment } from "./stringify.ts"
+ * stringify({ string: comment(`hello world`) })
+ * // <string><!--hello world--></string>
+ * ```
+ */ export function comment(text) {
+  return {
+    "~name": "~comment",
+    "#text": text
+  };
+}
+/** Create XML prolog. */ function xml_prolog(document, options) {
+  ;
+  document["~name"] ??= "xml";
+  return xml_instruction(document, options);
+}
+/** Create XML instruction. */ function xml_instruction(node, { format: { indent } }) {
+  let text = "";
+  const attributes = xml_attributes(node, arguments[1]);
+  if (attributes.length) {
+    text += `<?${node["~name"].replace(/^~/, "")}`;
+    for (const [name, value] of attributes)text += ` ${name}="${value}"`;
+    text += `?>${indent ? "\n" : ""}`;
+  }
+  return text;
+}
+/** Create XML doctype. */ function xml_doctype(node, { format: { indent } }) {
+  let text = "";
+  const attributes = xml_attributes(node, arguments[1]);
+  const elements = xml_children(node, arguments[1]);
+  if (attributes.length + elements.length) {
+    text += `<!DOCTYPE`;
+    for (const [name] of attributes)text += ` ${!/^[A-Za-z0-9_]+$/.test(name) ? `"${name}"` : name}`;
+    if (elements.length) {
+      text += `${indent ? `\n${indent}` : " "}[${indent ? "\n" : ""}`;
+      for (const element of elements)text += `${indent}<!ELEMENT ${element["~name"]} (${element["#text"]})>${indent ? "\n" : ""}`;
+      text += `${indent ? indent : ""}]${indent ? "\n" : ""}`;
+    }
+    text += `>${indent ? "\n" : ""}`;
+  }
+  return text;
+}
+/** Create XML node. */ function xml_node(node, { format: { breakline = 0, indent = "" }, replace, depth = 0 }) {
+  if (replace?.custom) {
+    if (replace.custom({
+      name: node["~name"],
+      key: null,
+      value: null,
+      node
+    }) === undefined) return "";
+  }
+  let text = `${indent.repeat(depth)}<${node["~name"]}`;
+  const attributes = xml_attributes(node, arguments[1]);
+  const children = xml_children(node, arguments[1]);
+  const preserve = node["@xml:space"] === "preserve";
+  for (const [name, value] of attributes)text += ` ${name}="${value}"`;
+  if (children.length || "#text" in node && node["#text"].length) {
+    const inline = indent && !preserve && (children.length || node["#text"].length > breakline - indent.length * depth);
+    text += `>${indent && !preserve && children.length ? "\n" : ""}`;
+    if ("#text" in node) {
+      if (inline) text += `\n${indent.repeat(depth + 1)}`;
+      text += node["#text"];
+      if (inline) text += "\n";
+    }
+    for (const child of children)text += xml_node(child, {
+      ...arguments[1],
+      depth: depth + 1
+    });
+    if (inline) text += indent.repeat(depth);
+    text += `</${node["~name"]}>${indent ? "\n" : ""}`;
+  } else {
+    text += `/>${indent ? "\n" : ""}`;
+  }
+  return text;
+}
+/** Extract children from node. */ function xml_children(node, options) {
+  const children = Object.keys(node).filter((key)=>/^[A-Za-z_]/.test(key)).flatMap((key)=>[
+      node[key]
+    ].flat().map((value)=>{
+      switch(true){
+        case value === null:
+          return {
+            ["~name"]: key,
+            ["#text"]: ""
+          };
+        case typeof value === "object":
+          {
+            const child = {
+              ...value,
+              ["~name"]: key
+            };
+            if (value["~name"]?.startsWith("~")) child[internal] = value["~name"];
+            return child;
+          }
+        default:
+          return {
+            ["~name"]: key,
+            ["#text"]: `${value}`
+          };
+      }
+    })).map((node)=>{
+    if ("#text" in node) {
+      const cdata = node[internal] === "~cdata";
+      const comment = node[internal] === "~comment";
+      node["#text"] = replace(node, "#text", {
+        ...options,
+        escape: cdata ? [] : [
+          "&",
+          "<",
+          ">"
+        ]
+      });
+      if (node["#text"] === undefined) delete node["#text"];
+      else node["#text"] = cdata ? `<![CDATA[${node["#text"]}]]>` : comment ? `<!--${node["#text"]}-->` : `${node["#text"]}`;
+    }
+    return node;
+  });
+  return children;
+}
+/** Extract attributes from node. */ function xml_attributes(node, options) {
+  return Object.entries(node).filter(([key])=>key.startsWith("@")).map(([key])=>[
+      key.slice(1),
+      replace(node, key, {
+        ...options,
+        escape: [
+          "&",
+          '"',
+          "'"
+        ]
+      })
+    ]).filter(([_, value])=>value !== undefined);
+}
+/** Entities */ const entities = {
+  "&": "&amp;",
+  '"': "&quot;",
+  "<": "&lt;",
+  ">": "&gt;",
+  "'": "&apos;"
+};
+/** Replace value. */ function replace(node, key, options) {
+  let value = `${node[key]}`;
+  if (options?.escape) {
+    if (options?.replace?.entities) options.escape = Object.keys(entities);
+    for (const char of options?.escape)value = `${value}`.replaceAll(char, entities[char]);
+  }
+  if (options?.replace?.custom) return options.replace.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/stringify.ts"],"sourcesContent":["/**\n * Stringify an XML document object into a XML string.\n * @module\n */\n\n// Imports\nimport type { Nullable, Stringifyable, XmlDocument, XmlNode, XmlText } from \"./_types.js\"\nexport type * from \"./_types.js\"\n\n/** XML stringifier options. */\nexport type StringifyOptions = {\n  /** Format options. */\n  format?: FormatOptions\n  /** Replace options. */\n  replace?: ReplaceOptions\n}\n\n/** XML stringifier {@linkcode StringifyOptions}`.format` */\nexport type FormatOptions = {\n  /**\n   * Indent string (defaults to `\"  \"`).\n   * Set to empty string to disable indentation and enable minification.\n   */\n  indent?: string\n  /** Break text node if its length is greater than this value (defaults to `128`). */\n  breakline?: number\n}\n\n/** XML stringifier {@linkcode StringifyOptions}`.replace` */\nexport type ReplaceOptions = {\n  /**\n   * Force escape all XML entities.\n   * By default, only the ones that would break the XML structure are escaped.\n   */\n  entities?: boolean\n  /**\n   * Custom replacer (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?: Replacer\n}\n\n/**\n * Custom XML stringifier replacer.\n * It can be used to change the way some nodes are stringified.\n */\nexport type Replacer = (args: { name: string; key: Nullable<string>; value: Nullable<string>; node: Readonly<XmlNode> }) => unknown\n\n/** XML stringifier options (with non-nullable format options). */\ntype _Options = StringifyOptions & { format: NonNullable<StringifyOptions[\"format\"]> }\n\n/** Internal symbol to store properties without erasing user-provided ones. */\nconst internal = Symbol(\"internal\")\n\n/**\n * Stringify an {@link XmlDocument} object into a XML string.\n *\n * Output can be customized using the {@link options} parameter.\n *\n * ```ts\n * import { stringify } from \"./stringify.ts\"\n *\n * console.log(stringify({\n *   \"@version\": \"1.0\",\n *   \"@standalone\": \"yes\",\n *   root: {\n *     text: \"hello\",\n *     array: [\"world\", \"monde\", \"世界\", \"🌏\"],\n *     number: 42,\n *     boolean: true,\n *     complex: {\n *       \"@attribute\": \"value\",\n *       \"#text\": \"content\",\n *     },\n *   }\n * }))\n * ```\n */\nexport function stringify(document: Stringifyable, options?: StringifyOptions): string {\n  options ??= {}\n  options.format ??= {}\n  options.format.indent ??= \"  \"\n  options.format.breakline ??= 128\n  const _options = options as _Options\n  let text = \"\"\n  document = clone(document)\n  // Add prolog\n  text += xml_prolog(document as XmlDocument, _options)\n  // Add processing instructions\n  if (document[\"#instructions\"]) {\n    for (const [name, nodes] of Object.entries(document[\"#instructions\"])) {\n      for (const node of [nodes].flat()) {\n        if (!(\"~name\" in node))\n          Object.defineProperties(node, { [\"~name\"]: { enumerable: false, writable: false, value: name } })\n        text += xml_instruction(node, _options)\n      }\n    }\n  }\n  // Add doctype\n  if (document[\"#doctype\"])\n    text += xml_doctype(document[\"#doctype\"] as XmlNode, _options)\n\n  // Add root node\n  const [root, ...garbage] = xml_children(document as XmlDocument, _options)\n  if (!root)\n    throw new SyntaxError(\"No root node detected\")\n  if (garbage.length)\n    throw new SyntaxError(\"Multiple root node detected\")\n  text += xml_node(root, { ..._options, depth: 0 })\n\n  return text.trim()\n}\n\n/**\n * Clone the provided user document so it {@linkcode stringify} can edit it in-place without affecting user.\n *\n * It copies all enumerable properties along non-enumerable one supported by `parse`\n */\nfunction clone(document: Record<PropertyKey, unknown>) {\n  const cloned = (Array.isArray(document) ? [] : {}) as typeof document\n  for (const property in document)\n    cloned[property] = ((document[property] !== null) && ([\"object\", \"function\"].includes(typeof document[property]))) ? clone(document[property] as Record<PropertyKey, unknown>) : document[property]\n  ;[\"~name\", \"~parent\", \"#text\", \"~children\", \"#comments\", \"#text\", \"#doctype\", \"#instructions\", internal].forEach((property) => {\n    if (property in document)\n      Object.defineProperty(cloned, property, Object.getOwnPropertyDescriptor(document, property)!)\n  })\n  return cloned\n}\n\n/**\n * Helper to create a CDATA node.\n *\n * ```ts\n * import { stringify, cdata } from \"./stringify.ts\"\n * stringify({ string: cdata(`hello <world>`) })\n * // <string><![CDATA[hello <world>]]></string>\n * ```\n */\nexport function cdata(text: string): Omit<XmlText, \"~parent\"> {\n  return {\n    \"~name\": \"~cdata\",\n    \"#text\": text,\n  }\n}\n\n/**\n * Helper to create a comment node.\n *\n * ```ts\n * import { stringify, comment } from \"./stringify.ts\"\n * stringify({ string: comment(`hello world`) })\n * // <string><!--hello world--></string>\n * ```\n */\nexport function comment(text: string): Omit<XmlText, \"~parent\"> {\n  return {\n    \"~name\": \"~comment\",\n    \"#text\": text,\n  }\n}\n\n/** Create XML prolog. */\nfunction xml_prolog(document: XmlDocument, options: _Options): string {\n  ;(document as Record<PropertyKey, unknown>)[\"~name\"] ??= \"xml\"\n  return xml_instruction(document, options)\n}\n\n/** Create XML instruction. */\nfunction xml_instruction(node: XmlNode, { format: { indent } }: _Options): string {\n  let text = \"\"\n  const attributes = xml_attributes(node as XmlNode, arguments[1])\n  if (attributes.length) {\n    text += `<?${node[\"~name\"].replace(/^~/, \"\")}`\n    for (const [name, value] of attributes)\n      text += ` ${name}=\"${value}\"`\n    text += `?>${indent ? \"\\n\" : \"\"}`\n  }\n  return text\n}\n\n/** Create XML doctype. */\nfunction xml_doctype(node: XmlNode, { format: { indent } }: _Options): string {\n  let text = \"\"\n  const attributes = xml_attributes(node, arguments[1])\n  const elements = xml_children(node, arguments[1])\n  if (attributes.length + elements.length) {\n    text += `<!DOCTYPE`\n    for (const [name] of attributes)\n      text += ` ${!/^[A-Za-z0-9_]+$/.test(name) ? `\"${name}\"` : name}`\n    if (elements.length) {\n      text += `${indent ? `\\n${indent}` : \" \"}[${indent ? \"\\n\" : \"\"}`\n      for (const element of elements)\n        text += `${indent}<!ELEMENT ${element[\"~name\"]} (${element[\"#text\"]})>${indent ? \"\\n\" : \"\"}`\n      text += `${indent ? indent : \"\"}]${indent ? \"\\n\" : \"\"}`\n    }\n    text += `>${indent ? \"\\n\" : \"\"}`\n  }\n  return text\n}\n\n/** Create XML node. */\nfunction xml_node(node: XmlNode, { format: { breakline = 0, indent = \"\" }, replace, depth = 0 }: _Options & { depth?: number }): string {\n  if (replace?.custom) {\n    if (replace.custom({ name: node[\"~name\"], key: null, value: null, node }) === undefined)\n      return \"\"\n  }\n  let text = `${indent.repeat(depth)}<${node[\"~name\"]}`\n  const attributes = xml_attributes(node, arguments[1])\n  const children = xml_children(node, arguments[1])\n  const preserve = node[\"@xml:space\"] === \"preserve\"\n  for (const [name, value] of attributes)\n    text += ` ${name}=\"${value}\"`\n  if ((children.length) || ((\"#text\" in node) && (node[\"#text\"].length))) {\n    const inline = indent && (!preserve) && ((children.length) || (node[\"#text\"].length > breakline - indent.length * depth))\n    text += `>${indent && (!preserve) && (children.length) ? \"\\n\" : \"\"}`\n    if (\"#text\" in node) {\n      if (inline)\n        text += `\\n${indent.repeat(depth + 1)}`\n      text += node[\"#text\"]\n      if (inline)\n        text += \"\\n\"\n    }\n    for (const child of children)\n      text += xml_node(child, { ...arguments[1], depth: depth + 1 })\n    if (inline)\n      text += indent.repeat(depth)\n    text += `</${node[\"~name\"]}>${indent ? \"\\n\" : \"\"}`\n  } else {\n    text += `/>${indent ? \"\\n\" : \"\"}`\n  }\n  return text\n}\n\n/** Extract children from node. */\nfunction xml_children(node: XmlNode, options: StringifyOptions): Array<XmlNode> {\n  const children = Object.keys(node)\n    .filter((key) => /^[A-Za-z_]/.test(key))\n    .flatMap((key) =>\n      [node![key]].flat().map((value) => {\n        switch (true) {\n          case value === null:\n            return ({ [\"~name\"]: key, [\"#text\"]: \"\" })\n          case typeof value === \"object\": {\n            const child = { ...value as Record<PropertyKey, unknown>, [\"~name\"]: key } as Record<PropertyKey, unknown>\n            if (((value as Record<PropertyKey, unknown>)[\"~name\"] as string)?.startsWith(\"~\"))\n              child[internal] = (value as Record<PropertyKey, unknown>)[\"~name\"]\n            return child\n          }\n          default:\n            return ({ [\"~name\"]: key, [\"#text\"]: `${value}` })\n        }\n      })\n    )\n    .map((node) => {\n      if (\"#text\" in node) {\n        const cdata = node[internal] === \"~cdata\"\n        const comment = node[internal] === \"~comment\"\n        node[\"#text\"] = replace(node as XmlNode, \"#text\", { ...options, escape: cdata ? [] : [\"&\", \"<\", \">\"] }) as string\n        if (node[\"#text\"] === undefined)\n          delete node[\"#text\"]\n        else\n          node[\"#text\"] = cdata ? `<![CDATA[${node[\"#text\"]}]]>` : comment ? `<!--${node[\"#text\"]}-->` : `${node[\"#text\"]}`\n      }\n      return node\n    }) as ReturnType<typeof xml_children>\n  return children\n}\n\n/** Extract attributes from node. */\nfunction xml_attributes(node: XmlNode, options: StringifyOptions): Array<[string, string]> {\n  return Object.entries(node!)\n    .filter(([key]) => key.startsWith(\"@\"))\n    .map(([key]) => [key.slice(1), replace(node!, key, { ...options, escape: [\"&\", '\"', \"'\"] })])\n    .filter(([_, value]) => value !== undefined) as ReturnType<typeof xml_attributes>\n}\n\n/** Entities */\nconst entities = {\n  \"&\": \"&amp;\", //Keep first\n  '\"': \"&quot;\",\n  \"<\": \"&lt;\",\n  \">\": \"&gt;\",\n  \"'\": \"&apos;\",\n} as const\n\n/** Replace value. */\nfunction replace(node: XmlNode | XmlText, key: string, options: StringifyOptions & { escape?: Array<keyof typeof entities> }) {\n  let value = `${(node as XmlNode)[key]}` as string\n  if (options?.escape) {\n    if (options?.replace?.entities)\n      options.escape = Object.keys(entities) as Array<keyof typeof entities>\n    for (const char of options?.escape)\n      value = `${value}`.replaceAll(char, entities[char])\n  }\n  if (options?.replace?.custom)\n    return options.replace.custom({ name: node[\"~name\"], key, value, node: node as XmlNode })\n  return value\n}\n"],"names":[],"mappings":"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"}

package/wasm/parse.d.ts

@@ -0,0 +1,77 @@
+import { type CleanOptions, type FlattenOptions, type ReviveOptions } from "../_parser.js";
+import type { ReaderSync, 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.
+   */ mode?: "xml" | "html";
+};
+/**
+ * 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 (`@`).
+ *
+ * You can also pass an object that implements {@link ReaderSync} instead of a string.
+ *
+ * ```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 file into an object.
+ *
+ * Output (cleaning, flattening, reviving, etc.) can be customized using the {@link ParseOptions} parameter.
+ *
+ * ```ts
+ * import { fromFileUrl } from "@std/path"
+ *
+ * const file = await Deno.open(fromFileUrl(import.meta.resolve("../bench/assets/small.xml")))
+ * console.log(parse(file))
+ * ```
+ */ export declare function parse(content: ReaderSync, options?: ParseOptions): XmlDocument;
+/**
+ * Parse a XML stream into an object.
+ *
+ * Output (cleaning, flattening, reviving, etc.) can be customized using the {@link ParseOptions} parameter.
+ *
+ * ```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/wasm/parse.js

@@ -0,0 +1,123 @@
+/**
+ * Parse a XML string into an object (legacy WASM backend).
+ *
+ * This backend predates the {@link ../parse.ts} implementation based on `@std/xml` and is kept as an alternative,
+ * mainly because it additionally supports the more permissive `html` parsing mode.
+ * Both share the same options, output structure and types.
+ *
+ * @module
+ */ // Imports
+import { initSync, JsReader, source, Token, tokenize } from "./wasm_xml_parser.js";
+import { finalize, xml_doctype, xml_element, xml_instruction, xml_node, xml_text } from "../_parser.js";
+initSync(source());
+export function parse(content, options) {
+  if (content instanceof ReadableStream) return new Response(content).bytes().then((bytes)=>parse_bytes(bytes, options));
+  return parse_bytes(content, options);
+}
+/** Tokenize a XML document with the WASM tokenizer and map the tokens to the same document structure as the std backend. */ function parse_bytes(content, options) {
+  const xml = xml_node("~xml");
+  const stack = [
+    xml
+  ];
+  const tokens = [];
+  const states = [];
+  const flags = {
+    root: false
+  };
+  try {
+    const reader = content instanceof Uint8Array ? new JsReader(content) : new JsReader(new TextEncoder().encode(content), typeof content === "object" ? content : undefined);
+    tokenize(reader, tokens, states, options?.mode === "html");
+  } catch (error) {
+    if (states.at(-1)?.[0] === Token.StateParseAttribute) tokens.push([
+      Token.Error,
+      `Failed to parse attribute around position ${states.at(-1)[1]}`
+    ]);
+    if (!states.length) throw new EvalError(`WASM XML parser crashed: ${error}`);
+  }
+  const errors = tokens.find(([token])=>token === Token.Error);
+  if (errors) throw new SyntaxError(`Malformed XML document: ${errors[1]}`);
+  for (const [token, name, value = name] of tokens){
+    switch(token){
+      // XML declaration
+      case Token.XMLDeclaration:
+        {
+          // https://www.w3.org/TR/REC-xml/#NT-VersionNum
+          const version = value.match(/version=(["'])(?<version>1\.\d+)(\1)/)?.groups?.version;
+          if (version) xml["@version"] = version;
+          // https://www.w3.org/TR/REC-xml/#NT-EncodingDecl
+          const encoding = value.match(/encoding=(["'])(?<encoding>[A-Za-z][-\w.]*)(\1)/)?.groups?.encoding;
+          if (encoding) xml["@encoding"] = encoding;
+          // https://www.w3.org/TR/REC-xml/#NT-SDDecl
+          const standalone = value.match(/standalone=(["'])(?<standalone>yes|no)(\1)/)?.groups?.standalone;
+          if (standalone) xml["@standalone"] = standalone;
+          break;
+        }
+      // XML Doctype definition
+      case Token.XMLDoctype:
+        {
+          xml["#doctype"] = Object.assign(xml_node("~doctype", {
+            parent: xml
+          }), xml_doctype(value));
+          break;
+        }
+      // XML processing instruction
+      case Token.XMLInstruction:
+        {
+          const target = value.match(/^\S+/)?.[0] ?? "";
+          xml_instruction(xml, target, value.slice(target.length).trim());
+          break;
+        }
+      // XML tag opened
+      case Token.TagOpen:
+        {
+          if (stack.length === 1) {
+            if (flags.root) throw new SyntaxError("Multiple root node detected");
+            flags.root = true;
+          }
+          stack.push(xml_element(name, stack.at(-1)));
+          break;
+        }
+      // XML tag closed
+      case Token.TagClose:
+        {
+          stack.pop();
+          break;
+        }
+      // XML attribute
+      case Token.TagAttribute:
+        {
+          stack.at(-1)[`@${name}`] = value;
+          break;
+        }
+      // Text
+      case Token.Text:
+        {
+          xml_text(value, {
+            type: "~text",
+            parent: stack.at(-1)
+          });
+          break;
+        }
+      // CDATA
+      case Token.CData:
+        {
+          xml_text(value, {
+            type: "~cdata",
+            parent: stack.at(-1)
+          });
+          break;
+        }
+      // Comment
+      case Token.Comment:
+        {
+          xml_text(value, {
+            type: "~comment",
+            parent: stack.at(-1)
+          });
+          break;
+        }
+    }
+  }
+  return finalize(xml, options);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/libs/libs/@libs/xml/wasm/parse.ts"],"sourcesContent":["/**\n * Parse a XML string into an object (legacy WASM backend).\n *\n * This backend predates the {@link ../parse.ts} implementation based on `@std/xml` and is kept as an alternative,\n * mainly because it additionally supports the more permissive `html` parsing mode.\n * Both share the same options, output structure and types.\n *\n * @module\n */\n\n// Imports\nimport { initSync, JsReader, source, Token, tokenize } from \"./wasm_xml_parser.js\"\nimport { type CleanOptions, finalize, type FlattenOptions, type ReviveOptions, xml_doctype, xml_element, xml_instruction, xml_node, xml_text } from \"../_parser.js\"\nimport type { ReaderSync, XmlDocument, XmlNode } from \"../_types.js\"\nexport type * from \"../_types.js\"\nexport type { CleanOptions, FlattenOptions, ReviveOptions, Reviver } from \"../_parser.js\"\ninitSync(source())\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  mode?: \"xml\" | \"html\"\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 * You can also pass an object that implements {@link ReaderSync} instead of a string.\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 * Parse a XML file into an object.\n *\n * Output (cleaning, flattening, reviving, etc.) can be customized using the {@link ParseOptions} parameter.\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(parse(file))\n * ```\n */\nexport function parse(content: ReaderSync, options?: ParseOptions): XmlDocument\n/**\n * Parse a XML stream into an object.\n *\n * Output (cleaning, flattening, reviving, etc.) can be customized using the {@link ParseOptions} parameter.\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 | ReaderSync | ReadableStream<Uint8Array>, options?: ParseOptions) {\n  if (content instanceof ReadableStream)\n    return new Response(content).bytes().then((bytes) => parse_bytes(bytes, options))\n  return parse_bytes(content, options)\n}\n\n/** Tokenize a XML document with the WASM tokenizer and map the tokens to the same document structure as the std backend. */\nfunction parse_bytes(content: string | ReaderSync | Uint8Array, options?: ParseOptions): XmlDocument {\n  const xml = xml_node(\"~xml\") as XmlDocument\n  const stack = [xml] as Array<XmlNode>\n  const tokens = [] as Array<[number, string, string?]>\n  const states = [] as Array<[number, number]>\n  const flags = { root: false }\n  try {\n    const reader = content instanceof Uint8Array ? new JsReader(content) : new JsReader(new TextEncoder().encode(content as string), typeof content === \"object\" ? content : undefined)\n    tokenize(reader, tokens, states, options?.mode === \"html\")\n  } catch (error) {\n    if (states.at(-1)?.[0] === Token.StateParseAttribute)\n      tokens.push([Token.Error, `Failed to parse attribute around position ${states.at(-1)![1]}`])\n    if (!states.length)\n      throw new EvalError(`WASM XML parser crashed: ${error}`)\n  }\n  const errors = tokens.find(([token]) => token === Token.Error)\n  if (errors)\n    throw new SyntaxError(`Malformed XML document: ${errors[1]}`)\n  for (const [token, name, value = name] of tokens) {\n    switch (token) {\n      // XML declaration\n      case Token.XMLDeclaration: {\n        // https://www.w3.org/TR/REC-xml/#NT-VersionNum\n        const version = value.match(/version=([\"'])(?<version>1\\.\\d+)(\\1)/)?.groups?.version\n        if (version)\n          xml[\"@version\"] = version as typeof xml[\"@version\"]\n        // https://www.w3.org/TR/REC-xml/#NT-EncodingDecl\n        const encoding = value.match(/encoding=([\"'])(?<encoding>[A-Za-z][-\\w.]*)(\\1)/)?.groups?.encoding\n        if (encoding)\n          xml[\"@encoding\"] = encoding as typeof xml[\"@encoding\"]\n        // https://www.w3.org/TR/REC-xml/#NT-SDDecl\n        const standalone = value.match(/standalone=([\"'])(?<standalone>yes|no)(\\1)/)?.groups?.standalone\n        if (standalone)\n          xml[\"@standalone\"] = standalone as typeof xml[\"@standalone\"]\n        break\n      }\n      // XML Doctype definition\n      case Token.XMLDoctype: {\n        xml[\"#doctype\"] = Object.assign(xml_node(\"~doctype\", { parent: xml }), xml_doctype(value))\n        break\n      }\n      // XML processing instruction\n      case Token.XMLInstruction: {\n        const target = value.match(/^\\S+/)?.[0] ?? \"\"\n        xml_instruction(xml, target, value.slice(target.length).trim())\n        break\n      }\n      // XML tag opened\n      case Token.TagOpen: {\n        if (stack.length === 1) {\n          if (flags.root)\n            throw new SyntaxError(\"Multiple root node detected\")\n          flags.root = true\n        }\n        stack.push(xml_element(name, stack.at(-1)!))\n        break\n      }\n      // XML tag closed\n      case Token.TagClose: {\n        stack.pop()\n        break\n      }\n      // XML attribute\n      case Token.TagAttribute: {\n        stack.at(-1)![`@${name}`] = value\n        break\n      }\n      // Text\n      case Token.Text: {\n        xml_text(value, { type: \"~text\", parent: stack.at(-1)! })\n        break\n      }\n      // CDATA\n      case Token.CData: {\n        xml_text(value, { type: \"~cdata\", parent: stack.at(-1)! })\n        break\n      }\n      // Comment\n      case Token.Comment: {\n        xml_text(value, { type: \"~comment\", parent: stack.at(-1)! })\n        break\n      }\n    }\n  }\n  return finalize(xml, options)\n}\n"],"names":[],"mappings":"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"}