@lowlighter/xml 6.0.0 → 8.0.0

package/stringify.mjs

@@ -1 +0,0 @@
-var t=Symbol("internal");function e(t,e){e??={},e.format??={},e.format.indent??="  ",e.format.breakline??=128;const n=e;let o="";if(o+=function(t,e){return t["~name"]??="xml",r(t,e)}(t,n),t["#instructions"])for(const e of Object.values(t["#instructions"]))for(const t of[e].flat())o+=r(t,n);t["#doctype"]&&(o+=function(t,{format:{indent:e}}){let n="";const o=l(t,arguments[1]),r=c(t,arguments[1]);if(o.length+r.length){n+="<!DOCTYPE";for(const[t]of o)n+=` ${/^[A-Za-z0-9_]+$/.test(t)?t:`"${t}"`}`;if(r.length){n+=`${e?`\n${e}`:" "}[${e?"\n":""}`;for(const t of r)n+=`${e}<!ELEMENT ${t["~name"]} (${t["#text"]})>${e?"\n":""}`;n+=`${e||""}]${e?"\n":""}`}n+=">"+(e?"\n":"")}return n}(t["#doctype"],n));const[f,...i]=c(t,n);if(!f)throw new SyntaxError("No root node detected");if(i.length)throw new SyntaxError("Multiple root node detected");return o+=a(f,{...n,depth:0}),o.trim()}function n(t){return{"~name":"~cdata","#text":t}}function o(t){return{"~name":"~comment","#text":t}}function r(t,{format:{indent:e}}){let n="";const o=l(t,arguments[1]);if(o.length){n+=`<?${t["~name"].replace(/^~/,"")}`;for(const[t,e]of o)n+=` ${t}="${e}"`;n+="?>"+(e?"\n":"")}return n}function a(t,{format:{breakline:e=0,indent:n=""},replace:o,depth:r=0}){if(o?.custom&&void 0===o.custom({name:t["~name"],key:null,value:null,node:t}))return"";let f=`${n.repeat(r)}<${t["~name"]}`;const i=l(t,arguments[1]),s=c(t,arguments[1]),u="preserve"===t["@xml:space"];for(const[t,e]of i)f+=` ${t}="${e}"`;if(s.length||"#text"in t&&t["#text"].length){const o=n&&!u&&(s.length||t["#text"].length>e-n.length*r);f+=">"+(n&&!u&&s.length?"\n":""),"#text"in t&&(o&&(f+=`\n${n.repeat(r+1)}`),f+=t["#text"],o&&(f+="\n"));for(const t of s)f+=a(t,{...arguments[1],depth:r+1});o&&(f+=n.repeat(r)),f+=`</${t["~name"]}>${n?"\n":""}`}else f+="/>"+(n?"\n":"");return f}function c(e,n){return Object.keys(e).filter((t=>/^[A-Za-z_]/.test(t))).flatMap((n=>[e[n]].flat().map((e=>{switch(!0){case null===e:return{"~name":n,"#text":""};case"object"==typeof e:{const o={...e,"~name":n};return e["~name"]?.startsWith("~")&&(o[t]=e["~name"]),o}default:return{"~name":n,"#text":`${e}`}}})))).map((e=>{if("#text"in e){const o="~cdata"===e[t],r="~comment"===e[t];e["#text"]=i(e,"#text",{...n,escape:o?[]:["<",">"]}),void 0===e["#text"]?delete e["#text"]:e["#text"]=o?`<![CDATA[${e["#text"]}]]>`:r?`\x3c!--${e["#text"]}--\x3e`:`${e["#text"]}`}return e}))}function l(t,e){return Object.entries(t).filter((([t])=>t.startsWith("@"))).map((([n])=>[n.slice(1),i(t,n,{...e,escape:['"',"'"]})])).filter((([t,e])=>void 0!==e))}var f={"&":"&amp;",'"':"&quot;","<":"&lt;",">":"&gt;","'":"&apos;"};function i(t,e,n){let o=`${t[e]}`;if(n?.escape){n?.replace?.entities&&(n.escape=Object.keys(f));for(const t of n?.escape)o=`${o}`.replaceAll(t,f[t])}return n?.replace?.custom?n.replace.custom({name:t["~name"],key:e,value:o,node:t}):o}export{n as cdata,o as comment,e as stringify};

package/stringify.ts

