@graphty/graph-io 0.3.18 → 0.3.20

package/dist/graph-io.js

@@ -1,288 +1,173 @@
-import { I as ImportReportBuilder, a as throwIfAborted } from "./chunks/report-BOk0p5y8.js";
-import { A, b, B, c, d, e, C, f, g, h, D, i, j, k, l, m, n, o, p, q, E, r, s, u, G, H, v, w, x, y, z, F, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, _, $, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, aa, ab, ac, ad, ae, af, ag, ah, ai, aj, ak, al, am, an, ao, ap, aq, ar, as, at, au, av, aw, ax, ay, az, aA, aB, aC, aD, t } from "./chunks/report-BOk0p5y8.js";
-import { C as C2, c as c2, a } from "./chunks/children-CL3Cy0ez.js";
+import { ag as describe, w as ImportReportBuilder, y as throwIfAborted } from "./chunks/report-B1z4WT9e.js";
+import { A, m, n, Z, ah, B, C, a5, ai, l, j, aj, ak, D, a, i, c, al, d, J, a4, u, E, am, G, an, I, a8, b, a2, r, s, K, ao, ap, e, f, af, M, a9, aq, aa, N, $, O, ar, ab, h, as, P, at, a6, ac, R, S, p, o, a3, au, g, t, ae, ad, a1, T, k, Y, q, U, av, a7, W, a0, aw, ax, H, ay, az, aA, L, aB, aC, aD, aE, aF, X, aG, F, z, V, v, x } from "./chunks/report-B1z4WT9e.js";
+import { C as C2, c as c2, a as a10 } from "./chunks/children-CL3Cy0ez.js";
 import { GraphFormatError, GraphBuilder } from "@graphty/graph-format";
 import { csvImporter, csvExporter } from "./csv.js";
 import { CSV_CAPABILITIES, CSV_ISSUE, CSV_LOSS } from "./csv.js";
-import { b as dotImporter, d as dotExporter } from "./chunks/importer-Br_QeAeE.js";
-import { D as D2, a as a10 } from "./chunks/importer-Br_QeAeE.js";
+import { c as cxImporter } from "./chunks/importer-BaQpCEcJ.js";
+import { C as C3 } from "./chunks/importer-BaQpCEcJ.js";
+import { c as cx2Exporter } from "./chunks/exporter-BGrsWamJ.js";
+import { C as C4, a as a11 } from "./chunks/exporter-BGrsWamJ.js";
+import { c as cx2Importer } from "./chunks/importer-vi3bSdtw.js";
+import { C as C5 } from "./chunks/importer-vi3bSdtw.js";
+import { c as cysImporter } from "./chunks/importer-DD-xv9_Y.js";
+import { C as C6 } from "./chunks/importer-DD-xv9_Y.js";
+import { b as dotImporter, d as dotExporter } from "./chunks/importer-BWY2FFc5.js";
+import { D as D2, a as a12 } from "./chunks/importer-BWY2FFc5.js";
 import { gexfImporter, gexfExporter } from "./gexf.js";
 import { GEXF_1_2_CAPABILITIES, GEXF_ISSUE, GEXF_LOSS } from "./gexf.js";
 import { gmlImporter, gmlExporter } from "./gml.js";
 import { GML_ISSUE, GML_LOSS } from "./gml.js";
-import { b as graphmlImporter, g as graphmlExporter } from "./chunks/importer-DHagxvDD.js";
-import { G as G2, a as a11 } from "./chunks/importer-DHagxvDD.js";
-import { s as sniffJsonDialect, e as jsonImporter, c as jsonExporter } from "./chunks/importer-Du5crN9l.js";
-import { J as J2, a as a12, b as b2, d as d2, j as j2 } from "./chunks/importer-Du5crN9l.js";
+import { b as graphmlImporter, g as graphmlExporter } from "./chunks/importer-DIrbbnAf.js";
+import { G as G2, a as a13 } from "./chunks/importer-DIrbbnAf.js";
+import { r as rankFormats, S as SNIFF_HEAD_BYTES, e as jsonImporter, c as jsonExporter } from "./chunks/importer-Wv4C4gaF.js";
+import { G as G3, J as J2, a as a14, b as b2, d as d2, f as f2, h as h2, j as j2, n as n2, s as s2, g as g2 } from "./chunks/importer-Wv4C4gaF.js";
 import { neo4jImporter, neo4jExporter } from "./neo4j.js";
 import { ID_SPACE_COLUMN, LABELS_COLUMN, NEO4J_CAPABILITIES, NEO4J_ISSUE, NEO4J_LOSS, ORIGINAL_ID_COLUMN, TYPE_COLUMN } from "./neo4j.js";
