"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
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);
var __publicField = (obj, key, value) => {
  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
  return value;
};

// dist/index.js
var dist_exports = {};
__export(dist_exports, {
  HTMLLoader: () => HTMLLoader,
  SAXParser: () => SAXParser,
  XMLLoader: () => XMLLoader,
  _uncapitalize: () => uncapitalize,
  _uncapitalizeKeys: () => uncapitalizeKeys,
  convertXMLFieldToArrayInPlace: () => convertXMLFieldToArrayInPlace,
  convertXMLValueToArray: () => convertXMLValueToArray
});
module.exports = __toCommonJS(dist_exports);

// dist/sax-ts/sax.js
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 {
  EVENTS = EVENTS;
  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
  };
  XML_ENTITIES = {
    amp: "&",
    gt: ">",
    lt: "<",
    quot: '"',
    apos: "'"
  };
  S = 0;
  opt;
  trackPosition = false;
  column = 0;
  line = 0;
  c = "";
  error;
  q = "";
  bufferCheckPosition;
  closed = false;
  tags = [];
  looseCase = "";
  closedRoot = false;
  sawRoot = false;
  strict = false;
  tag;
  strictEntities;
  state;
  noscript = false;
  attribList = [];
  ns;
  position = 0;
  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> ... <
  };
  BUFFERS = BUFFERS;
  // private parser: (strict: boolean, opt: any) => SAXParser;
  CDATA = "[CDATA[";
  DOCTYPE = "DOCTYPE";
  XML_NAMESPACE = "http://www.w3.org/XML/1998/namespace";
  XMLNS_NAMESPACE = "http://www.w3.org/2000/xmlns/";
  rootNS = {
    xml: this.XML_NAMESPACE,
    xmlns: this.XMLNS_NAMESPACE
  };
  comment;
  sgmlDecl;
  textNode = "";
  tagName;
  doctype;
  procInstName;
  procInstBody;
  entity = "";
  attribName;
  attribValue;
  cdata = "";
  script = "";
  startTagPosition = 0;
  constructor() {
    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 {
  opt = DEFAULT_SAX_PARSER_OPTIONS;
  events = DEFAULT_SAX_EVENTS;
  constructor(opt) {
    super();
    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();
  }
};
__publicField(SAXParser, "ENTITIES", ENTITIES);

// dist/lib/xml-utils/uncapitalize.js
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;
}

// dist/lib/parsers/parse-xml.js
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;
}

// dist/xml-loader.js
var VERSION = true ? "4.3.1" : "latest";
var XMLLoader = {
  dataType: null,
  batchType: null,
  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");
}

// dist/html-loader.js
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);
}

// dist/lib/xml-utils/xml-utils.js
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]);
}
//# sourceMappingURL=index.cjs.map