@graphty/graph-io 0.3.25 → 0.3.27

package/dist/graph-io.js

@@ -1,41 +1,446 @@
-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 { INVALID_INDEX, GraphFormatError, GraphBuilder } from "@graphty/graph-format";
+import { GraphBuilder as GraphBuilder2, GraphFormatError as GraphFormatError2, INVALID_INDEX as INVALID_INDEX2 } from "@graphty/graph-format";
+import { al as resolveImportOptions, a8 as ImportReportBuilder, ao as reportSinkOptions, an as reportUnusedOptions, ar as IdCoercer, aq as DirectionResolver, az as LineReader, am as throwIfAborted, aL as parseWeightText, aM as isAbortError, aN as BAD_LINE_CODE, aO as messageOf, aP as describe, b as plural, aQ as UNKNOWN_OPTION_CODE, a7 as chooseGraph, aR as normalizeInput, aS as foreignKind, E as EMPTY_INPUT_CODE, aT as ImportError, aU as FETCH_CODE, $ as agree, aV as EDGES_MERGED_CODE, aW as SELF_LOOPS_DROPPED_CODE, O as OPTION_IGNORED_CODE, aX as WEIGHT_NOT_FOUND_CODE, aY as lockReader, aZ as abortable } from "./chunks/export-CHd4tQE2.js";
+import { ae, Y, V, B, a_, a3, at, a$, C, b0, A, b1, k, j, i, b2, b3, b4, D, d, o, b5, m, u, n, F, b6, v, x, b7, b8, aB, af, H, I, b9, J, G, ba, y, z, bb, a2, L, s, t, M, l, W, T, bc, bd, aA, be, bf, N, bg, bh, Q, ai, bi, P, aD, ay, au, K, R, bj, ag, S, Z, _, bk, f, ah, ak, bl, bm, bn, ad, aC, U, g, w, q, bo, h, bp, bq, aj, ax, X, aH, c, a, br, aI, bs, a1, bt, bu, e, bv, aF, aa, ab, bw, aG, ap, bx, by, bz, bA, aK, bB, p, bC, bD, r, aE, a4 } from "./chunks/export-CHd4tQE2.js";
+import { T as TextCellWriter } from "./chunks/text-DzXjAiTl.js";
+import { W as W2, i as i2, a as a5, p as p2 } from "./chunks/text-DzXjAiTl.js";
+import { C as C2, c as c2, a as a6 } from "./chunks/children-CL3Cy0ez.js";
+import { c as collectBytes } from "./chunks/writer-DxjgHwSe.js";
+import { D as D2, d as d2, e as e2, j as j2, t as t2 } from "./chunks/writer-DxjgHwSe.js";
 import { csvImporter, csvExporter } from "./csv.js";
 import { CSV_CAPABILITIES, CSV_ISSUE, CSV_LOSS } from "./csv.js";