-import { o as oboImporter } from "./chunks/importer-aNJfe0qu.js";
-import { O as O2 } from "./chunks/importer-aNJfe0qu.js";
-import { b as pajekImporter, p as pajekExporter } from "./chunks/importer-d0uQxFp6.js";
-import { P as P2, a as a13 } from "./chunks/importer-d0uQxFp6.js";
-import { D as D3, L as L2, N as N2, c as c3, a as a14, b as b3, d as d3, e as e2, f as f2, g as g2, h as h2, i as i2, j as j3, k as k2, l as l2, m as m2, n as n2, o as o2, p as p2, s as s2, t as t2 } from "./chunks/writer-GAdltGmC.js";
-import { T as T2, W as W2, i as i3, a as a15, p as p3 } from "./chunks/text-Dr0Ifpag.js";
-import { X as X2, a as a16, h as h3, t as t3, x as x2 } from "./chunks/escape-D-gZWO26.js";
-const GRAPH_FORMATS = Object.freeze([
-  "json",
-  "graphml",
-  "gexf",
-  "csv",
-  "gml",
-  "dot",
-  "pajek",
-  "neo4j",
-  "obo"
-]);
-const SNIFF_HEAD_BYTES = 8192;
-function extensionOf(filename) {
-  const base = filename.slice(Math.max(filename.lastIndexOf("/"), filename.lastIndexOf("\\")) + 1);
-  const dot = base.lastIndexOf(".");
-  if (dot <= 0 || dot === base.length - 1) {
-    return null;
-  }
-  return base.slice(dot).toLowerCase();
-}
-function normalizeMimeType(mimeType) {
-  const semicolon = mimeType.indexOf(";");
-  return (semicolon < 0 ? mimeType : mimeType.slice(0, semicolon)).trim().toLowerCase();
+import { o as oboImporter } from "./chunks/importer-DEcKhsmQ.js";
+import { O as O2 } from "./chunks/importer-DEcKhsmQ.js";
+import { b as pajekImporter, p as pajekExporter } from "./chunks/importer-zGLo8Dg_.js";
+import { P as P2, a as a15 } from "./chunks/importer-zGLo8Dg_.js";
+import { x as xgmmlExporter } from "./chunks/exporter-DIeGJXAZ.js";
+import { x as xgmmlImporter } from "./chunks/importer-D_e7e7LX.js";
+import { X as X2, a as a16 } from "./chunks/importer-D_e7e7LX.js";
+import { L as L2, N as N2, c as c3, a as a17, i as i2, m as m2, s as s3 } from "./chunks/export-Bh60Dv-n.js";
+import { e as e2, b as b3, f as f3, a as a18, c as c4, d as d3, i as i3, p as p2 } from "./chunks/weights-Dzba96G3.js";
+import { T as T2, W as W2, i as i4, a as a19, p as p3 } from "./chunks/text-Dr0Ifpag.js";
+import { D as D3, c as c5, d as d4, e as e3, j as j3, t as t2 } from "./chunks/writer-C7flM-Ih.js";
+import { X as X3, b as b4, h as h3, t as t3, x as x2 } from "./chunks/escape-B-tkk_Cl.js";
+const TOO_MANY_EMPTY_CELLS_CODE = "E_TOO_MANY_EMPTY_CELLS";
+const DEFAULT_MAX_EMPTY_CELLS = 2 ** 24;
+function maxEmptyCellsOption(value) {
+  if (value === void 0) {
+    return DEFAULT_MAX_EMPTY_CELLS;
+  }
+  if (typeof value === "number" && value >= 0 && (Number.isInteger(value) || value === Infinity)) {
+    return value;
+  }
+  throw new GraphFormatError(
+    "E_UNSUPPORTED",
+    `option maxEmptyCells: ${describe(value)} is not a non-negative integer or Infinity`,
+    { option: "maxEmptyCells", found: value }
+  );
 }
-function headBytes(head) {
-  if (typeof head === "string") {
-    return new TextEncoder().encode(head.slice(0, SNIFF_HEAD_BYTES)).subarray(0, SNIFF_HEAD_BYTES);
+class CellBudgetBuilder extends GraphBuilder {
+  /**
+   * Create a builder with a limit.
+   * @param options - the builder options
+   * @param format - the format being read, for the error's report
+   * @param maxEmptyCells - the most empty slots allowed
+   */
+  constructor(options, format, maxEmptyCells) {
+    super(options);
+    this.format = format;
+    this.maxEmptyCells = maxEmptyCells;
+    this.nodeColumns = /* @__PURE__ */ new Set();
+    this.edgeColumns = /* @__PURE__ */ new Set();
+    this.values = 0;
   }
-  if (head.byteLength >= 2 && (head[0] === 255 && head[1] === 254 || head[0] === 254 && head[1] === 255)) {
-    const encoding = head[0] === 255 ? "utf-16le" : "utf-16be";
-    return headBytes(new TextDecoder(encoding).decode(head.subarray(0, SNIFF_HEAD_BYTES)));
+  /**
+   * Add a node, then check the limit (its row adds a slot to every node column).
+   * @param id - the node id
+   * @returns the node index
+   */
+  addNode(id) {
+    const index = super.addNode(id);
+    this.checkBudget();
+    return index;
   }
-  return head.byteLength > SNIFF_HEAD_BYTES ? head.subarray(0, SNIFF_HEAD_BYTES) : head;
-}
-function rankFormats(hints, importers) {
-  const extension = typeof hints.filename === "string" ? extensionOf(hints.filename) : null;
-  const mime = typeof hints.mimeType === "string" ? normalizeMimeType(hints.mimeType) : null;
-  const head = hints.head === void 0 || hints.head === null ? null : headBytes(hints.head);
-  const candidates = [];
-  let rank = 0;
-  for (const importer of importers) {
-    const extensionMatch = extension !== null && importer.extensions.some((e3) => e3.toLowerCase() === extension);
-    const mimeMatch = mime !== null && importer.mimeTypes.some((m3) => m3.toLowerCase() === mime);
-    let content = 0;
-    if (head !== null && head.byteLength > 0 && typeof importer.sniff === "function") {
-      content = clamp(importer.sniff(head));
-    }
-    let confidence;
-    if (content > 0) {
-      confidence = 0.5 + 0.35 * content + (extensionMatch ? 0.1 : 0) + (mimeMatch ? 0.05 : 0);
-    } else if (extensionMatch || mimeMatch) {
-      confidence = (extensionMatch ? 0.3 : 0) + (mimeMatch ? 0.1 : 0);
-    } else {
-      continue;
-    }
-    const dialect = importer.format === "json" && head !== null ? sniffJsonDialectHead(head) : null;
-    const result2 = Object.freeze({
-      format: importer.format,
-      confidence: Math.min(1, confidence),
-      content,
-      extension: extensionMatch,
-      mimeType: mimeMatch,
-      dialect
-    });
-    candidates.push({ result: result2, rank: rank++ });
-  }
-  candidates.sort((a17, b4) => b4.result.confidence - a17.result.confidence || a17.rank - b4.rank);
-  return candidates.map((c4) => c4.result);
-}
-function sniffFormat(hints, importers) {
-  const ranked = rankFormats(hints, importers);
-  return ranked.length > 0 ? ranked[0] : null;
-}
-function sniffJsonDialectHead(head) {
-  const text = typeof head === "string" ? head : new TextDecoder("utf-8", { fatal: false }).decode(head);
-  const body = text.charCodeAt(0) === 65279 ? text.slice(1) : text;
-  const trimmed = body.trimStart();
-  if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) {
-    return null;
-  }
-  let root;
-  try {
-    root = JSON.parse(trimmed);
-  } catch {
-    root = skeletonOf(trimmed);
-  }
-  return sniffJsonDialect(root);
-}
-function skeletonOf(text) {
-  const keys = scanKeys(text);
-  if (text.startsWith("[")) {
-    const first = keys.get("nodes[0]");
-    return first === void 0 ? null : [objectOf(first)];
-  }
-  const rootKeys = keys.get("");
-  if (rootKeys === void 0) {
-    return null;
-  }
-  const root = {};
-  for (const key of rootKeys) {
-    switch (key) {
-      case "graph":
-      case "options":
-        root[key] = objectOf(keys.get(key));
-        break;
-      case "graphs": {
-        const nodes = keys.get("graphs[0].nodes[]");
-        const edges = keys.get("graphs[0].edges[]");
-        const graph = {};
-        if (nodes !== void 0) {
-          graph.nodes = [objectOf(nodes)];
-        }
-        if (edges !== void 0) {
-          graph.edges = [objectOf(edges)];
-        }
-        root[key] = nodes === void 0 && edges === void 0 ? [] : [graph];
-        break;
-      }
-      case "nodes":
-      case "edges":
-      case "links": {
-        const first = keys.get(`${key}[0]`);
-        root[key] = first === void 0 ? [] : [objectOf(first)];
-        break;
-      }
-      default:
-        root[key] = true;
-        break;
-    }
+  /**
+   * Add an edge, then check the limit (its row adds a slot to every edge column).
+   * @param source - source id
+   * @param target - target id
+   * @param weight - the weight
+   * @returns the edge index
+   */
+  addEdge(source, target, weight) {
+    const edge = super.addEdge(source, target, weight);
+    this.checkBudget();
+    return edge;
   }
-  return root;
-}
-function objectOf(names) {
-  const out = {};
-  if (names !== void 0) {
-    for (const name of names) {
-      out[name] = name === "attributes" || name === "data" ? {} : true;
-    }
+  /**
+   * Declare a node column, then check the limit.
+   * @param decl - the declaration
+   * @returns the column handle
+   */
+  declareNodeColumn(decl) {
+    const handle = super.declareNodeColumn(decl);
+    this.nodeColumns.add(handle);
+    this.checkBudget();
+    return handle;
   }
-  return out;
-}
-function scanKeys(text) {
-  const found = /* @__PURE__ */ new Map();
-  const kinds = [];
-  const labels = [];
-  const counts = [];
-  let pendingKey = null;
-  let expectingKey = false;
-  const pathOf = () => {
-    const depth = kinds.length;
-    if (depth === 1) {
-      return kinds[0] === "object" ? "" : null;
-    }
-    if (depth === 2 && kinds[0] === "array" && kinds[1] === "object" && labels[1] === "0") {
-      return "nodes[0]";
-    }
-    if (depth === 2 && kinds[0] === "object" && kinds[1] === "object") {
-      return labels[1] === "graph" || labels[1] === "options" ? labels[1] : null;
-    }
-    if (depth === 5 && kinds.join() === "object,array,object,array,object" && labels[1] === "graphs" && labels[2] === "0" && (labels[3] === "nodes" || labels[3] === "edges")) {
-      return labels[3] === "nodes" ? "graphs[0].nodes[]" : "graphs[0].edges[]";
-    }
-    if (depth === 3 && kinds[0] === "object" && kinds[1] === "array" && kinds[2] === "object") {
-      const section = labels[1];
-      if ((section === "nodes" || section === "edges" || section === "links") && labels[2] === "0") {
-        return `${section}[0]`;
-      }
-    }
-    return null;
-  };
-  let i4 = 0;
-  const n3 = text.length;
-  while (i4 < n3) {
-    const ch = text[i4];
-    if (ch === '"') {
-      const end = scanString(text, i4 + 1);
-      if (end < 0) {
-        break;
-      }
-      const literal = text.slice(i4 + 1, end);
-      i4 = end + 1;
-      if (expectingKey) {
-        pendingKey = decodeKey(literal);
-        expectingKey = false;
-      }
-      continue;
-    }
-    if (ch === "{" || ch === "[") {
-      let label = "";
-      if (kinds.length > 0) {
-        label = kinds[kinds.length - 1] === "object" ? pendingKey ?? "" : String(counts[counts.length - 1]);
-      }
-      kinds.push(ch === "{" ? "object" : "array");
-      labels.push(label);
-      counts.push(0);
-      expectingKey = ch === "{";
-      pendingKey = null;
-    } else if (ch === "}" || ch === "]") {
-      kinds.pop();
-      labels.pop();
-      counts.pop();
-      expectingKey = false;
-      pendingKey = null;
-    } else if (ch === ":") {
-      if (pendingKey !== null) {
-        const path = pathOf();
-        if (path !== null) {
-          let set = found.get(path);
-          if (set === void 0) {
-            set = /* @__PURE__ */ new Set();
-            found.set(path, set);
-          }
-          set.add(pendingKey);
-        }
-      }
-    } else if (ch === ",") {
-      const top = kinds.length - 1;
-      if (top >= 0) {
-        counts[top]++;
-        expectingKey = kinds[top] === "object";
-      }
-      pendingKey = null;
-    }
-    i4++;
+  /**
+   * Declare an edge column, then check the limit.
+   * @param decl - the declaration
+   * @returns the column handle
+   */
+  declareEdgeColumn(decl) {
+    const handle = super.declareEdgeColumn(decl);
+    this.edgeColumns.add(handle);
+    this.checkBudget();
+    return handle;
   }
-  return found;
-}
-function scanString(text, from) {
-  let i4 = from;
-  while (i4 < text.length) {
-    const ch = text[i4];
-    if (ch === "\\") {
-      i4 += 2;
-      continue;
-    }
-    if (ch === '"') {
-      return i4;
-    }
-    i4++;
+  /**
+   * Set a node cell (a new name declares a column), then check the limit.
+   * @param column - the handle or name
+   * @param index - the node index
+   * @param value - the value
+   */
+  setNodeValue(column, index, value) {
+    super.setNodeValue(column, index, value);
+    this.nodeColumns.add(typeof column === "string" ? this.nodeColumn(column) : column);
+    this.count(value);
   }
-  return -1;
-}
-function decodeKey(literal) {
-  if (!literal.includes("\\")) {
-    return literal;
+  /**
+   * Set an edge cell (a new name declares a column), then check the limit.
+   * @param column - the handle or name
+   * @param edge - the edge index
+   * @param value - the value
+   */
+  setEdgeValue(column, edge, value) {
+    super.setEdgeValue(column, edge, value);
+    this.edgeColumns.add(typeof column === "string" ? this.edgeColumn(column) : column);
+    this.count(value);
   }
-  try {
-    return JSON.parse(`"${literal}"`);
-  } catch {
-    return literal;
+  /**
+   * Count a written value and check the budget.
+   * @param value - the value; null and undefined unset a slot and do not count
+   */
+  count(value) {
+    if (value !== null && value !== void 0) {
+      this.values++;
+    }
+    this.checkBudget();
   }
-}
-function clamp(value) {
-  if (!(value > 0)) {
-    return 0;
+  /**
+   * Throw when the columns' slots minus the values written pass the limit.
+   * @throws ImportError E_TOO_MANY_EMPTY_CELLS
+   */
+  checkBudget() {
+    const slots = this.nodeColumns.size * this.nodeBound + this.edgeColumns.size * this.edgeBound;
+    const empty = slots - this.values;
+    if (empty > this.maxEmptyCells) {
+      new ImportReportBuilder(this.format, Infinity).fail(
+        TOO_MANY_EMPTY_CELLS_CODE,
+        `the attributes are too sparse: ${this.nodeColumns.size} node and ${this.edgeColumns.size} edge attribute column(s) over ${this.nodeBound} node(s) and ${this.edgeBound} edge(s) would allocate more than ${this.maxEmptyCells} slots that hold no value; pass a larger maxEmptyCells (or Infinity) to read the file anyway`,
+        void 0,
+        { emptyCells: empty, maxEmptyCells: this.maxEmptyCells }
+      );
+    }
   }
-  return value > 1 ? 1 : value;
 }
 const UNKNOWN_FORMAT_CODE = "E_UNKNOWN_FORMAT";
-const REGISTRY_KEYS = /* @__PURE__ */ new Set(["format", "filename", "mimeType", "builder", "freeze"]);
+const REGISTRY_KEYS = /* @__PURE__ */ new Set([
+  "format",
+  "filename",
+  "mimeType",
+  "builder",
+  "freeze",
+  "maxEmptyCells"
+]);
 class FormatRegistry {
   constructor() {
     this.importerMap = /* @__PURE__ */ new Map();
@@ -399,7 +284,7 @@ class FormatRegistry {
    */
   async importGraph(input, options = {}) {
     const chosen = await this.choose(input, options);
-    const builder = seededBuilder(options);
+    const builder = seededBuilder(options, chosen.importer.format);
     let report;
     try {
       report = await chosen.importer.import(chosen.source, builder, importerOptions(options));
@@ -425,13 +310,13 @@ class FormatRegistry {
     let reports;
     try {
       if (importer.importAll === void 0) {
-        builders.push(seededBuilder(options));
+        builders.push(seededBuilder(options, importer.format));
         reports = [await importer.import(chosen.source, builders[0], importerOptions(options))];
       } else {
         reports = await importer.importAll(
           chosen.source,
           () => {
-            const builder = seededBuilder(options);
+            const builder = seededBuilder(options, importer.format);
             builders.push(builder);
             return builder;
           },
@@ -442,7 +327,7 @@ class FormatRegistry {
       await chosen.peeked?.close();
       throw err;
     }
-    return reports.map((report, i4) => result(chosen, builders[i4], report, options));
+    return reports.map((report, i5) => result(chosen, builders[i5], report, options));
   }
   /**
    * The graphs of an input that can hold several, without importing them (a Cytoscape session's
@@ -517,7 +402,7 @@ class FormatRegistry {
   }
 }
 function createRegistry() {
-  return new FormatRegistry().registerImporter(jsonImporter).registerExporter(jsonExporter).registerImporter(graphmlImporter).registerExporter(graphmlExporter).registerImporter(gexfImporter).registerExporter(gexfExporter).registerImporter(csvImporter).registerExporter(csvExporter).registerImporter(gmlImporter).registerExporter(gmlExporter).registerImporter(dotImporter).registerExporter(dotExporter).registerImporter(pajekImporter).registerExporter(pajekExporter).registerImporter(neo4jImporter).registerExporter(neo4jExporter).registerImporter(oboImporter);
+  return new FormatRegistry().registerImporter(jsonImporter).registerExporter(jsonExporter).registerImporter(graphmlImporter).registerExporter(graphmlExporter).registerImporter(gexfImporter).registerExporter(gexfExporter).registerImporter(csvImporter).registerExporter(csvExporter).registerImporter(gmlImporter).registerExporter(gmlExporter).registerImporter(dotImporter).registerExporter(dotExporter).registerImporter(pajekImporter).registerExporter(pajekExporter).registerImporter(neo4jImporter).registerExporter(neo4jExporter).registerImporter(xgmmlImporter).registerExporter(xgmmlExporter).registerImporter(cx2Importer).registerExporter(cx2Exporter).registerImporter(cxImporter).registerImporter(oboImporter).registerImporter(cysImporter);
 }
 const registry = createRegistry();
 function importGraph(input, options) {
@@ -550,15 +435,20 @@ function importerOptions(options) {
   }
   return out;
 }
-function seededBuilder(options) {
-  return new GraphBuilder({
-    weightDtype: options.weightDtype ?? "f64",
-    ...options.builder,
-    directed: true,
-    addMissingNodes: options.addMissingNodes ?? true,
-    duplicateEdges: options.duplicateEdges ?? "keep",
-    selfLoops: options.selfLoops ?? "keep"
-  });
+function seededBuilder(options, format) {
+  const maxEmptyCells = maxEmptyCellsOption(options.maxEmptyCells);
+  return new CellBudgetBuilder(
+    {
+      weightDtype: options.weightDtype ?? "f64",
+      ...options.builder,
+      directed: true,
+      addMissingNodes: options.addMissingNodes ?? true,
+      duplicateEdges: options.duplicateEdges ?? "keep",
+      selfLoops: options.selfLoops ?? "keep"
+    },
+    format,
+    maxEmptyCells
+  );
 }
 function result(chosen, builder, report, options) {
   const frozen = builder.freezeWithReport(options.freeze);
@@ -621,10 +511,10 @@ async function peekHead(input, bytes, signal) {
   return { head: joinHead(buffered, bytes), input: replayed, close: () => replayed.close() };
 }
 function joinHead(chunks, bytes) {
-  if (chunks.every((c4) => c4 instanceof Uint8Array)) {
+  if (chunks.every((c6) => c6 instanceof Uint8Array)) {
     const total = Math.min(
       bytes,
-      chunks.reduce((sum, c4) => sum + c4.byteLength, 0)
+      chunks.reduce((sum, c6) => sum + c6.byteLength, 0)
     );
     const head = new Uint8Array(total);
     let offset = 0;
@@ -711,36 +601,41 @@ function readerIterator(stream) {
 }
 export {
   A as AMBIGUOUS_GRAPH_NAME_CODE,
-  b as ASPECT_ORDER_CODE,
-  B as BAD_ASPECT_BLOCK_CODE,
-  c as BAD_DEFAULT_CODE,
-  d as BAD_OPTIONS_CODE,
-  e as BAD_VALUE_CODE,
+  m as ASPECT_ORDER_CODE,
+  n as BAD_ASPECT_BLOCK_CODE,
+  Z as BAD_DEFAULT_CODE,
+  ah as BAD_OPTIONS_CODE,
+  B as BAD_VALUE_CODE,
   C as COLUMN_RENAMED_CODE,
-  f as COLUMN_RENAMED_LOSS_CODE,
-  g as COUNT_HINT_CODE,
-  h as COUNT_MISMATCH_CODE,
+  a5 as COLUMN_RENAMED_LOSS_CODE,
+  ai as COUNT_HINT_CODE,
+  l as COUNT_MISMATCH_CODE,
   CSV_CAPABILITIES,
   CSV_ISSUE,
   CSV_LOSS,
+  C4 as CX2_CAPABILITIES,
+  C5 as CX2_ISSUE,
+  a11 as CX2_LOSS,
+  C3 as CX_ISSUE,
+  C6 as CYS_ISSUE,
   C2 as ChildrenCsr,
-  D as DANGLING_REFERENCE_CODE,
+  j as DANGLING_REFERENCE_CODE,
   D3 as DEFAULT_CHUNK_BYTES,
-  i as DEFAULT_ERROR_LIMIT,
-  j as DIRECTED_COLUMN,
-  k as DIRECTION_FORCED_CODE,
-  l as DIRECTION_REFUSED_CODE,
+  aj as DEFAULT_ERROR_LIMIT,
+  ak as DIRECTED_COLUMN,
+  D as DIRECTION_FORCED_CODE,
+  a as DIRECTION_REFUSED_CODE,
   D2 as DOT_ISSUE,
-  a10 as DOT_LOSS,
-  m as DUPLICATE_ATTRIBUTE_CODE,
-  n as DUPLICATE_EDGE_ID_CODE,
-  o as DUPLICATE_KEY_CODE,
-  p as DUPLICATE_NODE_CODE,
-  q as DirectionResolver,
-  E as EMPTY_COLUMN_DROPPED_CODE,
-  r as EMPTY_INPUT_CODE,
-  s as ENCODING_FALLBACK_CODE,
-  u as EQUATION_AS_TEXT_CODE,
+  a12 as DOT_LOSS,
+  i as DUPLICATE_ATTRIBUTE_CODE,
+  c as DUPLICATE_EDGE_ID_CODE,
+  al as DUPLICATE_KEY_CODE,
+  d as DUPLICATE_NODE_CODE,
+  J as DirectionResolver,
+  a4 as EMPTY_COLUMN_DROPPED_CODE,
+  u as EMPTY_INPUT_CODE,
+  E as ENCODING_FALLBACK_CODE,
+  am as EQUATION_AS_TEXT_CODE,
   FormatRegistry,
   GEXF_1_2_CAPABILITIES,
   GEXF_ISSUE,
@@ -748,110 +643,116 @@ export {
   GML_ISSUE,
   GML_LOSS,
   G2 as GRAPHML_ISSUE,
-  a11 as GRAPHML_LOSS,
-  GRAPH_FORMATS,
+  a13 as GRAPHML_LOSS,
+  G3 as GRAPH_FORMATS,
   G as GRAPH_NOT_FOUND_CODE,
-  H as HYPEREDGE_CODE,
-  v as ID_MERGED_CODE,
+  an as HYPEREDGE_CODE,
+  I as ID_MERGED_CODE,
   ID_SPACE_COLUMN,
-  w as ID_TEXT_COLLISION_CODE,
-  x as ID_TEXT_TYPE_CODE,
-  y as INTEGRAL_F64_CODE,
-  z as INVALID_ENCODING_CODE,
-  F as INVALID_UTF8_CODE,
-  J as IdCoercer,
-  K as ImportError,
+  a8 as ID_TEXT_COLLISION_CODE,
+  b as ID_TEXT_TYPE_CODE,
+  a2 as INTEGRAL_F64_CODE,
+  r as INVALID_ENCODING_CODE,
+  s as INVALID_UTF8_CODE,
+  K as IdCoercer,
+  ao as ImportError,
   ImportReportBuilder,
   J2 as JSON_DIALECTS,
-  a12 as JSON_ISSUE,
+  a14 as JSON_ISSUE,
   b2 as JSON_LOSS,
   LABELS_COLUMN,
   L2 as LOSS,
-  L as LineReader,
-  M as MISSING_ENDPOINT_CODE,
-  N as MISSING_ID_CODE,
-  O as MIXED_DIRECTION_CODE,
-  P as MULTIPLE_GRAPHS_CODE,
-  Q as MUTUAL_AS_UNDIRECTED_CODE,
-  R as MUTUAL_COLUMN,
-  S as MUTUAL_EXPANDED_CODE,
+  ap as LineReader,
+  e as MISSING_ENDPOINT_CODE,
+  f as MISSING_ID_CODE,
+  af as MIXED_DIRECTION_CODE,
+  M as MULTIPLE_GRAPHS_CODE,
+  a9 as MUTUAL_AS_UNDIRECTED_CODE,
+  aq as MUTUAL_COLUMN,
+  aa as MUTUAL_EXPANDED_CODE,
   NEO4J_CAPABILITIES,
   NEO4J_ISSUE,
   NEO4J_LOSS,
   N2 as NO_CAPABILITIES,
-  T as NO_GRAPH_CODE,
+  N as NO_GRAPH_CODE,
   O2 as OBO_ISSUE,
-  U as OPTIONS_GAINED_CODE,
-  V as OPTION_IGNORED_CODE,
+  $ as OPTIONS_GAINED_CODE,
+  O as OPTION_IGNORED_CODE,
   ORIGINAL_ID_COLUMN,
-  W as PAIR_COLUMN,
+  ar as PAIR_COLUMN,
   P2 as PAJEK_ISSUE,
-  a13 as PAJEK_LOSS,
-  X as PARENTS_DROPPED_CODE,
-  Y as PARENT_CYCLE_CODE,
-  Z as PARSE_ERROR_CODE,
-  _ as PRECISION_CODE,
-  $ as RENAMED_CODE,
-  a0 as ROLE_ASSUMED_CODE,
-  a1 as ROLE_DROPPED_CODE,
-  a2 as ROLE_TAKEN_CODE,
-  a3 as SINK_OPTION_CODE,
+  a15 as PAJEK_LOSS,
+  ab as PARENTS_DROPPED_CODE,
+  h as PARENT_CYCLE_CODE,
+  as as PARSE_ERROR_CODE,
+  P as PRECISION_CODE,
+  at as RENAMED_CODE,
+  a6 as ROLE_ASSUMED_CODE,
+  ac as ROLE_DROPPED_CODE,
+  R as ROLE_TAKEN_CODE,
+  S as SINK_OPTION_CODE,
   SNIFF_HEAD_BYTES,
-  a4 as STATUS_FAILED_CODE,
-  a5 as STATUS_WARNING_CODE,
-  a6 as STORAGE_CLASS_CODE,
-  a7 as STRAY_TEXT_CODE,
-  a8 as STYLES_NOT_IMPORTED_CODE,
-  a9 as SYNTAX_CODE,
-  aa as TEMPORAL_DROPPED_CODE,
-  ab as TEMPORAL_TEXT_DROPPED_CODE,
-  ac as TEXT_INFERRED_CODE,
-  ad as TOO_LARGE_CODE,
+  p as STATUS_FAILED_CODE,
+  o as STATUS_WARNING_CODE,
+  a3 as STORAGE_CLASS_CODE,
+  au as STRAY_TEXT_CODE,
+  g as STYLES_NOT_IMPORTED_CODE,
+  t as SYNTAX_CODE,
+  ae as TEMPORAL_DROPPED_CODE,
+  ad as TEMPORAL_TEXT_DROPPED_CODE,
+  a1 as TEXT_INFERRED_CODE,
+  T as TOO_LARGE_CODE,
   TYPE_COLUMN,
   T2 as TextCellWriter,
-  ae as UNKNOWN_ATTR_TYPE_CODE,
-  af as UNKNOWN_ELEMENT_CODE,
-  ag as UNKNOWN_ENCODING_CODE,
+  k as UNKNOWN_ATTR_TYPE_CODE,
+  Y as UNKNOWN_ELEMENT_CODE,
+  q as UNKNOWN_ENCODING_CODE,
   UNKNOWN_FORMAT_CODE,
-  ah as UNKNOWN_PARENT_CODE,
-  ai as UNKNOWN_TYPE_CODE,
-  aj as WEIGHT_KEY_CLASH_CODE,
-  ak as WIDENED_CODE,
+  U as UNKNOWN_PARENT_CODE,
+  av as UNKNOWN_TYPE_CODE,
+  a7 as WEIGHT_KEY_CLASH_CODE,
+  W as WIDENED_CODE,
   W2 as WIDENING_UNSUPPORTED_CODE,
-  al as XML_ILLEGAL_CHAR_CODE,
-  am as XML_SYNTAX_CODE,
-  X2 as XmlSyntaxError,
-  a16 as XmlTokenizer,
-  an as canonicalId,
+  X2 as XGMML_ISSUE,
+  a16 as XGMML_LOSS,
+  a0 as XML_ILLEGAL_CHAR_CODE,
+  aw as XML_SYNTAX_CODE,
+  X3 as XmlSyntaxError,
+  b4 as XmlTokenizer,
+  ax as canonicalId,
   c3 as capabilities,
-  a14 as checkCapabilities,
+  a17 as checkCapabilities,
   checkExport,
   c2 as childrenCsr,
-  a as childrenFromColumn,
-  ao as chooseGraph,
-  ap as coerceId,
-  aq as coerceIdText,
-  b3 as collectBytes,
+  a10 as childrenFromColumn,
+  H as chooseGraph,
+  ay as coerceId,
+  az as coerceIdText,
+  c5 as collectBytes,
   createRegistry,
   csvExporter,
   csvImporter,
-  ar as declareCompanion,
-  as as declareResolved,
-  d3 as decodeChunks,
-  at as decodeEntryName,
+  cx2Exporter,
+  cx2Importer,
+  cxImporter,
+  cysImporter,
+  aA as declareCompanion,
+  L as declareResolved,
+  d4 as decodeChunks,
+  aB as decodeEntryName,
   d2 as dialectCapabilities,
   dotExporter,
   dotImporter,
-  e2 as encodeChunks,
-  f2 as explicitWeights,
+  e3 as encodeChunks,
+  e2 as explicitWeights,
   exportGraph,
   exportGraphToString,
-  extensionOf,
-  g2 as formatDecimal,
-  h2 as formatF32,
-  i2 as formatF64,
-  j3 as formatGmlReal,
-  k2 as formatInteger,
+  f2 as extensionOf,
+  b3 as formatDecimal,
+  f3 as formatF32,
+  a18 as formatF64,
+  c4 as formatGmlReal,
+  d3 as formatInteger,
   gexfExporter,
   gexfImporter,
   gmlExporter,
@@ -859,47 +760,49 @@ export {
   graphmlExporter,
   graphmlImporter,
   h3 as hasIllegalXmlChar,
-  headBytes,
+  h2 as headBytes,
   importAllGraphs,
   importGraph,
-  i3 as inferTextDtype,
-  au as inputLength,
-  av as isAbortError,
-  aw as isCanonicalIntegerText,
-  ax as isImportInput,
-  l2 as isNmtoken,
-  a15 as isNumericText,
-  m2 as isWeightField,
-  n2 as joinText,
+  i4 as inferTextDtype,
+  aC as inputLength,
+  aD as isAbortError,
+  aE as isCanonicalIntegerText,
+  aF as isImportInput,
+  i2 as isNmtoken,
+  a19 as isNumericText,
+  i3 as isWeightField,
+  j3 as joinText,
   j2 as jsonCapabilities,
   jsonExporter,
   jsonImporter,
   listGraphs,
-  o2 as mangleNmtoken,
+  m2 as mangleNmtoken,
   neo4jExporter,
   neo4jImporter,
-  normalizeMimeType,
+  n2 as normalizeMimeType,
   oboImporter,
-  ay as pairFolding,
+  X as pairFolding,
   pajekExporter,
   pajekImporter,
   p3 as parseTextCell,
   p2 as parseWeightText,
   rankFormats,
-  az as readText,
+  aG as readText,
   registry,
-  aA as reportSinkOptions,
-  aB as reportUnusedOptions,
-  aC as resolveExportOptions,
-  aD as resolveImportOptions,
-  s2 as sanitizeIds,
+  F as reportSinkOptions,
+  z as reportUnusedOptions,
+  V as resolveExportOptions,
+  v as resolveImportOptions,
+  s3 as sanitizeIds,
   sniff,
-  sniffFormat,
-  sniffJsonDialectHead,
-  t as textChunks,
+  s2 as sniffFormat,
+  g2 as sniffJsonDialectHead,
+  x as textChunks,
   throwIfAborted,
   t2 as toReadableStream,
   t3 as tokenizeXml,
+  xgmmlExporter,
+  xgmmlImporter,
   x2 as xmlIllegalTextNotes
 };
 //# sourceMappingURL=graph-io.js.map