@@ -1,287 +0,0 @@
-// Imports
-import type { Nullable, record, rw } from "@libs/typing"
-import type { stringifyable, xml_document, xml_node, xml_text } from "./_types.ts"
-export type { Nullable, stringifyable, xml_document, xml_node, xml_text }
-
-/** XML stringifier options. */
-export type options = {
-  /** Format options. */
-  format?: {
-    /**
-     * 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
-  }
-  /** Replace options. */
-  replace?: {
-    /**
-     * 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?: (args: { name: string; key: Nullable<string>; value: Nullable<string>; node: Readonly<xml_node> }) => unknown
-  }
-}
-
-/** XML stringifier options (with non-nullable format options). */
-type _options = options & { format: NonNullable<options["format"]> }
-
-/** Internal symbol to store properties without erasing user-provided ones. */
-const internal = Symbol("internal")
-
-/**
- * Stringify an {@link xml_document} object into a XML string.
- *
- * Output can be customized using the {@link options} parameter.
- *
- * @example
- * ```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",
- *     },
- *   }
- * }))
- * ```
- *
- * @module
- */
-export function stringify(document: stringifyable, options?: options): string {
-  options ??= {}
-  options.format ??= {}
-  options.format.indent ??= "  "
-  options.format.breakline ??= 128
-  const _options = options as _options
-  let text = ""
-  // Add prolog
-  text += xml_prolog(document as xml_document, _options)
-  // Add processing instructions
-  if (document["#instructions"]) {
-    for (const nodes of Object.values(document["#instructions"])) {
-      for (const node of [nodes].flat()) {
-        text += xml_instruction(node, _options)
-      }
-    }
-  }
-  // Add doctype
-  if (document["#doctype"]) {
-    text += xml_doctype(document["#doctype"] as xml_node, _options)
-  }
-
-  // Add root node
-  const [root, ...garbage] = xml_children(document as xml_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()
-}
-
-/**
- * Helper to create a CDATA node.
- *
- * @example
- * ```ts
- * import { stringify, cdata } from "./stringify.ts"
- * stringify({ string: cdata(`hello <world>`) })
- * // <string><![CDATA[hello <world>]]></string>
- * ```
- */
-export function cdata(text: string): Omit<xml_text, "~parent"> {
-  return {
-    "~name": "~cdata",
-    "#text": text,
-  }
-}
-
-/**
- * Helper to create a comment node.
- *
- * @example
- * ```ts
- * import { stringify, comment } from "./stringify.ts"
- * stringify({ string: comment(`hello world`) })
- * // <string><!--hello world--></string>
- * ```
- */
-export function comment(text: string): Omit<xml_text, "~parent"> {
-  return {
-    "~name": "~comment",
-    "#text": text,
-  }
-}
-
-/** Create XML prolog. */
-function xml_prolog(document: xml_document, options: _options): string {
-  ;(document as rw)["~name"] ??= "xml"
-  return xml_instruction(document, options)
-}
-
-/** Create XML instruction. */
-function xml_instruction(node: xml_node, { format: { indent } }: _options): string {
-  let text = ""
-  const attributes = xml_attributes(node as xml_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: xml_node, { format: { indent } }: _options): string {
-  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: xml_node, { format: { breakline = 0, indent = "" }, replace, depth = 0 }: _options & { depth?: number }): string {
-  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: xml_node, options: options): Array<xml_node> {
-  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 as record, ["~name"]: key } as record
-            if (((value as record)["~name"] as string)?.startsWith("~")) {
-              child[internal] = (value as record)["~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 as xml_node, "#text", { ...options, escape: cdata ? [] : ["<", ">"] }) as string
-        if (node["#text"] === undefined) {
-          delete node["#text"]
-        } else {
-          node["#text"] = cdata ? `<![CDATA[${node["#text"]}]]>` : comment ? `<!--${node["#text"]}-->` : `${node["#text"]}`
-        }
-      }
-      return node
-    }) as ReturnType<typeof xml_children>
-  return children
-}
-
-/** Extract attributes from node. */
-function xml_attributes(node: xml_node, options: options): Array<[string, string]> {
-  return Object.entries(node!)
-    .filter(([key]) => key.startsWith("@"))
-    .map(([key]) => [key.slice(1), replace(node!, key, { ...options, escape: ['"', "'"] })])
-    .filter(([_, value]) => value !== undefined) as ReturnType<typeof xml_attributes>
-}
-
-/** Entities */
-const entities = {
-  "&": "&amp;", //Keep first
-  '"': "&quot;",
-  "<": "&lt;",
-  ">": "&gt;",
-  "'": "&apos;",
-} as const
-
-/** Replace value. */
-function replace(node: xml_node | xml_text, key: string, options: options & { escape?: Array<keyof typeof entities> }) {
-  let value = `${(node as xml_node)[key]}` as string
-  if (options?.escape) {
-    if (options?.replace?.entities) {
-      options.escape = Object.keys(entities) as Array<keyof typeof 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 as xml_node })
-  }
-  return value
-}

package/stringify_test.ts

@@ -1,303 +0,0 @@
-import { type options as parse_options, parse } from "./parse.ts"
-import { cdata, comment, type options as stringify_options, stringify } from "./stringify.ts"
-import { expect, test } from "@libs/testing"
-
-// This operation ensure that reforming a parsed XML will still yield same data
-const check = (xml: string, options?: parse_options & stringify_options) => {
-  expect(stringify(parse(xml, options), options), xml)
-  return parse(stringify(parse(xml, options), options), options)
-}
-
-test("all")("`stringify()` xml syntax xml prolog", () =>
-  expect(
-    check(
-      `<?xml version="1.0" encoding="UTF-8"?>
-<root/>`,
-    ),
-  ).toEqual(
-    {
-      "@version": "1.0",
-      "@encoding": "UTF-8",
-      root: null,
-    },
-  ))
-
-test("all")("`stringify()` xml syntax xml stylesheet", () =>
-  expect(
-    check(
-      `<?xml version="1.0" encoding="UTF-8"?>
-  <?xml-stylesheet href="styles.xsl" type="text/xsl"?>
-  <root/>`,
-    ),
-  ).toEqual(
-    {
-      "@version": "1.0",
-      "@encoding": "UTF-8",
-      "#instructions": {
-        "xml-stylesheet": {
-          "@href": "styles.xsl",
-          "@type": "text/xsl",
-        },
-      },
-      root: null,
-    },
-  ))
-
-test("all")("`stringify()` xml syntax doctype", () =>
-  expect(
-    check(
-      `<!DOCTYPE type "quoted attribute" [
-          <!ELEMENT element (value)>
-        ]>
-  <root/>`,
-    ),
-  ).toEqual(
-    {
-      "#doctype": {
-        "@type": "",
-        "@quoted attribute": "",
-        element: "value",
-      },
-      root: null,
-    },
-  ))
-
-for (const indent of ["  ", ""]) {
-  test("all")(`\`stringify()\` xml example w3schools.com#3 (indent = "${indent}")`, () =>
-    expect(
-      check(
-        `
-      <?xml version="1.0" encoding="UTF-8"?>
-      <?xml-stylesheet href="styles.xsl" type="text/xsl"?>
-      <!DOCTYPE type "quoted attribute" [
-        <!ELEMENT element (value)>
-      ]>
-      <bookstore>
-        <notebook/>
-        <book category="cooking">
-          <!-- Comment Node -->
-          <title lang="en">Everyday Italian</title>
-          <author>Giada De Laurentiis</author>
-          <year>2005</year>
-          <price>30</price>
-        </book>
-        <book category="children">
-          <!-- First Comment Node -->
-          <!-- Second Comment Node -->
-          <title lang="en">Harry Potter</title>
-          <author>J K. Rowling</author>
-          <year>2005</year>
-          <price>29.99</price>
-        </book>
-        <book category="web">
-          <title lang="en">XQuery Kick Start</title>
-          <author>James McGovern</author>
-          <author>Per Bothner</author>
-          <author>Kurt Cagle</author>
-          <author>James Linn</author>
-          <author>Vaidyanathan Nagarajan</author>
-          <year>2003</year>
-          <price>49.99</price>
-        </book>
-        <book category="web" cover="paperback">
-          <title lang="en">Learning XML</title>
-          <author>Erik T. Ray</author>
-          <year>2003</year>
-          <price>39.95</price>
-        </book>
-      </bookstore>`,
-        { revive: { booleans: true, numbers: true }, format: { indent } },
-      ),
-    ).toEqual(
-      {
-        "@version": "1.0",
-        "@encoding": "UTF-8",
-        "#instructions": {
-          "xml-stylesheet": {
-            "@href": "styles.xsl",
-            "@type": "text/xsl",
-          },
-        },
-        "#doctype": {
-          "@type": "",
-          "@quoted attribute": "",
-          element: "value",
-        },
-        bookstore: {
-          notebook: null,
-          book: [
-            {
-              "@category": "cooking",
-              title: { "@lang": "en", "#text": "Everyday Italian" },
-              author: "Giada De Laurentiis",
-              year: 2005,
-              price: 30,
-            },
-            {
-              "@category": "children",
-              title: { "@lang": "en", "#text": "Harry Potter" },
-              author: "J K. Rowling",
-              year: 2005,
-              price: 29.99,
-            },
-            {
-              "@category": "web",
-              title: { "@lang": "en", "#text": "XQuery Kick Start" },
-              author: [
-                "James McGovern",
-                "Per Bothner",
-                "Kurt Cagle",
-                "James Linn",
-                "Vaidyanathan Nagarajan",
-              ],
-              year: 2003,
-              price: 49.99,
-            },
-            {
-              "@category": "web",
-              "@cover": "paperback",
-              title: { "@lang": "en", "#text": "Learning XML" },
-              author: "Erik T. Ray",
-              year: 2003,
-              price: 39.95,
-            },
-          ],
-        },
-      },
-    ))
-}
-
-test("all")("`stringify()` xml types", () =>
-  expect(
-    check(
-      `<types>
-    <boolean>true</boolean>
-    <null/>
-    <string>hello</string>
-  </types>`,
-      { revive: { booleans: true } },
-    ),
-  ).toEqual(
-    {
-      types: {
-        boolean: true,
-        null: null,
-        string: "hello",
-      },
-    },
-  ))
-
-test("all")("`stringify()` xml entities", () =>
-  expect(
-    check(`<string>&quot; &lt; &gt; &amp; &apos;</string>`),
-  ).toEqual(
-    {
-      string: `" < > & '`,
-    },
-  ))
-
-test("all")(
-  "`stringify()` xml entities are escaped only where needed",
-  () =>
-    expect(stringify({
-      root: {
-        "@attribute": `<text with escaped quotes (',")>`,
-        text: `only < and > should be escaped, not &, ", '`,
-      },
-    }, { format: { breakline: 0 } })).toEqual(
-      `
-<root attribute="<text with escaped quotes (&apos;,&quot;)>">
-  <text>
-    only &lt; and &gt; should be escaped, not &, ", '
-  </text>
-</root>`.trim(),
-    ),
-)
-
-test("all")(
-  "`stringify()` xml entiries are always escaped when escapeAllEntities is true",
-  () =>
-    expect(stringify({
-      root: {
-        "@attribute": `< > &, ", '`,
-        text: `< > &, ", '`,
-      },
-    }, { replace: { entities: true }, format: { breakline: 0 } })).toEqual(
-      `
-<root attribute="&lt; &gt; &amp;, &quot;, &apos;">
-  <text>
-    &lt; &gt; &amp;, &quot;, &apos;
-  </text>
-</root>`.trim(),
-    ),
-)
-
-test("all")("`stringify()` xml space preserve", () =>
-  expect(
-    check(`<text xml:space="preserve"> hello world </text>`),
-  ).toEqual(
-    {
-      text: {
-        "#text": " hello world ",
-        "@xml:space": "preserve",
-      },
-    },
-  ))
-
-test("all")("`stringify()` cdata is preserved on root nodes", () =>
-  expect(
-    stringify({ string: cdata(`hello <world>`) }),
-  ).toBe("<string><![CDATA[hello <world>]]></string>"))
-
-test("all")("`stringify()` cdata is preserved on child nodes", () =>
-  expect(
-    stringify({ nested: { string: cdata(`hello <world>`) } }),
-  ).toBe(`
-<nested>
-  <string><![CDATA[hello <world>]]></string>
-</nested>`.trim()))
-
-test("all")("`stringify()` comments is preserved on root nodes", () =>
-  expect(
-    stringify({ string: comment(`hello world`) }),
-  ).toBe("<string><!--hello world--></string>"))
-
-test("all")("`stringify()` comments is preserved on child nodes", () =>
-  expect(
-    stringify({ nested: { string: comment(`hello world`) } }),
-  ).toBe(`
-<nested>
-  <string><!--hello world--></string>
-</nested>`.trim()))
-
-// Custom replacer
-
-test("all")("`stringify()` xml replacer", () =>
-  expect(
-    stringify({ root: { not: true, yes: true, delete: true, attribute: { "@delete": true } } }, {
-      replace: {
-        custom: ({ name, key, value }) => {
-          if ((name === "delete") || (key === "@delete")) {
-            return undefined
-          }
-          if ((name === "not") && (key === "#text")) {
-            return !value
-          }
-          return value
-        },
-      },
-    }),
-  ).toBe(
-    `
-<root>
-  <not>false</not>
-  <yes>true</yes>
-  <attribute/>
-</root>`.trim(),
-  ))
-
-//Errors checks
-
-test("all")("`stringify()` xml syntax no root node", () => expect(() => stringify({})).toThrow(SyntaxError))
-
-test("all")("`stringify()` xml syntax multiple root nodes", () => expect(() => stringify({ root: null, garbage: null })).toThrow(SyntaxError))