-import { c as cxImporter } from "./chunks/importer-DET1tg6s.js";
-import { C as C3 } from "./chunks/importer-DET1tg6s.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 { d as cxImporter, c as cxExporter } from "./chunks/importer-CIAzt-wo.js";
+import { C as C3, a as a7, b } from "./chunks/importer-CIAzt-wo.js";
+import { c as cx2Exporter } from "./chunks/exporter-IHv4nkCm.js";
+import { C as C4, a as a8 } from "./chunks/exporter-IHv4nkCm.js";
+import { c as cx2Importer } from "./chunks/importer-BVRE--Un.js";
+import { C as C5 } from "./chunks/importer-BVRE--Un.js";
+import { d as cysImporter, c as cysExporter } from "./chunks/importer-BSALvkui.js";
+import { C as C6, a as a9, b as b10 } from "./chunks/importer-BSALvkui.js";
+import { b as dotImporter, d as dotExporter } from "./chunks/importer-B1wmPQjr.js";
+import { D as D3, a as a10 } from "./chunks/importer-B1wmPQjr.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-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-eUREhBGj.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-eUREhBGj.js";
+import { a as graphmlImporter, g as graphmlExporter } from "./chunks/importer-DpEW5zeG.js";
+import { r as rankFormats, S as SNIFF_HEAD_BYTES, e as jsonImporter, c as jsonExporter } from "./chunks/exporter-D23CKNqF.js";
+import { G as G2, J as J2, a as a11, b as b11, d as d3, g as g2, h as h2, j as j3, f as f2, n as n2, s as s2, i as i3 } from "./chunks/exporter-D23CKNqF.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-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";
+import { ID_SPACE_COLUMN, LABELS_COLUMN, NEO4J_CAPABILITIES, NEO4J_ISSUE, NEO4J_LOSS, ORIGINAL_ID_COLUMN, TYPE_COLUMN, exportNeo4jFiles } from "./neo4j.js";
+import { c as oboImporter, o as oboExporter } from "./chunks/exporter-DhtW6FxK.js";
+import { O, a as a12, b as b12 } from "./chunks/exporter-DhtW6FxK.js";
+import { b as pajekImporter, p as pajekExporter } from "./chunks/importer-z_FL4VMb.js";
+import { P as P2, a as a13 } from "./chunks/importer-z_FL4VMb.js";
+import { x as xgmmlExporter } from "./chunks/exporter-DfWTgrti.js";
+import { x as xgmmlImporter } from "./chunks/importer-B2W_58pz.js";
+import { X as X2, a as a14 } from "./chunks/importer-B2W_58pz.js";
+import { G as G3, a as a15 } from "./chunks/constants-ikG85dT8.js";
+import { X as X3, b as b13, h as h3, t as t3, x as x2 } from "./chunks/escape-D1HPTUrP.js";
+const USED = /* @__PURE__ */ new Set(["ids", "defaultDirected", "weightFrom", "addMissingNodes"]);
+function defineLineFormat(definition) {
+  const { format, extensions, mimeTypes = [], directed = false, comment = "#", sniff: sniff2, parseLine } = definition;
+  const importer = {
+    format,
+    extensions,
+    mimeTypes,
+    options: [],
+    import: async (input, sink, options) => {
+      const opts = resolveImportOptions(options, {
+        ids: "canonical",
+        defaultDirected: directed,
+        weightFrom: "weight"
+      });
+      const report = new ImportReportBuilder(format, opts.errorLimit);
+      reportSinkOptions(sink, options, report);
+      reportUnusedOptions(options, report, USED);
+      const ids = new IdCoercer(opts.ids);
+      const edges = new DirectionResolver(sink, report, opts.onMixedDirection);
+      const kind = opts.defaultDirected ? "directed" : "undirected";
+      edges.setHeader(opts.defaultDirected);
+      const attributes = new AttributeWriter(sink, report, opts.weightFrom);
+      const write = (domain, row, values) => {
+        attributes.write(domain, row, values);
+      };
+      const addNode = (id) => {
+        const nodeId = ids.text(id);
+        if (sink.indexOf(nodeId) === INVALID_INDEX) {
+          report.counts.nodes++;
+        }
+        return sink.addNode(nodeId);
+      };
+      let line = 0;
+      const graph = {
+        node: (id, attributes2) => {
+          write("node", addNode(id), attributes2);
+        },
+        edge: (source, target, attributes2) => {
+          const raw = opts.weightFrom === null ? void 0 : attributes2?.[opts.weightFrom];
+          const weight = raw === null || raw === void 0 ? void 0 : parseWeightText(String(raw), report);
+          const [s3, t4] = [ids.text(source), ids.text(target)];
+          const added = new Set([s3, t4].filter((id) => sink.indexOf(id) === INVALID_INDEX)).size;
+          const edge = edges.addEdge(s3, t4, kind, weight, { line });
+          report.counts.nodes += added;
+          report.counts.edges++;
+          write("edge", edge, attributes2);
+        }
+      };
+      const lines = new LineReader(input, report, opts);
+      for await (const text of lines) {
+        ({ line } = lines);
+        if (line % 64 === 0) {
+          throwIfAborted(opts.signal);
+        }
+        const trimmed = text.trim();
+        if (trimmed === "" || comment !== null && trimmed.startsWith(comment)) {
+          continue;
+        }
+        try {
+          parseLine(trimmed.split(/\s+/), graph, text);
+        } catch (err) {
+          recordLineError(report, err, line);
+        }
+      }
+      throwIfAborted(opts.signal);
+      return report.finish();
+    }
+  };
+  return Object.freeze(sniff2 === void 0 ? importer : { ...importer, sniff: sniff2 });
+}
+function recordLineError(report, err, line) {
+  if (isAbortError(err)) {
+    throw err;
+  }
+  if (err instanceof GraphFormatError) {
+    report.recordError(err, { line });
+  } else {
+    report.error("parse-error", BAD_LINE_CODE, err instanceof Error ? err.message : messageOf(err), { line });
+  }
+}
+class AttributeWriter {
+  /**
+   * Create a writer.
+   * @param sink - the sink
+   * @param report - the report
+   * @param weightFrom - the edge attribute read as the weight (not written as a column), or null
+   */
+  constructor(sink, report, weightFrom) {
+    this.sink = sink;
+    this.report = report;
+    this.weightFrom = weightFrom;
+    this.writers = { node: /* @__PURE__ */ new Map(), edge: /* @__PURE__ */ new Map() };
+  }
+  /**
+   * Write one element's attributes; null and undefined values are left unset.
+   * @param domain - node or edge
+   * @param row - the element's index
+   * @param attributes - the attributes, or undefined
+   */
+  write(domain, row, attributes) {
+    for (const [name, value] of Object.entries(attributes ?? {})) {
+      if (value === null || value === void 0 || domain === "edge" && name === this.weightFrom) {
+        continue;
+      }
+      if (name === "label") {
+        this.writeLabel(domain, row, String(value));
+        continue;
+      }
+      let writer = this.writers[domain].get(name);
+      if (writer === void 0) {
+        writer = new TextCellWriter(name, domain, this.sink, this.report);
+        this.writers[domain].set(name, writer);
+      }
+      writer.write(row, String(value));
+    }
+  }
+  /**
+   * Write a label: text, whatever it looks like, in the column that byRole("label") finds.
+   * @param domain - node or edge
+   * @param row - the element's index
+   * @param text - the label
+   */
+  writeLabel(domain, row, text) {
+    const decl = { name: "label", dtype: "string", role: "label" };
+    if (domain === "node") {
+      this.sink.setNodeValue(this.sink.declareNodeColumn(decl), row, text);
+    } else {
+      this.sink.setEdgeValue(this.sink.declareEdgeColumn(decl), row, text);
+    }
+  }
+}
+function compareSnapshots(expected, actual, options = {}) {
+  const diffs = [];
+  const limit = options.limit ?? 50;
+  const tolerance = options.tolerance ?? 0;
+  const ctx = {
+    options,
+    diff: (path, e3, a16, message) => {
+      diffs.push({
+        path,
+        expected: e3,
+        actual: a16,
+        message: message ?? `${path}: expected ${show(e3)}, got ${show(a16)}`
+      });
+      if (diffs.length >= limit) {
+        throw new LimitReached();
+      }
+    },
+    same: (e3, a16) => valuesEqual(e3, a16, tolerance)
+  };
+  try {
+    compareGraphs(expected, actual, ctx);
+  } catch (err) {
+    if (!(err instanceof LimitReached)) {
+      throw err;
+    }
+  }
+  return diffs;
+}
+class LimitReached extends Error {
+}
+function compareGraphs(expected, actual, ctx) {
+  const { diff } = ctx;
+  if (expected.directed !== actual.directed) {
+    diff("directed", expected.directed, actual.directed);
+  }
+  if (expected.nodeCount !== actual.nodeCount) {
+    diff("nodeCount", expected.nodeCount, actual.nodeCount);
+  }
+  if (expected.edgeCount !== actual.edgeCount) {
+    diff("edgeCount", expected.edgeCount, actual.edgeCount);
+  }
+  compareIds(expected, actual, diff);
+  if (expected.nodeCount !== actual.nodeCount || expected.edgeCount !== actual.edgeCount) {
+    return;
+  }
+  compareTopology(expected, actual, diff);
+  compareWeights(expected, actual, ctx);
+  compareTables("nodes", expected.nodes, actual.nodes, ctx);
+  compareTables("edges", expected.edges, actual.edges, ctx);
+  compareTables("graph", expected.graph, actual.graph, ctx);
+  if (ctx.options.extensions !== false) {
+    compareExtensions(expected, actual, ctx);
+  }
+}
+function compareIds(expected, actual, diff) {
+  const expectedIds = expected.ids.toArray();
+  const actualIds = actual.ids.toArray();
+  const n3 = Math.min(expectedIds.length, actualIds.length);
+  for (let i4 = 0; i4 < n3; i4++) {
+    if (!Object.is(expectedIds[i4], actualIds[i4])) {
+      diff(`ids[${i4}]`, expectedIds[i4], actualIds[i4]);
+    }
+  }
+}
+function compareTopology(expected, actual, diff) {
+  if (!typedEqual(expected.rowPtr, actual.rowPtr)) {
+    diff("rowPtr", expected.rowPtr, actual.rowPtr, "rowPtr differs");
+  }
+  if (!typedEqual(expected.colIdx, actual.colIdx)) {
+    diff("colIdx", expected.colIdx, actual.colIdx, "colIdx differs");
+  }
+  const el = expected.edgeList();
+  const al = actual.edgeList();
+  for (let e3 = 0; e3 < expected.edgeCount; e3++) {
+    if (el.src[e3] !== al.src[e3] || el.dst[e3] !== al.dst[e3]) {
+      diff(`edge[${e3}]`, `${el.src[e3]}->${el.dst[e3]}`, `${al.src[e3]}->${al.dst[e3]}`);
+    }
+  }
+}
+function compareWeights(expected, actual, ctx) {
+  if (expected.flags.weighted !== actual.flags.weighted) {
+    ctx.diff("flags.weighted", expected.flags.weighted, actual.flags.weighted);
+    return;
+  }
+  if (!expected.flags.weighted) {
+    return;
+  }
+  const eShadow = expected.edges.byRole("weight");
+  const aShadow = actual.edges.byRole("weight");
+  if (eShadow !== null && aShadow !== null) {
+    compareExactWeights(expected.edgeCount, eShadow, aShadow, ctx);
+    return;
+  }
+  if (ctx.options.weightExplicitness !== false && eShadow === null !== (aShadow === null)) {
+    ctx.diff(
+      "weightColumn",
+      eShadow !== null,
+      aShadow !== null,
+      "one snapshot has a role-weight column, the other does not"
+    );
+  }
+  const ew = expected.edgeList().weights;
+  const aw = actual.edgeList().weights;
+  for (let e3 = 0; e3 < expected.edgeCount; e3++) {
+    const ev = ew === null ? 1 : ew[e3];
+    const av = aw === null ? 1 : aw[e3];
+    if (!ctx.same(ev, av)) {
+      ctx.diff(`weight[${e3}]`, ev, av);
+    }
+  }
+}
+function compareExactWeights(edgeCount, expected, actual, ctx) {
+  for (let e3 = 0; e3 < edgeCount; e3++) {
+    const eSet = expected.isSet(e3);
+    const aSet = actual.isSet(e3);
+    if (ctx.options.weightExplicitness !== false && eSet !== aSet) {
+      ctx.diff(`weightExplicit[${e3}]`, eSet, aSet);
+    } else if (eSet && aSet && !ctx.same(expected.value(e3), actual.value(e3))) {
+      ctx.diff(`weight[${e3}]`, expected.value(e3), actual.value(e3));
+    }
+  }
+}
+function compareExtensions(expected, actual, ctx) {
+  for (const [name, table] of expected.extensions) {
+    const other = actual.extensions.get(name);
+    if (other === void 0) {
+      ctx.diff(`extensions.${name}`, "present", "absent");
+    } else if (table.rowCount === other.rowCount) {
+      compareTables(`extensions.${name}`, table, other, ctx);
+    } else {
+      ctx.diff(`extensions.${name}.rowCount`, table.rowCount, other.rowCount);
+    }
+  }
+  if (ctx.options.allowExtraColumns === false) {
+    for (const name of actual.extensions.keys()) {
+      if (!expected.extensions.has(name)) {
+        ctx.diff(`extensions.${name}`, "absent", "present");
+      }
+    }
+  }
+}
+function compareTables(label, expected, actual, ctx) {
+  const ignoreNames = new Set(ctx.options.ignoreColumns ?? []);
+  const ignoreRoles = new Set(ctx.options.ignoreRoles ?? []);
+  const skip = (column) => {
+    const { name, role } = column.meta;
+    return ignoreNames.has(name) || role !== null && (ignoreRoles.has(role) || label === "edges" && role === "weight");
+  };
+  for (const column of expected) {
+    if (skip(column)) {
+      continue;
+    }
+    const path = `${label}.${column.meta.name}`;
+    const other = actual.get(column.meta.name);
+    if (other === null) {
+      ctx.diff(path, "present", "absent", `${path}: column missing after round trip`);
+    } else {
+      compareColumn(path, column, other, ctx);
+    }
+  }
+  if (ctx.options.allowExtraColumns === false) {
+    for (const column of actual) {
+      if (!skip(column) && expected.get(column.meta.name) === null) {
+        const path = `${label}.${column.meta.name}`;
+        ctx.diff(path, "absent", "present", `${path}: extra column after round trip`);
+      }
+    }
+  }
+}
+function compareColumn(path, column, other, ctx) {
+  compareDeclaration(path, column, other, ctx);
+  if (column.length !== other.length) {
+    ctx.diff(`${path}.length`, column.length, other.length);
+    return;
+  }
+  for (let r2 = 0; r2 < column.length; r2++) {
+    const eSet = column.isSet(r2);
+    const aSet = other.isSet(r2);
+    if (eSet !== aSet) {
+      ctx.diff(`${path}[${r2}]`, eSet ? column.value(r2) : void 0, aSet ? other.value(r2) : void 0);
+    } else if (eSet) {
+      const ev = cellValue(column, r2);
+      const av = cellValue(other, r2);
+      if (!ctx.same(ev, av)) {
+        ctx.diff(`${path}[${r2}]`, ev, av);
+      }
+    }
+  }
+}
+function compareDeclaration(path, column, other, ctx) {
+  const { options, diff } = ctx;
+  const e3 = column.meta;
+  const a16 = other.meta;
+  if (options.dtypes !== false) {
+    for (const key of ["dtype", "itemDtype", "components"]) {
+      if (e3[key] !== a16[key]) {
+        diff(`${path}.${key}`, e3[key], a16[key]);
+      }
+    }
+  }
+  if (options.roles !== false && e3.role !== a16.role) {
+    diff(`${path}.role`, e3.role, a16.role);
+  }
+  const eType = e3.origin?.type ?? null;
+  const aType = a16.origin?.type ?? null;
+  if (options.originType === true && eType !== aType) {
+    diff(`${path}.origin.type`, eType, aType);
+  }
+}
+function cellValue(column, row) {
+  switch (column.dtype) {
+    case "list":
+      return [...column.sliceOf(row)];
+    case "json":
+      return column.values[row];
+    default: {
+      const value = column.value(row);
+      return ArrayBuffer.isView(value) ? Array.from(value) : value;
+    }
+  }
+}
+function valuesEqual(e3, a16, tolerance) {
+  if (typeof e3 === "number" && typeof a16 === "number") {
+    if (Object.is(e3, a16)) {
+      return true;
+    }
+    return Number.isFinite(e3) && Number.isFinite(a16) && Math.abs(e3 - a16) <= tolerance;
+  }
+  if (Array.isArray(e3) || ArrayBuffer.isView(e3)) {
+    const ea = Array.from(e3);
+    if (!(Array.isArray(a16) || ArrayBuffer.isView(a16))) {
+      return false;
+    }
+    const aa2 = Array.from(a16);
+    return ea.length === aa2.length && ea.every((v2, i4) => valuesEqual(v2, aa2[i4], tolerance));
+  }
+  if (typeof e3 === "object" && e3 !== null && typeof a16 === "object" && a16 !== null) {
+    const eo = e3;
+    const ao = a16;
+    const keys = Object.keys(eo);
+    if (keys.length !== Object.keys(ao).length) {
+      return false;
+    }
+    return keys.every((k2) => Object.hasOwn(ao, k2) && valuesEqual(eo[k2], ao[k2], tolerance));
+  }
+  return Object.is(e3, a16);
+}
+function typedEqual(a16, b14) {
+  if (a16.length !== b14.length) {
+    return false;
+  }
+  for (let i4 = 0; i4 < a16.length; i4++) {
+    if (a16[i4] !== b14[i4]) {
+      return false;
+    }
+  }
+  return true;
+}
+function show(v2) {
+  if (ArrayBuffer.isView(v2)) {
+    const items = Array.from(v2);
+    return `[${items.slice(0, 8).join(", ")}${items.length > 8 ? ", ..." : ""}]`;
+  }
+  try {
+    const text = JSON.stringify(v2);
+    return text ?? String(v2);
+  } catch {
+    return String(v2);
+  }
+}
+function describeDiffs(diffs) {
+  return diffs.length === 0 ? "no differences" : diffs.map((d4) => `  - ${d4.message}`).join("\n");
+}
 const TOO_MANY_EMPTY_CELLS_CODE = "E_TOO_MANY_EMPTY_CELLS";
 const DEFAULT_MAX_EMPTY_CELLS = 2 ** 24;
 function maxEmptyCellsOption(value) {
@@ -152,7 +557,7 @@ class CellBudgetBuilder extends GraphBuilder {
     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`,
+        `the attributes are too sparse: ${this.nodeColumns.size} node and ${this.edgeColumns.size} edge attribute columns over ${this.nodeBound} node${plural(this.nodeBound)} and ${this.edgeBound} edge${plural(this.edgeBound)} 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 }
       );
