@loaders.gl/graphs 5.0.0-alpha.9 → 5.0.0-beta.2

package/dist/gexf-loader.cjs

@@ -0,0 +1,2940 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/gexf-loader-types.ts
+async function preload() {
+  const { GEXFLoaderWithParser: GEXFLoaderWithParser3 } = await Promise.resolve().then(() => (init_gexf_loader(), gexf_loader_exports));
+  return GEXFLoaderWithParser3;
+}
+var VERSION, GEXFLoader;
+var init_gexf_loader_types = __esm({
+  "src/gexf-loader-types.ts"() {
+    "use strict";
+    VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+    GEXFLoader = {
+      name: "GEXF",
+      id: "gexf",
+      module: "graphs",
+      version: VERSION,
+      extensions: ["gexf"],
+      mimeTypes: ["application/gexf+xml"],
+      text: true,
+      worker: false,
+      dataType: null,
+      batchType: null,
+      options: { gexf: { shape: "arrow-table" } },
+      preload
+    };
+  }
+});
+
+// ../documents/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)) {
+      Object.defineProperty(newObject, uncapitalize(key), {
+        value: uncapitalizeKeys(value),
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    }
+    return newObject;
+  }
+  return object;
+}
+var init_uncapitalize = __esm({
+  "../documents/src/lib/xml-utils/uncapitalize.ts"() {
+    "use strict";
+  }
+});
+
+// ../documents/src/sax-ts/sax.ts
+var DEFAULT_SAX_EVENTS, DEFAULT_SAX_PARSER_OPTIONS, EVENTS, BUFFERS, nameStart, nameBody, entityStart, entityBody, ENTITIES, SAX, SAXParser;
+var init_sax = __esm({
+  "../documents/src/sax-ts/sax.ts"() {
+    "use strict";
+    DEFAULT_SAX_EVENTS = {
+      ontext: () => {
+      },
+      onprocessinginstruction: () => {
+      },
+      onsgmldeclaration: () => {
+      },
+      ondoctype: () => {
+      },
+      oncomment: () => {
+      },
+      onopentagstart: () => {
+      },
+      onattribute: () => {
+      },
+      onopentag: () => {
+      },
+      onclosetag: () => {
+      },
+      onopencdata: () => {
+      },
+      oncdata: () => {
+      },
+      onclosecdata: () => {
+      },
+      onerror: () => {
+      },
+      onend: () => {
+      },
+      onready: () => {
+      },
+      onscript: () => {
+      },
+      onopennamespace: () => {
+      },
+      onclosenamespace: () => {
+      }
+    };
+    DEFAULT_SAX_PARSER_OPTIONS = {
+      ...DEFAULT_SAX_EVENTS,
+      strict: false,
+      MAX_BUFFER_LENGTH: 64 * 1024,
+      lowercase: false,
+      lowercasetags: false,
+      noscript: false,
+      strictEntities: false,
+      preserveCase: false,
+      caseInsensitiveTags: false,
+      processEntities: true,
+      xmlns: void 0,
+      position: void 0,
+      trim: void 0,
+      normalize: void 0
+    };
+    EVENTS = [
+      "text",
+      "processinginstruction",
+      "sgmldeclaration",
+      "doctype",
+      "comment",
+      "opentagstart",
+      "attribute",
+      "opentag",
+      "closetag",
+      "opencdata",
+      "cdata",
+      "closecdata",
+      "error",
+      "end",
+      "ready",
+      "script",
+      "opennamespace",
+      "closenamespace"
+    ];
+    BUFFERS = [
+      "comment",
+      "sgmlDecl",
+      "textNode",
+      "tagName",
+      "doctype",
+      "procInstName",
+      "procInstBody",
+      "entity",
+      "attribName",
+      "attribValue",
+      "cdata",
+      "script"
+    ];
+    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]/;
+    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-]/;
+    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]/;
+    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-]/;
+    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;
+    });
+    SAX = class _SAX {
+      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");
+                Object.defineProperty(this.tag.attributes, this.attribName, {
+                  value: "",
+                  enumerable: true,
+                  configurable: true,
+                  writable: true
+                });
+                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.strict && 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.opt.preserveCase) {
+          this.attribName = this.attribName[this.looseCase]();
+        }
+        if (this.attribList.indexOf(this.attribName) !== -1 || Object.hasOwn(this.tag.attributes, this.attribName)) {
+          this.strictFail("Duplicate attribute");
+          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 {
+          Object.defineProperty(this.tag.attributes, this.attribName, {
+            value: this.attribValue,
+            enumerable: true,
+            configurable: true,
+            writable: true
+          });
+          this.emitNode("onattribute", {
+            name: this.attribName,
+            value: this.attribValue
+          });
+        }
+        this.attribName = this.attribValue = "";
+      }
+      newTag() {
+        if (!this.strict && !this.opt.preserveCase) this.tagName = this.tagName[this.looseCase]();
+        const parent = this.tags[this.tags.length - 1] || this;
+        const tag = { name: this.tagName, attributes: {} };
+        this.tag = tag;
+        if (this.opt.xmlns) {
+          tag.ns = parent.ns;
+        }
+        this.attribList.length = 0;
+        this.emitNode("onopentagstart", tag);
+      }
+      /** Validates an entity before optionally preserving its authored spelling. */
+      parseEntity() {
+        const decoded = this.decodeEntity();
+        return this.opt.processEntities === false ? `&${this.entity};` : decoded;
+      }
+      /** Decodes predefined, configured, or numeric entities without resolving document types. */
+      decodeEntity() {
+        let entity = this.entity;
+        const entityLC = entity.toLowerCase();
+        let num = NaN;
+        let numStr = "";
+        if (typeof this.ENTITIES[entity] === "string" || typeof this.ENTITIES[entity] === "number") {
+          return this.ENTITIES[entity];
+        }
+        if (typeof this.ENTITIES[entityLC] === "string" || typeof this.ENTITIES[entityLC] === "number") {
+          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 (Number.isNaN(num) || numStr.toLowerCase() !== entity) {
+          this.strictFail("Invalid character entity");
+          return `&${this.entity};`;
+        }
+        if (num < 0 || num > 1114111 || num >= 55296 && num <= 57343 || num < 32 && ![9, 10, 13].includes(num) || num === 65534 || num === 65535) {
+          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;
+            }
+            Object.defineProperty(this.tag.attributes, name, {
+              value: a,
+              enumerable: true,
+              configurable: true,
+              writable: true
+            });
+            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;
+        }
+        const caseInsensitiveTags = !this.strict && (this.opt.caseInsensitiveTags || !this.opt.preserveCase);
+        if (this.script) {
+          const normalizedScriptCloseTag = caseInsensitiveTags ? this.tagName.toLowerCase() : this.tagName;
+          if (normalizedScriptCloseTag !== "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;
+        const normalizedTagName = caseInsensitiveTags ? tagName.toLowerCase() : tagName;
+        while (t--) {
+          const close = this.tags[t];
+          const normalizedOpenTagName = caseInsensitiveTags ? close.name.toLowerCase() : close.name;
+          if (normalizedOpenTagName !== normalizedTagName) {
+            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.tags.pop();
+          this.tag = tag;
+          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;
+      }
+    };
+    SAXParser = class extends SAX {
+      static ENTITIES = ENTITIES;
+      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();
+      }
+    };
+  }
+});
+
+// ../documents/src/lib/parsers/parse-xml-internal.ts
+function setXMLField(object, name, value) {
+  Object.defineProperty(object, name, {
+    value,
+    enumerable: true,
+    configurable: true,
+    writable: true
+  });
+}
+function parseXMLInternal(text, options = {}) {
+  if (options.strict !== false && /[^\u0009\u000a\u000d\u0020-\ud7ff\ue000-\ufffd\u{10000}-\u{10ffff}]/u.test(text)) {
+    throw new Error("XML: invalid XML character");
+  }
+  const maximumDepth = options.maxDepth ?? 256;
+  if (!Number.isSafeInteger(maximumDepth) || maximumDepth < 1 || maximumDepth > 4096) {
+    throw new Error("XML: maxDepth must be an integer between 1 and 4096");
+  }
+  const state = new InternalXMLParserState(options, maximumDepth);
+  const parser = new SAXParser({
+    strict: options.strict !== false,
+    strictEntities: !options.htmlEntities,
+    preserveCase: true,
+    caseInsensitiveTags: options.strict === false,
+    processEntities: options.processEntities !== false,
+    onopentag: (tag) => state.openElement(tag.name, tag.attributes || {}),
+    ontext: (value) => state.addText(value),
+    oncdata: (value) => state.addText(value),
+    onscript: (value) => state.addText(value),
+    onclosetag: () => state.closeElement(),
+    onerror: (error) => {
+      throw error;
+    }
+  });
+  parser.write(text).close();
+  if (options.strict === false) {
+    while (state.stack.length) state.closeElement();
+  }
+  if (state.result === void 0) throw new Error("XML: document requires a root element");
+  return state.result;
+}
+var InternalXMLParserState;
+var init_parse_xml_internal = __esm({
+  "../documents/src/lib/parsers/parse-xml-internal.ts"() {
+    "use strict";
+    init_sax();
+    InternalXMLParserState = class {
+      /** Initializes conversion options and the element nesting budget. */
+      constructor(options, maximumDepth) {
+        this.options = options;
+        this.maximumDepth = maximumDepth;
+      }
+      options;
+      maximumDepth;
+      /** Open element stack. */
+      stack = [];
+      /** Parsed root document. */
+      result;
+      /** Starts an element, rejecting multiple roots and excessive nesting. */
+      openElement(name, attributes) {
+        if (this.stack.length >= this.maximumDepth)
+          throw new Error("XML: maximum nesting depth exceeded");
+        if (!this.stack.length && this.result !== void 0 && this.options.strict !== false) {
+          throw new Error("XML: document requires a single root element");
+        }
+        const elementName = this.normalizeName(name);
+        const parent = this.stack[this.stack.length - 1];
+        this.stack.push({
+          name: elementName,
+          path: parent ? `${parent.path}.${elementName}` : elementName,
+          attributes: this.normalizeAttributes(attributes),
+          children: {},
+          text: ""
+        });
+      }
+      /** Accumulates text without losing whitespace between text and CDATA chunks. */
+      addText(text) {
+        const current = this.stack[this.stack.length - 1];
+        if (current) current.text += text;
+      }
+      /** Finishes an element and attaches it to its parent or the document root. */
+      closeElement() {
+        const node = this.stack.pop();
+        if (!node) return;
+        const value = this.finalizeElement(node);
+        const parent = this.stack[this.stack.length - 1];
+        if (parent) this.addChild(parent.children, node.name, node.path, value);
+        else {
+          if (this.result === void 0) this.result = {};
+          this.addChild(this.result, node.name, node.path, value);
+        }
+      }
+      /** Converts a completed element, keeping grouping and coercion independent. */
+      finalizeElement(node) {
+        const text = this.options.trimValues === false ? node.text : node.text.trim();
+        const hasAttributes = Object.keys(node.attributes).length > 0;
+        if (!hasAttributes && !Object.keys(node.children).length) {
+          return this.parseValue(text, this.options.parseTagValue !== false);
+        }
+        const object = node.children;
+        if (text)
+          setXMLField(
+            object,
+            this.options.textNodeName ?? "value",
+            this.parseValue(text, this.options.parseTagValue !== false)
+          );
+        if (hasAttributes && this.options.attributesGroupName) {
+          setXMLField(object, this.options.attributesGroupName, node.attributes);
+        } else {
+          for (const [name, value] of Object.entries(node.attributes)) setXMLField(object, name, value);
+        }
+        return object;
+      }
+      /** Appends an element while preserving repeated and explicitly array-valued fields. */
+      addChild(object, name, path, value) {
+        var _a;
+        if (!Object.hasOwn(object, name)) {
+          setXMLField(object, name, ((_a = this.options.arrayPaths) == null ? void 0 : _a.includes(path)) ? [value] : value);
+        } else {
+          const existing = object[name];
+          if (Array.isArray(existing)) existing.push(value);
+          else setXMLField(object, name, [existing, value]);
+        }
+      }
+      /** Applies namespace, prefix, grouping and scalar options to attributes. */
+      normalizeAttributes(attributes) {
+        const normalized = {};
+        if (this.options.ignoreAttributes) return normalized;
+        for (const [name, value] of Object.entries(attributes)) {
+          if (this.options.removeNSPrefix && (name === "xmlns" || name.startsWith("xmlns:"))) continue;
+          const text = this.options.trimValues === false ? value : value.trim();
+          setXMLField(
+            normalized,
+            (this.options.attributeNamePrefix ?? "") + this.normalizeName(name),
+            this.parseValue(text, this.options.parseAttributeValue === true)
+          );
+        }
+        return normalized;
+      }
+      /** Removes a namespace prefix only when requested. */
+      normalizeName(name) {
+        return this.options.removeNSPrefix ? name.slice(name.indexOf(":") + 1) : name;
+      }
+      /** Coerces only finite numeric values and lowercase XML boolean literals. */
+      parseValue(value, convert) {
+        if (!convert) return value;
+        if (value === "true" || value === "false") return value === "true";
+        if (value !== "" && value.trim() !== "" && Number.isFinite(Number(value))) return Number(value);
+        return value;
+      }
+    };
+  }
+});
+
+// ../documents/src/lib/parsers/parse-xml.ts
+function parseXMLSync(text, options = {}) {
+  if (Object.hasOwn(options, "_fastXML") || Object.hasOwn(options, "_sax")) {
+    throw new Error("XML: backend-specific options were removed; use native XML options");
+  }
+  if (options._parser && !["internal", "sax"].includes(options._parser)) {
+    throw new Error("XML: unsupported parser backend; use the native documents parser");
+  }
+  const parsed = parseXMLInternal(text, options);
+  return options.uncapitalizeKeys ? uncapitalizeKeys(parsed) : parsed;
+}
+function validateXML(text) {
+  try {
+    parseXMLInternal(text, {});
+    return true;
+  } catch (error) {
+    return error instanceof Error ? error : new Error(String(error));
+  }
+}
+var init_parse_xml = __esm({
+  "../documents/src/lib/parsers/parse-xml.ts"() {
+    "use strict";
+    init_uncapitalize();
+    init_parse_xml_internal();
+  }
+});
+
+// ../documents/src/xml-parser.ts
+var init_xml_parser = __esm({
+  "../documents/src/xml-parser.ts"() {
+    "use strict";
+    init_parse_xml();
+  }
+});
+
+// ../core/src/schema-utils/lib/schema/convert-arrow-schema.ts
+function convertArrowToSchema(arrowSchema) {
+  return serializeArrowSchema(arrowSchema);
+}
+function serializeArrowSchema(arrowSchema) {
+  return {
+    fields: arrowSchema.fields.map((arrowField) => serializeArrowField(arrowField)),
+    metadata: serializeArrowMetadata(arrowSchema.metadata)
+  };
+}
+function serializeArrowMetadata(arrowMetadata) {
+  return Object.fromEntries(arrowMetadata);
+}
+function serializeArrowField(field) {
+  return {
+    name: field.name,
+    type: serializeArrowType(field.type),
+    nullable: field.nullable,
+    metadata: serializeArrowMetadata(field.metadata)
+  };
+}
+function serializeArrowType(arrowType) {
+  if (isArrowViewType(arrowType, "BinaryView")) {
+    return "binary-view";
+  }
+  if (isArrowViewType(arrowType, "Utf8View")) {
+    return "utf8-view";
+  }
+  if (isOptionalArrowType(arrowType, "LargeList")) {
+    const largeListType = arrowType;
+    return {
+      type: "large-list",
+      children: [serializeArrowField(largeListType.valueField)]
+    };
+  }
+  switch (arrowType.constructor) {
+    case arrow.Null:
+      return "null";
+    case arrow.Binary:
+      return "binary";
+    case arrow.FixedSizeBinary:
+      return {
+        type: "fixed-size-binary",
+        byteWidth: arrowType.byteWidth
+      };
+    case arrow.Bool:
+      return "bool";
+    case arrow.Int:
+      const intType = arrowType;
+      return `${intType.isSigned ? "" : "u"}int${intType.bitWidth}`;
+    case arrow.Int8:
+      return "int8";
+    case arrow.Int16:
+      return "int16";
+    case arrow.Int32:
+      return "int32";
+    case arrow.Int64:
+      return "int64";
+    case arrow.Uint8:
+      return "uint8";
+    case arrow.Uint16:
+      return "uint16";
+    case arrow.Uint32:
+      return "uint32";
+    case arrow.Uint64:
+      return "uint64";
+    case arrow.Float:
+      const precision = arrowType.precision;
+      switch (precision) {
+        case arrow.Precision.HALF:
+          return "float16";
+        case arrow.Precision.SINGLE:
+          return "float32";
+        case arrow.Precision.DOUBLE:
+          return "float64";
+        default:
+          return "float16";
+      }
+    case arrow.Float16:
+      return "float16";
+    case arrow.Float32:
+      return "float32";
+    case arrow.Float64:
+      return "float64";
+    case arrow.Utf8:
+      return "utf8";
+    case arrow.Decimal:
+      const decimal = arrowType;
+      return {
+        type: "decimal",
+        bitWidth: decimal.bitWidth,
+        precision: decimal.precision,
+        scale: decimal.scale
+      };
+    case arrow.Date_:
+      const dateUnit = arrowType.unit;
+      return dateUnit === arrow.DateUnit.DAY ? "date-day" : "date-millisecond";
+    case arrow.DateDay:
+      return "date-day";
+    case arrow.DateMillisecond:
+      return "date-millisecond";
+    case arrow.Time:
+      const timeUnit = arrowType.unit;
+      switch (timeUnit) {
+        case arrow.TimeUnit.SECOND:
+          return "time-second";
+        case arrow.TimeUnit.MILLISECOND:
+          return "time-millisecond";
+        case arrow.TimeUnit.MICROSECOND:
+          return "time-microsecond";
+        case arrow.TimeUnit.NANOSECOND:
+          return "time-nanosecond";
+        default:
+          return "time-second";
+      }
+    case arrow.TimeMillisecond:
+      return "time-millisecond";
+    case arrow.TimeSecond:
+      return "time-second";
+    case arrow.TimeMicrosecond:
+      return "time-microsecond";
+    case arrow.TimeNanosecond:
+      return "time-nanosecond";
+    case arrow.Timestamp:
+      const timeStampUnit = arrowType.unit;
+      switch (timeStampUnit) {
+        case arrow.TimeUnit.SECOND:
+          return "timestamp-second";
+        case arrow.TimeUnit.MILLISECOND:
+          return "timestamp-millisecond";
+        case arrow.TimeUnit.MICROSECOND:
+          return "timestamp-microsecond";
+        case arrow.TimeUnit.NANOSECOND:
+          return "timestamp-nanosecond";
+        default:
+          return "timestamp-second";
+      }
+    case arrow.TimestampSecond:
+      return "timestamp-second";
+    case arrow.TimestampMillisecond:
+      return "timestamp-millisecond";
+    case arrow.TimestampMicrosecond:
+      return "timestamp-microsecond";
+    case arrow.TimestampNanosecond:
+      return "timestamp-nanosecond";
+    case arrow.Interval:
+      const intervalUnit = arrowType.unit;
+      switch (intervalUnit) {
+        case arrow.IntervalUnit.DAY_TIME:
+          return "interval-daytime";
+        case arrow.IntervalUnit.YEAR_MONTH:
+          return "interval-yearmonth";
+        default:
+          return "interval-daytime";
+      }
+    case arrow.IntervalDayTime:
+      return "interval-daytime";
+    case arrow.IntervalYearMonth:
+      return "interval-yearmonth";
+    case arrow.Map_:
+      const mapType = arrowType;
+      return {
+        type: "map",
+        keysSorted: mapType.keysSorted,
+        children: mapType.children.map((arrowField) => serializeArrowField(arrowField))
+      };
+    case arrow.List:
+      const listType = arrowType;
+      const listField = listType.valueField;
+      return {
+        type: "list",
+        children: [serializeArrowField(listField)]
+      };
+    case arrow.FixedSizeList:
+      const fixedSizeList = arrowType;
+      return {
+        type: "fixed-size-list",
+        listSize: fixedSizeList.listSize,
+        children: [serializeArrowField(fixedSizeList.children[0])]
+      };
+    case arrow.Struct:
+      const structType = arrowType;
+      return {
+        type: "struct",
+        children: structType.children.map((arrowField) => serializeArrowField(arrowField))
+      };
+    case arrow.SparseUnion:
+    case arrow.DenseUnion:
+      const unionType = arrowType;
+      return {
+        type: unionType instanceof arrow.DenseUnion ? "dense-union" : "sparse-union",
+        typeIds: unionType.typeIds,
+        children: unionType.children.map((arrowField) => serializeArrowField(arrowField)),
+        typeIdToChildIndex: { ...unionType.typeIdToChildIndex }
+      };
+    case arrow.Dictionary:
+      const dictionaryType = arrowType;
+      return {
+        type: "dictionary",
+        id: dictionaryType.id,
+        indices: serializeArrowDictionaryKeyType(dictionaryType.indices),
+        dictionary: serializeArrowType(dictionaryType.dictionary),
+        isOrdered: dictionaryType.isOrdered
+      };
+    default:
+      throw new Error(`arrow type not supported: ${arrowType.constructor.name}`);
+  }
+}
+function getOptionalArrowConstructor(typeName) {
+  return arrow[typeName];
+}
+function isArrowViewType(arrowType, viewTypeName) {
+  const constructor = getOptionalArrowConstructor(viewTypeName);
+  if (constructor && arrowType instanceof constructor) {
+    return true;
+  }
+  const guards = arrow.DataType;
+  const guard = viewTypeName === "BinaryView" ? guards.isBinaryView : guards.isUtf8View;
+  return Boolean(guard == null ? void 0 : guard(arrowType));
+}
+function isOptionalArrowType(arrowType, typeName) {
+  const constructor = getOptionalArrowConstructor(typeName);
+  return Boolean(constructor && arrowType instanceof constructor);
+}
+function serializeArrowDictionaryKeyType(arrowType) {
+  if (arrowType instanceof arrow.Int) {
+    const prefix = arrowType.isSigned ? "int" : "uint";
+    const keyType = `${prefix}${arrowType.bitWidth}`;
+    if (isSchemaDictionaryKeyType(keyType)) {
+      return keyType;
+    }
+  }
+  switch (arrowType.constructor) {
+    case arrow.Int8:
+      return "int8";
+    case arrow.Int16:
+      return "int16";
+    case arrow.Int32:
+      return "int32";
+    case arrow.Uint8:
+      return "uint8";
+    case arrow.Uint16:
+      return "uint16";
+    case arrow.Uint32:
+      return "uint32";
+    default:
+      throw new Error(`arrow dictionary index type not supported: ${arrowType.constructor.name}`);
+  }
+}
+function isSchemaDictionaryKeyType(keyType) {
+  return ["int8", "int16", "int32", "uint8", "uint16", "uint32"].includes(keyType);
+}
+var arrow;
+var init_convert_arrow_schema = __esm({
+  "../core/src/schema-utils/lib/schema/convert-arrow-schema.ts"() {
+    "use strict";
+    arrow = __toESM(require("apache-arrow"), 1);
+  }
+});
+
+// ../core/src/schema-utils/index.ts
+var init_schema_utils = __esm({
+  "../core/src/schema-utils/index.ts"() {
+    "use strict";
+    init_convert_arrow_schema();
+  }
+});
+
+// src/lib/build-graph-tables.ts
+function buildGraphTables(nodes, edges, shape, declarations) {
+  if (shape === "plain-graph-data") {
+    return { shape, nodes: Array.from(nodes), edges: Array.from(edges) };
+  }
+  if (shape !== "arrow-table" && shape !== "object-row-table") {
+    throw new Error(`Unsupported graph shape: ${shape}`);
+  }
+  const nodeTable = buildGraphTable(nodes, false, shape, declarations == null ? void 0 : declarations.nodes);
+  const edgeTable = buildGraphTable(edges, true, shape, declarations == null ? void 0 : declarations.edges);
+  return {
+    shape: "tables",
+    tables: [
+      { name: "nodes", table: nodeTable },
+      { name: "edges", table: edgeTable }
+    ]
+  };
+}
+function buildGraphTable(records, isEdge, shape, declarations) {
+  const columnNames = isEdge ? ["id", "sourceId", "targetId", "directed", "label", "attributes"] : ["id", "label", "attributes"];
+  const columns = new Map(columnNames.map((name) => [name, []]));
+  for (const record of records) {
+    for (const name of columnNames) {
+      const value = record[name];
+      columns.get(name).push(
+        name === "id" || name === "sourceId" || name === "targetId" ? String(value) : value ?? null
+      );
+    }
+  }
+  if (shape === "object-row-table") {
+    return {
+      shape,
+      data: columns.get("id").map(
+        (_, index) => Object.fromEntries(columnNames.map((name) => [name, columns.get(name)[index]]))
+      )
+    };
+  }
+  const vectors = /* @__PURE__ */ Object.create(null);
+  for (const [name, values] of columns) {
+    const type = name === "attributes" ? inferAttributeType(values, declarations) : name === "directed" ? new import_apache_arrow.Bool() : new import_apache_arrow.Utf8();
+    vectors[name] = (0, import_apache_arrow.vectorFromArray)(
+      values.map((value) => normalizeValue(value, type)),
+      type
+    );
+  }
+  const data = new import_apache_arrow.Table(vectors);
+  return { shape, schema: convertArrowToSchema(data.schema), data };
+}
+function inferAttributeType(values, declarations) {
+  const names = new Set(declarations == null ? void 0 : declarations.keys());
+  for (const value of values) {
+    if (value && typeof value === "object") {
+      for (const name of Object.keys(value)) {
+        names.add(name);
+      }
+    }
+  }
+  return new import_apache_arrow.Struct(
+    Array.from(names, (name) => {
+      const fieldValues = values.map(
+        (value) => (value == null ? void 0 : value[name]) ?? null
+      );
+      return new import_apache_arrow.Field(name, inferValueType(fieldValues, declarations == null ? void 0 : declarations.get(name)), true);
+    })
+  );
+}
+function inferValueType(values, declaration) {
+  const present = values.filter((value) => value !== null && value !== void 0);
+  if (declaration && typeof declaration === "object") {
+    if (!present.every((value) => Array.isArray(value))) return new import_apache_arrow.Utf8();
+    return new import_apache_arrow.List(
+      new import_apache_arrow.Field(
+        "item",
+        inferValueType(
+          present.flatMap((value) => value),
+          declaration.list
+        ),
+        true
+      )
+    );
+  }
+  if (declaration) {
+    const declaredTypes = {
+      boolean: new import_apache_arrow.Bool(),
+      int: new import_apache_arrow.Int32(),
+      long: new import_apache_arrow.Int64(),
+      float: new import_apache_arrow.Float32(),
+      double: new import_apache_arrow.Float64(),
+      string: new import_apache_arrow.Utf8()
+    };
+    const valid = present.every((value) => {
+      switch (declaration) {
+        case "boolean":
+          return typeof value === "boolean";
+        case "int":
+          return typeof value === "number" && Number.isInteger(value) && value >= -2147483648 && value <= 2147483647;
+        case "long":
+          return typeof value === "bigint" && value >= -(2n ** 63n) && value < 2n ** 63n;
+        case "float":
+        case "double":
+          return typeof value === "number";
+        case "string":
+          return typeof value === "string";
+      }
+    });
+    return valid ? declaredTypes[declaration] : new import_apache_arrow.Utf8();
+  }
+  if (present.length && present.every((value) => typeof value === "boolean")) return new import_apache_arrow.Bool();
+  if (present.length && present.every((value) => typeof value === "number")) return new import_apache_arrow.Float64();
+  if (present.length && present.every((value) => Array.isArray(value))) {
+    return new import_apache_arrow.List(
+      new import_apache_arrow.Field("item", inferValueType(present.flatMap((value) => value)), true)
+    );
+  }
+  if (present.length && present.every((value) => typeof value === "object" && !Array.isArray(value))) {
+    return inferAttributeType(present);
+  }
+  return new import_apache_arrow.Utf8();
+}
+function normalizeValue(value, type) {
+  if (value === null || value === void 0) return null;
+  if (type instanceof import_apache_arrow.Struct) {
+    return Object.fromEntries(
+      type.children.map((field) => [
+        field.name,
+        normalizeValue(value[field.name], field.type)
+      ])
+    );
+  }
+  if (type instanceof import_apache_arrow.List)
+    return value.map((item) => normalizeValue(item, type.valueType));
+  if (type instanceof import_apache_arrow.Utf8 && typeof value !== "string") {
+    return typeof value === "object" ? JSON.stringify(value) : String(value);
+  }
+  return value;
+}
+var import_apache_arrow;
+var init_build_graph_tables = __esm({
+  "src/lib/build-graph-tables.ts"() {
+    "use strict";
+    import_apache_arrow = require("apache-arrow");
+    init_schema_utils();
+  }
+});
+
+// src/lib/parse-gexf.ts
+function parseGEXF(input, shape = "arrow-table") {
+  const text = typeof input === "string" ? input : new TextDecoder().decode(input);
+  const validation = validateXML(text);
+  if (validation !== true) throw new Error(`Invalid GEXF XML: ${validation.message}`);
+  if (/<!DOCTYPE\s/i.test(text)) throw new Error("GEXF document types are unsupported.");
+  const document = normalizeNamespaces(parseXMLSync(text, XML_OPTIONS), {});
+  const root = getElement(document.gexf, "gexf");
+  const version = root["@_version"];
+  if (version && !["1.2", "1.2draft", "1.3"].includes(version)) {
+    throw new Error(`Unsupported GEXF version: ${version}`);
+  }
+  const graph = getElement(root.graph, "graph");
+  const directed = parseDirection(graph["@_defaultedgetype"] ?? "undirected");
+  const definitions = {
+    nodes: /* @__PURE__ */ new Map(),
+    edges: /* @__PURE__ */ new Map()
+  };
+  for (const attributes of getElements(graph.attributes)) {
+    const domain = attributes["@_class"];
+    if (domain !== "node" && domain !== "edge")
+      throw new Error("GEXF attributes require a node or edge class.");
+    const scoped = domain === "node" ? definitions.nodes : definitions.edges;
+    const names = new Set(Array.from(scoped.values(), (definition) => definition.name));
+    for (const attribute of getElements(attributes.attribute)) {
+      const identifier = requireAttribute(attribute, "id");
+      const name = requireAttribute(attribute, "title");
+      if (name === "gexf" || names.has(name) || scoped.has(identifier)) {
+        throw new Error(`Duplicate or reserved GEXF attribute: ${name}`);
+      }
+      names.add(name);
+      const type = parseAttributeType(requireAttribute(attribute, "type"));
+      scoped.set(identifier, {
+        name,
+        type,
+        defaultValue: attribute.default === void 0 ? void 0 : castValue(readTextContent(attribute.default), type)
+      });
+    }
+  }
+  const nodeElements = getElements(getContainer(graph.nodes).node);
+  const edgeElements = getElements(getContainer(graph.edges).edge);
+  const nodeIdentifiers = /* @__PURE__ */ new Set();
+  for (const node of nodeElements) {
+    const identifier = requireAttribute(node, "id");
+    if (nodeIdentifiers.has(identifier)) throw new Error(`Duplicate GEXF node ID: ${identifier}`);
+    nodeIdentifiers.add(identifier);
+  }
+  const edgeIdentifiers = new Set(
+    edgeElements.map((edge) => edge["@_id"]).filter((identifier) => typeof identifier === "string")
+  );
+  const seenEdges = /* @__PURE__ */ new Set();
+  function* iterateNodes() {
+    for (const node of nodeElements) yield parseRecord(node, definitions.nodes);
+  }
+  function* iterateEdges() {
+    for (const [index, edge] of edgeElements.entries()) {
+      const sourceId = requireAttribute(edge, "source");
+      const targetId = requireAttribute(edge, "target");
+      if (!nodeIdentifiers.has(sourceId) || !nodeIdentifiers.has(targetId)) {
+        throw new Error("GEXF edge references an undeclared node.");
+      }
+      let identifier = edge["@_id"] === void 0 ? void 0 : requireAttribute(edge, "id");
+      if (identifier === void 0) {
+        identifier = `edge-${index}`;
+        while (edgeIdentifiers.has(identifier)) identifier = `_${identifier}`;
+        edgeIdentifiers.add(identifier);
+      }
+      if (seenEdges.has(identifier)) throw new Error(`Duplicate GEXF edge ID: ${identifier}`);
+      seenEdges.add(identifier);
+      yield {
+        ...parseRecord(edge, definitions.edges, identifier),
+        sourceId,
+        targetId,
+        directed: edge["@_type"] === void 0 ? directed : parseDirection(edge["@_type"])
+      };
+    }
+  }
+  const metadataAttributes = /* @__PURE__ */ Object.create(null);
+  const meta = getContainer(root.meta);
+  for (const name of ["creator", "description", "keywords"]) {
+    if (meta[name] !== void 0) metadataAttributes[name] = readTextContent(meta[name]);
+  }
+  if (typeof meta["@_lastmodifieddate"] === "string")
+    metadataAttributes.lastmodifieddate = meta["@_lastmodifieddate"];
+  const declarations = {
+    nodes: new Map(
+      Array.from(definitions.nodes.values(), (definition) => [definition.name, definition.type])
+    ),
+    edges: new Map(
+      Array.from(definitions.edges.values(), (definition) => [definition.name, definition.type])
+    )
+  };
+  return {
+    ...buildGraphTables(iterateNodes(), iterateEdges(), shape, declarations),
+    metadata: { version, directed, attributes: metadataAttributes }
+  };
+}
+function normalizeNamespaces(element, inherited) {
+  const namespaces = Object.assign(/* @__PURE__ */ Object.create(null), inherited);
+  for (const [name, value] of Object.entries(element)) {
+    if (name === "@_xmlns") namespaces[""] = String(value);
+    else if (name.startsWith("@_xmlns:")) namespaces[name.slice(8)] = String(value);
+  }
+  const normalized = /* @__PURE__ */ Object.create(null);
+  for (const [name, value] of Object.entries(element)) {
+    if (name.startsWith("@_") || name === "#text" || name.startsWith("?")) {
+      normalized[name] = value;
+      continue;
+    }
+    const separator = name.indexOf(":");
+    const prefix = separator < 0 ? "" : name.slice(0, separator);
+    const localName = name.slice(separator + 1);
+    const children = Array.isArray(value) ? value : [value];
+    for (const child of children) {
+      const object = typeof child === "object" && child !== null ? child : {};
+      const namespace = object[prefix ? `@_xmlns:${prefix}` : "@_xmlns"] ?? namespaces[prefix];
+      const match = typeof namespace === "string" ? GEXF_NAMESPACE.exec(namespace) : null;
+      const key = match ? `${match[1] ? "viz:" : ""}${localName}` : namespace || prefix ? `foreign:${name}` : localName;
+      const childValue = typeof child === "object" && child !== null ? match || !namespace && !prefix ? normalizeNamespaces(object, namespaces) : object : child;
+      if (normalized[key] === void 0) normalized[key] = childValue;
+      else
+        normalized[key] = [
+          ...Array.isArray(normalized[key]) ? normalized[key] : [normalized[key]],
+          childValue
+        ];
+    }
+  }
+  assertStaticElement(normalized);
+  return normalized;
+}
+function assertStaticElement(element) {
+  if (element["@_mode"] !== void 0 && element["@_mode"] !== "static" || TEMPORAL_ATTRIBUTES.some((name) => element[`@_${name}`] !== void 0) || element.spells !== void 0) {
+    throw new Error("Dynamic GEXF graphs and temporal values are unsupported.");
+  }
+  if (element["@_pid"] !== void 0 || element.parents !== void 0 || element["@_id"] !== void 0 && (element.nodes !== void 0 || element.edges !== void 0)) {
+    throw new Error("Hierarchical GEXF graphs are unsupported.");
+  }
+}
+function getElement(value, name) {
+  if (value === "") return {};
+  if (value && typeof value === "object" && !Array.isArray(value)) return value;
+  throw new Error(`GEXF requires one <${name}> element.`);
+}
+function readTextContent(value) {
+  if (typeof value === "string") return value;
+  const text = getElement(value, "text")["#text"];
+  return typeof text === "string" ? text : "";
+}
+function getContainer(value) {
+  return value === void 0 ? {} : getElement(value, "container");
+}
+function getElements(value) {
+  if (value === void 0) return [];
+  return (Array.isArray(value) ? value : [value]).map((entry) => getElement(entry, "record"));
+}
+function requireAttribute(element, name) {
+  const value = element[`@_${name}`];
+  if (typeof value !== "string" || value === "")
+    throw new Error(`GEXF requires a ${name} attribute.`);
+  return value;
+}
+function parseDirection(value) {
+  if (value !== "directed" && value !== "undirected")
+    throw new Error(`Unsupported GEXF edge type: ${String(value)}`);
+  return value === "directed";
+}
+function parseAttributeType(value) {
+  if (value.startsWith("list") && !value.slice(4).startsWith("list")) {
+    return { list: parseAttributeType(value.slice(4)) };
+  }
+  if (value === "integer" || value === "byte" || value === "short") return "int";
+  if (value === "boolean" || value === "long" || value === "float" || value === "double")
+    return value;
+  if (["string", "anyURI", "date", "char", "bigdecimal", "biginteger"].includes(value))
+    return "string";
+  throw new Error(`Unsupported GEXF attribute type: ${value}`);
+}
+function castValue(text, type) {
+  if (typeof type === "object") {
+    return parseListValues(text).map((value) => castValue(value, type.list));
+  }
+  if (type === "string") return text;
+  const trimmed = text.trim();
+  if (type === "boolean") {
+    if (trimmed === "true" || trimmed === "1") return true;
+    if (trimmed === "false" || trimmed === "0") return false;
+    return text;
+  }
+  if (type === "int" || type === "long") {
+    if (!/^[+-]?\d+$/.test(trimmed)) return text;
+    return type === "long" ? BigInt(trimmed) : Number.isSafeInteger(Number(trimmed)) ? Number(trimmed) : text;
+  }
+  if (trimmed === "INF") return Infinity;
+  if (trimmed === "-INF") return -Infinity;
+  if (trimmed === "NaN") return NaN;
+  if (!/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/.test(trimmed)) return text;
+  const number = Number(trimmed);
+  const represented = type === "float" ? Math.fround(number) : number;
+  const nonzero = /[1-9]/.test(trimmed.split(/[eE]/)[0]);
+  return Number.isFinite(represented) && (represented !== 0 || !nonzero) ? number : text;
+}
+function parseListValues(text) {
+  const trimmed = text.trim();
+  const bracketed = trimmed.startsWith("[");
+  if (bracketed !== trimmed.endsWith("]")) throw new Error("Invalid GEXF list brackets.");
+  const contents = bracketed ? trimmed.slice(1, -1) : trimmed;
+  if (!contents.trim()) return [];
+  const values = [];
+  let value = "";
+  let quote = "";
+  let quoted = false;
+  let closed = false;
+  for (let index = 0; index < contents.length; index++) {
+    const character = contents[index];
+    if (quote) {
+      if (character === "\\" && (contents[index + 1] === quote || contents[index + 1] === "\\")) {
+        value += contents[++index];
+      } else if (character === quote) {
+        quote = "";
+        closed = true;
+      } else value += character;
+    } else if (character === "," || !bracketed && (character === "|" || character === ";")) {
+      values.push(quoted ? value : value.trim());
+      value = "";
+      quoted = false;
+      closed = false;
+    } else if (closed) {
+      if (character.trim()) throw new Error("Invalid GEXF list text after a quote.");
+    } else if ((character === "'" || character === '"') && !value.trim()) {
+      quote = character;
+      quoted = true;
+      value = "";
+    } else value += character;
+  }
+  if (quote) throw new Error("Unterminated GEXF list quote.");
+  values.push(quoted ? value : value.trim());
+  return values;
+}
+function parseRecord(element, definitions, identifier) {
+  const attributes = /* @__PURE__ */ Object.create(null);
+  for (const definition of definitions.values()) {
+    if (definition.defaultValue !== void 0)
+      attributes[definition.name] = Array.isArray(definition.defaultValue) ? [...definition.defaultValue] : definition.defaultValue;
+  }
+  for (const attvalue of getElements(getContainer(element.attvalues).attvalue)) {
+    const key = requireAttribute(attvalue, "for");
+    const definition = definitions.get(key);
+    if (!definition) throw new Error(`Undeclared GEXF attribute: ${key}`);
+    attributes[definition.name] = castValue(requireValue(attvalue), definition.type);
+  }
+  const native = /* @__PURE__ */ Object.create(null);
+  if (element["@_weight"] !== void 0)
+    native.weight = castValue(String(element["@_weight"]), "double");
+  if (element["@_kind"] !== void 0) native.kind = element["@_kind"];
+  const visualization = /* @__PURE__ */ Object.create(null);
+  for (const name of ["color", "position", "size", "shape", "thickness"]) {
+    const value = element[`viz:${name}`];
+    if (value === void 0) continue;
+    const properties = /* @__PURE__ */ Object.create(null);
+    for (const [key, property] of Object.entries(getElement(value, `viz:${name}`))) {
+      if (key.startsWith("@_") && !key.startsWith("@_xmlns")) {
+        const propertyName = key.slice(2);
+        properties[propertyName] = ["r", "g", "b", "a", "x", "y", "z"].includes(propertyName) || propertyName === "value" && (name === "size" || name === "thickness") ? castValue(String(property), "double") : property;
+      }
+    }
+    visualization[name] = properties;
+  }
+  if (Object.keys(visualization).length) native.viz = visualization;
+  if (Object.keys(native).length) attributes.gexf = native;
+  return {
+    id: identifier ?? requireAttribute(element, "id"),
+    label: element["@_label"],
+    attributes
+  };
+}
+function requireValue(element) {
+  const value = element["@_value"];
+  if (typeof value !== "string") throw new Error("GEXF attvalue requires a value attribute.");
+  return value;
+}
+var XML_OPTIONS, GEXF_NAMESPACE, TEMPORAL_ATTRIBUTES;
+var init_parse_gexf = __esm({
+  "src/lib/parse-gexf.ts"() {
+    "use strict";
+    init_xml_parser();
+    init_build_graph_tables();
+    XML_OPTIONS = {
+      ignoreAttributes: false,
+      parseAttributeValue: false,
+      parseTagValue: false,
+      trimValues: false,
+      attributeNamePrefix: "@_",
+      textNodeName: "#text"
+    };
+    GEXF_NAMESPACE = /^https?:\/\/(?:www\.)?gexf.net\/1\.(?:2(?:draft)?|3)(\/viz)?$/;
+    TEMPORAL_ATTRIBUTES = [
+      "start",
+      "end",
+      "startopen",
+      "endopen",
+      "timestamp",
+      "timestamps",
+      "intervals"
+    ];
+  }
+});
+
+// src/gexf-loader.ts
+var gexf_loader_exports = {};
+__export(gexf_loader_exports, {
+  GEXFLoaderWithParser: () => GEXFLoaderWithParser
+});
+var GEXFLoaderWithParser;
+var init_gexf_loader = __esm({
+  "src/gexf-loader.ts"() {
+    "use strict";
+    init_gexf_loader_types();
+    init_parse_gexf();
+    GEXFLoaderWithParser = {
+      ...GEXFLoader,
+      parse: async (data, options) => {
+        var _a;
+        return parseGEXF(data, ((_a = options == null ? void 0 : options.gexf) == null ? void 0 : _a.shape) ?? "arrow-table");
+      },
+      parseSync: (data, options) => {
+        var _a;
+        return parseGEXF(data, ((_a = options == null ? void 0 : options.gexf) == null ? void 0 : _a.shape) ?? "arrow-table");
+      },
+      parseTextSync: (data, options) => {
+        var _a;
+        return parseGEXF(data, ((_a = options == null ? void 0 : options.gexf) == null ? void 0 : _a.shape) ?? "arrow-table");
+      }
+    };
+  }
+});
+
+// dist/gexf-loader.js
+var gexf_loader_exports2 = {};
+__export(gexf_loader_exports2, {
+  GEXFLoaderWithParser: () => GEXFLoaderWithParser2
+});
+module.exports = __toCommonJS(gexf_loader_exports2);
+
+// dist/gexf-loader-types.js
+var VERSION2 = true ? "5.0.0-beta.2" : "latest";
+async function preload2() {
+  const { GEXFLoaderWithParser: GEXFLoaderWithParser3 } = await Promise.resolve().then(() => (init_gexf_loader(), gexf_loader_exports));
+  return GEXFLoaderWithParser3;
+}
+var GEXFLoader2 = {
+  name: "GEXF",
+  id: "gexf",
+  module: "graphs",
+  version: VERSION2,
+  extensions: ["gexf"],
+  mimeTypes: ["application/gexf+xml"],
+  text: true,
+  worker: false,
+  dataType: null,
+  batchType: null,
+  options: { gexf: { shape: "arrow-table" } },
+  preload: preload2
+};
+
+// dist/lib/parse-gexf.js
+init_xml_parser();
+
+// dist/lib/build-graph-tables.js
+var import_apache_arrow2 = require("apache-arrow");
+init_schema_utils();
+function buildGraphTables2(nodes, edges, shape, declarations) {
+  if (shape === "plain-graph-data") {
+    return { shape, nodes: Array.from(nodes), edges: Array.from(edges) };
+  }
+  if (shape !== "arrow-table" && shape !== "object-row-table") {
+    throw new Error(`Unsupported graph shape: ${shape}`);
+  }
+  const nodeTable = buildGraphTable2(nodes, false, shape, declarations == null ? void 0 : declarations.nodes);
+  const edgeTable = buildGraphTable2(edges, true, shape, declarations == null ? void 0 : declarations.edges);
+  return {
+    shape: "tables",
+    tables: [
+      { name: "nodes", table: nodeTable },
+      { name: "edges", table: edgeTable }
+    ]
+  };
+}
+function buildGraphTable2(records, isEdge, shape, declarations) {
+  const columnNames = isEdge ? ["id", "sourceId", "targetId", "directed", "label", "attributes"] : ["id", "label", "attributes"];
+  const columns = new Map(columnNames.map((name) => [name, []]));
+  for (const record of records) {
+    for (const name of columnNames) {
+      const value = record[name];
+      columns.get(name).push(name === "id" || name === "sourceId" || name === "targetId" ? String(value) : value ?? null);
+    }
+  }
+  if (shape === "object-row-table") {
+    return {
+      shape,
+      data: columns.get("id").map((_, index) => Object.fromEntries(columnNames.map((name) => [name, columns.get(name)[index]])))
+    };
+  }
+  const vectors = /* @__PURE__ */ Object.create(null);
+  for (const [name, values] of columns) {
+    const type = name === "attributes" ? inferAttributeType2(values, declarations) : name === "directed" ? new import_apache_arrow2.Bool() : new import_apache_arrow2.Utf8();
+    vectors[name] = (0, import_apache_arrow2.vectorFromArray)(values.map((value) => normalizeValue2(value, type)), type);
+  }
+  const data = new import_apache_arrow2.Table(vectors);
+  return { shape, schema: convertArrowToSchema(data.schema), data };
+}
+function inferAttributeType2(values, declarations) {
+  const names = new Set(declarations == null ? void 0 : declarations.keys());
+  for (const value of values) {
+    if (value && typeof value === "object") {
+      for (const name of Object.keys(value)) {
+        names.add(name);
+      }
+    }
+  }
+  return new import_apache_arrow2.Struct(Array.from(names, (name) => {
+    const fieldValues = values.map((value) => (value == null ? void 0 : value[name]) ?? null);
+    return new import_apache_arrow2.Field(name, inferValueType2(fieldValues, declarations == null ? void 0 : declarations.get(name)), true);
+  }));
+}
+function inferValueType2(values, declaration) {
+  const present = values.filter((value) => value !== null && value !== void 0);
+  if (declaration && typeof declaration === "object") {
+    if (!present.every((value) => Array.isArray(value)))
+      return new import_apache_arrow2.Utf8();
+    return new import_apache_arrow2.List(new import_apache_arrow2.Field("item", inferValueType2(present.flatMap((value) => value), declaration.list), true));
+  }
+  if (declaration) {
+    const declaredTypes = {
+      boolean: new import_apache_arrow2.Bool(),
+      int: new import_apache_arrow2.Int32(),
+      long: new import_apache_arrow2.Int64(),
+      float: new import_apache_arrow2.Float32(),
+      double: new import_apache_arrow2.Float64(),
+      string: new import_apache_arrow2.Utf8()
+    };
+    const valid = present.every((value) => {
+      switch (declaration) {
+        case "boolean":
+          return typeof value === "boolean";
+        case "int":
+          return typeof value === "number" && Number.isInteger(value) && value >= -2147483648 && value <= 2147483647;
+        case "long":
+          return typeof value === "bigint" && value >= -(2n ** 63n) && value < 2n ** 63n;
+        case "float":
+        case "double":
+          return typeof value === "number";
+        case "string":
+          return typeof value === "string";
+      }
+    });
+    return valid ? declaredTypes[declaration] : new import_apache_arrow2.Utf8();
+  }
+  if (present.length && present.every((value) => typeof value === "boolean"))
+    return new import_apache_arrow2.Bool();
+  if (present.length && present.every((value) => typeof value === "number"))
+    return new import_apache_arrow2.Float64();
+  if (present.length && present.every((value) => Array.isArray(value))) {
+    return new import_apache_arrow2.List(new import_apache_arrow2.Field("item", inferValueType2(present.flatMap((value) => value)), true));
+  }
+  if (present.length && present.every((value) => typeof value === "object" && !Array.isArray(value))) {
+    return inferAttributeType2(present);
+  }
+  return new import_apache_arrow2.Utf8();
+}
+function normalizeValue2(value, type) {
+  if (value === null || value === void 0)
+    return null;
+  if (type instanceof import_apache_arrow2.Struct) {
+    return Object.fromEntries(type.children.map((field) => [
+      field.name,
+      normalizeValue2(value[field.name], field.type)
+    ]));
+  }
+  if (type instanceof import_apache_arrow2.List)
+    return value.map((item) => normalizeValue2(item, type.valueType));
+  if (type instanceof import_apache_arrow2.Utf8 && typeof value !== "string") {
+    return typeof value === "object" ? JSON.stringify(value) : String(value);
+  }
+  return value;
+}
+
+// dist/lib/parse-gexf.js
+var XML_OPTIONS2 = {
+  ignoreAttributes: false,
+  parseAttributeValue: false,
+  parseTagValue: false,
+  trimValues: false,
+  attributeNamePrefix: "@_",
+  textNodeName: "#text"
+};
+var GEXF_NAMESPACE2 = /^https?:\/\/(?:www\.)?gexf.net\/1\.(?:2(?:draft)?|3)(\/viz)?$/;
+var TEMPORAL_ATTRIBUTES2 = [
+  "start",
+  "end",
+  "startopen",
+  "endopen",
+  "timestamp",
+  "timestamps",
+  "intervals"
+];
+function parseGEXF2(input, shape = "arrow-table") {
+  const text = typeof input === "string" ? input : new TextDecoder().decode(input);
+  const validation = validateXML(text);
+  if (validation !== true)
+    throw new Error(`Invalid GEXF XML: ${validation.message}`);
+  if (/<!DOCTYPE\s/i.test(text))
+    throw new Error("GEXF document types are unsupported.");
+  const document = normalizeNamespaces2(parseXMLSync(text, XML_OPTIONS2), {});
+  const root = getElement2(document.gexf, "gexf");
+  const version = root["@_version"];
+  if (version && !["1.2", "1.2draft", "1.3"].includes(version)) {
+    throw new Error(`Unsupported GEXF version: ${version}`);
+  }
+  const graph = getElement2(root.graph, "graph");
+  const directed = parseDirection2(graph["@_defaultedgetype"] ?? "undirected");
+  const definitions = {
+    nodes: /* @__PURE__ */ new Map(),
+    edges: /* @__PURE__ */ new Map()
+  };
+  for (const attributes of getElements2(graph.attributes)) {
+    const domain = attributes["@_class"];
+    if (domain !== "node" && domain !== "edge")
+      throw new Error("GEXF attributes require a node or edge class.");
+    const scoped = domain === "node" ? definitions.nodes : definitions.edges;
+    const names = new Set(Array.from(scoped.values(), (definition) => definition.name));
+    for (const attribute of getElements2(attributes.attribute)) {
+      const identifier = requireAttribute2(attribute, "id");
+      const name = requireAttribute2(attribute, "title");
+      if (name === "gexf" || names.has(name) || scoped.has(identifier)) {
+        throw new Error(`Duplicate or reserved GEXF attribute: ${name}`);
+      }
+      names.add(name);
+      const type = parseAttributeType2(requireAttribute2(attribute, "type"));
+      scoped.set(identifier, {
+        name,
+        type,
+        defaultValue: attribute.default === void 0 ? void 0 : castValue2(readTextContent2(attribute.default), type)
+      });
+    }
+  }
+  const nodeElements = getElements2(getContainer2(graph.nodes).node);
+  const edgeElements = getElements2(getContainer2(graph.edges).edge);
+  const nodeIdentifiers = /* @__PURE__ */ new Set();
+  for (const node of nodeElements) {
+    const identifier = requireAttribute2(node, "id");
+    if (nodeIdentifiers.has(identifier))
+      throw new Error(`Duplicate GEXF node ID: ${identifier}`);
+    nodeIdentifiers.add(identifier);
+  }
+  const edgeIdentifiers = new Set(edgeElements.map((edge) => edge["@_id"]).filter((identifier) => typeof identifier === "string"));
+  const seenEdges = /* @__PURE__ */ new Set();
+  function* iterateNodes() {
+    for (const node of nodeElements)
+      yield parseRecord2(node, definitions.nodes);
+  }
+  function* iterateEdges() {
+    for (const [index, edge] of edgeElements.entries()) {
+      const sourceId = requireAttribute2(edge, "source");
+      const targetId = requireAttribute2(edge, "target");
+      if (!nodeIdentifiers.has(sourceId) || !nodeIdentifiers.has(targetId)) {
+        throw new Error("GEXF edge references an undeclared node.");
+      }
+      let identifier = edge["@_id"] === void 0 ? void 0 : requireAttribute2(edge, "id");
+      if (identifier === void 0) {
+        identifier = `edge-${index}`;
+        while (edgeIdentifiers.has(identifier))
+          identifier = `_${identifier}`;
+        edgeIdentifiers.add(identifier);
+      }
+      if (seenEdges.has(identifier))
+        throw new Error(`Duplicate GEXF edge ID: ${identifier}`);
+      seenEdges.add(identifier);
+      yield {
+        ...parseRecord2(edge, definitions.edges, identifier),
+        sourceId,
+        targetId,
+        directed: edge["@_type"] === void 0 ? directed : parseDirection2(edge["@_type"])
+      };
+    }
+  }
+  const metadataAttributes = /* @__PURE__ */ Object.create(null);
+  const meta = getContainer2(root.meta);
+  for (const name of ["creator", "description", "keywords"]) {
+    if (meta[name] !== void 0)
+      metadataAttributes[name] = readTextContent2(meta[name]);
+  }
+  if (typeof meta["@_lastmodifieddate"] === "string")
+    metadataAttributes.lastmodifieddate = meta["@_lastmodifieddate"];
+  const declarations = {
+    nodes: new Map(Array.from(definitions.nodes.values(), (definition) => [definition.name, definition.type])),
+    edges: new Map(Array.from(definitions.edges.values(), (definition) => [definition.name, definition.type]))
+  };
+  return {
+    ...buildGraphTables2(iterateNodes(), iterateEdges(), shape, declarations),
+    metadata: { version, directed, attributes: metadataAttributes }
+  };
+}
+function normalizeNamespaces2(element, inherited) {
+  const namespaces = Object.assign(/* @__PURE__ */ Object.create(null), inherited);
+  for (const [name, value] of Object.entries(element)) {
+    if (name === "@_xmlns")
+      namespaces[""] = String(value);
+    else if (name.startsWith("@_xmlns:"))
+      namespaces[name.slice(8)] = String(value);
+  }
+  const normalized = /* @__PURE__ */ Object.create(null);
+  for (const [name, value] of Object.entries(element)) {
+    if (name.startsWith("@_") || name === "#text" || name.startsWith("?")) {
+      normalized[name] = value;
+      continue;
+    }
+    const separator = name.indexOf(":");
+    const prefix = separator < 0 ? "" : name.slice(0, separator);
+    const localName = name.slice(separator + 1);
+    const children = Array.isArray(value) ? value : [value];
+    for (const child of children) {
+      const object = typeof child === "object" && child !== null ? child : {};
+      const namespace = object[prefix ? `@_xmlns:${prefix}` : "@_xmlns"] ?? namespaces[prefix];
+      const match = typeof namespace === "string" ? GEXF_NAMESPACE2.exec(namespace) : null;
+      const key = match ? `${match[1] ? "viz:" : ""}${localName}` : namespace || prefix ? `foreign:${name}` : localName;
+      const childValue = typeof child === "object" && child !== null ? match || !namespace && !prefix ? normalizeNamespaces2(object, namespaces) : object : child;
+      if (normalized[key] === void 0)
+        normalized[key] = childValue;
+      else
+        normalized[key] = [
+          ...Array.isArray(normalized[key]) ? normalized[key] : [normalized[key]],
+          childValue
+        ];
+    }
+  }
+  assertStaticElement2(normalized);
+  return normalized;
+}
+function assertStaticElement2(element) {
+  if (element["@_mode"] !== void 0 && element["@_mode"] !== "static" || TEMPORAL_ATTRIBUTES2.some((name) => element[`@_${name}`] !== void 0) || element.spells !== void 0) {
+    throw new Error("Dynamic GEXF graphs and temporal values are unsupported.");
+  }
+  if (element["@_pid"] !== void 0 || element.parents !== void 0 || element["@_id"] !== void 0 && (element.nodes !== void 0 || element.edges !== void 0)) {
+    throw new Error("Hierarchical GEXF graphs are unsupported.");
+  }
+}
+function getElement2(value, name) {
+  if (value === "")
+    return {};
+  if (value && typeof value === "object" && !Array.isArray(value))
+    return value;
+  throw new Error(`GEXF requires one <${name}> element.`);
+}
+function readTextContent2(value) {
+  if (typeof value === "string")
+    return value;
+  const text = getElement2(value, "text")["#text"];
+  return typeof text === "string" ? text : "";
+}
+function getContainer2(value) {
+  return value === void 0 ? {} : getElement2(value, "container");
+}
+function getElements2(value) {
+  if (value === void 0)
+    return [];
+  return (Array.isArray(value) ? value : [value]).map((entry) => getElement2(entry, "record"));
+}
+function requireAttribute2(element, name) {
+  const value = element[`@_${name}`];
+  if (typeof value !== "string" || value === "")
+    throw new Error(`GEXF requires a ${name} attribute.`);
+  return value;
+}
+function parseDirection2(value) {
+  if (value !== "directed" && value !== "undirected")
+    throw new Error(`Unsupported GEXF edge type: ${String(value)}`);
+  return value === "directed";
+}
+function parseAttributeType2(value) {
+  if (value.startsWith("list") && !value.slice(4).startsWith("list")) {
+    return { list: parseAttributeType2(value.slice(4)) };
+  }
+  if (value === "integer" || value === "byte" || value === "short")
+    return "int";
+  if (value === "boolean" || value === "long" || value === "float" || value === "double")
+    return value;
+  if (["string", "anyURI", "date", "char", "bigdecimal", "biginteger"].includes(value))
+    return "string";
+  throw new Error(`Unsupported GEXF attribute type: ${value}`);
+}
+function castValue2(text, type) {
+  if (typeof type === "object") {
+    return parseListValues2(text).map((value) => castValue2(value, type.list));
+  }
+  if (type === "string")
+    return text;
+  const trimmed = text.trim();
+  if (type === "boolean") {
+    if (trimmed === "true" || trimmed === "1")
+      return true;
+    if (trimmed === "false" || trimmed === "0")
+      return false;
+    return text;
+  }
+  if (type === "int" || type === "long") {
+    if (!/^[+-]?\d+$/.test(trimmed))
+      return text;
+    return type === "long" ? BigInt(trimmed) : Number.isSafeInteger(Number(trimmed)) ? Number(trimmed) : text;
+  }
+  if (trimmed === "INF")
+    return Infinity;
+  if (trimmed === "-INF")
+    return -Infinity;
+  if (trimmed === "NaN")
+    return NaN;
+  if (!/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/.test(trimmed))
+    return text;
+  const number = Number(trimmed);
+  const represented = type === "float" ? Math.fround(number) : number;
+  const nonzero = /[1-9]/.test(trimmed.split(/[eE]/)[0]);
+  return Number.isFinite(represented) && (represented !== 0 || !nonzero) ? number : text;
+}
+function parseListValues2(text) {
+  const trimmed = text.trim();
+  const bracketed = trimmed.startsWith("[");
+  if (bracketed !== trimmed.endsWith("]"))
+    throw new Error("Invalid GEXF list brackets.");
+  const contents = bracketed ? trimmed.slice(1, -1) : trimmed;
+  if (!contents.trim())
+    return [];
+  const values = [];
+  let value = "";
+  let quote = "";
+  let quoted = false;
+  let closed = false;
+  for (let index = 0; index < contents.length; index++) {
+    const character = contents[index];
+    if (quote) {
+      if (character === "\\" && (contents[index + 1] === quote || contents[index + 1] === "\\")) {
+        value += contents[++index];
+      } else if (character === quote) {
+        quote = "";
+        closed = true;
+      } else
+        value += character;
+    } else if (character === "," || !bracketed && (character === "|" || character === ";")) {
+      values.push(quoted ? value : value.trim());
+      value = "";
+      quoted = false;
+      closed = false;
+    } else if (closed) {
+      if (character.trim())
+        throw new Error("Invalid GEXF list text after a quote.");
+    } else if ((character === "'" || character === '"') && !value.trim()) {
+      quote = character;
+      quoted = true;
+      value = "";
+    } else
+      value += character;
+  }
+  if (quote)
+    throw new Error("Unterminated GEXF list quote.");
+  values.push(quoted ? value : value.trim());
+  return values;
+}
+function parseRecord2(element, definitions, identifier) {
+  const attributes = /* @__PURE__ */ Object.create(null);
+  for (const definition of definitions.values()) {
+    if (definition.defaultValue !== void 0)
+      attributes[definition.name] = Array.isArray(definition.defaultValue) ? [...definition.defaultValue] : definition.defaultValue;
+  }
+  for (const attvalue of getElements2(getContainer2(element.attvalues).attvalue)) {
+    const key = requireAttribute2(attvalue, "for");
+    const definition = definitions.get(key);
+    if (!definition)
+      throw new Error(`Undeclared GEXF attribute: ${key}`);
+    attributes[definition.name] = castValue2(requireValue2(attvalue), definition.type);
+  }
+  const native = /* @__PURE__ */ Object.create(null);
+  if (element["@_weight"] !== void 0)
+    native.weight = castValue2(String(element["@_weight"]), "double");
+  if (element["@_kind"] !== void 0)
+    native.kind = element["@_kind"];
+  const visualization = /* @__PURE__ */ Object.create(null);
+  for (const name of ["color", "position", "size", "shape", "thickness"]) {
+    const value = element[`viz:${name}`];
+    if (value === void 0)
+      continue;
+    const properties = /* @__PURE__ */ Object.create(null);
+    for (const [key, property] of Object.entries(getElement2(value, `viz:${name}`))) {
+      if (key.startsWith("@_") && !key.startsWith("@_xmlns")) {
+        const propertyName = key.slice(2);
+        properties[propertyName] = ["r", "g", "b", "a", "x", "y", "z"].includes(propertyName) || propertyName === "value" && (name === "size" || name === "thickness") ? castValue2(String(property), "double") : property;
+      }
+    }
+    visualization[name] = properties;
+  }
+  if (Object.keys(visualization).length)
+    native.viz = visualization;
+  if (Object.keys(native).length)
+    attributes.gexf = native;
+  return {
+    id: identifier ?? requireAttribute2(element, "id"),
+    label: element["@_label"],
+    attributes
+  };
+}
+function requireValue2(element) {
+  const value = element["@_value"];
+  if (typeof value !== "string")
+    throw new Error("GEXF attvalue requires a value attribute.");
+  return value;
+}
+
+// dist/gexf-loader.js
+var GEXFLoaderWithParser2 = {
+  ...GEXFLoader2,
+  parse: async (data, options) => {
+    var _a;
+    return parseGEXF2(data, ((_a = options == null ? void 0 : options.gexf) == null ? void 0 : _a.shape) ?? "arrow-table");
+  },
+  parseSync: (data, options) => {
+    var _a;
+    return parseGEXF2(data, ((_a = options == null ? void 0 : options.gexf) == null ? void 0 : _a.shape) ?? "arrow-table");
+  },
+  parseTextSync: (data, options) => {
+    var _a;
+    return parseGEXF2(data, ((_a = options == null ? void 0 : options.gexf) == null ? void 0 : _a.shape) ?? "arrow-table");
+  }
+};
+//# sourceMappingURL=gexf-loader.cjs.map