@graphty/graph-io 0.0.0 → 0.2.0

package/dist/graph-io.js

@@ -0,0 +1,790 @@
+import { I as ImportReportBuilder, a as throwIfAborted } from "./chunks/writer-DxSKC7TL.js";
+import { B, b, C, c, d, D, e, f, g, h, i, j, k, l, E, m, H, n, o, p, q, r, s, u, L, v, M, w, x, y, z, A, F, N, G, O, J, P, K, 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, aE } from "./chunks/writer-DxSKC7TL.js";
+import { C as C2, c as c2, a } from "./chunks/children-CL3Cy0ez.js";
+import { GraphBuilder, GraphFormatError } 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-DbnGYr3_.js";
+import { D as D2, a as a10 } from "./chunks/importer-DbnGYr3_.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-GozH8DkN.js";
+import { G as G2, a as a11 } from "./chunks/importer-GozH8DkN.js";
+import { s as sniffJsonDialect, e as jsonImporter, c as jsonExporter } from "./chunks/importer-CQnJuWJw.js";
+import { J as J2, a as a12, b as b2, d as d2, j as j2 } from "./chunks/importer-CQnJuWJw.js";
+import { neo4jImporter, neo4jExporter } from "./neo4j.js";
+import { ID_SPACE_COLUMN, LABELS_COLUMN, NEO4J_CAPABILITIES, NEO4J_ISSUE, NEO4J_LOSS, TYPE_COLUMN } from "./neo4j.js";
+import { b as pajekImporter, p as pajekExporter } from "./chunks/importer-CpCpfbxr.js";
+import { P as P2, a as a13 } from "./chunks/importer-CpCpfbxr.js";
+import { T as T2, W as W2, i as i2, a as a14, p as p2 } from "./chunks/text-CajMdVFy.js";
+import { X as X2, a as a15, h as h2, t as t2, x as x2 } from "./chunks/escape-DyI8JofU.js";
+const GRAPH_FORMATS = Object.freeze([
+  "json",
+  "graphml",
+  "gexf",
+  "csv",
+  "gml",
+  "dot",
+  "pajek",
+  "neo4j"
+]);
+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();
+}
+function headBytes(head) {
+  if (typeof head === "string") {
+    return new TextEncoder().encode(head.slice(0, SNIFF_HEAD_BYTES)).subarray(0, SNIFF_HEAD_BYTES);
+  }
+  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((e2) => e2.toLowerCase() === extension);
+    const mimeMatch = mime !== null && importer.mimeTypes.some((m2) => m2.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 result = Object.freeze({
+      format: importer.format,
+      confidence: Math.min(1, confidence),
+      content,
+      extension: extensionMatch,
+      mimeType: mimeMatch,
+      dialect
+    });
+    candidates.push({ result, rank: rank++ });
+  }
+  candidates.sort((a16, b3) => b3.result.confidence - a16.result.confidence || a16.rank - b3.rank);
+  return candidates.map((c3) => c3.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":
+        root[key] = [];
+        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;
+    }
+  }
+  return root;
+}
+function objectOf(names) {
+  const out = {};
+  if (names !== void 0) {
+    for (const name of names) {
+      out[name] = name === "attributes" || name === "data" ? {} : true;
+    }
+  }
+  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 === 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 i3 = 0;
+  const n2 = text.length;
+  while (i3 < n2) {
+    const ch = text[i3];
+    if (ch === '"') {
+      const end = scanString(text, i3 + 1);
+      if (end < 0) {
+        break;
+      }
+      const literal = text.slice(i3 + 1, end);
+      i3 = 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;
+    }
+    i3++;
+  }
+  return found;
+}
+function scanString(text, from) {
+  let i3 = from;
+  while (i3 < text.length) {
+    const ch = text[i3];
+    if (ch === "\\") {
+      i3 += 2;
+      continue;
+    }
+    if (ch === '"') {
+      return i3;
+    }
+    i3++;
+  }
+  return -1;
+}
+function decodeKey(literal) {
+  if (!literal.includes("\\")) {
+    return literal;
+  }
+  try {
+    return JSON.parse(`"${literal}"`);
+  } catch {
+    return literal;
+  }
+}
+function clamp(value) {
+  if (!(value > 0)) {
+    return 0;
+  }
+  return value > 1 ? 1 : value;
+}
+const UNKNOWN_FORMAT_CODE = "E_UNKNOWN_FORMAT";
+const REGISTRY_KEYS = /* @__PURE__ */ new Set(["format", "filename", "mimeType", "builder", "freeze"]);
+class FormatRegistry {
+  constructor() {
+    this.importerMap = /* @__PURE__ */ new Map();
+    this.exporterMap = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Register an importer under its format name, replacing one of the same name in place (the
+   * original registration order is kept).
+   * @param importer - the importer
+   * @returns this registry, for chaining
+   */
+  registerImporter(importer) {
+    this.importerMap.set(importer.format, importer);
+    return this;
+  }
+  /**
+   * Register an exporter under its format name, replacing one of the same name.
+   * @param exporter - the exporter
+   * @returns this registry, for chaining
+   */
+  registerExporter(exporter) {
+    this.exporterMap.set(exporter.format, exporter);
+    return this;
+  }
+  /**
+   * The importer of a format.
+   * @param format - the format name
+   * @returns the importer; E_UNSUPPORTED when none is registered
+   */
+  importer(format) {
+    const importer = this.importerMap.get(format);
+    if (importer === void 0) {
+      throw unknownFormat("importer", format, this.importerMap.keys());
+    }
+    return importer;
+  }
+  /**
+   * The exporter of a format.
+   * @param format - the format name
+   * @returns the exporter; E_UNSUPPORTED when none is registered
+   */
+  exporter(format) {
+    const exporter = this.exporterMap.get(format);
+    if (exporter === void 0) {
+      throw unknownFormat("exporter", format, this.exporterMap.keys());
+    }
+    return exporter;
+  }
+  /**
+   * Whether an importer is registered for a format.
+   * @param format - the format name
+   * @returns true when importer(format) would succeed
+   */
+  hasImporter(format) {
+    return this.importerMap.has(format);
+  }
+  /**
+   * Whether an exporter is registered for a format.
+   * @param format - the format name
+   * @returns true when exporter(format) would succeed
+   */
+  hasExporter(format) {
+    return this.exporterMap.has(format);
+  }
+  /**
+   * Every registered importer, in registration order.
+   * @returns the importers
+   */
+  importers() {
+    return [...this.importerMap.values()];
+  }
+  /**
+   * Every registered exporter, in registration order.
+   * @returns the exporters
+   */
+  exporters() {
+    return [...this.exporterMap.values()];
+  }
+  /**
+   * The names of every format with an importer or an exporter, importers' order first.
+   * @returns the format names, each once
+   */
+  formats() {
+    return [.../* @__PURE__ */ new Set([...this.importerMap.keys(), ...this.exporterMap.keys()])];
+  }
+  /**
+   * Rank the registered importers for an input (design section 8.2; the successor of
+   * graphty-element's detectFormat()).
+   * @param hints - the filename, MIME type and / or head of the input
+   * @returns the candidates, best first; empty when nothing matches
+   */
+  sniffAll(hints) {
+    return rankFormats(hints, this.importerMap.values());
+  }
+  /**
+   * The best importer for an input, or null when no registered importer claims it.
+   * @param hints - the filename, MIME type and / or head of the input
+   * @returns the best candidate, or null
+   */
+  sniff(hints) {
+    const ranked = this.sniffAll(hints);
+    return ranked.length > 0 ? ranked[0] : null;
+  }
+  /**
+   * Read an input into a fresh builder and freeze it (design section 8.4: for callers who do not
+   * own a sink). The format is the one named in the options, else sniffed from the filename,
+   * the MIME type and the first bytes of the content; the builder is seeded from the common
+   * options with `directed: true` as a placeholder that the importer overrides from the file.
+   * @param input - the text, bytes, stream or chunks to read
+   * @param options - the format, hints, common and format-specific import options
+   * @returns the snapshot, the import report and the freeze report
+   */
+  async importGraph(input, options = {}) {
+    const requested = options.format ?? "auto";
+    let importer;
+    let sniff2 = null;
+    let source = input;
+    let peeked = null;
+    if (requested === "auto") {
+      peeked = await peekHead(input, SNIFF_HEAD_BYTES, options.signal ?? null);
+      source = peeked.input;
+      sniff2 = this.sniff({ filename: options.filename, mimeType: options.mimeType, head: peeked.head });
+      if (sniff2 === null) {
+        const report2 = new ImportReportBuilder("unknown", 0);
+        return report2.fail(
+          UNKNOWN_FORMAT_CODE,
+          `no registered importer recognises the input${describeHints(options)}; pass the format explicitly`,
+          void 0,
+          { formats: this.formats() }
+        );
+      }
+      importer = this.importer(sniff2.format);
+    } else {
+      importer = this.importer(requested);
+    }
+    const builder = new GraphBuilder({
+      weightDtype: options.weightDtype ?? "f64",
+      ...options.builder,
+      directed: true,
+      addMissingNodes: options.addMissingNodes ?? true,
+      duplicateEdges: options.duplicateEdges ?? "keep",
+      selfLoops: options.selfLoops ?? "keep"
+    });
+    let report;
+    try {
+      report = await importer.import(source, builder, importerOptions(options));
+    } catch (err) {
+      await peeked?.close();
+      throw err;
+    }
+    const frozen = builder.freezeWithReport(options.freeze);
+    return Object.freeze({
+      format: importer.format,
+      sniff: sniff2,
+      snapshot: frozen.snapshot,
+      report,
+      freeze: frozen.report
+    });
+  }
+  /**
+   * Write a snapshot in a format, as UTF-8 chunks (design section 8.5).
+   * @param snapshot - the snapshot
+   * @param format - the format name
+   * @param options - the exporter's common and format-specific options
+   * @returns the encoded chunks
+   */
+  exportGraph(snapshot, format, options) {
+    return this.exporter(format).export(snapshot, options);
+  }
+  /**
+   * Write a snapshot in a format, as one string.
+   * @param snapshot - the snapshot
+   * @param format - the format name
+   * @param options - the exporter's common and format-specific options
+   * @returns the whole document
+   */
+  async exportGraphToString(snapshot, format, options) {
+    return this.exporter(format).exportToString(snapshot, options);
+  }
+  /**
+   * What exporting a snapshot in a format would lose, without writing anything.
+   * @param snapshot - the snapshot
+   * @param format - the format name
+   * @param options - the exporter's common and format-specific options
+   * @returns the loss notes, empty when the export is exact
+   */
+  checkExport(snapshot, format, options) {
+    return this.exporter(format).check(snapshot, options);
+  }
+}
+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);
+}
+const registry = createRegistry();
+function importGraph(input, options) {
+  return registry.importGraph(input, options);
+}
+function exportGraph(snapshot, format, options) {
+  return registry.exportGraph(snapshot, format, options);
+}
+async function exportGraphToString(snapshot, format, options) {
+  return registry.exportGraphToString(snapshot, format, options);
+}
+function checkExport(snapshot, format, options) {
+  return registry.checkExport(snapshot, format, options);
+}
+function sniff(hints) {
+  return registry.sniff(hints);
+}
+function importerOptions(options) {
+  const out = {};
+  for (const [key, value] of Object.entries(options)) {
+    if (!REGISTRY_KEYS.has(key)) {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+function unknownFormat(kind, format, known) {
+  const supported = [...known];
+  return new GraphFormatError(
+    "E_UNSUPPORTED",
+    `no ${kind} is registered for format ${JSON.stringify(format)}; known: ${supported.join(", ")}`,
+    { option: "format", found: format, supported }
+  );
+}
+function describeHints(options) {
+  const parts = [];
+  if (typeof options.filename === "string" && options.filename.length > 0) {
+    parts.push(`filename ${JSON.stringify(options.filename)}`);
+  }
+  if (typeof options.mimeType === "string" && options.mimeType.length > 0) {
+    parts.push(`MIME type ${JSON.stringify(options.mimeType)}`);
+  }
+  return parts.length === 0 ? "" : ` (${parts.join(", ")})`;
+}
+async function peekHead(input, bytes, signal) {
+  if (typeof input === "string") {
+    return { head: input.slice(0, bytes), input, close: () => Promise.resolve() };
+  }
+  if (input instanceof Uint8Array) {
+    return { head: input.subarray(0, bytes), input, close: () => Promise.resolve() };
+  }
+  throwIfAborted(signal);
+  const source = typeof input.getReader === "function" ? readerIterator(input) : input[Symbol.asyncIterator]();
+  const buffered = [];
+  let size = 0;
+  let finished = false;
+  while (size < bytes) {
+    if (signal !== null && signal.aborted) {
+      await source.return?.();
+      throwIfAborted(signal);
+    }
+    const next = await source.next();
+    if (next.done === true) {
+      finished = true;
+      break;
+    }
+    buffered.push(next.value);
+    size += typeof next.value === "string" ? next.value.length : next.value.byteLength;
+  }
+  if (!finished && signal !== null && signal.aborted) {
+    await source.return?.();
+    throwIfAborted(signal);
+  }
+  const replayed = replay(buffered, source, finished);
+  return { head: joinHead(buffered, bytes), input: replayed, close: () => replayed.close() };
+}
+function joinHead(chunks, bytes) {
+  if (chunks.every((c3) => c3 instanceof Uint8Array)) {
+    const total = Math.min(
+      bytes,
+      chunks.reduce((sum, c3) => sum + c3.byteLength, 0)
+    );
+    const head = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+      if (offset >= total) {
+        break;
+      }
+      const part = chunk.subarray(0, Math.min(chunk.byteLength, total - offset));
+      head.set(part, offset);
+      offset += part.byteLength;
+    }
+    return head;
+  }
+  const decoder = new TextDecoder("utf-8", { fatal: false });
+  let text = "";
+  for (const chunk of chunks) {
+    text += typeof chunk === "string" ? chunk : decoder.decode(chunk, { stream: true });
+    if (text.length >= bytes) {
+      break;
+    }
+  }
+  return text.slice(0, bytes);
+}
+function replay(buffered, source, finished) {
+  let exhausted = finished;
+  const close = async () => {
+    if (!exhausted) {
+      exhausted = true;
+      await source.return?.();
+    }
+  };
+  return {
+    close,
+    [Symbol.asyncIterator]() {
+      let position = 0;
+      return {
+        async next() {
+          if (position < buffered.length) {
+            return { done: false, value: buffered[position++] };
+          }
+          if (exhausted) {
+            return { done: true, value: void 0 };
+          }
+          const next = await source.next();
+          if (next.done === true) {
+            exhausted = true;
+            return { done: true, value: void 0 };
+          }
+          return next;
+        },
+        async return() {
+          await close();
+          return { done: true, value: void 0 };
+        }
+      };
+    }
+  };
+}
+function readerIterator(stream) {
+  const reader = stream.getReader();
+  let done = false;
+  return {
+    async next() {
+      if (done) {
+        return { done: true, value: void 0 };
+      }
+      const result = await reader.read();
+      if (result.done) {
+        done = true;
+        reader.releaseLock();
+        return { done: true, value: void 0 };
+      }
+      return { done: false, value: result.value };
+    },
+    async return() {
+      if (!done) {
+        done = true;
+        await reader.cancel().catch(() => void 0);
+        reader.releaseLock();
+      }
+      return { done: true, value: void 0 };
+    }
+  };
+}
+export {
+  B as BAD_DEFAULT_CODE,
+  b as BAD_OPTIONS_CODE,
+  C as COLUMN_RENAMED_CODE,
+  c as COLUMN_RENAMED_LOSS_CODE,
+  d as COUNT_HINT_CODE,
+  CSV_CAPABILITIES,
+  CSV_ISSUE,
+  CSV_LOSS,
+  C2 as ChildrenCsr,
+  D as DEFAULT_CHUNK_BYTES,
+  e as DEFAULT_ERROR_LIMIT,
+  f as DIRECTED_COLUMN,
+  g as DIRECTION_FORCED_CODE,
+  h as DIRECTION_REFUSED_CODE,
+  D2 as DOT_ISSUE,
+  a10 as DOT_LOSS,
+  i as DUPLICATE_EDGE_ID_CODE,
+  j as DUPLICATE_KEY_CODE,
+  k as DUPLICATE_NODE_CODE,
+  l as DirectionResolver,
+  E as EMPTY_COLUMN_DROPPED_CODE,
+  m as EMPTY_INPUT_CODE,
+  FormatRegistry,
+  GEXF_1_2_CAPABILITIES,
+  GEXF_ISSUE,
+  GEXF_LOSS,
+  GML_ISSUE,
+  GML_LOSS,
+  G2 as GRAPHML_ISSUE,
+  a11 as GRAPHML_LOSS,
+  GRAPH_FORMATS,
+  H as HYPEREDGE_CODE,
+  n as ID_MERGED_CODE,
+  ID_SPACE_COLUMN,
+  o as ID_TEXT_COLLISION_CODE,
+  p as ID_TEXT_TYPE_CODE,
+  q as INTEGRAL_F64_CODE,
+  r as INVALID_UTF8_CODE,
+  s as IdCoercer,
+  u as ImportError,
+  ImportReportBuilder,
+  J2 as JSON_DIALECTS,
+  a12 as JSON_ISSUE,
+  b2 as JSON_LOSS,
+  LABELS_COLUMN,
+  L as LOSS,
+  v as LineReader,
+  M as MISSING_ENDPOINT_CODE,
+  w as MISSING_ID_CODE,
+  x as MIXED_DIRECTION_CODE,
+  y as MULTIPLE_GRAPHS_CODE,
+  z as MUTUAL_AS_UNDIRECTED_CODE,
+  A as MUTUAL_COLUMN,
+  F as MUTUAL_EXPANDED_CODE,
+  NEO4J_CAPABILITIES,
+  NEO4J_ISSUE,
+  NEO4J_LOSS,
+  N as NO_CAPABILITIES,
+  G as NO_GRAPH_CODE,
+  O as OPTIONS_GAINED_CODE,
+  J as OPTION_IGNORED_CODE,
+  P as PAIR_COLUMN,
+  P2 as PAJEK_ISSUE,
+  a13 as PAJEK_LOSS,
+  K as PARENTS_DROPPED_CODE,
+  Q as PARSE_ERROR_CODE,
+  R as PRECISION_CODE,
+  S as RENAMED_CODE,
+  T as ROLE_ASSUMED_CODE,
+  U as ROLE_DROPPED_CODE,
+  V as ROLE_TAKEN_CODE,
+  W as SINK_OPTION_CODE,
+  SNIFF_HEAD_BYTES,
+  X as STORAGE_CLASS_CODE,
+  Y as STRAY_TEXT_CODE,
+  Z as SYNTAX_CODE,
+  _ as TEMPORAL_DROPPED_CODE,
+  $ as TEMPORAL_TEXT_DROPPED_CODE,
+  a0 as TEXT_INFERRED_CODE,
+  TYPE_COLUMN,
+  T2 as TextCellWriter,
+  a1 as UNKNOWN_ATTR_TYPE_CODE,
+  a2 as UNKNOWN_ELEMENT_CODE,
+  UNKNOWN_FORMAT_CODE,
+  a3 as UNKNOWN_PARENT_CODE,
+  a4 as UNKNOWN_TYPE_CODE,
+  a5 as WEIGHT_KEY_CLASH_CODE,
+  W2 as WIDENING_UNSUPPORTED_CODE,
+  a6 as XML_ILLEGAL_CHAR_CODE,
+  a7 as XML_SYNTAX_CODE,
+  X2 as XmlSyntaxError,
+  a15 as XmlTokenizer,
+  a8 as canonicalId,
+  a9 as capabilities,
+  aa as checkCapabilities,
+  checkExport,
+  c2 as childrenCsr,
+  a as childrenFromColumn,
+  ab as coerceId,
+  ac as coerceIdText,
+  ad as collectBytes,
+  createRegistry,
+  csvExporter,
+  csvImporter,
+  ae as declareCompanion,
+  af as declareResolved,
+  ag as decodeChunks,
+  d2 as dialectCapabilities,
+  dotExporter,
+  dotImporter,
+  ah as encodeChunks,
+  ai as explicitWeights,
+  exportGraph,
+  exportGraphToString,
+  extensionOf,
+  aj as formatDecimal,
+  ak as formatF32,
+  al as formatF64,
+  am as formatGmlReal,
+  an as formatInteger,
+  gexfExporter,
+  gexfImporter,
+  gmlExporter,
+  gmlImporter,
+  graphmlExporter,
+  graphmlImporter,
+  h2 as hasIllegalXmlChar,
+  headBytes,
+  importGraph,
+  i2 as inferTextDtype,
+  ao as inputLength,
+  ap as isAbortError,
+  aq as isCanonicalIntegerText,
+  ar as isImportInput,
+  as as isNmtoken,
+  a14 as isNumericText,
+  at as isWeightField,
+  au as joinText,
+  j2 as jsonCapabilities,
+  jsonExporter,
+  jsonImporter,
+  av as mangleNmtoken,
+  neo4jExporter,
+  neo4jImporter,
+  normalizeMimeType,
+  aw as pairFolding,
+  pajekExporter,
+  pajekImporter,
+  p2 as parseTextCell,
+  ax as parseWeightText,
+  rankFormats,
+  ay as readText,
+  registry,
+  az as reportSinkOptions,
+  aA as reportUnusedOptions,
+  aB as resolveExportOptions,
+  aC as resolveImportOptions,
+  aD as sanitizeIds,
+  sniff,
+  sniffFormat,
+  sniffJsonDialectHead,
+  t as textChunks,
+  throwIfAborted,
+  aE as toReadableStream,
+  t2 as tokenizeXml,
+  x2 as xmlIllegalTextNotes
+};
+//# sourceMappingURL=graph-io.js.map