@@ -160,6 +565,35 @@ class CellBudgetBuilder extends GraphBuilder {
   }
 }
 const UNKNOWN_FORMAT_CODE = "E_UNKNOWN_FORMAT";
+const SNIFF_FAILED_CODE = "W_SNIFF_FAILED";
+const FUNCTION_OPTIONS = /* @__PURE__ */ new Set([
+  "addMissingNodes",
+  "builder",
+  "defaultDirected",
+  "duplicateEdges",
+  "encoding",
+  "errorLimit",
+  "filename",
+  "format",
+  "freeze",
+  "graphIndex",
+  "graphName",
+  "hyperedges",
+  "ids",
+  "long",
+  "maxEmptyCells",
+  "mimeType",
+  "nodeIdFrom",
+  "onMixedDirection",
+  "onProgress",
+  "request",
+  "restoreMangledIds",
+  "sanitizeIds",
+  "selfLoops",
+  "signal",
+  "weightDtype",
+  "weightFrom"
+]);
 const REGISTRY_KEYS = /* @__PURE__ */ new Set([
   "format",
   "filename",
@@ -254,10 +688,10 @@ class FormatRegistry {
     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
+   * Every format that could be the input, best first, from the same hints as sniff(): use it to
+   * offer the user a choice when the best guess is not certain.
+   * @param hints - `{ filename, mimeType, head }`, any of them
+   * @returns the candidates, best first; empty when no format claims the input
    */
   sniffAll(hints) {
     return rankFormats(hints, this.importerMap.values());
@@ -272,39 +706,112 @@ class FormatRegistry {
     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.
-   * An input holding several graphs yields the first, with a warning naming how many were
-   * skipped; importAllGraphs() returns every one.
+   * Read a graph from a string, bytes or a stream. The format is the one you name in `format`,
+   * else it is detected from `filename`, `mimeType` and the first bytes of the content. From an
+   * input that holds several graphs, it reads the one `graphIndex` or `graphName` chooses, else
+   * the first, with a W_MULTIPLE_GRAPHS warning; importAllGraphs() returns every one.
    * @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
+   * @returns the graph (`snapshot`), the format it was read as, and the import report
    */
   async importGraph(input, options = {}) {
-    const chosen = await this.choose(input, options);
-    const builder = seededBuilder(options, chosen.importer.format);
+    const opts = options;
+    const picked = await this.choose(input, opts);
+    const unknown = this.unknownOptions(opts).map(
+      (name) => Object.freeze({
+        category: "unsupported",
+        severity: "warning",
+        code: UNKNOWN_OPTION_CODE,
+        message: unknownOptionText(name),
+        line: null,
+        element: name
+      })
+    );
+    const chosen = unknown.length === 0 ? picked : { ...picked, warnings: [...picked.warnings, ...unknown] };
+    const { importer } = chosen;
+    if ((opts.graphIndex !== void 0 || opts.graphName !== void 0) && importer.importAll !== void 0 && importer.listGraphs === void 0) {
+      const all = await this.readAll(chosen, opts);
+      const names = all.map((r2) => r2.snapshot.meta.name);
+      return all[chooseGraph(names, opts, new ImportReportBuilder(importer.format, 0))];
+    }
+    let builder;
     let report;
     try {
-      report = await chosen.importer.import(chosen.source, builder, importerOptions(options));
+      builder = seededBuilder(opts, chosen.importer.format);
+      report = await chosen.importer.import(chosen.source, builder, importerOptions(opts));
     } catch (err) {
       await chosen.peeked?.close();
-      throw err;
+      throw chosen.sniff === null ? notReadableAs(err, importer.format, opts.filename) : err;
+    }
+    return result(chosen, builder, report, opts);
+  }
+  /**
+   * Fetch a graph file from a URL and load it; see the top-level loadFromUrl() for the full
+   * description.
+   * @param url - an absolute URL, or in a browser one relative to the page
+   * @param options - import options, plus `request` for fetch
+   * @returns the graph, the format it was read as, and the import report
+   */
+  async loadFromUrl(url, options = {}) {
+    const opts = options;
+    const { request, ...rest } = opts;
+    const signal = request?.signal ?? rest.signal ?? null;
+    const method = request?.method ?? "GET";
+    const where = `${method} ${String(url)}`;
+    let response;
+    try {
+      response = await fetch(url, { signal: rest.signal, ...request });
+    } catch (err) {
+      if (signal?.aborted === true || isAbortError(err)) {
+        throw err;
+      }
+      return fetchFailed(rest, url, `${where} failed: ${fetchErrorText(url, err)}`, null, err);
+    }
+    if (!response.ok) {
+      await response.body?.cancel().catch(() => void 0);
+      const status = `${String(response.status)} ${response.statusText}`.trim();
+      return fetchFailed(rest, url, `${where} failed: ${status}`, response.status, null);
     }
-    return result(chosen, builder, report, options);
+    return this.importGraph(response.body ?? new Uint8Array(0), {
+      ...rest,
+      filename: rest.filename ?? urlFilename(url),
+      mimeType: rest.mimeType ?? response.headers.get("content-type")
+    });
+  }
+  /**
+   * Load a graph from a File or Blob; see the top-level loadFromFile() for the full description.
+   * @param file - the File or Blob to read
+   * @param options - the same options as importGraph()
+   * @returns the graph, the format it was read as, and the import report
+   */
+  loadFromFile(file, options = {}) {
+    const opts = options;
+    const { name } = file;
+    return this.importGraph(file.stream(), {
+      ...opts,
+      filename: opts.filename ?? (typeof name === "string" ? name : null),
+      mimeType: opts.mimeType ?? (file.type === "" ? null : file.type)
+    });
   }
   /**
    * Read every graph of an input (a DOT file with several graphs, a Pajek project with several
-   * networks, a JGF document with a `graphs` array), each into its own fresh builder, frozen.
-   * A format whose importer has no importAll() holds one graph per input, so the result has one
-   * entry. Options, sniffing and the builder seed are those of importGraph().
+   * networks, a JGF document with a `graphs` array), each as its own snapshot. A format that holds
+   * one graph per file gives one result. Options and detection are those of importGraph().
    * @param input - the text, bytes, stream or chunks to read
    * @param options - the format, hints, common and format-specific import options
    * @returns one result per graph, in document order
    */
   async importAllGraphs(input, options = {}) {
-    const chosen = await this.choose(input, options);
+    const opts = options;
+    return this.readAll(await this.choose(input, opts), opts);
+  }
+  /**
+   * Read every graph of an input with the chosen importer.
+   * @param chosen - the importer and the input to hand it
+   * @param options - the importGraph options
+   * @returns one result per graph, in document order
+   */
+  async readAll(chosen, options) {
     const { importer } = chosen;
     const builders = [];
     let reports;
@@ -325,9 +832,18 @@ class FormatRegistry {
       }
     } catch (err) {
       await chosen.peeked?.close();
-      throw err;
+      throw inGraph(
+        chosen.sniff === null ? notReadableAs(err, importer.format, options.filename) : err,
+        builders.length - 1
+      );
     }
-    return reports.map((report, i5) => result(chosen, builders[i5], report, options));
+    return reports.map((report, i4) => {
+      try {
+        return result(chosen, builders[i4], report, options);
+      } catch (err) {
+        throw inGraph(err, i4);
+      }
+    });
   }
   /**
    * The graphs of an input that can hold several, without importing them (a Cytoscape session's
@@ -339,39 +855,84 @@ class FormatRegistry {
    * list its graphs (importGraph() then reads the first)
    */
   async listGraphs(input, options = {}) {
-    const chosen = await this.choose(input, options);
+    const opts = options;
+    const chosen = await this.choose(input, opts);
     try {
-      return chosen.importer.listGraphs === void 0 ? null : await chosen.importer.listGraphs(chosen.source, importerOptions(options));
+      return chosen.importer.listGraphs === void 0 ? null : await chosen.importer.listGraphs(chosen.source, importerOptions(opts));
     } finally {
       await chosen.peeked?.close();
     }
   }
   /**
    * The importer for an input: the named format, or the sniffed one.
-   * @param input - the input
+   * @param rawInput - the input as the caller passed it
    * @param options - the importGraph options
    * @returns the importer, the sniff, and the input to read (replayed for a stream)
    */
-  async choose(input, options) {
+  async choose(rawInput, options) {
+    const input = normalizeInput(rawInput);
     const requested = options.format ?? "auto";
     if (requested !== "auto") {
-      return { importer: this.importer(requested), sniff: null, source: input, peeked: null };
-    }
-    const peeked = await peekHead(input, SNIFF_HEAD_BYTES, options.signal ?? null);
-    const sniff2 = this.sniff({ filename: options.filename, mimeType: options.mimeType, head: peeked.head });
-    if (sniff2 === null) {
-      const report = new ImportReportBuilder("unknown", 0);
-      return report.fail(
-        UNKNOWN_FORMAT_CODE,
-        `no registered importer recognises the input${describeHints(options)}; pass the format explicitly`,
-        void 0,
-        { formats: this.formats() }
+      return { importer: this.importer(requested), sniff: null, source: input, peeked: null, warnings: [] };
+    }
+    const common = resolveImportOptions(options, { ids: "keep", defaultDirected: true, weightFrom: null });
+    maxEmptyCellsOption(options.maxEmptyCells);
+    const peeked = await peekHead(input, SNIFF_HEAD_BYTES, common.signal);
+    const head = common.encoding !== null && peeked.head instanceof Uint8Array ? new TextDecoder(common.encoding).decode(peeked.head, { stream: true }) : peeked.head;
+    let sniff2;
+    const failures = new ImportReportBuilder("unknown", 0);
+    const warnings = [];
+    try {
+      const hints = { filename: options.filename, mimeType: options.mimeType, head };
+      const ranked = rankFormats(hints, this.importerMap.values(), (format, err) => {
+        warnings.push(
+          failures.warning(
+            "unsupported",
+            SNIFF_FAILED_CODE,
+            `the ${format} importer's sniff() threw (${messageOf(err)}); it was treated as not recognizing the input`,
+            { element: format }
+          )
+        );
+      });
+      sniff2 = ranked.length > 0 ? ranked[0] : null;
+    } catch (err) {
+      await peeked.close();
+      throw err;
+    }
+    const foreign = foreignKind(peeked.head);
+    const claimed = sniff2 !== null && sniff2.content > 0 && !(foreign?.startsWith("an HTML") ?? false);
+    if (sniff2 === null || foreign !== null && !claimed) {
+      await peeked.close();
+      return this.refuseUndetected(failures, head, foreign, options);
+    }
+    return { importer: this.importer(sniff2.format), sniff: sniff2, source: peeked.input, peeked, warnings };
+  }
+  /**
+   * Refuse an input no importer recognizes: empty, or not in a known graph format.
+   * @param failures - the report the error is recorded in
+   * @param head - the head, as sniffed
+   * @param foreign - what known non-graph file the head is, or null
+   * @param options - the importGraph options
+   * @returns never: always throws
+   */
+  refuseUndetected(failures, head, foreign, options) {
+    const text = typeof head === "string" ? head : new TextDecoder().decode(head ?? new Uint8Array(0));
+    if (text.trim() === "" && text.length < SNIFF_HEAD_BYTES) {
+      return failures.fail(
+        EMPTY_INPUT_CODE,
+        text === "" ? "the input is empty" : "the input holds only whitespace"
       );
     }
-    return { importer: this.importer(sniff2.format), sniff: sniff2, source: peeked.input, peeked };
+    const what = foreign === null ? "" : `: it is ${foreign}`;
+    return failures.fail(
+      UNKNOWN_FORMAT_CODE,
+      `the input is not in a graph format graph-io recognizes${describeHints(options)}${what}; if you know its format, pass it as the format option`,
+      void 0,
+      { formats: this.formats() }
+    );
   }
   /**
-   * Write a snapshot in a format, as UTF-8 chunks (design section 8.5).
+   * Write a snapshot in a format, as UTF-8 chunks.
    * @param snapshot - the snapshot
    * @param format - the format name
    * @param options - the exporter's common and format-specific options
@@ -390,6 +951,33 @@ class FormatRegistry {
   async exportGraphToString(snapshot, format, options) {
     return this.exporter(format).exportToString(snapshot, options);
   }
+  /**
+   * Write a snapshot in a format as one buffer of UTF-8 bytes; see the top-level
+   * exportGraphToBytes().
+   * @param snapshot - the graph to write
+   * @param format - a format name where `canExport` is true
+   * @param options - sanitizeIds, onMixedDirection and the format's own options
+   * @returns the encoded file
+   */
+  exportGraphToBytes(snapshot, format, options) {
+    return collectBytes(this.exportGraph(snapshot, format, options));
+  }
+  /**
+   * Write a snapshot in a format as a Blob typed with the format's first MIME type; see the
+   * top-level exportGraphToBlob().
+   * @param snapshot - the graph to write
+   * @param format - a format name where `canExport` is true
+   * @param options - sanitizeIds, onMixedDirection and the format's own options
+   * @returns the file as a Blob
+   */
+  async exportGraphToBlob(snapshot, format, options) {
+    const parts = [];
+    for await (const chunk of this.exportGraph(snapshot, format, options)) {
+      parts.push(chunk);
+    }
+    const info = this.listFormats().find((f3) => f3.format === format);
+    return new Blob(parts, { type: info?.mimeTypes[0] ?? "application/octet-stream" });
+  }
   /**
    * What exporting a snapshot in a format would lose, without writing anything.
    * @param snapshot - the snapshot
@@ -398,13 +986,96 @@ class FormatRegistry {
    * @returns the loss notes, empty when the export is exact
    */
   checkExport(snapshot, format, options) {
-    return this.exporter(format).check(snapshot, options);
+    const notes = this.exporter(format).check(snapshot, options);
+    const unknown = this.unknownOptions(options);
+    if (unknown.length === 0) {
+      return notes;
+    }
+    return Object.freeze([
+      ...notes,
+      ...unknown.map(
+        (name) => Object.freeze({
+          code: UNKNOWN_OPTION_CODE,
+          message: unknownOptionText(name),
+          column: null,
+          count: null
+        })
+      )
+    ]);
+  }
+  /**
+   * The option names no registered format and no load or save function takes (misspellings), or none while a
+   * registered format does not list its options.
+   * @param options - the caller's options
+   * @returns the unknown names
+   */
+  unknownOptions(options) {
+    if (options === null || options === void 0) {
+      return [];
+    }
+    const known = new Set(FUNCTION_OPTIONS);
+    for (const plugin of [...this.importerMap.values(), ...this.exporterMap.values()]) {
+      if (plugin.options === void 0) {
+        return [];
+      }
+      for (const name of plugin.options) {
+        known.add(name);
+      }
+    }
+    return Object.entries(options).filter(([name, value]) => value !== void 0 && !known.has(name)).map(([name]) => name);
+  }
+  /**
+   * Browser only: write a graph in a format and have the browser save it as a file; see the
+   * top-level downloadGraph(). Use this method on a registry from createRegistry() to download
+   * without bundling every built-in format.
+   * @param snapshot - the graph to write
+   * @param format - a format name from listFormats() where `canExport` is true
+   * @param options - the export options, plus `filename`
+   * @returns resolves once the download has been handed to the browser
+   */
+  async downloadGraph(snapshot, format, options = {}) {
+    if (typeof document === "undefined") {
+      throw new GraphFormatError(
+        "E_UNSUPPORTED",
+        "downloadGraph() needs a browser document; use exportGraphToBytes() and write the bytes yourself"
+      );
+    }
+    const { filename, ...rest } = options;
+    const blob = await this.exportGraphToBlob(snapshot, format, rest);
+    const extension = this.listFormats().find((f3) => f3.format === format)?.extensions[0] ?? `.${format}`;
+    const href = URL.createObjectURL(blob);
+    const anchor = document.createElement("a");
+    anchor.href = href;
+    anchor.download = filename ?? `graph${extension}`;
+    anchor.click();
+    setTimeout(() => {
+      URL.revokeObjectURL(href);
+    }, 0);
+  }
+  /**
+   * Every format this registry can read or write, in registration order; see the top-level
+   * listFormats().
+   * @returns one entry per format
+   */
+  listFormats() {
+    return this.formats().map((format) => {
+      const importer = this.importerMap.get(format);
+      const exporter = this.exporterMap.get(format);
+      return Object.freeze({
+        format,
+        extensions: importer?.extensions ?? exporter?.extensions ?? [],
+        mimeTypes: importer?.mimeTypes ?? exporter?.mimeTypes ?? [],
+        canImport: importer !== void 0,
+        canExport: exporter !== void 0,
+        capabilities: exporter?.capabilities ?? null
+      });
+    });
   }
 }
 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(xgmmlImporter).registerExporter(xgmmlExporter).registerImporter(cx2Importer).registerExporter(cx2Exporter).registerImporter(cxImporter).registerImporter(oboImporter).registerImporter(cysImporter);
+  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).registerExporter(cxExporter).registerImporter(oboImporter).registerExporter(oboExporter).registerImporter(cysImporter).registerExporter(cysExporter);
 }
-const registry = createRegistry();
+const registry = /* @__PURE__ */ createRegistry();
 function importGraph(input, options) {
   return registry.importGraph(input, options);
 }
@@ -423,9 +1094,59 @@ async function exportGraphToString(snapshot, format, options) {
 function checkExport(snapshot, format, options) {
   return registry.checkExport(snapshot, format, options);
 }
+function loadFromUrl(url, options) {
+  return registry.loadFromUrl(url, options);
+}
+function loadFromFile(file, options) {
+  return registry.loadFromFile(file, options);
+}
+function exportGraphToBytes(snapshot, format, options) {
+  return registry.exportGraphToBytes(snapshot, format, options);
+}
+function exportGraphToBlob(snapshot, format, options) {
+  return registry.exportGraphToBlob(snapshot, format, options);
+}
+async function downloadGraph(snapshot, format, options = {}) {
+  return registry.downloadGraph(snapshot, format, options);
+}
+function listFormats() {
+  return registry.listFormats();
+}
 function sniff(hints) {
   return registry.sniff(hints);
 }
+function fetchFailed(options, url, message, status, cause) {
+  const format = options.format === void 0 || options.format === "auto" ? "unknown" : options.format;
+  return new ImportReportBuilder(format, 0).fail(FETCH_CODE, message, void 0, { url: String(url), status, cause });
+}
+function notReadableAs(err, format, filename) {
+  if (!(err instanceof ImportError) || err.issue?.category !== "parse-error" || err.report.errorCount > 1 || err.report.counts.nodes + err.report.counts.edges > 0) {
+    return err;
+  }
+  const what = filename === void 0 || filename === null ? "the input" : JSON.stringify(filename);
+  return new ImportError(`${what} could not be read as ${format}: ${err.message}`, err.report, err.details);
+}
+function fetchErrorText(url, err) {
+  let absolute = null;
+  try {
+    absolute = new URL(url);
+  } catch {
+  }
+  if (absolute === null && globalThis.location === void 0) {
+    return "a relative URL needs a web page to resolve against; outside a browser pass an absolute http(s) URL, or read a local file with loadFromFile() or importGraph()";
+  }
+  if (absolute?.protocol === "file:") {
+    return "fetch() cannot read file: URLs here; read a local file with loadFromFile() or importGraph()";
+  }
+  const cause = err?.cause?.message;
+  const detail = typeof cause === "string" && cause !== "" ? ` (${cause})` : "";
+  return `the server could not be reached, or (in a browser) it does not allow this page to read the file (CORS)${detail}`;
+}
+function urlFilename(url) {
+  const path = new URL(url, "http://localhost/").pathname;
+  const name = path.slice(path.lastIndexOf("/") + 1);
+  return name === "" ? null : name;
+}
 function importerOptions(options) {
   const out = {};
   for (const [key, value] of Object.entries(options)) {
@@ -437,6 +1158,21 @@ function importerOptions(options) {
 }
 function seededBuilder(options, format) {
   const maxEmptyCells = maxEmptyCellsOption(options.maxEmptyCells);
+  try {
+    return newBuilder(options, format, maxEmptyCells);
+  } catch (err) {
+    if (err instanceof GraphFormatError && err.code === "E_UNSUPPORTED" && typeof err.details.field === "string") {
+      const option = err.details.field;
+      throw new GraphFormatError(
+        "E_UNSUPPORTED",
+        `option ${option}: ${JSON.stringify(err.details.found)} is not one of the values it takes`,
+        { option, found: err.details.found }
+      );
+    }
+    throw err;
+  }
+}
+function newBuilder(options, format, maxEmptyCells) {
   return new CellBudgetBuilder(
     {
       weightDtype: options.weightDtype ?? "f64",
@@ -450,16 +1186,108 @@ function seededBuilder(options, format) {
     maxEmptyCells
   );
 }
+function inGraph(err, index) {
+  if (!(err instanceof ImportError) || index < 0) {
+    return err;
+  }
+  return new ImportError(`graph ${index}: ${err.message}`, err.report, { ...err.details, graphIndex: index });
+}
 function result(chosen, builder, report, options) {
-  const frozen = builder.freezeWithReport(options.freeze);
-  return Object.freeze({
+  let frozen;
+  try {
+    frozen = builder.freezeWithReport(options.freeze);
+  } catch (err) {
+    throw freezeFailure(err, report);
+  }
+  const { warnings } = chosen;
+  const result2 = {
     format: chosen.importer.format,
     sniff: chosen.sniff,
     snapshot: frozen.snapshot,
-    report,
-    freeze: frozen.report
+    report: withFreezeWarnings(
+      weightNotFound(
+        warnings.length === 0 ? report : Object.freeze({
+          ...report,
+          issues: Object.freeze([...warnings, ...report.issues]),
+          warningCount: report.warningCount + warnings.length
+        }),
+        frozen.snapshot,
+        options.weightFrom
+      ),
+      frozen.report
+    )
+  };
+  Object.defineProperty(result2, "freeze", { value: frozen.report, enumerable: false });
+  return Object.freeze(result2);
+}
+function unknownOptionText(name) {
+  return `option ${JSON.stringify(name)} is not an option of any format or of the load and save functions, so it has no effect; check its spelling`;
+}
+function weightNotFound(report, snapshot, weightFrom) {
+  if (typeof weightFrom !== "string" || snapshot.edgeCount === 0 || snapshot.edgeList().weights !== null || report.issues.some((i4) => i4.code === OPTION_IGNORED_CODE && i4.element === "weightFrom")) {
+    return report;
+  }
+  const issue = Object.freeze({
+    category: "missing-value",
+    severity: "warning",
+    code: WEIGHT_NOT_FOUND_CODE,
+    message: `weightFrom: ${JSON.stringify(weightFrom)} names no attribute an edge has a value for, so the graph has no weights`,
+    line: null,
+    element: "weightFrom"
+  });
+  return Object.freeze({
+    ...report,
+    issues: Object.freeze([...report.issues, issue]),
+    warningCount: report.warningCount + 1
   });
 }
+function withFreezeWarnings(report, freeze) {
+  const added = [];
+  const warn = (category, code, message) => {
+    added.push(Object.freeze({ category, severity: "warning", code, message, line: null, element: null }));
+  };
+  if (freeze.mergedEdges > 0) {
+    warn(
+      "merged",
+      EDGES_MERGED_CODE,
+      `${freeze.mergedEdges} parallel edge${plural(freeze.mergedEdges)} ${agree(freeze.mergedEdges, "was", "were")} merged into one edge per pair by the duplicateEdges policy; whatever told them apart (a relation, a label) is lost`
+    );
+  }
+  if (freeze.droppedSelfLoops > 0) {
+    warn(
+      "validation-error",
+      SELF_LOOPS_DROPPED_CODE,
+      `${freeze.droppedSelfLoops} self-loop${plural(freeze.droppedSelfLoops)} ${agree(freeze.droppedSelfLoops, "was", "were")} removed by selfLoops: "drop"`
+    );
+  }
+  if (added.length === 0) {
+    return report;
+  }
+  return Object.freeze({
+    ...report,
+    issues: Object.freeze([...report.issues, ...added]),
+    warningCount: report.warningCount + added.length
+  });
+}
+function freezeFailure(err, report) {
+  if (!(err instanceof GraphFormatError) || err instanceof ImportError) {
+    return err;
+  }
+  const issue = Object.freeze({
+    category: "validation-error",
+    severity: "error",
+    code: err.code,
+    message: err.message,
+    line: null,
+    element: null
+  });
+  const failed = Object.freeze({
+    ...report,
+    issues: Object.freeze([...report.issues, issue]),
+    errorCount: report.errorCount + 1
+  });
+  return new ImportError(`the graph cannot be frozen: ${err.message}`, failed, { code: err.code, ...err.details });
+}
 function unknownFormat(kind, format, known) {
   const supported = [...known];
   return new GraphFormatError(
@@ -486,7 +1314,7 @@ async function peekHead(input, bytes, signal) {
     return { head: input.subarray(0, bytes), input, close: () => Promise.resolve() };
   }
   throwIfAborted(signal);
-  const source = typeof input.getReader === "function" ? readerIterator(input) : input[Symbol.asyncIterator]();
+  const source = typeof input.getReader === "function" ? readerIterator(input, signal) : input[Symbol.asyncIterator]();
   const buffered = [];
   let size = 0;
   let finished = false;
@@ -511,10 +1339,10 @@ async function peekHead(input, bytes, signal) {
   return { head: joinHead(buffered, bytes), input: replayed, close: () => replayed.close() };
 }
 function joinHead(chunks, bytes) {
-  if (chunks.every((c6) => c6 instanceof Uint8Array)) {
+  if (chunks.every((c3) => c3 instanceof Uint8Array)) {
     const total = Math.min(
       bytes,
-      chunks.reduce((sum, c6) => sum + c6.byteLength, 0)
+      chunks.reduce((sum, c3) => sum + c3.byteLength, 0)
     );
     const head = new Uint8Array(total);
     let offset = 0;
@@ -573,15 +1401,23 @@ function replay(buffered, source, finished) {
     }
   };
 }
-function readerIterator(stream) {
-  const reader = stream.getReader();
+function readerIterator(stream, signal) {
+  const reader = lockReader(stream);
   let done = false;
   return {
     async next() {
       if (done) {
         return { done: true, value: void 0 };
       }
-      const result2 = await reader.read();
+      let result2;
+      try {
+        result2 = await abortable(reader.read(), signal);
+      } catch (err) {
+        done = true;
+        await reader.cancel(signal?.reason).catch(() => void 0);
+        reader.releaseLock();
+        throw err;
+      }
       if (result2.done) {
         done = true;
         reader.releaseLock();
@@ -592,7 +1428,7 @@ function readerIterator(stream) {
     async return() {
       if (!done) {
         done = true;
-        await reader.cancel().catch(() => void 0);
+        await reader.cancel(signal?.reason).catch(() => void 0);
         reader.releaseLock();
       }
       return { done: true, value: void 0 };
@@ -600,204 +1436,260 @@ function readerIterator(stream) {
   };
 }
 export {
-  A as AMBIGUOUS_GRAPH_NAME_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,
+  ae as AMBIGUOUS_GRAPH_NAME_CODE,
+  Y as ASPECT_ORDER_CODE,
+  V as BAD_ASPECT_BLOCK_CODE,
+  B as BAD_DEFAULT_CODE,
+  BAD_LINE_CODE,
+  a_ as BAD_OPTIONS_CODE,
+  a3 as BAD_VALUE_CODE,
+  at as COLUMN_AS_PROPERTY_VALUE_CODE,
+  a$ as COLUMN_DROPPED_CODE,
   C as COLUMN_RENAMED_CODE,
-  a5 as COLUMN_RENAMED_LOSS_CODE,
-  ai as COUNT_HINT_CODE,
-  l as COUNT_MISMATCH_CODE,
+  b0 as COLUMN_RENAMED_LOSS_CODE,
+  A as COLUMN_TYPE_CODE,
+  b1 as CONTROL_CHARACTER_CODE,
+  k as COUNT_HINT_CODE,
+  j 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,
+  a8 as CX2_LOSS,
+  C3 as CX_CAPABILITIES,
+  a7 as CX_ISSUE,
+  b as CX_LOSS,
+  C6 as CYS_CAPABILITIES,
+  a9 as CYS_ISSUE,
+  b10 as CYS_LOSS,
   C2 as ChildrenCsr,
-  j as DANGLING_REFERENCE_CODE,
-  D3 as DEFAULT_CHUNK_BYTES,
-  aj as DEFAULT_ERROR_LIMIT,
-  ak as DIRECTED_COLUMN,
+  i as DANGLING_REFERENCE_CODE,
+  D2 as DEFAULT_CHUNK_BYTES,
+  b2 as DEFAULT_ERROR_LIMIT,
+  b3 as DIRECTED_COLUMN,
+  b4 as DIRECTION_DROPPED_CODE,
   D as DIRECTION_FORCED_CODE,
-  a as DIRECTION_REFUSED_CODE,
-  D2 as DOT_ISSUE,
-  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,
+  d as DIRECTION_REFUSED_CODE,
+  D3 as DOT_ISSUE,
+  a10 as DOT_LOSS,
+  o as DUPLICATE_ATTRIBUTE_CODE,
+  b5 as DUPLICATE_EDGE_CODE,
+  m as DUPLICATE_EDGE_ID_CODE,
+  u as DUPLICATE_KEY_CODE,
+  n as DUPLICATE_NODE_CODE,
+  DirectionResolver,
+  EDGES_MERGED_CODE,
+  F as ELEMENT_ISSUE,
+  b6 as EMPTY_COLUMN_DROPPED_CODE,
+  EMPTY_INPUT_CODE,
+  v as ENCODING_CONFLICT_CODE,
+  x as ENCODING_FALLBACK_CODE,
+  b7 as EQUATION_AS_TEXT_CODE,
+  FETCH_CODE,
+  b8 as FOREIGN_FORMAT_CODE,
   FormatRegistry,
   GEXF_1_2_CAPABILITIES,
   GEXF_ISSUE,
   GEXF_LOSS,
   GML_ISSUE,
   GML_LOSS,
-  G2 as GRAPHML_ISSUE,
-  a13 as GRAPHML_LOSS,
-  G3 as GRAPH_FORMATS,
-  G as GRAPH_NOT_FOUND_CODE,
-  an as HYPEREDGE_CODE,
+  G3 as GRAPHML_ISSUE,
+  a15 as GRAPHML_LOSS,
+  aB as GRAPH_COLUMN_AS_METADATA_CODE,
+  G2 as GRAPH_FORMATS,
+  af as GRAPH_NOT_FOUND_CODE,
+  GraphBuilder2 as GraphBuilder,
+  GraphFormatError2 as GraphFormatError,
+  H as HYPEREDGE_CODE,
   I as ID_MERGED_CODE,
   ID_SPACE_COLUMN,
-  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,
+  b9 as ID_TEXT_COLLISION_CODE,
+  J as ID_TEXT_TYPE_CODE,
+  G as INPUT_ISSUE,
+  ba as INTEGRAL_F64_CODE,
+  y as INVALID_ENCODING_CODE,
+  INVALID_INDEX2 as INVALID_INDEX,
+  z as INVALID_UTF8_CODE,
+  bb as ISSUES_SUPPRESSED_CODE,
+  IdCoercer,
+  ImportError,
   ImportReportBuilder,
   J2 as JSON_DIALECTS,
-  a14 as JSON_ISSUE,
-  b2 as JSON_LOSS,
+  a11 as JSON_ISSUE,
+  b11 as JSON_LOSS,
+  a2 as JSON_NONSTANDARD_NUMBER_CODE,
   LABELS_COLUMN,
-  L2 as LOSS,
-  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,
+  L as LOSS,
+  LineReader,
+  s as MISSING_ENDPOINT_CODE,
+  t as MISSING_ID_CODE,
+  M as MIXED_DIRECTION_CODE,
+  l as MULTIPLE_GRAPHS_CODE,
+  W as MULTI_ASPECT_FRAGMENT_CODE,
+  T as MUTUAL_AS_UNDIRECTED_CODE,
+  bc as MUTUAL_COLUMN,
+  bd as MUTUAL_EXPANDED_CODE,
   NEO4J_CAPABILITIES,
   NEO4J_ISSUE,
   NEO4J_LOSS,
-  N2 as NO_CAPABILITIES,
+  aA as NODE_ORDER_CODE,
+  be as NONFINITE_AS_NULL_CODE,
+  bf as NO_CAPABILITIES,
   N as NO_GRAPH_CODE,
-  O2 as OBO_ISSUE,
-  $ as OPTIONS_GAINED_CODE,
-  O as OPTION_IGNORED_CODE,
+  O as OBO_CAPABILITIES,
+  a12 as OBO_ISSUE,
+  b12 as OBO_LOSS,
+  bg as OPTIONS_GAINED_CODE,
+  OPTION_IGNORED_CODE,
   ORIGINAL_ID_COLUMN,
-  ar as PAIR_COLUMN,
+  bh as PAIR_COLUMN,
   P2 as PAJEK_ISSUE,
-  a15 as PAJEK_LOSS,
-  ab as PARENTS_DROPPED_CODE,
-  h as PARENT_CYCLE_CODE,
-  as as PARSE_ERROR_CODE,
+  a13 as PAJEK_LOSS,
+  Q as PARENTS_DROPPED_CODE,
+  ai as PARENT_CYCLE_CODE,
+  bi as PARSE_ERROR_CODE,
   P as PRECISION_CODE,
-  at as RENAMED_CODE,
-  a6 as ROLE_ASSUMED_CODE,
-  ac as ROLE_DROPPED_CODE,
+  aD as RELATION_ASSUMED_CODE,
+  ay as RENAMED_CODE,
+  au as ROLE_ASSUMED_CODE,
+  K as ROLE_DROPPED_CODE,
   R as ROLE_TAKEN_CODE,
+  SELF_LOOPS_DROPPED_CODE,
+  bj as SELF_LOOP_CODE,
+  ag as SINGLE_OBJECT_ASPECT_CODE,
   S as SINK_OPTION_CODE,
+  SNIFF_FAILED_CODE,
   SNIFF_HEAD_BYTES,
-  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,
+  Z as STATUS_FAILED_CODE,
+  _ as STATUS_WARNING_CODE,
+  bk as STORAGE_CLASS_CODE,
+  f as STRAY_TEXT_CODE,
+  ah as STYLES_NOT_IMPORTED_CODE,
+  ak as SYNTAX_CODE,
+  bl as TEMPORAL_DROPPED_CODE,
+  bm as TEMPORAL_TEXT_DROPPED_CODE,
+  bn as TEXT_INFERRED_CODE,
+  ad as TOO_LARGE_CODE,
+  aC as TYPEDEF_NODES_CODE,
   TYPE_COLUMN,
-  T2 as TextCellWriter,
-  k as UNKNOWN_ATTR_TYPE_CODE,
-  Y as UNKNOWN_ELEMENT_CODE,
-  q as UNKNOWN_ENCODING_CODE,
+  TextCellWriter,
+  U as UNKNOWN_ATTR_TYPE_CODE,
+  g as UNKNOWN_ELEMENT_CODE,
+  w as UNKNOWN_ENCODING_CODE,
   UNKNOWN_FORMAT_CODE,
-  U as UNKNOWN_PARENT_CODE,
-  av as UNKNOWN_TYPE_CODE,
-  a7 as WEIGHT_KEY_CLASH_CODE,
-  W as WIDENED_CODE,
+  UNKNOWN_OPTION_CODE,
+  q as UNKNOWN_PARENT_CODE,
+  bo as UNKNOWN_TYPE_CODE,
+  h as UNKNOWN_XML_ATTRIBUTE_CODE,
+  bp as WEIGHTS_DROPPED_CODE,
+  bq as WEIGHT_KEY_CLASH_CODE,
+  WEIGHT_NOT_FOUND_CODE,
+  aj as WIDENED_CODE,
   W2 as WIDENING_UNSUPPORTED_CODE,
   X2 as XGMML_ISSUE,
-  a16 as XGMML_LOSS,
-  a0 as XML_ILLEGAL_CHAR_CODE,
-  aw as XML_SYNTAX_CODE,
+  a14 as XGMML_LOSS,
+  ax as XML_ILLEGAL_CHAR_CODE,
+  X as XML_SYNTAX_CODE,
   X3 as XmlSyntaxError,
-  b4 as XmlTokenizer,
-  ax as canonicalId,
-  c3 as capabilities,
-  a17 as checkCapabilities,
+  b13 as XmlTokenizer,
+  aH as canonicalId,
+  c as capabilities,
+  a as checkCapabilities,
   checkExport,
   c2 as childrenCsr,
-  a10 as childrenFromColumn,
-  H as chooseGraph,
-  ay as coerceId,
-  az as coerceIdText,
-  c5 as collectBytes,
+  a6 as childrenFromColumn,
+  chooseGraph,
+  br as coerceId,
+  aI as coerceIdText,
+  collectBytes,
+  compareSnapshots,
   createRegistry,
   csvExporter,
   csvImporter,
   cx2Exporter,
   cx2Importer,
+  cxExporter,
   cxImporter,
+  cysExporter,
   cysImporter,
-  aA as declareCompanion,
-  L as declareResolved,
-  d4 as decodeChunks,
-  aB as decodeEntryName,
-  d2 as dialectCapabilities,
+  bs as declareCompanion,
+  a1 as declareResolved,
+  d2 as decodeChunks,
+  bt as decodeEntryName,
+  defineLineFormat,
+  describeDiffs,
+  d3 as dialectCapabilities,
   dotExporter,
   dotImporter,
-  e3 as encodeChunks,
-  e2 as explicitWeights,
+  downloadGraph,
+  bu as edgeWeights,
+  e2 as encodeChunks,
+  e as explicitWeights,
   exportGraph,
+  exportGraphToBlob,
+  exportGraphToBytes,
   exportGraphToString,
-  f2 as extensionOf,
-  b3 as formatDecimal,
-  f3 as formatF32,
-  a18 as formatF64,
-  c4 as formatGmlReal,
-  d3 as formatInteger,
+  exportNeo4jFiles,
+  g2 as extensionOf,
+  bv as forDecodedText,
+  aF as formatDecimal,
+  aa as formatF32,
+  ab as formatF64,
+  bw as formatGmlReal,
+  aG as formatInteger,
   gexfExporter,
   gexfImporter,
   gmlExporter,
   gmlImporter,
+  ap as graphChosen,
   graphmlExporter,
   graphmlImporter,
   h3 as hasIllegalXmlChar,
   h2 as headBytes,
   importAllGraphs,
   importGraph,
-  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,
+  i2 as inferTextDtype,
+  bx as inputLength,
+  isAbortError,
+  by as isCanonicalIntegerText,
+  bz as isImportInput,
+  bA as isNmtoken,
+  a5 as isNumericText,
+  aK as isWeightField,
+  j2 as joinText,
+  j3 as jsonCapabilities,
   jsonExporter,
   jsonImporter,
+  f2 as jsonShapeOf,
+  listFormats,
   listGraphs,
-  m2 as mangleNmtoken,
+  loadFromFile,
+  loadFromUrl,
+  bB as mangleNmtoken,
   neo4jExporter,
   neo4jImporter,
   n2 as normalizeMimeType,
+  oboExporter,
   oboImporter,
-  X as pairFolding,
+  p as pairFolding,
   pajekExporter,
   pajekImporter,
-  p3 as parseTextCell,
-  p2 as parseWeightText,
+  p2 as parseTextCell,
+  parseWeightText,
   rankFormats,
-  aG as readText,
+  bC as readText,
+  bD as refusedSave,
   registry,
-  F as reportSinkOptions,
-  z as reportUnusedOptions,
-  V as resolveExportOptions,
-  v as resolveImportOptions,
-  s3 as sanitizeIds,
+  reportSinkOptions,
+  reportUnusedOptions,
+  r as resolveExportOptions,
+  resolveImportOptions,
+  aE as sanitizeIds,
   sniff,
   s2 as sniffFormat,
-  g2 as sniffJsonDialectHead,
-  x as textChunks,
+  i3 as sniffJsonDialectHead,
+  a4 as textChunks,
   throwIfAborted,
   t2 as toReadableStream,
   t3 as tokenizeXml,