claude-code-best 1.4.3 → 1.5.0

package/dist/chunk-enhtm7h3.js

@@ -0,0 +1,1731 @@
+// @bun
+import {
+  __commonJS,
+  __require
+} from "./chunk-qp2qdcda.js";
+
+// node_modules/.bun/@smithy+util-body-length-node@4.2.3/node_modules/@smithy/util-body-length-node/dist-cjs/index.js
+var require_dist_cjs = __commonJS((exports) => {
+  var node_fs = __require("fs");
+  var calculateBodyLength = (body) => {
+    if (!body) {
+      return 0;
+    }
+    if (typeof body === "string") {
+      return Buffer.byteLength(body);
+    } else if (typeof body.byteLength === "number") {
+      return body.byteLength;
+    } else if (typeof body.size === "number") {
+      return body.size;
+    } else if (typeof body.start === "number" && typeof body.end === "number") {
+      return body.end + 1 - body.start;
+    } else if (body instanceof node_fs.ReadStream) {
+      if (body.path != null) {
+        return node_fs.lstatSync(body.path).size;
+      } else if (typeof body.fd === "number") {
+        return node_fs.fstatSync(body.fd).size;
+      }
+    }
+    throw new Error(`Body Length computation failed for ${body}`);
+  };
+  exports.calculateBodyLength = calculateBodyLength;
+});
+
+// node_modules/.bun/@aws+lambda-invoke-store@0.2.4/node_modules/@aws/lambda-invoke-store/dist-cjs/invoke-store.js
+var require_invoke_store = __commonJS((exports) => {
+  var PROTECTED_KEYS = {
+    REQUEST_ID: Symbol.for("_AWS_LAMBDA_REQUEST_ID"),
+    X_RAY_TRACE_ID: Symbol.for("_AWS_LAMBDA_X_RAY_TRACE_ID"),
+    TENANT_ID: Symbol.for("_AWS_LAMBDA_TENANT_ID")
+  };
+  var NO_GLOBAL_AWS_LAMBDA = ["true", "1"].includes(process.env?.AWS_LAMBDA_NODEJS_NO_GLOBAL_AWSLAMBDA ?? "");
+  if (!NO_GLOBAL_AWS_LAMBDA) {
+    globalThis.awslambda = globalThis.awslambda || {};
+  }
+
+  class InvokeStoreBase {
+    static PROTECTED_KEYS = PROTECTED_KEYS;
+    isProtectedKey(key) {
+      return Object.values(PROTECTED_KEYS).includes(key);
+    }
+    getRequestId() {
+      return this.get(PROTECTED_KEYS.REQUEST_ID) ?? "-";
+    }
+    getXRayTraceId() {
+      return this.get(PROTECTED_KEYS.X_RAY_TRACE_ID);
+    }
+    getTenantId() {
+      return this.get(PROTECTED_KEYS.TENANT_ID);
+    }
+  }
+
+  class InvokeStoreSingle extends InvokeStoreBase {
+    currentContext;
+    getContext() {
+      return this.currentContext;
+    }
+    hasContext() {
+      return this.currentContext !== undefined;
+    }
+    get(key) {
+      return this.currentContext?.[key];
+    }
+    set(key, value) {
+      if (this.isProtectedKey(key)) {
+        throw new Error(`Cannot modify protected Lambda context field: ${String(key)}`);
+      }
+      this.currentContext = this.currentContext || {};
+      this.currentContext[key] = value;
+    }
+    run(context, fn) {
+      this.currentContext = context;
+      return fn();
+    }
+  }
+
+  class InvokeStoreMulti extends InvokeStoreBase {
+    als;
+    static async create() {
+      const instance = new InvokeStoreMulti;
+      const asyncHooks = await import("async_hooks");
+      instance.als = new asyncHooks.AsyncLocalStorage;
+      return instance;
+    }
+    getContext() {
+      return this.als.getStore();
+    }
+    hasContext() {
+      return this.als.getStore() !== undefined;
+    }
+    get(key) {
+      return this.als.getStore()?.[key];
+    }
+    set(key, value) {
+      if (this.isProtectedKey(key)) {
+        throw new Error(`Cannot modify protected Lambda context field: ${String(key)}`);
+      }
+      const store = this.als.getStore();
+      if (!store) {
+        throw new Error("No context available");
+      }
+      store[key] = value;
+    }
+    run(context, fn) {
+      return this.als.run(context, fn);
+    }
+  }
+  exports.InvokeStore = undefined;
+  (function(InvokeStore) {
+    let instance = null;
+    async function getInstanceAsync(forceInvokeStoreMulti) {
+      if (!instance) {
+        instance = (async () => {
+          const isMulti = forceInvokeStoreMulti === true || "AWS_LAMBDA_MAX_CONCURRENCY" in process.env;
+          const newInstance = isMulti ? await InvokeStoreMulti.create() : new InvokeStoreSingle;
+          if (!NO_GLOBAL_AWS_LAMBDA && globalThis.awslambda?.InvokeStore) {
+            return globalThis.awslambda.InvokeStore;
+          } else if (!NO_GLOBAL_AWS_LAMBDA && globalThis.awslambda) {
+            globalThis.awslambda.InvokeStore = newInstance;
+            return newInstance;
+          } else {
+            return newInstance;
+          }
+        })();
+      }
+      return instance;
+    }
+    InvokeStore.getInstanceAsync = getInstanceAsync;
+    InvokeStore._testing = process.env.AWS_LAMBDA_BENCHMARK_MODE === "1" ? {
+      reset: () => {
+        instance = null;
+        if (globalThis.awslambda?.InvokeStore) {
+          delete globalThis.awslambda.InvokeStore;
+        }
+        globalThis.awslambda = { InvokeStore: undefined };
+      }
+    } : undefined;
+  })(exports.InvokeStore || (exports.InvokeStore = {}));
+  exports.InvokeStoreBase = InvokeStoreBase;
+});
+
+// node_modules/.bun/@smithy+util-body-length-browser@4.2.2/node_modules/@smithy/util-body-length-browser/dist-cjs/index.js
+var require_dist_cjs2 = __commonJS((exports) => {
+  var TEXT_ENCODER = typeof TextEncoder == "function" ? new TextEncoder : null;
+  var calculateBodyLength = (body) => {
+    if (typeof body === "string") {
+      if (TEXT_ENCODER) {
+        return TEXT_ENCODER.encode(body).byteLength;
+      }
+      let len = body.length;
+      for (let i = len - 1;i >= 0; i--) {
+        const code = body.charCodeAt(i);
+        if (code > 127 && code <= 2047)
+          len++;
+        else if (code > 2047 && code <= 65535)
+          len += 2;
+        if (code >= 56320 && code <= 57343)
+          i--;
+      }
+      return len;
+    } else if (typeof body.byteLength === "number") {
+      return body.byteLength;
+    } else if (typeof body.size === "number") {
+      return body.size;
+    }
+    throw new Error(`Body Length computation failed for ${body}`);
+  };
+  exports.calculateBodyLength = calculateBodyLength;
+});
+
+// node_modules/.bun/fast-xml-parser@5.5.8/node_modules/fast-xml-parser/lib/fxp.cjs
+var require_fxp = __commonJS((exports, module) => {
+  (() => {
+    var t = { d: (e2, i2) => {
+      for (var n2 in i2)
+        t.o(i2, n2) && !t.o(e2, n2) && Object.defineProperty(e2, n2, { enumerable: true, get: i2[n2] });
+    }, o: (t2, e2) => Object.prototype.hasOwnProperty.call(t2, e2), r: (t2) => {
+      typeof Symbol != "undefined" && Symbol.toStringTag && Object.defineProperty(t2, Symbol.toStringTag, { value: "Module" }), Object.defineProperty(t2, "__esModule", { value: true });
+    } }, e = {};
+    t.r(e), t.d(e, { XMLBuilder: () => $t, XMLParser: () => gt, XMLValidator: () => It });
+    const i = ":A-Za-z_\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD", n = new RegExp("^[" + i + "][" + i + "\\-.\\d\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$");
+    function s(t2, e2) {
+      const i2 = [];
+      let n2 = e2.exec(t2);
+      for (;n2; ) {
+        const s2 = [];
+        s2.startIndex = e2.lastIndex - n2[0].length;
+        const r2 = n2.length;
+        for (let t3 = 0;t3 < r2; t3++)
+          s2.push(n2[t3]);
+        i2.push(s2), n2 = e2.exec(t2);
+      }
+      return i2;
+    }
+    const r = function(t2) {
+      return !(n.exec(t2) == null);
+    }, o = ["hasOwnProperty", "toString", "valueOf", "__defineGetter__", "__defineSetter__", "__lookupGetter__", "__lookupSetter__"], a = ["__proto__", "constructor", "prototype"], h = { allowBooleanAttributes: false, unpairedTags: [] };
+    function l(t2, e2) {
+      e2 = Object.assign({}, h, e2);
+      const i2 = [];
+      let n2 = false, s2 = false;
+      t2[0] === "\uFEFF" && (t2 = t2.substr(1));
+      for (let r2 = 0;r2 < t2.length; r2++)
+        if (t2[r2] === "<" && t2[r2 + 1] === "?") {
+          if (r2 += 2, r2 = u(t2, r2), r2.err)
+            return r2;
+        } else {
+          if (t2[r2] !== "<") {
+            if (p(t2[r2]))
+              continue;
+            return b("InvalidChar", "char '" + t2[r2] + "' is not expected.", w(t2, r2));
+          }
+          {
+            let o2 = r2;
+            if (r2++, t2[r2] === "!") {
+              r2 = c(t2, r2);
+              continue;
+            }
+            {
+              let a2 = false;
+              t2[r2] === "/" && (a2 = true, r2++);
+              let h2 = "";
+              for (;r2 < t2.length && t2[r2] !== ">" && t2[r2] !== " " && t2[r2] !== "\t" && t2[r2] !== `
+` && t2[r2] !== "\r"; r2++)
+                h2 += t2[r2];
+              if (h2 = h2.trim(), h2[h2.length - 1] === "/" && (h2 = h2.substring(0, h2.length - 1), r2--), !y(h2)) {
+                let e3;
+                return e3 = h2.trim().length === 0 ? "Invalid space after '<'." : "Tag '" + h2 + "' is an invalid name.", b("InvalidTag", e3, w(t2, r2));
+              }
+              const l2 = g(t2, r2);
+              if (l2 === false)
+                return b("InvalidAttr", "Attributes for '" + h2 + "' have open quote.", w(t2, r2));
+              let d2 = l2.value;
+              if (r2 = l2.index, d2[d2.length - 1] === "/") {
+                const i3 = r2 - d2.length;
+                d2 = d2.substring(0, d2.length - 1);
+                const s3 = x(d2, e2);
+                if (s3 !== true)
+                  return b(s3.err.code, s3.err.msg, w(t2, i3 + s3.err.line));
+                n2 = true;
+              } else if (a2) {
+                if (!l2.tagClosed)
+                  return b("InvalidTag", "Closing tag '" + h2 + "' doesn't have proper closing.", w(t2, r2));
+                if (d2.trim().length > 0)
+                  return b("InvalidTag", "Closing tag '" + h2 + "' can't have attributes or invalid starting.", w(t2, o2));
+                if (i2.length === 0)
+                  return b("InvalidTag", "Closing tag '" + h2 + "' has not been opened.", w(t2, o2));
+                {
+                  const e3 = i2.pop();
+                  if (h2 !== e3.tagName) {
+                    let i3 = w(t2, e3.tagStartPos);
+                    return b("InvalidTag", "Expected closing tag '" + e3.tagName + "' (opened in line " + i3.line + ", col " + i3.col + ") instead of closing tag '" + h2 + "'.", w(t2, o2));
+                  }
+                  i2.length == 0 && (s2 = true);
+                }
+              } else {
+                const a3 = x(d2, e2);
+                if (a3 !== true)
+                  return b(a3.err.code, a3.err.msg, w(t2, r2 - d2.length + a3.err.line));
+                if (s2 === true)
+                  return b("InvalidXml", "Multiple possible root nodes found.", w(t2, r2));
+                e2.unpairedTags.indexOf(h2) !== -1 || i2.push({ tagName: h2, tagStartPos: o2 }), n2 = true;
+              }
+              for (r2++;r2 < t2.length; r2++)
+                if (t2[r2] === "<") {
+                  if (t2[r2 + 1] === "!") {
+                    r2++, r2 = c(t2, r2);
+                    continue;
+                  }
+                  if (t2[r2 + 1] !== "?")
+                    break;
+                  if (r2 = u(t2, ++r2), r2.err)
+                    return r2;
+                } else if (t2[r2] === "&") {
+                  const e3 = N(t2, r2);
+                  if (e3 == -1)
+                    return b("InvalidChar", "char '&' is not expected.", w(t2, r2));
+                  r2 = e3;
+                } else if (s2 === true && !p(t2[r2]))
+                  return b("InvalidXml", "Extra text at the end", w(t2, r2));
+              t2[r2] === "<" && r2--;
+            }
+          }
+        }
+      return n2 ? i2.length == 1 ? b("InvalidTag", "Unclosed tag '" + i2[0].tagName + "'.", w(t2, i2[0].tagStartPos)) : !(i2.length > 0) || b("InvalidXml", "Invalid '" + JSON.stringify(i2.map((t3) => t3.tagName), null, 4).replace(/\r?\n/g, "") + "' found.", { line: 1, col: 1 }) : b("InvalidXml", "Start tag expected.", 1);
+    }
+    function p(t2) {
+      return t2 === " " || t2 === "\t" || t2 === `
+` || t2 === "\r";
+    }
+    function u(t2, e2) {
+      const i2 = e2;
+      for (;e2 < t2.length; e2++)
+        if (t2[e2] == "?" || t2[e2] == " ") {
+          const n2 = t2.substr(i2, e2 - i2);
+          if (e2 > 5 && n2 === "xml")
+            return b("InvalidXml", "XML declaration allowed only at the start of the document.", w(t2, e2));
+          if (t2[e2] == "?" && t2[e2 + 1] == ">") {
+            e2++;
+            break;
+          }
+          continue;
+        }
+      return e2;
+    }
+    function c(t2, e2) {
+      if (t2.length > e2 + 5 && t2[e2 + 1] === "-" && t2[e2 + 2] === "-") {
+        for (e2 += 3;e2 < t2.length; e2++)
+          if (t2[e2] === "-" && t2[e2 + 1] === "-" && t2[e2 + 2] === ">") {
+            e2 += 2;
+            break;
+          }
+      } else if (t2.length > e2 + 8 && t2[e2 + 1] === "D" && t2[e2 + 2] === "O" && t2[e2 + 3] === "C" && t2[e2 + 4] === "T" && t2[e2 + 5] === "Y" && t2[e2 + 6] === "P" && t2[e2 + 7] === "E") {
+        let i2 = 1;
+        for (e2 += 8;e2 < t2.length; e2++)
+          if (t2[e2] === "<")
+            i2++;
+          else if (t2[e2] === ">" && (i2--, i2 === 0))
+            break;
+      } else if (t2.length > e2 + 9 && t2[e2 + 1] === "[" && t2[e2 + 2] === "C" && t2[e2 + 3] === "D" && t2[e2 + 4] === "A" && t2[e2 + 5] === "T" && t2[e2 + 6] === "A" && t2[e2 + 7] === "[") {
+        for (e2 += 8;e2 < t2.length; e2++)
+          if (t2[e2] === "]" && t2[e2 + 1] === "]" && t2[e2 + 2] === ">") {
+            e2 += 2;
+            break;
+          }
+      }
+      return e2;
+    }
+    const d = '"', f = "'";
+    function g(t2, e2) {
+      let i2 = "", n2 = "", s2 = false;
+      for (;e2 < t2.length; e2++) {
+        if (t2[e2] === d || t2[e2] === f)
+          n2 === "" ? n2 = t2[e2] : n2 !== t2[e2] || (n2 = "");
+        else if (t2[e2] === ">" && n2 === "") {
+          s2 = true;
+          break;
+        }
+        i2 += t2[e2];
+      }
+      return n2 === "" && { value: i2, index: e2, tagClosed: s2 };
+    }
+    const m = new RegExp(`(\\s*)([^\\s=]+)(\\s*=)?(\\s*(['"])(([\\s\\S])*?)\\5)?`, "g");
+    function x(t2, e2) {
+      const i2 = s(t2, m), n2 = {};
+      for (let t3 = 0;t3 < i2.length; t3++) {
+        if (i2[t3][1].length === 0)
+          return b("InvalidAttr", "Attribute '" + i2[t3][2] + "' has no space in starting.", v(i2[t3]));
+        if (i2[t3][3] !== undefined && i2[t3][4] === undefined)
+          return b("InvalidAttr", "Attribute '" + i2[t3][2] + "' is without value.", v(i2[t3]));
+        if (i2[t3][3] === undefined && !e2.allowBooleanAttributes)
+          return b("InvalidAttr", "boolean attribute '" + i2[t3][2] + "' is not allowed.", v(i2[t3]));
+        const s2 = i2[t3][2];
+        if (!E(s2))
+          return b("InvalidAttr", "Attribute '" + s2 + "' is an invalid name.", v(i2[t3]));
+        if (Object.prototype.hasOwnProperty.call(n2, s2))
+          return b("InvalidAttr", "Attribute '" + s2 + "' is repeated.", v(i2[t3]));
+        n2[s2] = 1;
+      }
+      return true;
+    }
+    function N(t2, e2) {
+      if (t2[++e2] === ";")
+        return -1;
+      if (t2[e2] === "#")
+        return function(t3, e3) {
+          let i3 = /\d/;
+          for (t3[e3] === "x" && (e3++, i3 = /[\da-fA-F]/);e3 < t3.length; e3++) {
+            if (t3[e3] === ";")
+              return e3;
+            if (!t3[e3].match(i3))
+              break;
+          }
+          return -1;
+        }(t2, ++e2);
+      let i2 = 0;
+      for (;e2 < t2.length; e2++, i2++)
+        if (!(t2[e2].match(/\w/) && i2 < 20)) {
+          if (t2[e2] === ";")
+            break;
+          return -1;
+        }
+      return e2;
+    }
+    function b(t2, e2, i2) {
+      return { err: { code: t2, msg: e2, line: i2.line || i2, col: i2.col } };
+    }
+    function E(t2) {
+      return r(t2);
+    }
+    function y(t2) {
+      return r(t2);
+    }
+    function w(t2, e2) {
+      const i2 = t2.substring(0, e2).split(/\r?\n/);
+      return { line: i2.length, col: i2[i2.length - 1].length + 1 };
+    }
+    function v(t2) {
+      return t2.startIndex + t2[1].length;
+    }
+    const T = (t2) => o.includes(t2) ? "__" + t2 : t2, P = { preserveOrder: false, attributeNamePrefix: "@_", attributesGroupName: false, textNodeName: "#text", ignoreAttributes: true, removeNSPrefix: false, allowBooleanAttributes: false, parseTagValue: true, parseAttributeValue: false, trimValues: true, cdataPropName: false, numberParseOptions: { hex: true, leadingZeros: true, eNotation: true }, tagValueProcessor: function(t2, e2) {
+      return e2;
+    }, attributeValueProcessor: function(t2, e2) {
+      return e2;
+    }, stopNodes: [], alwaysCreateTextNode: false, isArray: () => false, commentPropName: false, unpairedTags: [], processEntities: true, htmlEntities: false, ignoreDeclaration: false, ignorePiTags: false, transformTagName: false, transformAttributeName: false, updateTag: function(t2, e2, i2) {
+      return t2;
+    }, captureMetaData: false, maxNestedTags: 100, strictReservedNames: true, jPath: true, onDangerousProperty: T };
+    function S(t2, e2) {
+      if (typeof t2 != "string")
+        return;
+      const i2 = t2.toLowerCase();
+      if (o.some((t3) => i2 === t3.toLowerCase()))
+        throw new Error(`[SECURITY] Invalid ${e2}: "${t2}" is a reserved JavaScript keyword that could cause prototype pollution`);
+      if (a.some((t3) => i2 === t3.toLowerCase()))
+        throw new Error(`[SECURITY] Invalid ${e2}: "${t2}" is a reserved JavaScript keyword that could cause prototype pollution`);
+    }
+    function A(t2) {
+      return typeof t2 == "boolean" ? { enabled: t2, maxEntitySize: 1e4, maxExpansionDepth: 10, maxTotalExpansions: 1000, maxExpandedLength: 1e5, maxEntityCount: 100, allowedTags: null, tagFilter: null } : typeof t2 == "object" && t2 !== null ? { enabled: t2.enabled !== false, maxEntitySize: Math.max(1, t2.maxEntitySize ?? 1e4), maxExpansionDepth: Math.max(1, t2.maxExpansionDepth ?? 10), maxTotalExpansions: Math.max(1, t2.maxTotalExpansions ?? 1000), maxExpandedLength: Math.max(1, t2.maxExpandedLength ?? 1e5), maxEntityCount: Math.max(1, t2.maxEntityCount ?? 100), allowedTags: t2.allowedTags ?? null, tagFilter: t2.tagFilter ?? null } : A(true);
+    }
+    const O = function(t2) {
+      const e2 = Object.assign({}, P, t2), i2 = [{ value: e2.attributeNamePrefix, name: "attributeNamePrefix" }, { value: e2.attributesGroupName, name: "attributesGroupName" }, { value: e2.textNodeName, name: "textNodeName" }, { value: e2.cdataPropName, name: "cdataPropName" }, { value: e2.commentPropName, name: "commentPropName" }];
+      for (const { value: t3, name: e3 } of i2)
+        t3 && S(t3, e3);
+      return e2.onDangerousProperty === null && (e2.onDangerousProperty = T), e2.processEntities = A(e2.processEntities), e2.stopNodes && Array.isArray(e2.stopNodes) && (e2.stopNodes = e2.stopNodes.map((t3) => typeof t3 == "string" && t3.startsWith("*.") ? ".." + t3.substring(2) : t3)), e2;
+    };
+    let C;
+    C = typeof Symbol != "function" ? "@@xmlMetadata" : Symbol("XML Node Metadata");
+
+    class $ {
+      constructor(t2) {
+        this.tagname = t2, this.child = [], this[":@"] = Object.create(null);
+      }
+      add(t2, e2) {
+        t2 === "__proto__" && (t2 = "#__proto__"), this.child.push({ [t2]: e2 });
+      }
+      addChild(t2, e2) {
+        t2.tagname === "__proto__" && (t2.tagname = "#__proto__"), t2[":@"] && Object.keys(t2[":@"]).length > 0 ? this.child.push({ [t2.tagname]: t2.child, ":@": t2[":@"] }) : this.child.push({ [t2.tagname]: t2.child }), e2 !== undefined && (this.child[this.child.length - 1][C] = { startIndex: e2 });
+      }
+      static getMetaDataSymbol() {
+        return C;
+      }
+    }
+
+    class I {
+      constructor(t2) {
+        this.suppressValidationErr = !t2, this.options = t2;
+      }
+      readDocType(t2, e2) {
+        const i2 = Object.create(null);
+        let n2 = 0;
+        if (t2[e2 + 3] !== "O" || t2[e2 + 4] !== "C" || t2[e2 + 5] !== "T" || t2[e2 + 6] !== "Y" || t2[e2 + 7] !== "P" || t2[e2 + 8] !== "E")
+          throw new Error("Invalid Tag instead of DOCTYPE");
+        {
+          e2 += 9;
+          let s2 = 1, r2 = false, o2 = false, a2 = "";
+          for (;e2 < t2.length; e2++)
+            if (t2[e2] !== "<" || o2)
+              if (t2[e2] === ">") {
+                if (o2 ? t2[e2 - 1] === "-" && t2[e2 - 2] === "-" && (o2 = false, s2--) : s2--, s2 === 0)
+                  break;
+              } else
+                t2[e2] === "[" ? r2 = true : a2 += t2[e2];
+            else {
+              if (r2 && M(t2, "!ENTITY", e2)) {
+                let s3, r3;
+                if (e2 += 7, [s3, r3, e2] = this.readEntityExp(t2, e2 + 1, this.suppressValidationErr), r3.indexOf("&") === -1) {
+                  if (this.options.enabled !== false && this.options.maxEntityCount != null && n2 >= this.options.maxEntityCount)
+                    throw new Error(`Entity count (${n2 + 1}) exceeds maximum allowed (${this.options.maxEntityCount})`);
+                  const t3 = s3.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+                  i2[s3] = { regx: RegExp(`&${t3};`, "g"), val: r3 }, n2++;
+                }
+              } else if (r2 && M(t2, "!ELEMENT", e2)) {
+                e2 += 8;
+                const { index: i3 } = this.readElementExp(t2, e2 + 1);
+                e2 = i3;
+              } else if (r2 && M(t2, "!ATTLIST", e2))
+                e2 += 8;
+              else if (r2 && M(t2, "!NOTATION", e2)) {
+                e2 += 9;
+                const { index: i3 } = this.readNotationExp(t2, e2 + 1, this.suppressValidationErr);
+                e2 = i3;
+              } else {
+                if (!M(t2, "!--", e2))
+                  throw new Error("Invalid DOCTYPE");
+                o2 = true;
+              }
+              s2++, a2 = "";
+            }
+          if (s2 !== 0)
+            throw new Error("Unclosed DOCTYPE");
+        }
+        return { entities: i2, i: e2 };
+      }
+      readEntityExp(t2, e2) {
+        const i2 = e2 = j(t2, e2);
+        for (;e2 < t2.length && !/\s/.test(t2[e2]) && t2[e2] !== '"' && t2[e2] !== "'"; )
+          e2++;
+        let n2 = t2.substring(i2, e2);
+        if (_(n2), e2 = j(t2, e2), !this.suppressValidationErr) {
+          if (t2.substring(e2, e2 + 6).toUpperCase() === "SYSTEM")
+            throw new Error("External entities are not supported");
+          if (t2[e2] === "%")
+            throw new Error("Parameter entities are not supported");
+        }
+        let s2 = "";
+        if ([e2, s2] = this.readIdentifierVal(t2, e2, "entity"), this.options.enabled !== false && this.options.maxEntitySize != null && s2.length > this.options.maxEntitySize)
+          throw new Error(`Entity "${n2}" size (${s2.length}) exceeds maximum allowed size (${this.options.maxEntitySize})`);
+        return [n2, s2, --e2];
+      }
+      readNotationExp(t2, e2) {
+        const i2 = e2 = j(t2, e2);
+        for (;e2 < t2.length && !/\s/.test(t2[e2]); )
+          e2++;
+        let n2 = t2.substring(i2, e2);
+        !this.suppressValidationErr && _(n2), e2 = j(t2, e2);
+        const s2 = t2.substring(e2, e2 + 6).toUpperCase();
+        if (!this.suppressValidationErr && s2 !== "SYSTEM" && s2 !== "PUBLIC")
+          throw new Error(`Expected SYSTEM or PUBLIC, found "${s2}"`);
+        e2 += s2.length, e2 = j(t2, e2);
+        let r2 = null, o2 = null;
+        if (s2 === "PUBLIC")
+          [e2, r2] = this.readIdentifierVal(t2, e2, "publicIdentifier"), t2[e2 = j(t2, e2)] !== '"' && t2[e2] !== "'" || ([e2, o2] = this.readIdentifierVal(t2, e2, "systemIdentifier"));
+        else if (s2 === "SYSTEM" && ([e2, o2] = this.readIdentifierVal(t2, e2, "systemIdentifier"), !this.suppressValidationErr && !o2))
+          throw new Error("Missing mandatory system identifier for SYSTEM notation");
+        return { notationName: n2, publicIdentifier: r2, systemIdentifier: o2, index: --e2 };
+      }
+      readIdentifierVal(t2, e2, i2) {
+        let n2 = "";
+        const s2 = t2[e2];
+        if (s2 !== '"' && s2 !== "'")
+          throw new Error(`Expected quoted string, found "${s2}"`);
+        const r2 = ++e2;
+        for (;e2 < t2.length && t2[e2] !== s2; )
+          e2++;
+        if (n2 = t2.substring(r2, e2), t2[e2] !== s2)
+          throw new Error(`Unterminated ${i2} value`);
+        return [++e2, n2];
+      }
+      readElementExp(t2, e2) {
+        const i2 = e2 = j(t2, e2);
+        for (;e2 < t2.length && !/\s/.test(t2[e2]); )
+          e2++;
+        let n2 = t2.substring(i2, e2);
+        if (!this.suppressValidationErr && !r(n2))
+          throw new Error(`Invalid element name: "${n2}"`);
+        let s2 = "";
+        if (t2[e2 = j(t2, e2)] === "E" && M(t2, "MPTY", e2))
+          e2 += 4;
+        else if (t2[e2] === "A" && M(t2, "NY", e2))
+          e2 += 2;
+        else if (t2[e2] === "(") {
+          const i3 = ++e2;
+          for (;e2 < t2.length && t2[e2] !== ")"; )
+            e2++;
+          if (s2 = t2.substring(i3, e2), t2[e2] !== ")")
+            throw new Error("Unterminated content model");
+        } else if (!this.suppressValidationErr)
+          throw new Error(`Invalid Element Expression, found "${t2[e2]}"`);
+        return { elementName: n2, contentModel: s2.trim(), index: e2 };
+      }
+      readAttlistExp(t2, e2) {
+        let i2 = e2 = j(t2, e2);
+        for (;e2 < t2.length && !/\s/.test(t2[e2]); )
+          e2++;
+        let n2 = t2.substring(i2, e2);
+        for (_(n2), i2 = e2 = j(t2, e2);e2 < t2.length && !/\s/.test(t2[e2]); )
+          e2++;
+        let s2 = t2.substring(i2, e2);
+        if (!_(s2))
+          throw new Error(`Invalid attribute name: "${s2}"`);
+        e2 = j(t2, e2);
+        let r2 = "";
+        if (t2.substring(e2, e2 + 8).toUpperCase() === "NOTATION") {
+          if (r2 = "NOTATION", t2[e2 = j(t2, e2 += 8)] !== "(")
+            throw new Error(`Expected '(', found "${t2[e2]}"`);
+          e2++;
+          let i3 = [];
+          for (;e2 < t2.length && t2[e2] !== ")"; ) {
+            const n3 = e2;
+            for (;e2 < t2.length && t2[e2] !== "|" && t2[e2] !== ")"; )
+              e2++;
+            let s3 = t2.substring(n3, e2);
+            if (s3 = s3.trim(), !_(s3))
+              throw new Error(`Invalid notation name: "${s3}"`);
+            i3.push(s3), t2[e2] === "|" && (e2++, e2 = j(t2, e2));
+          }
+          if (t2[e2] !== ")")
+            throw new Error("Unterminated list of notations");
+          e2++, r2 += " (" + i3.join("|") + ")";
+        } else {
+          const i3 = e2;
+          for (;e2 < t2.length && !/\s/.test(t2[e2]); )
+            e2++;
+          r2 += t2.substring(i3, e2);
+          const n3 = ["CDATA", "ID", "IDREF", "IDREFS", "ENTITY", "ENTITIES", "NMTOKEN", "NMTOKENS"];
+          if (!this.suppressValidationErr && !n3.includes(r2.toUpperCase()))
+            throw new Error(`Invalid attribute type: "${r2}"`);
+        }
+        e2 = j(t2, e2);
+        let o2 = "";
+        return t2.substring(e2, e2 + 8).toUpperCase() === "#REQUIRED" ? (o2 = "#REQUIRED", e2 += 8) : t2.substring(e2, e2 + 7).toUpperCase() === "#IMPLIED" ? (o2 = "#IMPLIED", e2 += 7) : [e2, o2] = this.readIdentifierVal(t2, e2, "ATTLIST"), { elementName: n2, attributeName: s2, attributeType: r2, defaultValue: o2, index: e2 };
+      }
+    }
+    const j = (t2, e2) => {
+      for (;e2 < t2.length && /\s/.test(t2[e2]); )
+        e2++;
+      return e2;
+    };
+    function M(t2, e2, i2) {
+      for (let n2 = 0;n2 < e2.length; n2++)
+        if (e2[n2] !== t2[i2 + n2 + 1])
+          return false;
+      return true;
+    }
+    function _(t2) {
+      if (r(t2))
+        return t2;
+      throw new Error(`Invalid entity name ${t2}`);
+    }
+    const D = /^[-+]?0x[a-fA-F0-9]+$/, V = /^([\-\+])?(0*)([0-9]*(\.[0-9]*)?)$/, k = { hex: true, leadingZeros: true, decimalPoint: ".", eNotation: true, infinity: "original" };
+    const F = /^([-+])?(0*)(\d*(\.\d*)?[eE][-\+]?\d+)$/, L = new Set(["push", "pop", "reset", "updateCurrent", "restore"]);
+
+    class G {
+      constructor(t2 = {}) {
+        this.separator = t2.separator || ".", this.path = [], this.siblingStacks = [];
+      }
+      push(t2, e2 = null, i2 = null) {
+        this.path.length > 0 && (this.path[this.path.length - 1].values = undefined);
+        const n2 = this.path.length;
+        this.siblingStacks[n2] || (this.siblingStacks[n2] = new Map);
+        const s2 = this.siblingStacks[n2], r2 = i2 ? `${i2}:${t2}` : t2, o2 = s2.get(r2) || 0;
+        let a2 = 0;
+        for (const t3 of s2.values())
+          a2 += t3;
+        s2.set(r2, o2 + 1);
+        const h2 = { tag: t2, position: a2, counter: o2 };
+        i2 != null && (h2.namespace = i2), e2 != null && (h2.values = e2), this.path.push(h2);
+      }
+      pop() {
+        if (this.path.length === 0)
+          return;
+        const t2 = this.path.pop();
+        return this.siblingStacks.length > this.path.length + 1 && (this.siblingStacks.length = this.path.length + 1), t2;
+      }
+      updateCurrent(t2) {
+        if (this.path.length > 0) {
+          const e2 = this.path[this.path.length - 1];
+          t2 != null && (e2.values = t2);
+        }
+      }
+      getCurrentTag() {
+        return this.path.length > 0 ? this.path[this.path.length - 1].tag : undefined;
+      }
+      getCurrentNamespace() {
+        return this.path.length > 0 ? this.path[this.path.length - 1].namespace : undefined;
+      }
+      getAttrValue(t2) {
+        if (this.path.length === 0)
+          return;
+        const e2 = this.path[this.path.length - 1];
+        return e2.values?.[t2];
+      }
+      hasAttr(t2) {
+        if (this.path.length === 0)
+          return false;
+        const e2 = this.path[this.path.length - 1];
+        return e2.values !== undefined && t2 in e2.values;
+      }
+      getPosition() {
+        return this.path.length === 0 ? -1 : this.path[this.path.length - 1].position ?? 0;
+      }
+      getCounter() {
+        return this.path.length === 0 ? -1 : this.path[this.path.length - 1].counter ?? 0;
+      }
+      getIndex() {
+        return this.getPosition();
+      }
+      getDepth() {
+        return this.path.length;
+      }
+      toString(t2, e2 = true) {
+        const i2 = t2 || this.separator;
+        return this.path.map((t3) => e2 && t3.namespace ? `${t3.namespace}:${t3.tag}` : t3.tag).join(i2);
+      }
+      toArray() {
+        return this.path.map((t2) => t2.tag);
+      }
+      reset() {
+        this.path = [], this.siblingStacks = [];
+      }
+      matches(t2) {
+        const e2 = t2.segments;
+        return e2.length !== 0 && (t2.hasDeepWildcard() ? this._matchWithDeepWildcard(e2) : this._matchSimple(e2));
+      }
+      _matchSimple(t2) {
+        if (this.path.length !== t2.length)
+          return false;
+        for (let e2 = 0;e2 < t2.length; e2++) {
+          const i2 = t2[e2], n2 = this.path[e2], s2 = e2 === this.path.length - 1;
+          if (!this._matchSegment(i2, n2, s2))
+            return false;
+        }
+        return true;
+      }
+      _matchWithDeepWildcard(t2) {
+        let e2 = this.path.length - 1, i2 = t2.length - 1;
+        for (;i2 >= 0 && e2 >= 0; ) {
+          const n2 = t2[i2];
+          if (n2.type === "deep-wildcard") {
+            if (i2--, i2 < 0)
+              return true;
+            const n3 = t2[i2];
+            let s2 = false;
+            for (let t3 = e2;t3 >= 0; t3--) {
+              const r2 = t3 === this.path.length - 1;
+              if (this._matchSegment(n3, this.path[t3], r2)) {
+                e2 = t3 - 1, i2--, s2 = true;
+                break;
+              }
+            }
+            if (!s2)
+              return false;
+          } else {
+            const t3 = e2 === this.path.length - 1;
+            if (!this._matchSegment(n2, this.path[e2], t3))
+              return false;
+            e2--, i2--;
+          }
+        }
+        return i2 < 0;
+      }
+      _matchSegment(t2, e2, i2) {
+        if (t2.tag !== "*" && t2.tag !== e2.tag)
+          return false;
+        if (t2.namespace !== undefined && t2.namespace !== "*" && t2.namespace !== e2.namespace)
+          return false;
+        if (t2.attrName !== undefined) {
+          if (!i2)
+            return false;
+          if (!e2.values || !(t2.attrName in e2.values))
+            return false;
+          if (t2.attrValue !== undefined) {
+            const i3 = e2.values[t2.attrName];
+            if (String(i3) !== String(t2.attrValue))
+              return false;
+          }
+        }
+        if (t2.position !== undefined) {
+          if (!i2)
+            return false;
+          const n2 = e2.counter ?? 0;
+          if (t2.position === "first" && n2 !== 0)
+            return false;
+          if (t2.position === "odd" && n2 % 2 != 1)
+            return false;
+          if (t2.position === "even" && n2 % 2 != 0)
+            return false;
+          if (t2.position === "nth" && n2 !== t2.positionValue)
+            return false;
+        }
+        return true;
+      }
+      snapshot() {
+        return { path: this.path.map((t2) => ({ ...t2 })), siblingStacks: this.siblingStacks.map((t2) => new Map(t2)) };
+      }
+      restore(t2) {
+        this.path = t2.path.map((t3) => ({ ...t3 })), this.siblingStacks = t2.siblingStacks.map((t3) => new Map(t3));
+      }
+      readOnly() {
+        return new Proxy(this, { get(t2, e2, i2) {
+          if (L.has(e2))
+            return () => {
+              throw new TypeError(`Cannot call '${e2}' on a read-only Matcher. Obtain a writable instance to mutate state.`);
+            };
+          const n2 = Reflect.get(t2, e2, i2);
+          return e2 === "path" || e2 === "siblingStacks" ? Object.freeze(Array.isArray(n2) ? n2.map((t3) => t3 instanceof Map ? Object.freeze(new Map(t3)) : Object.freeze({ ...t3 })) : n2) : typeof n2 == "function" ? n2.bind(t2) : n2;
+        }, set(t2, e2) {
+          throw new TypeError(`Cannot set property '${String(e2)}' on a read-only Matcher.`);
+        }, deleteProperty(t2, e2) {
+          throw new TypeError(`Cannot delete property '${String(e2)}' from a read-only Matcher.`);
+        } });
+      }
+    }
+
+    class R {
+      constructor(t2, e2 = {}) {
+        this.pattern = t2, this.separator = e2.separator || ".", this.segments = this._parse(t2), this._hasDeepWildcard = this.segments.some((t3) => t3.type === "deep-wildcard"), this._hasAttributeCondition = this.segments.some((t3) => t3.attrName !== undefined), this._hasPositionSelector = this.segments.some((t3) => t3.position !== undefined);
+      }
+      _parse(t2) {
+        const e2 = [];
+        let i2 = 0, n2 = "";
+        for (;i2 < t2.length; )
+          t2[i2] === this.separator ? i2 + 1 < t2.length && t2[i2 + 1] === this.separator ? (n2.trim() && (e2.push(this._parseSegment(n2.trim())), n2 = ""), e2.push({ type: "deep-wildcard" }), i2 += 2) : (n2.trim() && e2.push(this._parseSegment(n2.trim())), n2 = "", i2++) : (n2 += t2[i2], i2++);
+        return n2.trim() && e2.push(this._parseSegment(n2.trim())), e2;
+      }
+      _parseSegment(t2) {
+        const e2 = { type: "tag" };
+        let i2 = null, n2 = t2;
+        const s2 = t2.match(/^([^\[]+)(\[[^\]]*\])(.*)$/);
+        if (s2 && (n2 = s2[1] + s2[3], s2[2])) {
+          const t3 = s2[2].slice(1, -1);
+          t3 && (i2 = t3);
+        }
+        let r2, o2, a2 = n2;
+        if (n2.includes("::")) {
+          const e3 = n2.indexOf("::");
+          if (r2 = n2.substring(0, e3).trim(), a2 = n2.substring(e3 + 2).trim(), !r2)
+            throw new Error(`Invalid namespace in pattern: ${t2}`);
+        }
+        let h2 = null;
+        if (a2.includes(":")) {
+          const t3 = a2.lastIndexOf(":"), e3 = a2.substring(0, t3).trim(), i3 = a2.substring(t3 + 1).trim();
+          ["first", "last", "odd", "even"].includes(i3) || /^nth\(\d+\)$/.test(i3) ? (o2 = e3, h2 = i3) : o2 = a2;
+        } else
+          o2 = a2;
+        if (!o2)
+          throw new Error(`Invalid segment pattern: ${t2}`);
+        if (e2.tag = o2, r2 && (e2.namespace = r2), i2)
+          if (i2.includes("=")) {
+            const t3 = i2.indexOf("=");
+            e2.attrName = i2.substring(0, t3).trim(), e2.attrValue = i2.substring(t3 + 1).trim();
+          } else
+            e2.attrName = i2.trim();
+        if (h2) {
+          const t3 = h2.match(/^nth\((\d+)\)$/);
+          t3 ? (e2.position = "nth", e2.positionValue = parseInt(t3[1], 10)) : e2.position = h2;
+        }
+        return e2;
+      }
+      get length() {
+        return this.segments.length;
+      }
+      hasDeepWildcard() {
+        return this._hasDeepWildcard;
+      }
+      hasAttributeCondition() {
+        return this._hasAttributeCondition;
+      }
+      hasPositionSelector() {
+        return this._hasPositionSelector;
+      }
+      toString() {
+        return this.pattern;
+      }
+    }
+    function U(t2, e2) {
+      if (!t2)
+        return {};
+      const i2 = e2.attributesGroupName ? t2[e2.attributesGroupName] : t2;
+      if (!i2)
+        return {};
+      const n2 = {};
+      for (const t3 in i2)
+        t3.startsWith(e2.attributeNamePrefix) ? n2[t3.substring(e2.attributeNamePrefix.length)] = i2[t3] : n2[t3] = i2[t3];
+      return n2;
+    }
+    function B(t2) {
+      if (!t2 || typeof t2 != "string")
+        return;
+      const e2 = t2.indexOf(":");
+      if (e2 !== -1 && e2 > 0) {
+        const i2 = t2.substring(0, e2);
+        if (i2 !== "xmlns")
+          return i2;
+      }
+    }
+
+    class W {
+      constructor(t2) {
+        var e2;
+        if (this.options = t2, this.currentNode = null, this.tagsNodeStack = [], this.docTypeEntities = {}, this.lastEntities = { apos: { regex: /&(apos|#39|#x27);/g, val: "'" }, gt: { regex: /&(gt|#62|#x3E);/g, val: ">" }, lt: { regex: /&(lt|#60|#x3C);/g, val: "<" }, quot: { regex: /&(quot|#34|#x22);/g, val: '"' } }, this.ampEntity = { regex: /&(amp|#38|#x26);/g, val: "&" }, this.htmlEntities = { space: { regex: /&(nbsp|#160);/g, val: " " }, cent: { regex: /&(cent|#162);/g, val: "\xA2" }, pound: { regex: /&(pound|#163);/g, val: "\xA3" }, yen: { regex: /&(yen|#165);/g, val: "\xA5" }, euro: { regex: /&(euro|#8364);/g, val: "\u20AC" }, copyright: { regex: /&(copy|#169);/g, val: "\xA9" }, reg: { regex: /&(reg|#174);/g, val: "\xAE" }, inr: { regex: /&(inr|#8377);/g, val: "\u20B9" }, num_dec: { regex: /&#([0-9]{1,7});/g, val: (t3, e3) => rt(e3, 10, "&#") }, num_hex: { regex: /&#x([0-9a-fA-F]{1,6});/g, val: (t3, e3) => rt(e3, 16, "&#x") } }, this.addExternalEntities = Y, this.parseXml = J, this.parseTextData = z, this.resolveNameSpace = X, this.buildAttributesMap = Z, this.isItStopNode = tt, this.replaceEntitiesValue = Q, this.readStopNodeData = nt, this.saveTextToParentTag = H, this.addChild = K, this.ignoreAttributesFn = typeof (e2 = this.options.ignoreAttributes) == "function" ? e2 : Array.isArray(e2) ? (t3) => {
+          for (const i2 of e2) {
+            if (typeof i2 == "string" && t3 === i2)
+              return true;
+            if (i2 instanceof RegExp && i2.test(t3))
+              return true;
+          }
+        } : () => false, this.entityExpansionCount = 0, this.currentExpandedLength = 0, this.matcher = new G, this.readonlyMatcher = this.matcher.readOnly(), this.isCurrentNodeStopNode = false, this.options.stopNodes && this.options.stopNodes.length > 0) {
+          this.stopNodeExpressions = [];
+          for (let t3 = 0;t3 < this.options.stopNodes.length; t3++) {
+            const e3 = this.options.stopNodes[t3];
+            typeof e3 == "string" ? this.stopNodeExpressions.push(new R(e3)) : e3 instanceof R && this.stopNodeExpressions.push(e3);
+          }
+        }
+      }
+    }
+    function Y(t2) {
+      const e2 = Object.keys(t2);
+      for (let i2 = 0;i2 < e2.length; i2++) {
+        const n2 = e2[i2], s2 = n2.replace(/[.\-+*:]/g, "\\.");
+        this.lastEntities[n2] = { regex: new RegExp("&" + s2 + ";", "g"), val: t2[n2] };
+      }
+    }
+    function z(t2, e2, i2, n2, s2, r2, o2) {
+      if (t2 !== undefined && (this.options.trimValues && !n2 && (t2 = t2.trim()), t2.length > 0)) {
+        o2 || (t2 = this.replaceEntitiesValue(t2, e2, i2));
+        const n3 = this.options.jPath ? i2.toString() : i2, a2 = this.options.tagValueProcessor(e2, t2, n3, s2, r2);
+        return a2 == null ? t2 : typeof a2 != typeof t2 || a2 !== t2 ? a2 : this.options.trimValues || t2.trim() === t2 ? st(t2, this.options.parseTagValue, this.options.numberParseOptions) : t2;
+      }
+    }
+    function X(t2) {
+      if (this.options.removeNSPrefix) {
+        const e2 = t2.split(":"), i2 = t2.charAt(0) === "/" ? "/" : "";
+        if (e2[0] === "xmlns")
+          return "";
+        e2.length === 2 && (t2 = i2 + e2[1]);
+      }
+      return t2;
+    }
+    const q = new RegExp(`([^\\s=]+)\\s*(=\\s*(['"])([\\s\\S]*?)\\3)?`, "gm");
+    function Z(t2, e2, i2) {
+      if (this.options.ignoreAttributes !== true && typeof t2 == "string") {
+        const n2 = s(t2, q), r2 = n2.length, o2 = {}, a2 = {};
+        for (let t3 = 0;t3 < r2; t3++) {
+          const e3 = this.resolveNameSpace(n2[t3][1]), s2 = n2[t3][4];
+          if (e3.length && s2 !== undefined) {
+            let t4 = s2;
+            this.options.trimValues && (t4 = t4.trim()), t4 = this.replaceEntitiesValue(t4, i2, this.readonlyMatcher), a2[e3] = t4;
+          }
+        }
+        Object.keys(a2).length > 0 && typeof e2 == "object" && e2.updateCurrent && e2.updateCurrent(a2);
+        for (let t3 = 0;t3 < r2; t3++) {
+          const s2 = this.resolveNameSpace(n2[t3][1]), r3 = this.options.jPath ? e2.toString() : this.readonlyMatcher;
+          if (this.ignoreAttributesFn(s2, r3))
+            continue;
+          let a3 = n2[t3][4], h2 = this.options.attributeNamePrefix + s2;
+          if (s2.length)
+            if (this.options.transformAttributeName && (h2 = this.options.transformAttributeName(h2)), h2 = at(h2, this.options), a3 !== undefined) {
+              this.options.trimValues && (a3 = a3.trim()), a3 = this.replaceEntitiesValue(a3, i2, this.readonlyMatcher);
+              const t4 = this.options.jPath ? e2.toString() : this.readonlyMatcher, n3 = this.options.attributeValueProcessor(s2, a3, t4);
+              o2[h2] = n3 == null ? a3 : typeof n3 != typeof a3 || n3 !== a3 ? n3 : st(a3, this.options.parseAttributeValue, this.options.numberParseOptions);
+            } else
+              this.options.allowBooleanAttributes && (o2[h2] = true);
+        }
+        if (!Object.keys(o2).length)
+          return;
+        if (this.options.attributesGroupName) {
+          const t3 = {};
+          return t3[this.options.attributesGroupName] = o2, t3;
+        }
+        return o2;
+      }
+    }
+    const J = function(t2) {
+      t2 = t2.replace(/\r\n?/g, `
+`);
+      const e2 = new $("!xml");
+      let i2 = e2, n2 = "";
+      this.matcher.reset(), this.entityExpansionCount = 0, this.currentExpandedLength = 0;
+      const s2 = new I(this.options.processEntities);
+      for (let r2 = 0;r2 < t2.length; r2++)
+        if (t2[r2] === "<")
+          if (t2[r2 + 1] === "/") {
+            const e3 = et(t2, ">", r2, "Closing Tag is not closed.");
+            let s3 = t2.substring(r2 + 2, e3).trim();
+            if (this.options.removeNSPrefix) {
+              const t3 = s3.indexOf(":");
+              t3 !== -1 && (s3 = s3.substr(t3 + 1));
+            }
+            s3 = ot(this.options.transformTagName, s3, "", this.options).tagName, i2 && (n2 = this.saveTextToParentTag(n2, i2, this.readonlyMatcher));
+            const o2 = this.matcher.getCurrentTag();
+            if (s3 && this.options.unpairedTags.indexOf(s3) !== -1)
+              throw new Error(`Unpaired tag can not be used as closing tag: </${s3}>`);
+            o2 && this.options.unpairedTags.indexOf(o2) !== -1 && (this.matcher.pop(), this.tagsNodeStack.pop()), this.matcher.pop(), this.isCurrentNodeStopNode = false, i2 = this.tagsNodeStack.pop(), n2 = "", r2 = e3;
+          } else if (t2[r2 + 1] === "?") {
+            let e3 = it(t2, r2, false, "?>");
+            if (!e3)
+              throw new Error("Pi Tag is not closed.");
+            if (n2 = this.saveTextToParentTag(n2, i2, this.readonlyMatcher), this.options.ignoreDeclaration && e3.tagName === "?xml" || this.options.ignorePiTags)
+              ;
+            else {
+              const t3 = new $(e3.tagName);
+              t3.add(this.options.textNodeName, ""), e3.tagName !== e3.tagExp && e3.attrExpPresent && (t3[":@"] = this.buildAttributesMap(e3.tagExp, this.matcher, e3.tagName)), this.addChild(i2, t3, this.readonlyMatcher, r2);
+            }
+            r2 = e3.closeIndex + 1;
+          } else if (t2.substr(r2 + 1, 3) === "!--") {
+            const e3 = et(t2, "-->", r2 + 4, "Comment is not closed.");
+            if (this.options.commentPropName) {
+              const s3 = t2.substring(r2 + 4, e3 - 2);
+              n2 = this.saveTextToParentTag(n2, i2, this.readonlyMatcher), i2.add(this.options.commentPropName, [{ [this.options.textNodeName]: s3 }]);
+            }
+            r2 = e3;
+          } else if (t2.substr(r2 + 1, 2) === "!D") {
+            const e3 = s2.readDocType(t2, r2);
+            this.docTypeEntities = e3.entities, r2 = e3.i;
+          } else if (t2.substr(r2 + 1, 2) === "![") {
+            const e3 = et(t2, "]]>", r2, "CDATA is not closed.") - 2, s3 = t2.substring(r2 + 9, e3);
+            n2 = this.saveTextToParentTag(n2, i2, this.readonlyMatcher);
+            let o2 = this.parseTextData(s3, i2.tagname, this.readonlyMatcher, true, false, true, true);
+            o2 == null && (o2 = ""), this.options.cdataPropName ? i2.add(this.options.cdataPropName, [{ [this.options.textNodeName]: s3 }]) : i2.add(this.options.textNodeName, o2), r2 = e3 + 2;
+          } else {
+            let s3 = it(t2, r2, this.options.removeNSPrefix);
+            if (!s3) {
+              const e3 = t2.substring(Math.max(0, r2 - 50), Math.min(t2.length, r2 + 50));
+              throw new Error(`readTagExp returned undefined at position ${r2}. Context: "${e3}"`);
+            }
+            let o2 = s3.tagName;
+            const a2 = s3.rawTagName;
+            let { tagExp: h2, attrExpPresent: l2, closeIndex: p2 } = s3;
+            if ({ tagName: o2, tagExp: h2 } = ot(this.options.transformTagName, o2, h2, this.options), this.options.strictReservedNames && (o2 === this.options.commentPropName || o2 === this.options.cdataPropName || o2 === this.options.textNodeName || o2 === this.options.attributesGroupName))
+              throw new Error(`Invalid tag name: ${o2}`);
+            i2 && n2 && i2.tagname !== "!xml" && (n2 = this.saveTextToParentTag(n2, i2, this.readonlyMatcher, false));
+            const u2 = i2;
+            u2 && this.options.unpairedTags.indexOf(u2.tagname) !== -1 && (i2 = this.tagsNodeStack.pop(), this.matcher.pop());
+            let c2 = false;
+            h2.length > 0 && h2.lastIndexOf("/") === h2.length - 1 && (c2 = true, o2[o2.length - 1] === "/" ? (o2 = o2.substr(0, o2.length - 1), h2 = o2) : h2 = h2.substr(0, h2.length - 1), l2 = o2 !== h2);
+            let d2, f2 = null, g2 = {};
+            d2 = B(a2), o2 !== e2.tagname && this.matcher.push(o2, {}, d2), o2 !== h2 && l2 && (f2 = this.buildAttributesMap(h2, this.matcher, o2), f2 && (g2 = U(f2, this.options))), o2 !== e2.tagname && (this.isCurrentNodeStopNode = this.isItStopNode(this.stopNodeExpressions, this.matcher));
+            const m2 = r2;
+            if (this.isCurrentNodeStopNode) {
+              let e3 = "";
+              if (c2)
+                r2 = s3.closeIndex;
+              else if (this.options.unpairedTags.indexOf(o2) !== -1)
+                r2 = s3.closeIndex;
+              else {
+                const i3 = this.readStopNodeData(t2, a2, p2 + 1);
+                if (!i3)
+                  throw new Error(`Unexpected end of ${a2}`);
+                r2 = i3.i, e3 = i3.tagContent;
+              }
+              const n3 = new $(o2);
+              f2 && (n3[":@"] = f2), n3.add(this.options.textNodeName, e3), this.matcher.pop(), this.isCurrentNodeStopNode = false, this.addChild(i2, n3, this.readonlyMatcher, m2);
+            } else {
+              if (c2) {
+                ({ tagName: o2, tagExp: h2 } = ot(this.options.transformTagName, o2, h2, this.options));
+                const t3 = new $(o2);
+                f2 && (t3[":@"] = f2), this.addChild(i2, t3, this.readonlyMatcher, m2), this.matcher.pop(), this.isCurrentNodeStopNode = false;
+              } else {
+                if (this.options.unpairedTags.indexOf(o2) !== -1) {
+                  const t3 = new $(o2);
+                  f2 && (t3[":@"] = f2), this.addChild(i2, t3, this.readonlyMatcher, m2), this.matcher.pop(), this.isCurrentNodeStopNode = false, r2 = s3.closeIndex;
+                  continue;
+                }
+                {
+                  const t3 = new $(o2);
+                  if (this.tagsNodeStack.length > this.options.maxNestedTags)
+                    throw new Error("Maximum nested tags exceeded");
+                  this.tagsNodeStack.push(i2), f2 && (t3[":@"] = f2), this.addChild(i2, t3, this.readonlyMatcher, m2), i2 = t3;
+                }
+              }
+              n2 = "", r2 = p2;
+            }
+          }
+        else
+          n2 += t2[r2];
+      return e2.child;
+    };
+    function K(t2, e2, i2, n2) {
+      this.options.captureMetaData || (n2 = undefined);
+      const s2 = this.options.jPath ? i2.toString() : i2, r2 = this.options.updateTag(e2.tagname, s2, e2[":@"]);
+      r2 === false || (typeof r2 == "string" ? (e2.tagname = r2, t2.addChild(e2, n2)) : t2.addChild(e2, n2));
+    }
+    function Q(t2, e2, i2) {
+      const n2 = this.options.processEntities;
+      if (!n2 || !n2.enabled)
+        return t2;
+      if (n2.allowedTags) {
+        const s2 = this.options.jPath ? i2.toString() : i2;
+        if (!(Array.isArray(n2.allowedTags) ? n2.allowedTags.includes(e2) : n2.allowedTags(e2, s2)))
+          return t2;
+      }
+      if (n2.tagFilter) {
+        const s2 = this.options.jPath ? i2.toString() : i2;
+        if (!n2.tagFilter(e2, s2))
+          return t2;
+      }
+      for (const e3 of Object.keys(this.docTypeEntities)) {
+        const i3 = this.docTypeEntities[e3], s2 = t2.match(i3.regx);
+        if (s2) {
+          if (this.entityExpansionCount += s2.length, n2.maxTotalExpansions && this.entityExpansionCount > n2.maxTotalExpansions)
+            throw new Error(`Entity expansion limit exceeded: ${this.entityExpansionCount} > ${n2.maxTotalExpansions}`);
+          const e4 = t2.length;
+          if (t2 = t2.replace(i3.regx, i3.val), n2.maxExpandedLength && (this.currentExpandedLength += t2.length - e4, this.currentExpandedLength > n2.maxExpandedLength))
+            throw new Error(`Total expanded content size exceeded: ${this.currentExpandedLength} > ${n2.maxExpandedLength}`);
+        }
+      }
+      for (const e3 of Object.keys(this.lastEntities)) {
+        const i3 = this.lastEntities[e3], s2 = t2.match(i3.regex);
+        if (s2 && (this.entityExpansionCount += s2.length, n2.maxTotalExpansions && this.entityExpansionCount > n2.maxTotalExpansions))
+          throw new Error(`Entity expansion limit exceeded: ${this.entityExpansionCount} > ${n2.maxTotalExpansions}`);
+        t2 = t2.replace(i3.regex, i3.val);
+      }
+      if (t2.indexOf("&") === -1)
+        return t2;
+      if (this.options.htmlEntities)
+        for (const e3 of Object.keys(this.htmlEntities)) {
+          const i3 = this.htmlEntities[e3], s2 = t2.match(i3.regex);
+          if (s2 && (this.entityExpansionCount += s2.length, n2.maxTotalExpansions && this.entityExpansionCount > n2.maxTotalExpansions))
+            throw new Error(`Entity expansion limit exceeded: ${this.entityExpansionCount} > ${n2.maxTotalExpansions}`);
+          t2 = t2.replace(i3.regex, i3.val);
+        }
+      return t2.replace(this.ampEntity.regex, this.ampEntity.val);
+    }
+    function H(t2, e2, i2, n2) {
+      return t2 && (n2 === undefined && (n2 = e2.child.length === 0), (t2 = this.parseTextData(t2, e2.tagname, i2, false, !!e2[":@"] && Object.keys(e2[":@"]).length !== 0, n2)) !== undefined && t2 !== "" && e2.add(this.options.textNodeName, t2), t2 = ""), t2;
+    }
+    function tt(t2, e2) {
+      if (!t2 || t2.length === 0)
+        return false;
+      for (let i2 = 0;i2 < t2.length; i2++)
+        if (e2.matches(t2[i2]))
+          return true;
+      return false;
+    }
+    function et(t2, e2, i2, n2) {
+      const s2 = t2.indexOf(e2, i2);
+      if (s2 === -1)
+        throw new Error(n2);
+      return s2 + e2.length - 1;
+    }
+    function it(t2, e2, i2, n2 = ">") {
+      const s2 = function(t3, e3, i3 = ">") {
+        let n3, s3 = "";
+        for (let r3 = e3;r3 < t3.length; r3++) {
+          let e4 = t3[r3];
+          if (n3)
+            e4 === n3 && (n3 = "");
+          else if (e4 === '"' || e4 === "'")
+            n3 = e4;
+          else if (e4 === i3[0]) {
+            if (!i3[1])
+              return { data: s3, index: r3 };
+            if (t3[r3 + 1] === i3[1])
+              return { data: s3, index: r3 };
+          } else
+            e4 === "\t" && (e4 = " ");
+          s3 += e4;
+        }
+      }(t2, e2 + 1, n2);
+      if (!s2)
+        return;
+      let r2 = s2.data;
+      const o2 = s2.index, a2 = r2.search(/\s/);
+      let h2 = r2, l2 = true;
+      a2 !== -1 && (h2 = r2.substring(0, a2), r2 = r2.substring(a2 + 1).trimStart());
+      const p2 = h2;
+      if (i2) {
+        const t3 = h2.indexOf(":");
+        t3 !== -1 && (h2 = h2.substr(t3 + 1), l2 = h2 !== s2.data.substr(t3 + 1));
+      }
+      return { tagName: h2, tagExp: r2, closeIndex: o2, attrExpPresent: l2, rawTagName: p2 };
+    }
+    function nt(t2, e2, i2) {
+      const n2 = i2;
+      let s2 = 1;
+      for (;i2 < t2.length; i2++)
+        if (t2[i2] === "<")
+          if (t2[i2 + 1] === "/") {
+            const r2 = et(t2, ">", i2, `${e2} is not closed`);
+            if (t2.substring(i2 + 2, r2).trim() === e2 && (s2--, s2 === 0))
+              return { tagContent: t2.substring(n2, i2), i: r2 };
+            i2 = r2;
+          } else if (t2[i2 + 1] === "?")
+            i2 = et(t2, "?>", i2 + 1, "StopNode is not closed.");
+          else if (t2.substr(i2 + 1, 3) === "!--")
+            i2 = et(t2, "-->", i2 + 3, "StopNode is not closed.");
+          else if (t2.substr(i2 + 1, 2) === "![")
+            i2 = et(t2, "]]>", i2, "StopNode is not closed.") - 2;
+          else {
+            const n3 = it(t2, i2, ">");
+            n3 && ((n3 && n3.tagName) === e2 && n3.tagExp[n3.tagExp.length - 1] !== "/" && s2++, i2 = n3.closeIndex);
+          }
+    }
+    function st(t2, e2, i2) {
+      if (e2 && typeof t2 == "string") {
+        const e3 = t2.trim();
+        return e3 === "true" || e3 !== "false" && function(t3, e4 = {}) {
+          if (e4 = Object.assign({}, k, e4), !t3 || typeof t3 != "string")
+            return t3;
+          let i3 = t3.trim();
+          if (e4.skipLike !== undefined && e4.skipLike.test(i3))
+            return t3;
+          if (t3 === "0")
+            return 0;
+          if (e4.hex && D.test(i3))
+            return function(t4) {
+              if (parseInt)
+                return parseInt(t4, 16);
+              if (Number.parseInt)
+                return Number.parseInt(t4, 16);
+              if (window && window.parseInt)
+                return window.parseInt(t4, 16);
+              throw new Error("parseInt, Number.parseInt, window.parseInt are not supported");
+            }(i3);
+          if (isFinite(i3)) {
+            if (i3.includes("e") || i3.includes("E"))
+              return function(t4, e5, i4) {
+                if (!i4.eNotation)
+                  return t4;
+                const n3 = e5.match(F);
+                if (n3) {
+                  let s2 = n3[1] || "";
+                  const r2 = n3[3].indexOf("e") === -1 ? "E" : "e", o2 = n3[2], a2 = s2 ? t4[o2.length + 1] === r2 : t4[o2.length] === r2;
+                  return o2.length > 1 && a2 ? t4 : (o2.length !== 1 || !n3[3].startsWith(`.${r2}`) && n3[3][0] !== r2) && o2.length > 0 ? i4.leadingZeros && !a2 ? (e5 = (n3[1] || "") + n3[3], Number(e5)) : t4 : Number(e5);
+                }
+                return t4;
+              }(t3, i3, e4);
+            {
+              const s2 = V.exec(i3);
+              if (s2) {
+                const r2 = s2[1] || "", o2 = s2[2];
+                let a2 = (n2 = s2[3]) && n2.indexOf(".") !== -1 ? ((n2 = n2.replace(/0+$/, "")) === "." ? n2 = "0" : n2[0] === "." ? n2 = "0" + n2 : n2[n2.length - 1] === "." && (n2 = n2.substring(0, n2.length - 1)), n2) : n2;
+                const h2 = r2 ? t3[o2.length + 1] === "." : t3[o2.length] === ".";
+                if (!e4.leadingZeros && (o2.length > 1 || o2.length === 1 && !h2))
+                  return t3;
+                {
+                  const n3 = Number(i3), s3 = String(n3);
+                  if (n3 === 0)
+                    return n3;
+                  if (s3.search(/[eE]/) !== -1)
+                    return e4.eNotation ? n3 : t3;
+                  if (i3.indexOf(".") !== -1)
+                    return s3 === "0" || s3 === a2 || s3 === `${r2}${a2}` ? n3 : t3;
+                  let h3 = o2 ? a2 : i3;
+                  return o2 ? h3 === s3 || r2 + h3 === s3 ? n3 : t3 : h3 === s3 || h3 === r2 + s3 ? n3 : t3;
+                }
+              }
+              return t3;
+            }
+          }
+          var n2;
+          return function(t4, e5, i4) {
+            const n3 = e5 === 1 / 0;
+            switch (i4.infinity.toLowerCase()) {
+              case "null":
+                return null;
+              case "infinity":
+                return e5;
+              case "string":
+                return n3 ? "Infinity" : "-Infinity";
+              default:
+                return t4;
+            }
+          }(t3, Number(i3), e4);
+        }(t2, i2);
+      }
+      return t2 !== undefined ? t2 : "";
+    }
+    function rt(t2, e2, i2) {
+      const n2 = Number.parseInt(t2, e2);
+      return n2 >= 0 && n2 <= 1114111 ? String.fromCodePoint(n2) : i2 + t2 + ";";
+    }
+    function ot(t2, e2, i2, n2) {
+      if (t2) {
+        const n3 = t2(e2);
+        i2 === e2 && (i2 = n3), e2 = n3;
+      }
+      return { tagName: e2 = at(e2, n2), tagExp: i2 };
+    }
+    function at(t2, e2) {
+      if (a.includes(t2))
+        throw new Error(`[SECURITY] Invalid name: "${t2}" is a reserved JavaScript keyword that could cause prototype pollution`);
+      return o.includes(t2) ? e2.onDangerousProperty(t2) : t2;
+    }
+    const ht = $.getMetaDataSymbol();
+    function lt(t2, e2) {
+      if (!t2 || typeof t2 != "object")
+        return {};
+      if (!e2)
+        return t2;
+      const i2 = {};
+      for (const n2 in t2)
+        n2.startsWith(e2) ? i2[n2.substring(e2.length)] = t2[n2] : i2[n2] = t2[n2];
+      return i2;
+    }
+    function pt(t2, e2, i2, n2) {
+      return ut(t2, e2, i2, n2);
+    }
+    function ut(t2, e2, i2, n2) {
+      let s2;
+      const r2 = {};
+      for (let o2 = 0;o2 < t2.length; o2++) {
+        const a2 = t2[o2], h2 = ct(a2);
+        if (h2 !== undefined && h2 !== e2.textNodeName) {
+          const t3 = lt(a2[":@"] || {}, e2.attributeNamePrefix);
+          i2.push(h2, t3);
+        }
+        if (h2 === e2.textNodeName)
+          s2 === undefined ? s2 = a2[h2] : s2 += "" + a2[h2];
+        else {
+          if (h2 === undefined)
+            continue;
+          if (a2[h2]) {
+            let t3 = ut(a2[h2], e2, i2, n2);
+            const s3 = ft(t3, e2);
+            if (a2[":@"] ? dt(t3, a2[":@"], n2, e2) : Object.keys(t3).length !== 1 || t3[e2.textNodeName] === undefined || e2.alwaysCreateTextNode ? Object.keys(t3).length === 0 && (e2.alwaysCreateTextNode ? t3[e2.textNodeName] = "" : t3 = "") : t3 = t3[e2.textNodeName], a2[ht] !== undefined && typeof t3 == "object" && t3 !== null && (t3[ht] = a2[ht]), r2[h2] !== undefined && Object.prototype.hasOwnProperty.call(r2, h2))
+              Array.isArray(r2[h2]) || (r2[h2] = [r2[h2]]), r2[h2].push(t3);
+            else {
+              const i3 = e2.jPath ? n2.toString() : n2;
+              e2.isArray(h2, i3, s3) ? r2[h2] = [t3] : r2[h2] = t3;
+            }
+            h2 !== undefined && h2 !== e2.textNodeName && i2.pop();
+          }
+        }
+      }
+      return typeof s2 == "string" ? s2.length > 0 && (r2[e2.textNodeName] = s2) : s2 !== undefined && (r2[e2.textNodeName] = s2), r2;
+    }
+    function ct(t2) {
+      const e2 = Object.keys(t2);
+      for (let t3 = 0;t3 < e2.length; t3++) {
+        const i2 = e2[t3];
+        if (i2 !== ":@")
+          return i2;
+      }
+    }
+    function dt(t2, e2, i2, n2) {
+      if (e2) {
+        const s2 = Object.keys(e2), r2 = s2.length;
+        for (let o2 = 0;o2 < r2; o2++) {
+          const r3 = s2[o2], a2 = r3.startsWith(n2.attributeNamePrefix) ? r3.substring(n2.attributeNamePrefix.length) : r3, h2 = n2.jPath ? i2.toString() + "." + a2 : i2;
+          n2.isArray(r3, h2, true, true) ? t2[r3] = [e2[r3]] : t2[r3] = e2[r3];
+        }
+      }
+    }
+    function ft(t2, e2) {
+      const { textNodeName: i2 } = e2, n2 = Object.keys(t2).length;
+      return n2 === 0 || !(n2 !== 1 || !t2[i2] && typeof t2[i2] != "boolean" && t2[i2] !== 0);
+    }
+
+    class gt {
+      constructor(t2) {
+        this.externalEntities = {}, this.options = O(t2);
+      }
+      parse(t2, e2) {
+        if (typeof t2 != "string" && t2.toString)
+          t2 = t2.toString();
+        else if (typeof t2 != "string")
+          throw new Error("XML data is accepted in String or Bytes[] form.");
+        if (e2) {
+          e2 === true && (e2 = {});
+          const i3 = l(t2, e2);
+          if (i3 !== true)
+            throw Error(`${i3.err.msg}:${i3.err.line}:${i3.err.col}`);
+        }
+        const i2 = new W(this.options);
+        i2.addExternalEntities(this.externalEntities);
+        const n2 = i2.parseXml(t2);
+        return this.options.preserveOrder || n2 === undefined ? n2 : pt(n2, this.options, i2.matcher, i2.readonlyMatcher);
+      }
+      addEntity(t2, e2) {
+        if (e2.indexOf("&") !== -1)
+          throw new Error("Entity value can't have '&'");
+        if (t2.indexOf("&") !== -1 || t2.indexOf(";") !== -1)
+          throw new Error("An entity must be set without '&' and ';'. Eg. use '#xD' for '&#xD;'");
+        if (e2 === "&")
+          throw new Error("An entity with value '&' is not permitted");
+        this.externalEntities[t2] = e2;
+      }
+      static getMetaDataSymbol() {
+        return $.getMetaDataSymbol();
+      }
+    }
+    function mt(t2, e2) {
+      let i2 = "";
+      e2.format && e2.indentBy.length > 0 && (i2 = `
+`);
+      const n2 = [];
+      if (e2.stopNodes && Array.isArray(e2.stopNodes))
+        for (let t3 = 0;t3 < e2.stopNodes.length; t3++) {
+          const i3 = e2.stopNodes[t3];
+          typeof i3 == "string" ? n2.push(new R(i3)) : i3 instanceof R && n2.push(i3);
+        }
+      return xt(t2, e2, i2, new G, n2);
+    }
+    function xt(t2, e2, i2, n2, s2) {
+      let r2 = "", o2 = false;
+      if (e2.maxNestedTags && n2.getDepth() > e2.maxNestedTags)
+        throw new Error("Maximum nested tags exceeded");
+      if (!Array.isArray(t2)) {
+        if (t2 != null) {
+          let i3 = t2.toString();
+          return i3 = Tt(i3, e2), i3;
+        }
+        return "";
+      }
+      for (let a2 = 0;a2 < t2.length; a2++) {
+        const h2 = t2[a2], l2 = yt(h2);
+        if (l2 === undefined)
+          continue;
+        const p2 = Nt(h2[":@"], e2);
+        n2.push(l2, p2);
+        const u2 = vt(n2, s2);
+        if (l2 === e2.textNodeName) {
+          let t3 = h2[l2];
+          u2 || (t3 = e2.tagValueProcessor(l2, t3), t3 = Tt(t3, e2)), o2 && (r2 += i2), r2 += t3, o2 = false, n2.pop();
+          continue;
+        }
+        if (l2 === e2.cdataPropName) {
+          o2 && (r2 += i2), r2 += `<![CDATA[${h2[l2][0][e2.textNodeName]}]]>`, o2 = false, n2.pop();
+          continue;
+        }
+        if (l2 === e2.commentPropName) {
+          r2 += i2 + `<!--${h2[l2][0][e2.textNodeName]}-->`, o2 = true, n2.pop();
+          continue;
+        }
+        if (l2[0] === "?") {
+          const t3 = wt(h2[":@"], e2, u2), s3 = l2 === "?xml" ? "" : i2;
+          let a3 = h2[l2][0][e2.textNodeName];
+          a3 = a3.length !== 0 ? " " + a3 : "", r2 += s3 + `<${l2}${a3}${t3}?>`, o2 = true, n2.pop();
+          continue;
+        }
+        let c2 = i2;
+        c2 !== "" && (c2 += e2.indentBy);
+        const d2 = i2 + `<${l2}${wt(h2[":@"], e2, u2)}`;
+        let f2;
+        f2 = u2 ? bt(h2[l2], e2) : xt(h2[l2], e2, c2, n2, s2), e2.unpairedTags.indexOf(l2) !== -1 ? e2.suppressUnpairedNode ? r2 += d2 + ">" : r2 += d2 + "/>" : f2 && f2.length !== 0 || !e2.suppressEmptyNode ? f2 && f2.endsWith(">") ? r2 += d2 + `>${f2}${i2}</${l2}>` : (r2 += d2 + ">", f2 && i2 !== "" && (f2.includes("/>") || f2.includes("</")) ? r2 += i2 + e2.indentBy + f2 + i2 : r2 += f2, r2 += `</${l2}>`) : r2 += d2 + "/>", o2 = true, n2.pop();
+      }
+      return r2;
+    }
+    function Nt(t2, e2) {
+      if (!t2 || e2.ignoreAttributes)
+        return null;
+      const i2 = {};
+      let n2 = false;
+      for (let s2 in t2)
+        Object.prototype.hasOwnProperty.call(t2, s2) && (i2[s2.startsWith(e2.attributeNamePrefix) ? s2.substr(e2.attributeNamePrefix.length) : s2] = t2[s2], n2 = true);
+      return n2 ? i2 : null;
+    }
+    function bt(t2, e2) {
+      if (!Array.isArray(t2))
+        return t2 != null ? t2.toString() : "";
+      let i2 = "";
+      for (let n2 = 0;n2 < t2.length; n2++) {
+        const s2 = t2[n2], r2 = yt(s2);
+        if (r2 === e2.textNodeName)
+          i2 += s2[r2];
+        else if (r2 === e2.cdataPropName)
+          i2 += s2[r2][0][e2.textNodeName];
+        else if (r2 === e2.commentPropName)
+          i2 += s2[r2][0][e2.textNodeName];
+        else {
+          if (r2 && r2[0] === "?")
+            continue;
+          if (r2) {
+            const t3 = Et(s2[":@"], e2), n3 = bt(s2[r2], e2);
+            n3 && n3.length !== 0 ? i2 += `<${r2}${t3}>${n3}</${r2}>` : i2 += `<${r2}${t3}/>`;
+          }
+        }
+      }
+      return i2;
+    }
+    function Et(t2, e2) {
+      let i2 = "";
+      if (t2 && !e2.ignoreAttributes)
+        for (let n2 in t2) {
+          if (!Object.prototype.hasOwnProperty.call(t2, n2))
+            continue;
+          let s2 = t2[n2];
+          s2 === true && e2.suppressBooleanAttributes ? i2 += ` ${n2.substr(e2.attributeNamePrefix.length)}` : i2 += ` ${n2.substr(e2.attributeNamePrefix.length)}="${s2}"`;
+        }
+      return i2;
+    }
+    function yt(t2) {
+      const e2 = Object.keys(t2);
+      for (let i2 = 0;i2 < e2.length; i2++) {
+        const n2 = e2[i2];
+        if (Object.prototype.hasOwnProperty.call(t2, n2) && n2 !== ":@")
+          return n2;
+      }
+    }
+    function wt(t2, e2, i2) {
+      let n2 = "";
+      if (t2 && !e2.ignoreAttributes)
+        for (let s2 in t2) {
+          if (!Object.prototype.hasOwnProperty.call(t2, s2))
+            continue;
+          let r2;
+          i2 ? r2 = t2[s2] : (r2 = e2.attributeValueProcessor(s2, t2[s2]), r2 = Tt(r2, e2)), r2 === true && e2.suppressBooleanAttributes ? n2 += ` ${s2.substr(e2.attributeNamePrefix.length)}` : n2 += ` ${s2.substr(e2.attributeNamePrefix.length)}="${r2}"`;
+        }
+      return n2;
+    }
+    function vt(t2, e2) {
+      if (!e2 || e2.length === 0)
+        return false;
+      for (let i2 = 0;i2 < e2.length; i2++)
+        if (t2.matches(e2[i2]))
+          return true;
+      return false;
+    }
+    function Tt(t2, e2) {
+      if (t2 && t2.length > 0 && e2.processEntities)
+        for (let i2 = 0;i2 < e2.entities.length; i2++) {
+          const n2 = e2.entities[i2];
+          t2 = t2.replace(n2.regex, n2.val);
+        }
+      return t2;
+    }
+    const Pt = { attributeNamePrefix: "@_", attributesGroupName: false, textNodeName: "#text", ignoreAttributes: true, cdataPropName: false, format: false, indentBy: "  ", suppressEmptyNode: false, suppressUnpairedNode: true, suppressBooleanAttributes: true, tagValueProcessor: function(t2, e2) {
+      return e2;
+    }, attributeValueProcessor: function(t2, e2) {
+      return e2;
+    }, preserveOrder: false, commentPropName: false, unpairedTags: [], entities: [{ regex: new RegExp("&", "g"), val: "&amp;" }, { regex: new RegExp(">", "g"), val: "&gt;" }, { regex: new RegExp("<", "g"), val: "&lt;" }, { regex: new RegExp("'", "g"), val: "&apos;" }, { regex: new RegExp('"', "g"), val: "&quot;" }], processEntities: true, stopNodes: [], oneListGroup: false, maxNestedTags: 100, jPath: true };
+    function St(t2) {
+      if (this.options = Object.assign({}, Pt, t2), this.options.stopNodes && Array.isArray(this.options.stopNodes) && (this.options.stopNodes = this.options.stopNodes.map((t3) => typeof t3 == "string" && t3.startsWith("*.") ? ".." + t3.substring(2) : t3)), this.stopNodeExpressions = [], this.options.stopNodes && Array.isArray(this.options.stopNodes))
+        for (let t3 = 0;t3 < this.options.stopNodes.length; t3++) {
+          const e3 = this.options.stopNodes[t3];
+          typeof e3 == "string" ? this.stopNodeExpressions.push(new R(e3)) : e3 instanceof R && this.stopNodeExpressions.push(e3);
+        }
+      var e2;
+      this.options.ignoreAttributes === true || this.options.attributesGroupName ? this.isAttribute = function() {
+        return false;
+      } : (this.ignoreAttributesFn = typeof (e2 = this.options.ignoreAttributes) == "function" ? e2 : Array.isArray(e2) ? (t3) => {
+        for (const i2 of e2) {
+          if (typeof i2 == "string" && t3 === i2)
+            return true;
+          if (i2 instanceof RegExp && i2.test(t3))
+            return true;
+        }
+      } : () => false, this.attrPrefixLen = this.options.attributeNamePrefix.length, this.isAttribute = Ct), this.processTextOrObjNode = At, this.options.format ? (this.indentate = Ot, this.tagEndChar = `>
+`, this.newLine = `
+`) : (this.indentate = function() {
+        return "";
+      }, this.tagEndChar = ">", this.newLine = "");
+    }
+    function At(t2, e2, i2, n2) {
+      const s2 = this.extractAttributes(t2);
+      if (n2.push(e2, s2), this.checkStopNode(n2)) {
+        const s3 = this.buildRawContent(t2), r3 = this.buildAttributesForStopNode(t2);
+        return n2.pop(), this.buildObjectNode(s3, e2, r3, i2);
+      }
+      const r2 = this.j2x(t2, i2 + 1, n2);
+      return n2.pop(), t2[this.options.textNodeName] !== undefined && Object.keys(t2).length === 1 ? this.buildTextValNode(t2[this.options.textNodeName], e2, r2.attrStr, i2, n2) : this.buildObjectNode(r2.val, e2, r2.attrStr, i2);
+    }
+    function Ot(t2) {
+      return this.options.indentBy.repeat(t2);
+    }
+    function Ct(t2) {
+      return !(!t2.startsWith(this.options.attributeNamePrefix) || t2 === this.options.textNodeName) && t2.substr(this.attrPrefixLen);
+    }
+    St.prototype.build = function(t2) {
+      if (this.options.preserveOrder)
+        return mt(t2, this.options);
+      {
+        Array.isArray(t2) && this.options.arrayNodeName && this.options.arrayNodeName.length > 1 && (t2 = { [this.options.arrayNodeName]: t2 });
+        const e2 = new G;
+        return this.j2x(t2, 0, e2).val;
+      }
+    }, St.prototype.j2x = function(t2, e2, i2) {
+      let n2 = "", s2 = "";
+      if (this.options.maxNestedTags && i2.getDepth() >= this.options.maxNestedTags)
+        throw new Error("Maximum nested tags exceeded");
+      const r2 = this.options.jPath ? i2.toString() : i2, o2 = this.checkStopNode(i2);
+      for (let a2 in t2)
+        if (Object.prototype.hasOwnProperty.call(t2, a2))
+          if (t2[a2] === undefined)
+            this.isAttribute(a2) && (s2 += "");
+          else if (t2[a2] === null)
+            this.isAttribute(a2) || a2 === this.options.cdataPropName ? s2 += "" : a2[0] === "?" ? s2 += this.indentate(e2) + "<" + a2 + "?" + this.tagEndChar : s2 += this.indentate(e2) + "<" + a2 + "/" + this.tagEndChar;
+          else if (t2[a2] instanceof Date)
+            s2 += this.buildTextValNode(t2[a2], a2, "", e2, i2);
+          else if (typeof t2[a2] != "object") {
+            const h2 = this.isAttribute(a2);
+            if (h2 && !this.ignoreAttributesFn(h2, r2))
+              n2 += this.buildAttrPairStr(h2, "" + t2[a2], o2);
+            else if (!h2)
+              if (a2 === this.options.textNodeName) {
+                let e3 = this.options.tagValueProcessor(a2, "" + t2[a2]);
+                s2 += this.replaceEntitiesValue(e3);
+              } else {
+                i2.push(a2);
+                const n3 = this.checkStopNode(i2);
+                if (i2.pop(), n3) {
+                  const i3 = "" + t2[a2];
+                  s2 += i3 === "" ? this.indentate(e2) + "<" + a2 + this.closeTag(a2) + this.tagEndChar : this.indentate(e2) + "<" + a2 + ">" + i3 + "</" + a2 + this.tagEndChar;
+                } else
+                  s2 += this.buildTextValNode(t2[a2], a2, "", e2, i2);
+              }
+          } else if (Array.isArray(t2[a2])) {
+            const n3 = t2[a2].length;
+            let r3 = "", o3 = "";
+            for (let h2 = 0;h2 < n3; h2++) {
+              const n4 = t2[a2][h2];
+              if (n4 === undefined)
+                ;
+              else if (n4 === null)
+                a2[0] === "?" ? s2 += this.indentate(e2) + "<" + a2 + "?" + this.tagEndChar : s2 += this.indentate(e2) + "<" + a2 + "/" + this.tagEndChar;
+              else if (typeof n4 == "object")
+                if (this.options.oneListGroup) {
+                  i2.push(a2);
+                  const t3 = this.j2x(n4, e2 + 1, i2);
+                  i2.pop(), r3 += t3.val, this.options.attributesGroupName && n4.hasOwnProperty(this.options.attributesGroupName) && (o3 += t3.attrStr);
+                } else
+                  r3 += this.processTextOrObjNode(n4, a2, e2, i2);
+              else if (this.options.oneListGroup) {
+                let t3 = this.options.tagValueProcessor(a2, n4);
+                t3 = this.replaceEntitiesValue(t3), r3 += t3;
+              } else {
+                i2.push(a2);
+                const t3 = this.checkStopNode(i2);
+                if (i2.pop(), t3) {
+                  const t4 = "" + n4;
+                  r3 += t4 === "" ? this.indentate(e2) + "<" + a2 + this.closeTag(a2) + this.tagEndChar : this.indentate(e2) + "<" + a2 + ">" + t4 + "</" + a2 + this.tagEndChar;
+                } else
+                  r3 += this.buildTextValNode(n4, a2, "", e2, i2);
+              }
+            }
+            this.options.oneListGroup && (r3 = this.buildObjectNode(r3, a2, o3, e2)), s2 += r3;
+          } else if (this.options.attributesGroupName && a2 === this.options.attributesGroupName) {
+            const e3 = Object.keys(t2[a2]), i3 = e3.length;
+            for (let s3 = 0;s3 < i3; s3++)
+              n2 += this.buildAttrPairStr(e3[s3], "" + t2[a2][e3[s3]], o2);
+          } else
+            s2 += this.processTextOrObjNode(t2[a2], a2, e2, i2);
+      return { attrStr: n2, val: s2 };
+    }, St.prototype.buildAttrPairStr = function(t2, e2, i2) {
+      return i2 || (e2 = this.options.attributeValueProcessor(t2, "" + e2), e2 = this.replaceEntitiesValue(e2)), this.options.suppressBooleanAttributes && e2 === "true" ? " " + t2 : " " + t2 + '="' + e2 + '"';
+    }, St.prototype.extractAttributes = function(t2) {
+      if (!t2 || typeof t2 != "object")
+        return null;
+      const e2 = {};
+      let i2 = false;
+      if (this.options.attributesGroupName && t2[this.options.attributesGroupName]) {
+        const n2 = t2[this.options.attributesGroupName];
+        for (let t3 in n2)
+          Object.prototype.hasOwnProperty.call(n2, t3) && (e2[t3.startsWith(this.options.attributeNamePrefix) ? t3.substring(this.options.attributeNamePrefix.length) : t3] = n2[t3], i2 = true);
+      } else
+        for (let n2 in t2) {
+          if (!Object.prototype.hasOwnProperty.call(t2, n2))
+            continue;
+          const s2 = this.isAttribute(n2);
+          s2 && (e2[s2] = t2[n2], i2 = true);
+        }
+      return i2 ? e2 : null;
+    }, St.prototype.buildRawContent = function(t2) {
+      if (typeof t2 == "string")
+        return t2;
+      if (typeof t2 != "object" || t2 === null)
+        return String(t2);
+      if (t2[this.options.textNodeName] !== undefined)
+        return t2[this.options.textNodeName];
+      let e2 = "";
+      for (let i2 in t2) {
+        if (!Object.prototype.hasOwnProperty.call(t2, i2))
+          continue;
+        if (this.isAttribute(i2))
+          continue;
+        if (this.options.attributesGroupName && i2 === this.options.attributesGroupName)
+          continue;
+        const n2 = t2[i2];
+        if (i2 === this.options.textNodeName)
+          e2 += n2;
+        else if (Array.isArray(n2)) {
+          for (let t3 of n2)
+            if (typeof t3 == "string" || typeof t3 == "number")
+              e2 += `<${i2}>${t3}</${i2}>`;
+            else if (typeof t3 == "object" && t3 !== null) {
+              const n3 = this.buildRawContent(t3), s2 = this.buildAttributesForStopNode(t3);
+              e2 += n3 === "" ? `<${i2}${s2}/>` : `<${i2}${s2}>${n3}</${i2}>`;
+            }
+        } else if (typeof n2 == "object" && n2 !== null) {
+          const t3 = this.buildRawContent(n2), s2 = this.buildAttributesForStopNode(n2);
+          e2 += t3 === "" ? `<${i2}${s2}/>` : `<${i2}${s2}>${t3}</${i2}>`;
+        } else
+          e2 += `<${i2}>${n2}</${i2}>`;
+      }
+      return e2;
+    }, St.prototype.buildAttributesForStopNode = function(t2) {
+      if (!t2 || typeof t2 != "object")
+        return "";
+      let e2 = "";
+      if (this.options.attributesGroupName && t2[this.options.attributesGroupName]) {
+        const i2 = t2[this.options.attributesGroupName];
+        for (let t3 in i2) {
+          if (!Object.prototype.hasOwnProperty.call(i2, t3))
+            continue;
+          const n2 = t3.startsWith(this.options.attributeNamePrefix) ? t3.substring(this.options.attributeNamePrefix.length) : t3, s2 = i2[t3];
+          s2 === true && this.options.suppressBooleanAttributes ? e2 += " " + n2 : e2 += " " + n2 + '="' + s2 + '"';
+        }
+      } else
+        for (let i2 in t2) {
+          if (!Object.prototype.hasOwnProperty.call(t2, i2))
+            continue;
+          const n2 = this.isAttribute(i2);
+          if (n2) {
+            const s2 = t2[i2];
+            s2 === true && this.options.suppressBooleanAttributes ? e2 += " " + n2 : e2 += " " + n2 + '="' + s2 + '"';
+          }
+        }
+      return e2;
+    }, St.prototype.buildObjectNode = function(t2, e2, i2, n2) {
+      if (t2 === "")
+        return e2[0] === "?" ? this.indentate(n2) + "<" + e2 + i2 + "?" + this.tagEndChar : this.indentate(n2) + "<" + e2 + i2 + this.closeTag(e2) + this.tagEndChar;
+      {
+        let s2 = "</" + e2 + this.tagEndChar, r2 = "";
+        return e2[0] === "?" && (r2 = "?", s2 = ""), !i2 && i2 !== "" || t2.indexOf("<") !== -1 ? this.options.commentPropName !== false && e2 === this.options.commentPropName && r2.length === 0 ? this.indentate(n2) + `<!--${t2}-->` + this.newLine : this.indentate(n2) + "<" + e2 + i2 + r2 + this.tagEndChar + t2 + this.indentate(n2) + s2 : this.indentate(n2) + "<" + e2 + i2 + r2 + ">" + t2 + s2;
+      }
+    }, St.prototype.closeTag = function(t2) {
+      let e2 = "";
+      return this.options.unpairedTags.indexOf(t2) !== -1 ? this.options.suppressUnpairedNode || (e2 = "/") : e2 = this.options.suppressEmptyNode ? "/" : `></${t2}`, e2;
+    }, St.prototype.checkStopNode = function(t2) {
+      if (!this.stopNodeExpressions || this.stopNodeExpressions.length === 0)
+        return false;
+      for (let e2 = 0;e2 < this.stopNodeExpressions.length; e2++)
+        if (t2.matches(this.stopNodeExpressions[e2]))
+          return true;
+      return false;
+    }, St.prototype.buildTextValNode = function(t2, e2, i2, n2, s2) {
+      if (this.options.cdataPropName !== false && e2 === this.options.cdataPropName)
+        return this.indentate(n2) + `<![CDATA[${t2}]]>` + this.newLine;
+      if (this.options.commentPropName !== false && e2 === this.options.commentPropName)
+        return this.indentate(n2) + `<!--${t2}-->` + this.newLine;
+      if (e2[0] === "?")
+        return this.indentate(n2) + "<" + e2 + i2 + "?" + this.tagEndChar;
+      {
+        let s3 = this.options.tagValueProcessor(e2, t2);
+        return s3 = this.replaceEntitiesValue(s3), s3 === "" ? this.indentate(n2) + "<" + e2 + i2 + this.closeTag(e2) + this.tagEndChar : this.indentate(n2) + "<" + e2 + i2 + ">" + s3 + "</" + e2 + this.tagEndChar;
+      }
+    }, St.prototype.replaceEntitiesValue = function(t2) {
+      if (t2 && t2.length > 0 && this.options.processEntities)
+        for (let e2 = 0;e2 < this.options.entities.length; e2++) {
+          const i2 = this.options.entities[e2];
+          t2 = t2.replace(i2.regex, i2.val);
+        }
+      return t2;
+    };
+    const $t = St, It = { validate: l };
+    module.exports = e;
+  })();
+});
+
+export { require_invoke_store, require_dist_cjs, require_dist_cjs2 as require_dist_cjs1, require_fxp };