@loaders.gl/xml 4.0.0-beta.2 → 4.0.0-beta.4

package/dist/index.cjs

@@ -0,0 +1,1530 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  HTMLLoader: () => HTMLLoader,
+  SAXParser: () => SAXParser,
+  XMLLoader: () => XMLLoader,
+  _uncapitalize: () => uncapitalize,
+  _uncapitalizeKeys: () => uncapitalizeKeys,
+  convertXMLFieldToArrayInPlace: () => convertXMLFieldToArrayInPlace,
+  convertXMLValueToArray: () => convertXMLValueToArray
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/sax-ts/sax.ts
+var DEFAULT_SAX_EVENTS = {
+  ontext: () => {
+  },
+  onprocessinginstruction: () => {
+  },
+  onsgmldeclaration: () => {
+  },
+  ondoctype: () => {
+  },
+  oncomment: () => {
+  },
+  onopentagstart: () => {
+  },
+  onattribute: () => {
+  },
+  onopentag: () => {
+  },
+  onclosetag: () => {
+  },
+  onopencdata: () => {
+  },
+  oncdata: () => {
+  },
+  onclosecdata: () => {
+  },
+  onerror: () => {
+  },
+  onend: () => {
+  },
+  onready: () => {
+  },
+  onscript: () => {
+  },
+  onopennamespace: () => {
+  },
+  onclosenamespace: () => {
+  }
+};
+var DEFAULT_SAX_PARSER_OPTIONS = {
+  ...DEFAULT_SAX_EVENTS,
+  strict: false,
+  MAX_BUFFER_LENGTH: 64 * 1024,
+  lowercase: false,
+  lowercasetags: false,
+  noscript: false,
+  strictEntities: false,
+  xmlns: void 0,
+  position: void 0,
+  trim: void 0,
+  normalize: void 0
+};
+var EVENTS = [
+  "text",
+  "processinginstruction",
+  "sgmldeclaration",
+  "doctype",
+  "comment",
+  "opentagstart",
+  "attribute",
+  "opentag",
+  "closetag",
+  "opencdata",
+  "cdata",
+  "closecdata",
+  "error",
+  "end",
+  "ready",
+  "script",
+  "opennamespace",
+  "closenamespace"
+];
+var BUFFERS = [
+  "comment",
+  "sgmlDecl",
+  "textNode",
+  "tagName",
+  "doctype",
+  "procInstName",
+  "procInstBody",
+  "entity",
+  "attribName",
+  "attribValue",
+  "cdata",
+  "script"
+];
+var nameStart = /[:_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]/;
+var nameBody = /[:_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\u00B7\u0300-\u036F\u203F-\u2040.\d-]/;
+var entityStart = /[#:_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]/;
+var entityBody = /[#:_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\u00B7\u0300-\u036F\u203F-\u2040.\d-]/;
+var ENTITIES = {
+  amp: "&",
+  gt: ">",
+  lt: "<",
+  quot: '"',
+  apos: "'",
+  AElig: 198,
+  Aacute: 193,
+  Acirc: 194,
+  Agrave: 192,
+  Aring: 197,
+  Atilde: 195,
+  Auml: 196,
+  Ccedil: 199,
+  ETH: 208,
+  Eacute: 201,
+  Ecirc: 202,
+  Egrave: 200,
+  Euml: 203,
+  Iacute: 205,
+  Icirc: 206,
+  Igrave: 204,
+  Iuml: 207,
+  Ntilde: 209,
+  Oacute: 211,
+  Ocirc: 212,
+  Ograve: 210,
+  Oslash: 216,
+  Otilde: 213,
+  Ouml: 214,
+  THORN: 222,
+  Uacute: 218,
+  Ucirc: 219,
+  Ugrave: 217,
+  Uuml: 220,
+  Yacute: 221,
+  aacute: 225,
+  acirc: 226,
+  aelig: 230,
+  agrave: 224,
+  aring: 229,
+  atilde: 227,
+  auml: 228,
+  ccedil: 231,
+  eacute: 233,
+  ecirc: 234,
+  egrave: 232,
+  eth: 240,
+  euml: 235,
+  iacute: 237,
+  icirc: 238,
+  igrave: 236,
+  iuml: 239,
+  ntilde: 241,
+  oacute: 243,
+  ocirc: 244,
+  ograve: 242,
+  oslash: 248,
+  otilde: 245,
+  ouml: 246,
+  szlig: 223,
+  thorn: 254,
+  uacute: 250,
+  ucirc: 251,
+  ugrave: 249,
+  uuml: 252,
+  yacute: 253,
+  yuml: 255,
+  copy: 169,
+  reg: 174,
+  nbsp: 160,
+  iexcl: 161,
+  cent: 162,
+  pound: 163,
+  curren: 164,
+  yen: 165,
+  brvbar: 166,
+  sect: 167,
+  uml: 168,
+  ordf: 170,
+  laquo: 171,
+  not: 172,
+  shy: 173,
+  macr: 175,
+  deg: 176,
+  plusmn: 177,
+  sup1: 185,
+  sup2: 178,
+  sup3: 179,
+  acute: 180,
+  micro: 181,
+  para: 182,
+  middot: 183,
+  cedil: 184,
+  ordm: 186,
+  raquo: 187,
+  frac14: 188,
+  frac12: 189,
+  frac34: 190,
+  iquest: 191,
+  times: 215,
+  divide: 247,
+  OElig: 338,
+  oelig: 339,
+  Scaron: 352,
+  scaron: 353,
+  Yuml: 376,
+  fnof: 402,
+  circ: 710,
+  tilde: 732,
+  Alpha: 913,
+  Beta: 914,
+  Gamma: 915,
+  Delta: 916,
+  Epsilon: 917,
+  Zeta: 918,
+  Eta: 919,
+  Theta: 920,
+  Iota: 921,
+  Kappa: 922,
+  Lambda: 923,
+  Mu: 924,
+  Nu: 925,
+  Xi: 926,
+  Omicron: 927,
+  Pi: 928,
+  Rho: 929,
+  Sigma: 931,
+  Tau: 932,
+  Upsilon: 933,
+  Phi: 934,
+  Chi: 935,
+  Psi: 936,
+  Omega: 937,
+  alpha: 945,
+  beta: 946,
+  gamma: 947,
+  delta: 948,
+  epsilon: 949,
+  zeta: 950,
+  eta: 951,
+  theta: 952,
+  iota: 953,
+  kappa: 954,
+  lambda: 955,
+  mu: 956,
+  nu: 957,
+  xi: 958,
+  omicron: 959,
+  pi: 960,
+  rho: 961,
+  sigmaf: 962,
+  sigma: 963,
+  tau: 964,
+  upsilon: 965,
+  phi: 966,
+  chi: 967,
+  psi: 968,
+  omega: 969,
+  thetasym: 977,
+  upsih: 978,
+  piv: 982,
+  ensp: 8194,
+  emsp: 8195,
+  thinsp: 8201,
+  zwnj: 8204,
+  zwj: 8205,
+  lrm: 8206,
+  rlm: 8207,
+  ndash: 8211,
+  mdash: 8212,
+  lsquo: 8216,
+  rsquo: 8217,
+  sbquo: 8218,
+  ldquo: 8220,
+  rdquo: 8221,
+  bdquo: 8222,
+  dagger: 8224,
+  Dagger: 8225,
+  bull: 8226,
+  hellip: 8230,
+  permil: 8240,
+  prime: 8242,
+  Prime: 8243,
+  lsaquo: 8249,
+  rsaquo: 8250,
+  oline: 8254,
+  frasl: 8260,
+  euro: 8364,
+  image: 8465,
+  weierp: 8472,
+  real: 8476,
+  trade: 8482,
+  alefsym: 8501,
+  larr: 8592,
+  uarr: 8593,
+  rarr: 8594,
+  darr: 8595,
+  harr: 8596,
+  crarr: 8629,
+  lArr: 8656,
+  uArr: 8657,
+  rArr: 8658,
+  dArr: 8659,
+  hArr: 8660,
+  forall: 8704,
+  part: 8706,
+  exist: 8707,
+  empty: 8709,
+  nabla: 8711,
+  isin: 8712,
+  notin: 8713,
+  ni: 8715,
+  prod: 8719,
+  sum: 8721,
+  minus: 8722,
+  lowast: 8727,
+  radic: 8730,
+  prop: 8733,
+  infin: 8734,
+  ang: 8736,
+  and: 8743,
+  or: 8744,
+  cap: 8745,
+  cup: 8746,
+  int: 8747,
+  there4: 8756,
+  sim: 8764,
+  cong: 8773,
+  asymp: 8776,
+  ne: 8800,
+  equiv: 8801,
+  le: 8804,
+  ge: 8805,
+  sub: 8834,
+  sup: 8835,
+  nsub: 8836,
+  sube: 8838,
+  supe: 8839,
+  oplus: 8853,
+  otimes: 8855,
+  perp: 8869,
+  sdot: 8901,
+  lceil: 8968,
+  rceil: 8969,
+  lfloor: 8970,
+  rfloor: 8971,
+  lang: 9001,
+  rang: 9002,
+  loz: 9674,
+  spades: 9824,
+  clubs: 9827,
+  hearts: 9829,
+  diams: 9830
+};
+Object.keys(ENTITIES).forEach((key) => {
+  const e = ENTITIES[key];
+  ENTITIES[key] = typeof e === "number" ? String.fromCharCode(e) : e;
+});
+var SAX = class {
+  constructor() {
+    this.EVENTS = EVENTS;
+    this.ENTITIES = {
+      // TODO: make it readonly, needed for entity-mega test
+      // amp, gt, lt, quot and apos are resolved to strings instead of numerical
+      // codes, IDK why
+      ...ENTITIES
+    };
+    this.XML_ENTITIES = {
+      amp: "&",
+      gt: ">",
+      lt: "<",
+      quot: '"',
+      apos: "'"
+    };
+    this.S = 0;
+    this.trackPosition = false;
+    this.column = 0;
+    this.line = 0;
+    this.c = "";
+    this.q = "";
+    this.closed = false;
+    this.tags = [];
+    this.looseCase = "";
+    this.closedRoot = false;
+    this.sawRoot = false;
+    this.strict = false;
+    this.noscript = false;
+    this.attribList = [];
+    this.position = 0;
+    this.STATE = {
+      BEGIN: this.S++,
+      // leading byte order mark or whitespace
+      BEGIN_WHITESPACE: this.S++,
+      // leading whitespace
+      TEXT: this.S++,
+      // general stuff
+      TEXT_ENTITY: this.S++,
+      // &amp and such.
+      OPEN_WAKA: this.S++,
+      // <
+      SGML_DECL: this.S++,
+      // <!BLARG
+      SGML_DECL_QUOTED: this.S++,
+      // <!BLARG foo "bar
+      DOCTYPE: this.S++,
+      // <!DOCTYPE
+      DOCTYPE_QUOTED: this.S++,
+      // <!DOCTYPE "//blah
+      DOCTYPE_DTD: this.S++,
+      // <!DOCTYPE "//blah" [ ...
+      DOCTYPE_DTD_QUOTED: this.S++,
+      // <!DOCTYPE "//blah" [ "foo
+      COMMENT_STARTING: this.S++,
+      // <!-
+      COMMENT: this.S++,
+      // <!--
+      COMMENT_ENDING: this.S++,
+      // <!-- blah -
+      COMMENT_ENDED: this.S++,
+      // <!-- blah --
+      CDATA: this.S++,
+      // <![CDATA[ something
+      CDATA_ENDING: this.S++,
+      // ]
+      CDATA_ENDING_2: this.S++,
+      // ]]
+      PROC_INST: this.S++,
+      // <?hi
+      PROC_INST_BODY: this.S++,
+      // <?hi there
+      PROC_INST_ENDING: this.S++,
+      // <?hi "there" ?
+      OPEN_TAG: this.S++,
+      // <strong
+      OPEN_TAG_SLASH: this.S++,
+      // <strong /
+      ATTRIB: this.S++,
+      // <a
+      ATTRIB_NAME: this.S++,
+      // <a foo
+      ATTRIB_NAME_SAW_WHITE: this.S++,
+      // <a foo _
+      ATTRIB_VALUE: this.S++,
+      // <a foo=
+      ATTRIB_VALUE_QUOTED: this.S++,
+      // <a foo="bar
+      ATTRIB_VALUE_CLOSED: this.S++,
+      // <a foo="bar"
+      ATTRIB_VALUE_UNQUOTED: this.S++,
+      // <a foo=bar
+      ATTRIB_VALUE_ENTITY_Q: this.S++,
+      // <foo bar="&quot;"
+      ATTRIB_VALUE_ENTITY_U: this.S++,
+      // <foo bar=&quot
+      CLOSE_TAG: this.S++,
+      // </a
+      CLOSE_TAG_SAW_WHITE: this.S++,
+      // </a   >
+      SCRIPT: this.S++,
+      // <script> ...
+      SCRIPT_ENDING: this.S++
+      // <script> ... <
+    };
+    this.BUFFERS = BUFFERS;
+    // private parser: (strict: boolean, opt: any) => SAXParser;
+    this.CDATA = "[CDATA[";
+    this.DOCTYPE = "DOCTYPE";
+    this.XML_NAMESPACE = "http://www.w3.org/XML/1998/namespace";
+    this.XMLNS_NAMESPACE = "http://www.w3.org/2000/xmlns/";
+    this.rootNS = {
+      xml: this.XML_NAMESPACE,
+      xmlns: this.XMLNS_NAMESPACE
+    };
+    this.textNode = "";
+    this.entity = "";
+    this.cdata = "";
+    this.script = "";
+    this.startTagPosition = 0;
+    this.S = 0;
+    for (const s in this.STATE) {
+      if (this.STATE.hasOwnProperty(s)) {
+        this.STATE[this.STATE[s]] = s;
+      }
+    }
+    this.S = this.STATE;
+  }
+  static charAt(chunk, i) {
+    let result = "";
+    if (i < chunk.length) {
+      result = chunk.charAt(i);
+    }
+    return result;
+  }
+  static isWhitespace(c) {
+    return c === " " || c === "\n" || c === "\r" || c === "	";
+  }
+  static isQuote(c) {
+    return c === '"' || c === "'";
+  }
+  static isAttribEnd(c) {
+    return c === ">" || SAX.isWhitespace(c);
+  }
+  static isMatch(regex, c) {
+    return regex.test(c);
+  }
+  static notMatch(regex, c) {
+    return !SAX.isMatch(regex, c);
+  }
+  static qname(name, attribute) {
+    const i = name.indexOf(":");
+    const qualName = i < 0 ? ["", name] : name.split(":");
+    let prefix = qualName[0];
+    let local = qualName[1];
+    if (attribute && name === "xmlns") {
+      prefix = "xmlns";
+      local = "";
+    }
+    return { prefix, local };
+  }
+  write(chunk) {
+    if (this.error) {
+      throw this.error;
+    }
+    if (this.closed) {
+      return this.errorFunction("Cannot write after close. Assign an onready handler.");
+    }
+    if (chunk === null) {
+      return this.end();
+    }
+    if (typeof chunk === "object") {
+      chunk = chunk.toString();
+    }
+    let i = 0;
+    let c;
+    while (true) {
+      c = SAX.charAt(chunk, i++);
+      this.c = c;
+      if (!c) {
+        break;
+      }
+      if (this.trackPosition) {
+        this.position++;
+        if (c === "\n") {
+          this.line++;
+          this.column = 0;
+        } else {
+          this.column++;
+        }
+      }
+      switch (this.state) {
+        case this.S.BEGIN:
+          this.state = this.S.BEGIN_WHITESPACE;
+          if (c === "\uFEFF") {
+            continue;
+          }
+          this.beginWhiteSpace(c);
+          continue;
+        case this.S.BEGIN_WHITESPACE:
+          this.beginWhiteSpace(c);
+          continue;
+        case this.S.TEXT:
+          if (this.sawRoot && !this.closedRoot) {
+            const starti = i - 1;
+            while (c && c !== "<" && c !== "&") {
+              c = SAX.charAt(chunk, i++);
+              if (c && this.trackPosition) {
+                this.position++;
+                if (c === "\n") {
+                  this.line++;
+                  this.column = 0;
+                } else {
+                  this.column++;
+                }
+              }
+            }
+            this.textNode += chunk.substring(starti, i - 1);
+          }
+          if (c === "<" && !(this.sawRoot && this.closedRoot && !this.strict)) {
+            this.state = this.S.OPEN_WAKA;
+            this.startTagPosition = this.position;
+          } else {
+            if (!SAX.isWhitespace(c) && (!this.sawRoot || this.closedRoot)) {
+              this.strictFail("Text data outside of root node.");
+            }
+            if (c === "&") {
+              this.state = this.S.TEXT_ENTITY;
+            } else {
+              this.textNode += c;
+            }
+          }
+          continue;
+        case this.S.SCRIPT:
+          if (c === "<") {
+            this.state = this.S.SCRIPT_ENDING;
+          } else {
+            this.script += c;
+          }
+          continue;
+        case this.S.SCRIPT_ENDING:
+          if (c === "/") {
+            this.state = this.S.CLOSE_TAG;
+          } else {
+            this.script += `<${c}`;
+            this.state = this.S.SCRIPT;
+          }
+          continue;
+        case this.S.OPEN_WAKA:
+          if (c === "!") {
+            this.state = this.S.SGML_DECL;
+            this.sgmlDecl = "";
+          } else if (SAX.isWhitespace(c)) {
+          } else if (SAX.isMatch(nameStart, c)) {
+            this.state = this.S.OPEN_TAG;
+            this.tagName = c;
+          } else if (c === "/") {
+            this.state = this.S.CLOSE_TAG;
+            this.tagName = "";
+          } else if (c === "?") {
+            this.state = this.S.PROC_INST;
+            this.procInstName = this.procInstBody = "";
+          } else {
+            this.strictFail("Unencoded <");
+            if (this.startTagPosition + 1 < this.position) {
+              const pad = this.position - this.startTagPosition;
+              c = new Array(pad).join(" ") + c;
+            }
+            this.textNode += `<${c}`;
+            this.state = this.S.TEXT;
+          }
+          continue;
+        case this.S.SGML_DECL:
+          if ((this.sgmlDecl + c).toUpperCase() === this.CDATA) {
+            this.emitNode("onopencdata");
+            this.state = this.S.CDATA;
+            this.sgmlDecl = "";
+            this.cdata = "";
+          } else if (this.sgmlDecl + c === "--") {
+            this.state = this.S.COMMENT;
+            this.comment = "";
+            this.sgmlDecl = "";
+          } else if ((this.sgmlDecl + c).toUpperCase() === this.DOCTYPE) {
+            this.state = this.S.DOCTYPE;
+            if (this.doctype || this.sawRoot) {
+              this.strictFail("Inappropriately located doctype declaration");
+            }
+            this.doctype = "";
+            this.sgmlDecl = "";
+          } else if (c === ">") {
+            this.emitNode("onsgmldeclaration", this.sgmlDecl);
+            this.sgmlDecl = "";
+            this.state = this.S.TEXT;
+          } else if (SAX.isQuote(c)) {
+            this.state = this.S.SGML_DECL_QUOTED;
+            this.sgmlDecl += c;
+          } else {
+            this.sgmlDecl += c;
+          }
+          continue;
+        case this.S.SGML_DECL_QUOTED:
+          if (c === this.q) {
+            this.state = this.S.SGML_DECL;
+            this.q = "";
+          }
+          this.sgmlDecl += c;
+          continue;
+        case this.S.DOCTYPE:
+          if (c === ">") {
+            this.state = this.S.TEXT;
+            this.emitNode("ondoctype", this.doctype);
+            this.doctype = true;
+          } else {
+            this.doctype += c;
+            if (c === "[") {
+              this.state = this.S.DOCTYPE_DTD;
+            } else if (SAX.isQuote(c)) {
+              this.state = this.S.DOCTYPE_QUOTED;
+              this.q = c;
+            }
+          }
+          continue;
+        case this.S.DOCTYPE_QUOTED:
+          this.doctype += c;
+          if (c === this.q) {
+            this.q = "";
+            this.state = this.S.DOCTYPE;
+          }
+          continue;
+        case this.S.DOCTYPE_DTD:
+          this.doctype += c;
+          if (c === "]") {
+            this.state = this.S.DOCTYPE;
+          } else if (SAX.isQuote(c)) {
+            this.state = this.S.DOCTYPE_DTD_QUOTED;
+            this.q = c;
+          }
+          continue;
+        case this.S.DOCTYPE_DTD_QUOTED:
+          this.doctype += c;
+          if (c === this.q) {
+            this.state = this.S.DOCTYPE_DTD;
+            this.q = "";
+          }
+          continue;
+        case this.S.COMMENT:
+          if (c === "-") {
+            this.state = this.S.COMMENT_ENDING;
+          } else {
+            this.comment += c;
+          }
+          continue;
+        case this.S.COMMENT_ENDING:
+          if (c === "-") {
+            this.state = this.S.COMMENT_ENDED;
+            this.comment = this.textApplyOptions(this.comment);
+            if (this.comment) {
+              this.emitNode("oncomment", this.comment);
+            }
+            this.comment = "";
+          } else {
+            this.comment += `-${c}`;
+            this.state = this.S.COMMENT;
+          }
+          continue;
+        case this.S.COMMENT_ENDED:
+          if (c !== ">") {
+            this.strictFail("Malformed comment");
+            this.comment += `--${c}`;
+            this.state = this.S.COMMENT;
+          } else {
+            this.state = this.S.TEXT;
+          }
+          continue;
+        case this.S.CDATA:
+          if (c === "]") {
+            this.state = this.S.CDATA_ENDING;
+          } else {
+            this.cdata += c;
+          }
+          continue;
+        case this.S.CDATA_ENDING:
+          if (c === "]") {
+            this.state = this.S.CDATA_ENDING_2;
+          } else {
+            this.cdata += `]${c}`;
+            this.state = this.S.CDATA;
+          }
+          continue;
+        case this.S.CDATA_ENDING_2:
+          if (c === ">") {
+            if (this.cdata) {
+              this.emitNode("oncdata", this.cdata);
+            }
+            this.emitNode("onclosecdata");
+            this.cdata = "";
+            this.state = this.S.TEXT;
+          } else if (c === "]") {
+            this.cdata += "]";
+          } else {
+            this.cdata += `]]${c}`;
+            this.state = this.S.CDATA;
+          }
+          continue;
+        case this.S.PROC_INST:
+          if (c === "?") {
+            this.state = this.S.PROC_INST_ENDING;
+          } else if (SAX.isWhitespace(c)) {
+            this.state = this.S.PROC_INST_BODY;
+          } else {
+            this.procInstName += c;
+          }
+          continue;
+        case this.S.PROC_INST_BODY:
+          if (!this.procInstBody && SAX.isWhitespace(c)) {
+            continue;
+          } else if (c === "?") {
+            this.state = this.S.PROC_INST_ENDING;
+          } else {
+            this.procInstBody += c;
+          }
+          continue;
+        case this.S.PROC_INST_ENDING:
+          if (c === ">") {
+            this.emitNode("onprocessinginstruction", {
+              name: this.procInstName,
+              body: this.procInstBody
+            });
+            this.procInstName = this.procInstBody = "";
+            this.state = this.S.TEXT;
+          } else {
+            this.procInstBody += `?${c}`;
+            this.state = this.S.PROC_INST_BODY;
+          }
+          continue;
+        case this.S.OPEN_TAG:
+          if (SAX.isMatch(nameBody, c)) {
+            this.tagName += c;
+          } else {
+            this.newTag();
+            if (c === ">") {
+              this.openTag();
+            } else if (c === "/") {
+              this.state = this.S.OPEN_TAG_SLASH;
+            } else {
+              if (!SAX.isWhitespace(c)) {
+                this.strictFail("Invalid character in tag name");
+              }
+              this.state = this.S.ATTRIB;
+            }
+          }
+          continue;
+        case this.S.OPEN_TAG_SLASH:
+          if (c === ">") {
+            this.openTag(true);
+            this.closeTag();
+          } else {
+            this.strictFail("Forward-slash in opening tag not followed by >");
+            this.state = this.S.ATTRIB;
+          }
+          continue;
+        case this.S.ATTRIB:
+          if (SAX.isWhitespace(c)) {
+            continue;
+          } else if (c === ">") {
+            this.openTag();
+          } else if (c === "/") {
+            this.state = this.S.OPEN_TAG_SLASH;
+          } else if (SAX.isMatch(nameStart, c)) {
+            this.attribName = c;
+            this.attribValue = "";
+            this.state = this.S.ATTRIB_NAME;
+          } else {
+            this.strictFail("Invalid attribute name");
+          }
+          continue;
+        case this.S.ATTRIB_NAME:
+          if (c === "=") {
+            this.state = this.S.ATTRIB_VALUE;
+          } else if (c === ">") {
+            this.strictFail("Attribute without value");
+            this.attribValue = this.attribName;
+            this.attrib();
+            this.openTag();
+          } else if (SAX.isWhitespace(c)) {
+            this.state = this.S.ATTRIB_NAME_SAW_WHITE;
+          } else if (SAX.isMatch(nameBody, c)) {
+            this.attribName += c;
+          } else {
+            this.strictFail("Invalid attribute name");
+          }
+          continue;
+        case this.S.ATTRIB_NAME_SAW_WHITE:
+          if (c === "=") {
+            this.state = this.S.ATTRIB_VALUE;
+          } else if (SAX.isWhitespace(c)) {
+            continue;
+          } else {
+            this.strictFail("Attribute without value");
+            this.tag.attributes[this.attribName] = "";
+            this.attribValue = "";
+            this.emitNode("onattribute", {
+              name: this.attribName,
+              value: ""
+            });
+            this.attribName = "";
+            if (c === ">") {
+              this.openTag();
+            } else if (SAX.isMatch(nameStart, c)) {
+              this.attribName = c;
+              this.state = this.S.ATTRIB_NAME;
+            } else {
+              this.strictFail("Invalid attribute name");
+              this.state = this.S.ATTRIB;
+            }
+          }
+          continue;
+        case this.S.ATTRIB_VALUE:
+          if (SAX.isWhitespace(c)) {
+            continue;
+          } else if (SAX.isQuote(c)) {
+            this.q = c;
+            this.state = this.S.ATTRIB_VALUE_QUOTED;
+          } else {
+            this.strictFail("Unquoted attribute value");
+            this.state = this.S.ATTRIB_VALUE_UNQUOTED;
+            this.attribValue = c;
+          }
+          continue;
+        case this.S.ATTRIB_VALUE_QUOTED:
+          if (c !== this.q) {
+            if (c === "&") {
+              this.state = this.S.ATTRIB_VALUE_ENTITY_Q;
+            } else {
+              this.attribValue += c;
+            }
+            continue;
+          }
+          this.attrib();
+          this.q = "";
+          this.state = this.S.ATTRIB_VALUE_CLOSED;
+          continue;
+        case this.S.ATTRIB_VALUE_CLOSED:
+          if (SAX.isWhitespace(c)) {
+            this.state = this.S.ATTRIB;
+          } else if (c === ">") {
+            this.openTag();
+          } else if (c === "/") {
+            this.state = this.S.OPEN_TAG_SLASH;
+          } else if (SAX.isMatch(nameStart, c)) {
+            this.strictFail("No whitespace between attributes");
+            this.attribName = c;
+            this.attribValue = "";
+            this.state = this.S.ATTRIB_NAME;
+          } else {
+            this.strictFail("Invalid attribute name");
+          }
+          continue;
+        case this.S.ATTRIB_VALUE_UNQUOTED:
+          if (!SAX.isAttribEnd(c)) {
+            if (c === "&") {
+              this.state = this.S.ATTRIB_VALUE_ENTITY_U;
+            } else {
+              this.attribValue += c;
+            }
+            continue;
+          }
+          this.attrib();
+          if (c === ">") {
+            this.openTag();
+          } else {
+            this.state = this.S.ATTRIB;
+          }
+          continue;
+        case this.S.CLOSE_TAG:
+          if (!this.tagName) {
+            if (SAX.isWhitespace(c)) {
+              continue;
+            } else if (SAX.notMatch(nameStart, c)) {
+              if (this.script) {
+                this.script += `</${c}`;
+                this.state = this.S.SCRIPT;
+              } else {
+                this.strictFail("Invalid tagname in closing tag.");
+              }
+            } else {
+              this.tagName = c;
+            }
+          } else if (c === ">") {
+            this.closeTag();
+          } else if (SAX.isMatch(nameBody, c)) {
+            this.tagName += c;
+          } else if (this.script) {
+            this.script += `</${this.tagName}`;
+            this.tagName = "";
+            this.state = this.S.SCRIPT;
+          } else {
+            if (!SAX.isWhitespace(c)) {
+              this.strictFail("Invalid tagname in closing tag");
+            }
+            this.state = this.S.CLOSE_TAG_SAW_WHITE;
+          }
+          continue;
+        case this.S.CLOSE_TAG_SAW_WHITE:
+          if (SAX.isWhitespace(c)) {
+            continue;
+          }
+          if (c === ">") {
+            this.closeTag();
+          } else {
+            this.strictFail("Invalid characters in closing tag");
+          }
+          continue;
+        case this.S.TEXT_ENTITY:
+        case this.S.ATTRIB_VALUE_ENTITY_Q:
+        case this.S.ATTRIB_VALUE_ENTITY_U:
+          let returnState;
+          let buffer;
+          switch (this.state) {
+            case this.S.TEXT_ENTITY:
+              returnState = this.S.TEXT;
+              buffer = "textNode";
+              break;
+            case this.S.ATTRIB_VALUE_ENTITY_Q:
+              returnState = this.S.ATTRIB_VALUE_QUOTED;
+              buffer = "attribValue";
+              break;
+            case this.S.ATTRIB_VALUE_ENTITY_U:
+              returnState = this.S.ATTRIB_VALUE_UNQUOTED;
+              buffer = "attribValue";
+              break;
+            default:
+              throw new Error(`Unknown state: ${this.state}`);
+          }
+          if (c === ";") {
+            this[buffer] += this.parseEntity();
+            this.entity = "";
+            this.state = returnState;
+          } else if (SAX.isMatch(this.entity.length ? entityBody : entityStart, c)) {
+            this.entity += c;
+          } else {
+            this.strictFail("Invalid character in entity name");
+            this[buffer] += `&${this.entity}${c}`;
+            this.entity = "";
+            this.state = returnState;
+          }
+          continue;
+        default:
+          throw new Error(`Unknown state: ${this.state}`);
+      }
+    }
+    if (this.position >= this.bufferCheckPosition) {
+      this.checkBufferLength();
+    }
+    return this;
+  }
+  emit(event, data) {
+    if (this.events.hasOwnProperty(event)) {
+      const eventName = event.replace(/^on/, "");
+      this.events[event](data, eventName, this);
+    }
+  }
+  clearBuffers() {
+    for (let i = 0, l = this.BUFFERS.length; i < l; i++) {
+      this[this[i]] = "";
+    }
+  }
+  flushBuffers() {
+    this.closeText();
+    if (this.cdata !== "") {
+      this.emitNode("oncdata", this.cdata);
+      this.cdata = "";
+    }
+    if (this.script !== "") {
+      this.emitNode("onscript", this.script);
+      this.script = "";
+    }
+  }
+  end() {
+    if (this.sawRoot && !this.closedRoot)
+      this.strictFail("Unclosed root tag");
+    if (this.state !== this.S.BEGIN && this.state !== this.S.BEGIN_WHITESPACE && this.state !== this.S.TEXT) {
+      this.errorFunction("Unexpected end");
+    }
+    this.closeText();
+    this.c = "";
+    this.closed = true;
+    this.emit("onend");
+    return new SAXParser(this.opt);
+  }
+  errorFunction(er) {
+    this.closeText();
+    if (this.trackPosition) {
+      er += `
+Line: ${this.line}
+Column: ${this.column}
+Char: ${this.c}`;
+    }
+    const error = new Error(er);
+    this.error = error;
+    this.emit("onerror", error);
+    return this;
+  }
+  attrib() {
+    if (!this.strict) {
+      this.attribName = this.attribName[this.looseCase]();
+    }
+    if (this.attribList.indexOf(this.attribName) !== -1 || this.tag.attributes.hasOwnProperty(this.attribName)) {
+      this.attribName = this.attribValue = "";
+      return;
+    }
+    if (this.opt.xmlns) {
+      const qn = SAX.qname(this.attribName, true);
+      const prefix = qn.prefix;
+      const local = qn.local;
+      if (prefix === "xmlns") {
+        if (local === "xml" && this.attribValue !== this.XML_NAMESPACE) {
+          this.strictFail(
+            `xml: prefix must be bound to ${this.XML_NAMESPACE}
+Actual: ${this.attribValue}`
+          );
+        } else if (local === "xmlns" && this.attribValue !== this.XMLNS_NAMESPACE) {
+          this.strictFail(
+            `xmlns: prefix must be bound to ${this.XMLNS_NAMESPACE}
+Actual: ${this.attribValue}`
+          );
+        } else {
+          const tag = this.tag;
+          const parent = this.tags[this.tags.length - 1] || this;
+          if (tag.ns === parent.ns) {
+            tag.ns = Object.create(parent.ns);
+          }
+          tag.ns[local] = this.attribValue;
+        }
+      }
+      this.attribList.push([this.attribName, this.attribValue]);
+    } else {
+      this.tag.attributes[this.attribName] = this.attribValue;
+      this.emitNode("onattribute", {
+        name: this.attribName,
+        value: this.attribValue
+      });
+    }
+    this.attribName = this.attribValue = "";
+  }
+  newTag() {
+    if (!this.strict)
+      this.tagName = this.tagName[this.looseCase]();
+    const parent = this.tags[this.tags.length - 1] || this;
+    const tag = this.tag = { name: this.tagName, attributes: {} };
+    if (this.opt.xmlns) {
+      tag.ns = parent.ns;
+    }
+    this.attribList.length = 0;
+    this.emitNode("onopentagstart", tag);
+  }
+  parseEntity() {
+    let entity = this.entity;
+    const entityLC = entity.toLowerCase();
+    let num = NaN;
+    let numStr = "";
+    if (this.ENTITIES[entity]) {
+      return this.ENTITIES[entity];
+    }
+    if (this.ENTITIES[entityLC]) {
+      return this.ENTITIES[entityLC];
+    }
+    entity = entityLC;
+    if (entity.charAt(0) === "#") {
+      if (entity.charAt(1) === "x") {
+        entity = entity.slice(2);
+        num = parseInt(entity, 16);
+        numStr = num.toString(16);
+      } else {
+        entity = entity.slice(1);
+        num = parseInt(entity, 10);
+        numStr = num.toString(10);
+      }
+    }
+    entity = entity.replace(/^0+/, "");
+    if (isNaN(num) || numStr.toLowerCase() !== entity) {
+      this.strictFail("Invalid character entity");
+      return `&${this.entity};`;
+    }
+    return String.fromCodePoint(num);
+  }
+  beginWhiteSpace(c) {
+    if (c === "<") {
+      this.state = this.S.OPEN_WAKA;
+      this.startTagPosition = this.position;
+    } else if (!SAX.isWhitespace(c)) {
+      this.strictFail("Non-whitespace before first tag.");
+      this.textNode = c;
+      this.state = this.S.TEXT;
+    } else {
+    }
+  }
+  strictFail(message) {
+    if (typeof this !== "object" || !(this instanceof SAXParser)) {
+      throw new Error("bad call to strictFail");
+    }
+    if (this.strict) {
+      this.errorFunction(message);
+    }
+  }
+  textApplyOptions(text) {
+    if (this.opt.trim)
+      text = text.trim();
+    if (this.opt.normalize)
+      text = text.replace(/\s+/g, " ");
+    return text;
+  }
+  emitNode(nodeType, data) {
+    if (this.textNode)
+      this.closeText();
+    this.emit(nodeType, data);
+  }
+  closeText() {
+    this.textNode = this.textApplyOptions(this.textNode);
+    if (this.textNode !== void 0 && this.textNode !== "" && this.textNode !== "undefined") {
+      this.emit("ontext", this.textNode);
+    }
+    this.textNode = "";
+  }
+  checkBufferLength() {
+    var _a;
+    const maxAllowed = Math.max(this.opt.MAX_BUFFER_LENGTH, 10);
+    let maxActual = 0;
+    for (let i = 0, l = this.BUFFERS.length; i < l; i++) {
+      const len = ((_a = this[this.BUFFERS[i]]) == null ? void 0 : _a.length) || 0;
+      if (len > maxAllowed) {
+        switch (this.BUFFERS[i]) {
+          case "textNode":
+            this.closeText();
+            break;
+          case "cdata":
+            this.emitNode("oncdata", this.cdata);
+            this.cdata = "";
+            break;
+          case "script":
+            this.emitNode("onscript", this.script);
+            this.script = "";
+            break;
+          default:
+            this.errorFunction(`Max buffer length exceeded: ${this.BUFFERS[i]}`);
+        }
+      }
+      maxActual = Math.max(maxActual, len);
+    }
+    const m = this.opt.MAX_BUFFER_LENGTH - maxActual;
+    this.bufferCheckPosition = m + this.position;
+  }
+  openTag(selfClosing) {
+    if (this.opt.xmlns) {
+      const tag = this.tag;
+      const qn = SAX.qname(this.tagName);
+      tag.prefix = qn.prefix;
+      tag.local = qn.local;
+      tag.uri = tag.ns[qn.prefix] || "";
+      if (tag.prefix && !tag.uri) {
+        this.strictFail(`Unbound namespace prefix: ${JSON.stringify(this.tagName)}`);
+        tag.uri = qn.prefix;
+      }
+      const parent = this.tags[this.tags.length - 1] || this;
+      if (tag.ns && parent.ns !== tag.ns) {
+        const that = this;
+        Object.keys(tag.ns).forEach((p) => {
+          that.emitNode("onopennamespace", {
+            prefix: p,
+            uri: tag.ns[p]
+          });
+        });
+      }
+      for (let i = 0, l = this.attribList.length; i < l; i++) {
+        const nv = this.attribList[i];
+        const name = nv[0];
+        const value = nv[1];
+        const qualName = SAX.qname(name, true);
+        const prefix = qualName.prefix;
+        const local = qualName.local;
+        const uri = prefix === "" ? "" : tag.ns[prefix] || "";
+        const a = {
+          name,
+          value,
+          prefix,
+          local,
+          uri
+        };
+        if (prefix && prefix !== "xmlns" && !uri) {
+          this.strictFail(`Unbound namespace prefix: ${JSON.stringify(prefix)}`);
+          a.uri = prefix;
+        }
+        this.tag.attributes[name] = a;
+        this.emitNode("onattribute", a);
+      }
+      this.attribList.length = 0;
+    }
+    this.tag.isSelfClosing = Boolean(selfClosing);
+    this.sawRoot = true;
+    this.tags.push(this.tag);
+    this.emitNode("onopentag", this.tag);
+    if (!selfClosing) {
+      if (!this.noscript && this.tagName.toLowerCase() === "script") {
+        this.state = this.S.SCRIPT;
+      } else {
+        this.state = this.S.TEXT;
+      }
+      this.tag = null;
+      this.tagName = "";
+    }
+    this.attribName = this.attribValue = "";
+    this.attribList.length = 0;
+  }
+  closeTag() {
+    if (!this.tagName) {
+      this.strictFail("Weird empty close tag.");
+      this.textNode += "</>";
+      this.state = this.S.TEXT;
+      return;
+    }
+    if (this.script) {
+      if (this.tagName !== "script") {
+        this.script += `</${this.tagName}>`;
+        this.tagName = "";
+        this.state = this.S.SCRIPT;
+        return;
+      }
+      this.emitNode("onscript", this.script);
+      this.script = "";
+    }
+    let t = this.tags.length;
+    let tagName = this.tagName;
+    if (!this.strict) {
+      tagName = tagName[this.looseCase]();
+    }
+    while (t--) {
+      const close = this.tags[t];
+      if (close.name !== tagName) {
+        this.strictFail("Unexpected close tag");
+      } else {
+        break;
+      }
+    }
+    if (t < 0) {
+      this.strictFail(`Unmatched closing tag: ${this.tagName}`);
+      this.textNode += `</${this.tagName}>`;
+      this.state = this.S.TEXT;
+      return;
+    }
+    this.tagName = tagName;
+    let s = this.tags.length;
+    while (s-- > t) {
+      const tag = this.tag = this.tags.pop();
+      this.tagName = this.tag.name;
+      this.emitNode("onclosetag", this.tagName);
+      const x = {};
+      for (const i in tag.ns) {
+        if (tag.ns.hasOwnProperty(i)) {
+          x[i] = tag.ns[i];
+        }
+      }
+      const parent = this.tags[this.tags.length - 1] || this;
+      if (this.opt.xmlns && tag.ns !== parent.ns) {
+        const that = this;
+        Object.keys(tag.ns).forEach((p) => {
+          const n = tag.ns[p];
+          that.emitNode("onclosenamespace", { prefix: p, uri: n });
+        });
+      }
+    }
+    if (t === 0)
+      this.closedRoot = true;
+    this.tagName = this.attribValue = this.attribName = "";
+    this.attribList.length = 0;
+    this.state = this.S.TEXT;
+  }
+};
+var SAXParser = class extends SAX {
+  constructor(opt) {
+    super();
+    this.opt = DEFAULT_SAX_PARSER_OPTIONS;
+    this.events = DEFAULT_SAX_EVENTS;
+    this.clearBuffers();
+    this.opt = opt = { ...this.opt, ...opt };
+    this.events = { ...this.events, ...opt };
+    this.q = this.c = "";
+    this.opt.lowercase = this.opt.lowercase || this.opt.lowercasetags;
+    this.bufferCheckPosition = this.opt.MAX_BUFFER_LENGTH;
+    this.looseCase = this.opt.lowercase ? "toLowerCase" : "toUpperCase";
+    this.tags = [];
+    this.closed = this.closedRoot = this.sawRoot = false;
+    this.tag = this.error = null;
+    this.strict = Boolean(this.opt.strict);
+    this.noscript = Boolean(this.opt.strict || this.opt.noscript);
+    this.state = this.S.BEGIN;
+    this.strictEntities = this.opt.strictEntities;
+    this.ENTITIES = this.strictEntities ? Object.create(this.XML_ENTITIES) : Object.create(this.ENTITIES);
+    this.attribList = [];
+    if (this.opt.xmlns) {
+      this.ns = Object.create(this.rootNS);
+    }
+    this.trackPosition = this.opt.position !== false;
+    if (this.trackPosition) {
+      this.position = this.line = this.column = 0;
+    }
+    this.emit("onready");
+  }
+  resume() {
+    this.error = null;
+    return this;
+  }
+  close() {
+    return this.write(null);
+  }
+  flush() {
+    this.flushBuffers();
+  }
+};
+SAXParser.ENTITIES = ENTITIES;
+
+// src/lib/xml-utils/uncapitalize.ts
+function uncapitalize(str) {
+  return typeof str === "string" ? str.charAt(0).toLowerCase() + str.slice(1) : str;
+}
+function uncapitalizeKeys(object) {
+  if (Array.isArray(object)) {
+    return object.map((element) => uncapitalizeKeys(element));
+  }
+  if (object && typeof object === "object") {
+    const newObject = {};
+    for (const [key, value] of Object.entries(object)) {
+      newObject[uncapitalize(key)] = uncapitalizeKeys(value);
+    }
+    return newObject;
+  }
+  return object;
+}
+
+// src/lib/parsers/parse-xml.ts
+var import_fast_xml_parser = require("fast-xml-parser");
+function parseXMLSync(text, options) {
+  if ((options == null ? void 0 : options._parser) && options._parser !== "fast-xml-parser") {
+    throw new Error(options == null ? void 0 : options._parser);
+  }
+  const fastXMLOptions = {
+    // Default FastXML options
+    // https://github.com/NaturalIntelligence/fast-xml-parser/blob/master/docs/v4/2.XMLparseOptions.md#allowbooleanattributes
+    allowBooleanAttributes: true,
+    // https://github.com/NaturalIntelligence/fast-xml-parser/blob/master/docs/v4/2.XMLparseOptions.md#ignoredeclaration
+    ignoreDeclaration: true,
+    // https://github.com/NaturalIntelligence/fast-xml-parser/blob/master/docs/v4/2.XMLparseOptions.md#removensprefix
+    removeNSPrefix: options == null ? void 0 : options.removeNSPrefix,
+    // https://github.com/NaturalIntelligence/fast-xml-parser/blob/master/docs/v4/2.XMLparseOptions.md#textnodename
+    textNodeName: options == null ? void 0 : options.textNodeName,
+    // Let's application specify keys that are always arrays
+    isArray: (name, jpath, isLeafNode, isAttribute) => {
+      var _a;
+      const array = Boolean((_a = options == null ? void 0 : options.arrayPaths) == null ? void 0 : _a.some((path) => jpath === path));
+      return array;
+    },
+    // Application overrides
+    ...options == null ? void 0 : options._fastXML
+  };
+  const xml = fastParseXML(text, fastXMLOptions);
+  return (options == null ? void 0 : options.uncapitalizeKeys) ? uncapitalizeKeys(xml) : xml;
+}
+function fastParseXML(text, options) {
+  const parser = new import_fast_xml_parser.XMLParser({
+    ignoreAttributes: false,
+    attributeNamePrefix: "",
+    ...options
+  });
+  const parsedXML = parser.parse(text);
+  return parsedXML;
+}
+
+// src/xml-loader.ts
+var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+var XMLLoader = {
+  name: "XML",
+  id: "xml",
+  module: "xml",
+  version: VERSION,
+  worker: false,
+  extensions: ["xml"],
+  mimeTypes: ["application/xml", "text/xml"],
+  testText: testXMLFile,
+  options: {
+    xml: {
+      _parser: "fast-xml-parser",
+      uncapitalizeKeys: false,
+      removeNSPrefix: false,
+      textNodeName: "value",
+      arrayPaths: []
+    }
+  },
+  parse: async (arrayBuffer, options) => parseXMLSync(new TextDecoder().decode(arrayBuffer), {
+    ...XMLLoader.options.xml,
+    ...options == null ? void 0 : options.xml
+  }),
+  parseTextSync: (text, options) => parseXMLSync(text, { ...XMLLoader.options.xml, ...options == null ? void 0 : options.xml })
+};
+function testXMLFile(text) {
+  return text.startsWith("<?xml");
+}
+
+// src/html-loader.ts
+var import_loader_utils = require("@loaders.gl/loader-utils");
+var HTMLLoader = {
+  ...XMLLoader,
+  name: "HTML",
+  id: "html",
+  extensions: ["html", "htm"],
+  mimeTypes: ["text/html"],
+  testText: testHTMLFile,
+  parse: async (arrayBuffer, options) => parseTextSync(new TextDecoder().decode(arrayBuffer), options),
+  parseTextSync: (text, options) => parseTextSync(text, options)
+};
+function testHTMLFile(text) {
+  return text.startsWith("<html");
+}
+function parseTextSync(text, options) {
+  var _a, _b;
+  options = (0, import_loader_utils.mergeLoaderOptions)(options, {
+    xml: {
+      _parser: "fast-xml-parser",
+      _fastXML: {
+        htmlEntities: true
+      }
+    }
+  });
+  return (_b = (_a = XMLLoader).parseTextSync) == null ? void 0 : _b.call(_a, text, options);
+}
+
+// src/lib/xml-utils/xml-utils.ts
+function convertXMLValueToArray(xmlValue) {
+  if (Array.isArray(xmlValue)) {
+    return xmlValue;
+  }
+  if (xmlValue && typeof xmlValue === "object" && xmlValue["0"]) {
+  }
+  if (xmlValue) {
+    return [xmlValue];
+  }
+  return [];
+}
+function convertXMLFieldToArrayInPlace(xml, key) {
+  xml[key] = convertXMLValueToArray(xml[key]);
+}