@graphty/graph-io 0.0.0 → 0.2.0

package/dist/chunks/importer-CQnJuWJw.js

@@ -0,0 +1,2987 @@
+import { GraphFormatError, INVALID_INDEX } from "@graphty/graph-format";
+import { a9 as capabilities, L as LOSS, au as joinText, ah as encodeChunks, aa as checkCapabilities, aB as resolveExportOptions, aG as countMixedEdges, ai as explicitWeights, aw as pairFolding, ak as formatF32, J as OPTION_IGNORED_CODE, W as SINK_OPTION_CODE, H as HYPEREDGE_CODE, y as MULTIPLE_GRAPHS_CODE, n as ID_MERGED_CODE, i as DUPLICATE_EDGE_ID_CODE, k as DUPLICATE_NODE_CODE, a3 as UNKNOWN_PARENT_CODE, M as MISSING_ENDPOINT_CODE, w as MISSING_ID_CODE, Z as SYNTAX_CODE, m as EMPTY_INPUT_CODE, aC as resolveImportOptions, I as ImportReportBuilder, ay as readText, az as reportSinkOptions, aA as reportUnusedOptions, a as throwIfAborted, s as IdCoercer, l as DirectionResolver, aH as weightFromValue, aI as uniqueColumnName } from "./writer-DxSKC7TL.js";
+const JSON_DIALECTS = Object.freeze([
+  "node-link",
+  "d3",
+  "jgf",
+  "cytoscape",
+  "graphology",
+  "vis"
+]);
+const META_KEY = "json";
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasKey(record, key) {
+  return Object.prototype.hasOwnProperty.call(record, key);
+}
+function isJsonDialect(value) {
+  return typeof value === "string" && JSON_DIALECTS.includes(value);
+}
+function sniffJsonDialect(root) {
+  if (Array.isArray(root)) {
+    const first = firstJsonObject(root);
+    return root.length === 0 || first !== null && isJsonObject(first.data) ? "cytoscape" : null;
+  }
+  if (!isJsonObject(root)) {
+    return null;
+  }
+  if (hasKey(root, "elements")) {
+    return "cytoscape";
+  }
+  if (isJsonObject(root.graph) && (hasKey(root.graph, "nodes") || hasKey(root.graph, "edges"))) {
+    return "jgf";
+  }
+  if (Array.isArray(root.graphs)) {
+    return "jgf";
+  }
+  if (!hasKey(root, "nodes") && !hasKey(root, "edges") && !hasKey(root, "links")) {
+    return null;
+  }
+  const firstNode = firstJsonObject(root.nodes);
+  const firstEdge = firstJsonObject(hasKey(root, "edges") ? root.edges : root.links);
+  if (isJsonObject(root.options) && (hasKey(root.options, "type") || hasKey(root.options, "multi"))) {
+    return "graphology";
+  }
+  if (firstNode !== null && hasKey(firstNode, "key") && !hasKey(firstNode, "id")) {
+    return "graphology";
+  }
+  if (firstEdge !== null && !hasKey(firstEdge, "from")) {
+    if (hasKey(firstEdge, "undirected") || isJsonObject(firstEdge.attributes)) {
+      return "graphology";
+    }
+  }
+  if (firstEdge !== null && hasKey(firstEdge, "from") && hasKey(firstEdge, "to") && !hasKey(firstEdge, "source")) {
+    return "vis";
+  }
+  const bare = !hasKey(root, "directed") && !hasKey(root, "multigraph") && !hasKey(root, "graph");
+  return bare && hasKey(root, "links") ? "d3" : "node-link";
+}
+function firstJsonObject(value) {
+  if (!Array.isArray(value)) {
+    return null;
+  }
+  const found = value.find((item) => isJsonObject(item));
+  return isJsonObject(found) ? found : null;
+}
+function shapeMetaOf(meta) {
+  const raw = meta.extra[META_KEY];
+  if (!isJsonObject(raw)) {
+    return {};
+  }
+  const text = (key) => typeof raw[key] === "string" ? raw[key] : void 0;
+  const flag = (key) => typeof raw[key] === "boolean" ? raw[key] : void 0;
+  const { nodeIdKey } = raw;
+  return {
+    dialect: isJsonDialect(raw.dialect) ? raw.dialect : void 0,
+    edgesKey: text("edgesKey"),
+    nodeIdKey: nodeIdKey === null || typeof nodeIdKey === "string" ? nodeIdKey : void 0,
+    indexLinks: flag("indexLinks"),
+    sourceKey: text("sourceKey"),
+    targetKey: text("targetKey"),
+    id: text("id"),
+    type: text("type"),
+    allowSelfLoops: flag("allowSelfLoops"),
+    cytoscape: isJsonObject(raw.cytoscape) ? raw.cytoscape : void 0
+  };
+}
+const DIALECT_DEFAULT_DIRECTED = Object.freeze({
+  "node-link": false,
+  d3: false,
+  jgf: true,
+  cytoscape: true,
+  graphology: true,
+  vis: false
+});
+const JSON_DTYPES = Object.freeze(["f64", "i32", "bool", "string"]);
+const COMMON = {
+  multiEdges: true,
+  selfLoops: true,
+  idCharset: "any",
+  dtypes: JSON_DTYPES,
+  components: false,
+  lists: false,
+  json: true,
+  defaults: false,
+  options: false,
+  temporal: "none",
+  positions: false,
+  viz: false
+};
+const TABLES = Object.freeze({
+  "node-link": capabilities({
+    ...COMMON,
+    mixedDirection: false,
+    edgeIds: "none",
+    hierarchy: false,
+    graphAttributes: true
+  }),
+  d3: capabilities({
+    ...COMMON,
+    mixedDirection: false,
+    edgeIds: "none",
+    hierarchy: false,
+    graphAttributes: false
+  }),
+  jgf: capabilities({
+    ...COMMON,
+    mixedDirection: true,
+    edgeIds: "optional",
+    hierarchy: false,
+    graphAttributes: true
+  }),
+  cytoscape: capabilities({
+    ...COMMON,
+    positions: true,
+    mixedDirection: false,
+    edgeIds: "required",
+    hierarchy: true,
+    graphAttributes: true
+  }),
+  graphology: capabilities({
+    ...COMMON,
+    mixedDirection: true,
+    edgeIds: "optional",
+    hierarchy: false,
+    graphAttributes: true
+  }),
+  vis: capabilities({
+    ...COMMON,
+    mixedDirection: false,
+    edgeIds: "optional",
+    hierarchy: false,
+    graphAttributes: false
+  })
+});
+function dialectCapabilities(dialect) {
+  return TABLES[dialect];
+}
+const CYTOSCAPE_ELEMENT_KEYS = /* @__PURE__ */ new Set([
+  "selected",
+  "selectable",
+  "locked",
+  "grabbable",
+  "pannable",
+  "removed",
+  "scratch",
+  "renderedPosition"
+]);
+const CYTOSCAPE_STRUCTURAL_KEYS = /* @__PURE__ */ new Set(["data", "group", "position", "classes"]);
+const SUFFIX = Object.freeze({
+  /** A Cytoscape `data` key or a JGF / graphology attribute that collides with a structural column. */
+  data: "#data",
+  /** An element-level key the dialect does not define (Cytoscape, JGF, graphology). */
+  element: "#element"
+});
+const NODE_LINK_SOURCE_KEYS = Object.freeze(["source", "src", "from"]);
+const NODE_LINK_TARGET_KEYS = Object.freeze(["target", "dst", "to"]);
+const POSITION_COLUMN = "position";
+const CLASSES_COLUMN = "classes";
+const PARENT_COLUMN = "parent";
+const JSON_LOSS = Object.freeze({
+  /** Non-finite numbers (columns, weights) are written as null. */
+  NONFINITE_AS_NULL: "W_NONFINITE_AS_NULL",
+  /** Cytoscape, vis and d3 carry no direction; the file re-imports with the dialect's default direction. */
+  DIRECTION_DROPPED: "W_DIRECTION_DROPPED",
+  /** GEXF mutual pairs are written as two directed edges. */
+  MUTUAL_EXPANDED: LOSS.MUTUAL_EXPANDED,
+  /** JGF keys its nodes by string; numeric ids re-import as text unless ids: "canonical". */
+  NUMERIC_IDS_STRINGIFIED: "W_NUMERIC_IDS_STRINGIFIED",
+  /** JGF: two ids have the same text; export() throws E_INVALID_ID. */
+  ID_TEXT_COLLISION: LOSS.ID_TEXT_COLLISION,
+  /** JGF: integer-like id keys are enumerated first and ascending by JSON parsers; node order changes on re-import. */
+  NODE_ORDER: "W_NODE_ORDER",
+  /** A column named like a reserved key of the dialect (id, source, target, ...) is skipped. */
+  RESERVED_KEY: "W_RESERVED_KEY",
+  /** A plain edge column named like the weight key reads back as THE weight (or is skipped when weights are written). */
+  WEIGHT_KEY_CLASH: LOSS.WEIGHT_KEY_CLASH,
+  /** A position column without a slot (every dialect but Cytoscape) is a plain array attribute; the role is lost. */
+  POSITIONS_DROPPED: LOSS.POSITIONS,
+  /** Cytoscape positions are 2D; non-zero z values are dropped. */
+  POSITION_Z_DROPPED: "W_POSITION_Z_DROPPED",
+  /** Cytoscape has a single parent; a `parents` list column cannot be written. */
+  PARENTS_DROPPED: LOSS.PARENTS,
+  /** node-link / d3 have no edge id slot; the id column is written as a plain attribute. */
+  EDGE_IDS_DROPPED: LOSS.EDGE_IDS_DROPPED,
+  /** An f64 column of integral values reads back as i32 (JSON declares no types). */
+  INTEGRAL_F64_AS_I32: LOSS.INTEGRAL_F64,
+  /** A role column the dialect has no slot for is a plain attribute; the role is lost. */
+  ROLE_DROPPED: LOSS.ROLE,
+  /** A column without a set cell is not written (JSON declares no columns). */
+  EMPTY_COLUMN_DROPPED: LOSS.EMPTY_COLUMN
+});
+const SLOT_ROLES = Object.freeze({
+  "node-link": /* @__PURE__ */ new Set(),
+  d3: /* @__PURE__ */ new Set(),
+  jgf: /* @__PURE__ */ new Set(["label", "kind"]),
+  cytoscape: /* @__PURE__ */ new Set(["classes"]),
+  graphology: /* @__PURE__ */ new Set(),
+  vis: /* @__PURE__ */ new Set()
+});
+const STRUCTURAL_ROLES = /* @__PURE__ */ new Set([
+  "directed",
+  "pair",
+  "mutual",
+  "weight",
+  "timeText",
+  "originalId"
+]);
+const TEMPORAL_ROLES = /* @__PURE__ */ new Set(["start", "end", "timestamp", "timestamps", "spells", "open"]);
+const NESTED_DIALECTS = /* @__PURE__ */ new Set(["jgf", "cytoscape", "graphology"]);
+function resolve(snapshot, options) {
+  const o = options ?? {};
+  const common = resolveExportOptions(options);
+  const shape = shapeMetaOf(snapshot.meta);
+  let dialect;
+  if (o.dialect === void 0) {
+    dialect = shape.dialect ?? "node-link";
+  } else if (isJsonDialect(o.dialect)) {
+    ({ dialect } = o);
+  } else {
+    throw unsupported("dialect", o.dialect, JSON_DIALECTS);
+  }
+  const indent = o.indent ?? 0;
+  if (!Number.isInteger(indent) || indent < 0 || indent > 16) {
+    throw unsupported("indent", indent, ["an integer 0..16"]);
+  }
+  const sameDialect = shape.dialect === dialect;
+  const recorded = (value, fallback) => sameDialect && value !== void 0 ? value : fallback;
+  const edgesKey = keyOption$1("edgesKey", o.edgesKey) ?? recorded(shape.edgesKey, dialect === "d3" ? "links" : "edges");
+  let nodeIdKey;
+  if (o.nodeIdKey !== void 0) {
+    nodeIdKey = keyOption$1("nodeIdKey", o.nodeIdKey);
+  } else if (sameDialect && shape.nodeIdKey !== void 0) {
+    ({ nodeIdKey } = shape);
+  } else {
+    nodeIdKey = "id";
+  }
+  let indexLinks = o.indexLinks ?? recorded(shape.indexLinks, false);
+  if (typeof indexLinks !== "boolean") {
+    throw unsupported("indexLinks", indexLinks, ["true", "false"]);
+  }
+  if (nodeIdKey === null) {
+    indexLinks = true;
+  }
+  const sourceKey = keyOption$1("sourceKey", o.sourceKey) ?? recorded(shape.sourceKey, dialect === "vis" ? "from" : "source");
+  const targetKey = keyOption$1("targetKey", o.targetKey) ?? recorded(shape.targetKey, dialect === "vis" ? "to" : "target");
+  const { weightOrigin } = snapshot.meta;
+  const weightKey = keyOption$1("weightKey", o.weightKey) ?? (weightOrigin !== null && weightOrigin.format === "json" && weightOrigin.id !== null ? weightOrigin.id : "weight");
+  return { common, dialect, indent, edgesKey, nodeIdKey, indexLinks, sourceKey, targetKey, weightKey, shape };
+}
+function keyOption$1(name, value) {
+  if (value === void 0) {
+    return null;
+  }
+  if (typeof value !== "string" || value.length === 0) {
+    throw unsupported(name, value, ["a non-empty key"]);
+  }
+  return value;
+}
+function unsupported(name, found, supported) {
+  const shown = typeof found === "string" ? JSON.stringify(found) : String(found);
+  return new GraphFormatError("E_UNSUPPORTED", `option ${name}: ${shown} is not one of ${supported.join(", ")}`, {
+    option: name,
+    found: typeof found === "string" || typeof found === "number" ? found : typeof found,
+    supported: [...supported]
+  });
+}
+function numberText(value, f32, nonfinite) {
+  if (!Number.isFinite(value)) {
+    nonfinite.count++;
+    return "null";
+  }
+  if (f32) {
+    return formatF32(value);
+  }
+  return Object.is(value, -0) ? "0" : String(value);
+}
+function valueText(value, f32, nonfinite) {
+  switch (typeof value) {
+    case "number":
+      return numberText(value, f32, nonfinite);
+    case "boolean":
+      return value ? "true" : "false";
+    case "string":
+      return JSON.stringify(value);
+    case "undefined":
+      return "null";
+  }
+  if (value === null) {
+    return "null";
+  }
+  if (Array.isArray(value) || ArrayBuffer.isView(value)) {
+    const items = Array.from(value, (item) => valueText(item, f32, nonfinite));
+    return `[${items.join(",")}]`;
+  }
+  const text = JSON.stringify(value);
+  return text === void 0 ? "null" : text;
+}
+function cellText(column, row, ids, nonfinite) {
+  switch (column.dtype) {
+    case "list":
+      return valueText(column.sliceOf(row), column.child.dtype === "f32", nonfinite);
+    case "json":
+      return valueText(column.values[row], false, nonfinite);
+    case "u32":
+      if (column.meta.refersTo === "node" && column.meta.components === 1) {
+        const index = column.data[row];
+        return index === INVALID_INDEX ? "null" : JSON.stringify(ids.idOf(index));
+      }
+      return valueText(column.value(row), false, nonfinite);
+    case "f32":
+      return valueText(column.value(row), true, nonfinite);
+    default:
+      return valueText(column.value(row), false, nonfinite);
+  }
+}
+function countNonFinite(column) {
+  let data;
+  switch (column.dtype) {
+    case "f32":
+    case "f64":
+      ({ data } = column);
+      break;
+    case "list":
+      if (column.child.dtype !== "f32" && column.child.dtype !== "f64") {
+        return 0;
+      }
+      ({ data } = column.child);
+      break;
+    default:
+      return 0;
+  }
+  let count = 0;
+  for (let i = 0; i < data.length; i++) {
+    if (!Number.isFinite(data[i])) {
+      count++;
+    }
+  }
+  return count;
+}
+class JsonWriter {
+  /**
+   * Create a writer.
+   * @param indent - spaces per level; 0 for compact output
+   */
+  constructor(indent) {
+    this.parts = [];
+    this.depth = 0;
+    this.firstAtDepth = [];
+    this.indent = indent;
+  }
+  /**
+   * Open an object or an array.
+   * @param bracket - "{" or "["
+   */
+  open(bracket) {
+    this.parts.push(bracket);
+    this.depth++;
+    this.firstAtDepth.push(true);
+  }
+  /**
+   * Close the innermost object or array.
+   * @param bracket - "}" or "]"
+   */
+  close(bracket) {
+    const wasEmpty = this.firstAtDepth.pop() ?? true;
+    this.depth--;
+    if (!wasEmpty) {
+      this.parts.push(this.newline());
+    }
+    this.parts.push(bracket);
+  }
+  /**
+   * Start an object member: the separator and the quoted key.
+   * @param name - the key
+   */
+  key(name) {
+    this.separator();
+    this.parts.push(JSON.stringify(name), this.indent > 0 ? ": " : ":");
+  }
+  /** Start an array element: the separator only. */
+  item() {
+    this.separator();
+  }
+  /**
+   * Append raw JSON text (a value).
+   * @param text - the text
+   */
+  raw(text) {
+    this.parts.push(text);
+  }
+  /**
+   * Write a member with a value in one call.
+   * @param name - the key
+   * @param text - the value's JSON text
+   */
+  member(name, text) {
+    this.key(name);
+    this.parts.push(text);
+  }
+  /**
+   * Hand out the text accumulated since the last take.
+   * @returns the text
+   */
+  take() {
+    const text = this.parts.length === 1 ? this.parts[0] : this.parts.join("");
+    this.parts = [];
+    return text;
+  }
+  /** The comma and newline before a member or element. */
+  separator() {
+    const top = this.firstAtDepth.length - 1;
+    if (this.firstAtDepth[top]) {
+      this.firstAtDepth[top] = false;
+    } else {
+      this.parts.push(",");
+    }
+    this.parts.push(this.newline());
+  }
+  /**
+   * A newline plus the current indentation, or nothing in compact mode.
+   * @returns the text
+   */
+  newline() {
+    return this.indent > 0 ? `
+${" ".repeat(this.depth * this.indent)}` : "";
+  }
+}
+function plan(snapshot, resolved) {
+  const { dialect } = resolved;
+  const caps = dialectCapabilities(dialect);
+  const notes = checkCapabilities(snapshot, caps, resolved.common, {
+    roles: SLOT_ROLES[dialect],
+    positionDtype: "f32"
+  }).filter((n) => n.code !== LOSS.POSITIONS && n.code !== LOSS.EDGE_IDS_DROPPED);
+  const note = (code, message, column = null, count = null) => {
+    notes.push(Object.freeze({ code, message, column, count }));
+  };
+  const ctx = {
+    snapshot,
+    resolved,
+    dialect,
+    caps,
+    notes,
+    note,
+    reserved: reservedKeys(snapshot, resolved),
+    nonfinite: { count: 0 }
+  };
+  const nodes = planTable(ctx, snapshot.nodes, "node");
+  const edges = planTable(ctx, snapshot.edges, "edge");
+  const graph = caps.graphAttributes ? planTable(ctx, snapshot.graph, "graph") : [];
+  withdrawSlotNotes(notes, [...nodes, ...edges]);
+  const weights = planWeights(ctx, edges);
+  if (ctx.nonfinite.count > 0) {
+    note(
+      JSON_LOSS.NONFINITE_AS_NULL,
+      `${ctx.nonfinite.count} non-finite number(s) are written as null`,
+      null,
+      ctx.nonfinite.count
+    );
+  }
+  const { folding, directed } = planDirection(ctx);
+  const multigraph = snapshot.flags.multigraph || snapshot.meta.declaredMultigraph === true;
+  if (dialect === "jgf") {
+    jgfIdNotes(snapshot, note);
+  }
+  const edgeIds = snapshot.edges.byRole("id");
+  if (dialect === "cytoscape" && edgeIds !== null && edgeIds.nullCount > 0) {
+    note(
+      LOSS.EDGE_IDS_GENERATED,
+      `${edgeIds.nullCount} edge(s) have no id; canonical e<index> ids are generated for them`,
+      edgeIds.meta.name,
+      edgeIds.nullCount
+    );
+  }
+  return { resolved, notes, nodes, edges, graph, edgeIds, weights, folding, directed, multigraph };
+}
+function withdrawSlotNotes(notes, plans) {
+  for (const plan2 of plans) {
+    if (plan2.slot !== "classes") {
+      continue;
+    }
+    const at = notes.findIndex((n) => n.code === LOSS.LIST && n.column === plan2.column.meta.name);
+    if (at >= 0) {
+      notes.splice(at, 1);
+    }
+  }
+}
+function reservedKeys(snapshot, resolved) {
+  const { dialect } = resolved;
+  const node = /* @__PURE__ */ new Set();
+  const edge = new Set(snapshot.flags.weighted ? [resolved.weightKey] : []);
+  const graph = /* @__PURE__ */ new Set();
+  switch (dialect) {
+    case "node-link":
+    case "d3":
+      if (resolved.nodeIdKey !== null) {
+        node.add(resolved.nodeIdKey);
+      }
+      edge.add(resolved.sourceKey).add(resolved.targetKey);
+      break;
+    case "vis":
+      node.add(resolved.nodeIdKey ?? "id");
+      edge.add(resolved.sourceKey).add(resolved.targetKey);
+      break;
+    case "cytoscape":
+      node.add("id").add("parent");
+      edge.add("id").add("source").add("target");
+      break;
+    case "jgf":
+    case "graphology":
+      break;
+    default: {
+      const name = dialect;
+      throw new GraphFormatError("E_UNSUPPORTED", `unknown dialect ${name}`, { option: "dialect", found: name });
+    }
+  }
+  return { node, edge, graph };
+}
+function planTable(ctx, table, domain) {
+  const { dialect, note } = ctx;
+  const plans = [];
+  const reserved = ctx.reserved[domain];
+  const used = /* @__PURE__ */ new Set();
+  for (const column of table) {
+    const { meta } = column;
+    const { role } = meta;
+    const setRows = column.length - column.nullCount;
+    if (role !== null && (STRUCTURAL_ROLES.has(role) || TEMPORAL_ROLES.has(role))) {
+      continue;
+    }
+    if (domain !== "graph") {
+      ctx.nonfinite.count += countNonFinite(column);
+    }
+    const slotted = planSlot(ctx, column, domain);
+    if (slotted !== null) {
+      if (slotted !== SKIPPED) {
+        plans.push(slotted);
+      }
+      continue;
+    }
+    let key = meta.name;
+    let slot = "attribute";
+    if (NESTED_DIALECTS.has(dialect) && domain !== "graph") {
+      if (key.endsWith(SUFFIX.element)) {
+        key = key.slice(0, -SUFFIX.element.length);
+        slot = "element";
+      } else if (dialect === "cytoscape" && CYTOSCAPE_ELEMENT_KEYS.has(key)) {
+        slot = "element";
+      } else if (key.endsWith(SUFFIX.data)) {
+        key = key.slice(0, -SUFFIX.data.length);
+      }
+    }
+    if (slot === "attribute" && reserved.has(key)) {
+      note(
+        JSON_LOSS.RESERVED_KEY,
+        `${domain} column "${meta.name}" cannot be written: "${key}" is a reserved key of ${dialect}`,
+        meta.name,
+        setRows
+      );
+      continue;
+    }
+    const slotKey = `${slot}:${key}`;
+    if (used.has(slotKey)) {
+      note(
+        JSON_LOSS.RESERVED_KEY,
+        `${domain} column "${meta.name}" cannot be written: key "${key}" is already used by another column`,
+        meta.name,
+        setRows
+      );
+      continue;
+    }
+    used.add(slotKey);
+    if (setRows === 0 && domain !== "graph") {
+      note(
+        LOSS.EMPTY_COLUMN,
+        `${domain} column "${meta.name}" has no set cell and is not written: JSON writes values, never declarations`,
+        meta.name,
+        0
+      );
+    }
+    inferenceNotes(ctx, column, domain, setRows);
+    plans.push({ column, key, slot });
+  }
+  return plans;
+}
+const SKIPPED = /* @__PURE__ */ Symbol("skipped");
+function planSlot(ctx, column, domain) {
+  const { dialect, note } = ctx;
+  const { meta } = column;
+  const { role } = meta;
+  const setRows = column.length - column.nullCount;
+  if (role === "parent" || role === "parents") {
+    if (dialect === "cytoscape" && domain === "node") {
+      if (role === "parent" && column.dtype === "u32" && meta.refersTo === "node") {
+        return { column, key: "parent", slot: "parent" };
+      }
+      note(
+        LOSS.PARENTS,
+        `node column "${meta.name}" (${role}) cannot be written: Cytoscape has a single parent`,
+        meta.name,
+        setRows
+      );
+    }
+    return SKIPPED;
+  }
+  if (role === "position" && domain === "node") {
+    if (dialect === "cytoscape" && (column.dtype === "f32" || column.dtype === "f64") && meta.components >= 2) {
+      const z = countNonZeroZ(column);
+      if (z > 0) {
+        note(
+          JSON_LOSS.POSITION_Z_DROPPED,
+          `${z} position(s) have a non-zero z; Cytoscape positions are 2D`,
+          meta.name,
+          z
+        );
+      }
+      return { column, key: "position", slot: "cytoscapePosition" };
+    }
+    note(
+      LOSS.POSITIONS,
+      `node column "${meta.name}" (position) is written as a plain array attribute; its role is lost on re-import`,
+      meta.name,
+      setRows
+    );
+    return { column, key: meta.name, slot: "position" };
+  }
+  if (role === "id" && domain === "edge") {
+    if (dialect === "node-link" || dialect === "d3") {
+      note(
+        LOSS.EDGE_IDS_DROPPED,
+        `edge column "${meta.name}" (id) is written as a plain attribute; ${dialect} has no edge id`,
+        meta.name,
+        setRows
+      );
+      return null;
+    }
+    return SKIPPED;
+  }
+  if (dialect === "cytoscape" && role === "classes" && column.dtype === "list" && column.child.dtype === "string") {
+    return { column, key: "classes", slot: "classes" };
+  }
+  if (dialect === "jgf" && role === "label" && (column.dtype === "string" || column.dtype === "dict")) {
+    return { column, key: "label", slot: "label" };
+  }
+  if (dialect === "jgf" && role === "kind" && domain === "edge" && (column.dtype === "string" || column.dtype === "dict")) {
+    return { column, key: "relation", slot: "relation" };
+  }
+  return null;
+}
+function inferenceNotes(ctx, column, domain, setRows) {
+  if (column.dtype !== "f64" || column.meta.components > 1 || setRows === 0) {
+    return;
+  }
+  const { data } = column;
+  for (let r = 0; r < column.length; r++) {
+    if (column.isSet(r) && !Number.isInteger(data[r])) {
+      return;
+    }
+  }
+  ctx.note(
+    LOSS.INTEGRAL_F64,
+    `${domain} column "${column.meta.name}" is f64 with integral values only; JSON declares no types and it reads back as i32`,
+    column.meta.name,
+    setRows
+  );
+}
+function planWeights(ctx, edges) {
+  const { snapshot, nonfinite } = ctx;
+  const weights = explicitWeights(snapshot);
+  if (!weights.weighted) {
+    const clash = edges.find((p) => p.slot === "attribute" && p.key === ctx.resolved.weightKey);
+    if (clash !== void 0) {
+      ctx.note(
+        LOSS.WEIGHT_KEY_CLASH,
+        `edge column "${clash.column.meta.name}" is written under "${clash.key}", the key the importer reads THE weight from; it reads back as the weight, not as a column`,
+        clash.column.meta.name,
+        clash.column.length - clash.column.nullCount
+      );
+    }
+    return () => null;
+  }
+  for (let e = 0; e < snapshot.edgeCount; e++) {
+    if (weights.isExplicit(e) && !Number.isFinite(weights.value(e))) {
+      nonfinite.count++;
+    }
+  }
+  return (e) => {
+    if (!weights.isExplicit(e)) {
+      return null;
+    }
+    return Number.isFinite(weights.value(e)) ? weights.text(e) : "null";
+  };
+}
+function planDirection(ctx) {
+  const { snapshot, dialect, caps, note } = ctx;
+  const folding = pairFolding(snapshot);
+  if (folding.mutualCount > 0) {
+    note(
+      LOSS.MUTUAL_EXPANDED,
+      `${folding.mutualCount} mutual pair(s) are written as two directed edges; the mutual mark is lost`,
+      null,
+      folding.mutualCount
+    );
+  }
+  let { directed } = snapshot;
+  if (!caps.mixedDirection && countMixedEdges(snapshot) > 0 && ctx.resolved.common.onMixedDirection === "undirected") {
+    directed = false;
+  }
+  if (dialect === "cytoscape" || dialect === "vis" || dialect === "d3") {
+    const assumed = DIALECT_DEFAULT_DIRECTED[dialect];
+    if (directed !== assumed) {
+      note(
+        JSON_LOSS.DIRECTION_DROPPED,
+        `${dialect} has no direction flag; the ${directed ? "directed" : "undirected"} graph re-imports as ${assumed ? "directed" : "undirected"} unless defaultDirected is passed`
+      );
+    }
+  }
+  return { folding, directed };
+}
+function countNonZeroZ(column) {
+  if (column.dtype !== "f32" && column.dtype !== "f64" || column.meta.components < 3) {
+    return 0;
+  }
+  const { components } = column.meta;
+  let count = 0;
+  for (let r = 0; r < column.length; r++) {
+    if (column.isSet(r) && column.data[r * components + 2] !== 0) {
+      count++;
+    }
+  }
+  return count;
+}
+function jgfIdNotes(snapshot, note) {
+  const { ids } = snapshot;
+  const seen = /* @__PURE__ */ new Set();
+  let numeric = 0;
+  let collisions = 0;
+  let indexLike = 0;
+  let lastIndex = -1;
+  let ordered = true;
+  let sawOther = false;
+  for (let i = 0; i < ids.size; i++) {
+    const id = ids.idOf(i);
+    const text = String(id);
+    if (typeof id === "number") {
+      numeric++;
+    }
+    if (seen.has(text)) {
+      collisions++;
+    }
+    seen.add(text);
+    if (isArrayIndexKey(text)) {
+      indexLike++;
+      const n = Number(text);
+      if (sawOther || n <= lastIndex) {
+        ordered = false;
+      }
+      lastIndex = n;
+    } else {
+      sawOther = true;
+    }
+  }
+  if (numeric > 0) {
+    note(
+      JSON_LOSS.NUMERIC_IDS_STRINGIFIED,
+      `${numeric} numeric node id(s) become JGF object keys (strings); pass ids: "canonical" on re-import`,
+      null,
+      numeric
+    );
+  }
+  if (collisions > 0) {
+    note(
+      JSON_LOSS.ID_TEXT_COLLISION,
+      `${collisions} node id(s) share their text with another id; export() will throw`,
+      null,
+      collisions
+    );
+  }
+  if (!ordered) {
+    note(
+      JSON_LOSS.NODE_ORDER,
+      `${indexLike} integer-like node id(s) are enumerated first and ascending by JSON parsers; node order changes on re-import`,
+      null,
+      indexLike
+    );
+  }
+}
+function isArrayIndexKey(text) {
+  return /^(0|[1-9][0-9]*)$/.test(text) && Number(text) < 4294967295;
+}
+function* write(snapshot, p) {
+  const { dialect } = p.resolved;
+  if (p.notes.some((n) => n.code === LOSS.MIXED_DIRECTION_ERROR)) {
+    throw new GraphFormatError(
+      "E_DIRECTED",
+      `${dialect} has no mixed direction; pass onMixedDirection "directed" or "undirected"`,
+      { reason: "mixed direction", dialect }
+    );
+  }
+  if (p.notes.some((n) => n.code === JSON_LOSS.ID_TEXT_COLLISION)) {
+    throw new GraphFormatError("E_INVALID_ID", "two node ids have the same text; JGF keys nodes by text", {
+      reason: "collision"
+    });
+  }
+  switch (dialect) {
+    case "node-link":
+    case "d3":
+      yield* writeNodeLink(snapshot, p);
+      return;
+    case "vis":
+      yield* writeVis(snapshot, p);
+      return;
+    case "graphology":
+      yield* writeGraphology(snapshot, p);
+      return;
+    case "jgf":
+      yield* writeJgf(snapshot, p);
+      return;
+    case "cytoscape":
+      yield* writeCytoscape(snapshot, p);
+      return;
+    default: {
+      const name = dialect;
+      throw new GraphFormatError("E_UNSUPPORTED", `unknown dialect ${name}`, { option: "dialect", found: name });
+    }
+  }
+}
+function writeSlots(c, plans, row, slots) {
+  for (const item of plans) {
+    if (!slots.has(item.slot) || !item.column.isSet(row)) {
+      continue;
+    }
+    let text;
+    switch (item.slot) {
+      case "position": {
+        const value = item.column.value(row);
+        const dims = dimsOf(item.column);
+        const values = Array.from(value).slice(0, dims);
+        text = valueText(values, item.column.dtype === "f32", c.nonfinite);
+        break;
+      }
+      case "classes":
+        text = JSON.stringify(item.column.sliceOf(row).join(" "));
+        break;
+      default:
+        text = cellText(item.column, row, c.ids, c.nonfinite);
+        break;
+    }
+    c.w.member(item.key, text);
+  }
+}
+const ATTRIBUTE_SLOTS = /* @__PURE__ */ new Set(["attribute", "position"]);
+const ELEMENT_SLOTS = /* @__PURE__ */ new Set(["element", "classes"]);
+function dimsOf(column) {
+  const dims = column.meta.extra.sourceDims;
+  if (typeof dims === "number" && dims >= 1 && dims <= column.meta.components) {
+    return dims;
+  }
+  return column.meta.components;
+}
+function anySet(plans, row, slots) {
+  return plans.some((item) => slots.has(item.slot) && item.column.isSet(row));
+}
+function idText(id) {
+  return typeof id === "number" && Object.is(id, -0) ? "0" : JSON.stringify(id);
+}
+function edgeIdText(p, e, c) {
+  const column = p.edgeIds;
+  if (column === null || !column.isSet(e)) {
+    return null;
+  }
+  return cellText(column, e, c.ids, c.nonfinite);
+}
+function edgeDisposition(p, e) {
+  const { folding } = p;
+  if (folding.folded(e)) {
+    return "skip";
+  }
+  if (!p.directed) {
+    return "undirected";
+  }
+  if (folding.sourceDirected(e)) {
+    return "directed";
+  }
+  if (dialectCapabilities(p.resolved.dialect).mixedDirection) {
+    return "undirected";
+  }
+  return p.resolved.common.onMixedDirection === "directed" ? "directed" : "undirected";
+}
+function writeGraphObject(c, p) {
+  c.w.open("{");
+  for (const item of p.graph) {
+    if (item.column.isSet(0)) {
+      c.w.member(item.key, cellText(item.column, 0, c.ids, c.nonfinite));
+    }
+  }
+  c.w.close("}");
+}
+function endpoints(snapshot, p, e) {
+  const list = snapshot.edgeList();
+  const u = list.src[e];
+  const v = list.dst[e];
+  if (p.resolved.indexLinks) {
+    return [String(u), String(v)];
+  }
+  return [idText(snapshot.ids.idOf(u)), idText(snapshot.ids.idOf(v))];
+}
+function* writeNodeLink(snapshot, p) {
+  const { resolved } = p;
+  const c = { w: new JsonWriter(resolved.indent), ids: snapshot.ids, nonfinite: { count: 0 } };
+  const { w } = c;
+  w.open("{");
+  if (resolved.dialect !== "d3") {
+    w.member("directed", p.directed ? "true" : "false");
+    w.member("multigraph", p.multigraph ? "true" : "false");
+    w.key("graph");
+    writeGraphObject(c, p);
+  }
+  w.key("nodes");
+  w.open("[");
+  yield w.take();
+  for (let i = 0; i < snapshot.nodeCount; i++) {
+    w.item();
+    w.open("{");
+    if (resolved.nodeIdKey !== null) {
+      w.member(resolved.nodeIdKey, idText(snapshot.ids.idOf(i)));
+    }
+    writeSlots(c, p.nodes, i, ATTRIBUTE_SLOTS);
+    w.close("}");
+    yield w.take();
+  }
+  w.close("]");
+  w.key(resolved.edgesKey);
+  w.open("[");
+  for (let e = 0; e < snapshot.edgeCount; e++) {
+    const disposition = edgeDisposition(p, e);
+    if (disposition === "skip") {
+      continue;
+    }
+    const [s, t] = endpoints(snapshot, p, e);
+    w.item();
+    w.open("{");
+    w.member(resolved.sourceKey, s);
+    w.member(resolved.targetKey, t);
+    const weight = p.weights(e);
+    if (weight !== null) {
+      w.member(resolved.weightKey, weight);
+    }
+    writeSlots(c, p.edges, e, ATTRIBUTE_SLOTS);
+    w.close("}");
+    yield w.take();
+  }
+  w.close("]");
+  w.close("}");
+  yield w.take();
+}
+function* writeVis(snapshot, p) {
+  const { resolved } = p;
+  const c = { w: new JsonWriter(resolved.indent), ids: snapshot.ids, nonfinite: { count: 0 } };
+  const { w } = c;
+  const nodeIdKey = resolved.nodeIdKey ?? "id";
+  w.open("{");
+  w.key("nodes");
+  w.open("[");
+  yield w.take();
+  for (let i = 0; i < snapshot.nodeCount; i++) {
+    w.item();
+    w.open("{");
+    w.member(nodeIdKey, idText(snapshot.ids.idOf(i)));
+    writeSlots(c, p.nodes, i, ATTRIBUTE_SLOTS);
+    w.close("}");
+    yield w.take();
+  }
+  w.close("]");
+  w.key("edges");
+  w.open("[");
+  for (let e = 0; e < snapshot.edgeCount; e++) {
+    if (edgeDisposition(p, e) === "skip") {
+      continue;
+    }
+    const list = snapshot.edgeList();
+    w.item();
+    w.open("{");
+    const id = edgeIdText(p, e, c);
+    if (id !== null) {
+      w.member("id", id);
+    }
+    w.member(resolved.sourceKey, idText(snapshot.ids.idOf(list.src[e])));
+    w.member(resolved.targetKey, idText(snapshot.ids.idOf(list.dst[e])));
+    const weight = p.weights(e);
+    if (weight !== null) {
+      w.member(resolved.weightKey, weight);
+    }
+    writeSlots(c, p.edges, e, ATTRIBUTE_SLOTS);
+    w.close("}");
+    yield w.take();
+  }
+  w.close("]");
+  w.close("}");
+  yield w.take();
+}
+function* writeGraphology(snapshot, p) {
+  const { resolved } = p;
+  const c = { w: new JsonWriter(resolved.indent), ids: snapshot.ids, nonfinite: { count: 0 } };
+  const { w } = c;
+  let type;
+  if (!p.directed) {
+    type = "undirected";
+  } else {
+    type = countMixedEdges(snapshot) > 0 ? "mixed" : "directed";
+  }
+  w.open("{");
+  w.key("attributes");
+  writeGraphObject(c, p);
+  w.key("options");
+  w.open("{");
+  w.member("type", JSON.stringify(type));
+  if (snapshot.meta.declaredMultigraph !== null || p.multigraph) {
+    w.member("multi", p.multigraph ? "true" : "false");
+  }
+  if (resolved.shape.allowSelfLoops !== void 0) {
+    w.member("allowSelfLoops", !resolved.shape.allowSelfLoops && snapshot.selfLoopCount === 0 ? "false" : "true");
+  }
+  w.close("}");
+  w.key("nodes");
+  w.open("[");
+  yield w.take();
+  for (let i = 0; i < snapshot.nodeCount; i++) {
+    w.item();
+    w.open("{");
+    w.member("key", idText(snapshot.ids.idOf(i)));
+    if (anySet(p.nodes, i, ATTRIBUTE_SLOTS)) {
+      w.key("attributes");
+      w.open("{");
+      writeSlots(c, p.nodes, i, ATTRIBUTE_SLOTS);
+      w.close("}");
+    }
+    writeSlots(c, p.nodes, i, ELEMENT_SLOTS);
+    w.close("}");
+    yield w.take();
+  }
+  w.close("]");
+  w.key("edges");
+  w.open("[");
+  for (let e = 0; e < snapshot.edgeCount; e++) {
+    const disposition = edgeDisposition(p, e);
+    if (disposition === "skip") {
+      continue;
+    }
+    const list = snapshot.edgeList();
+    w.item();
+    w.open("{");
+    const id = edgeIdText(p, e, c);
+    if (id !== null) {
+      w.member("key", id);
+    }
+    w.member("source", idText(snapshot.ids.idOf(list.src[e])));
+    w.member("target", idText(snapshot.ids.idOf(list.dst[e])));
+    if (type === "mixed" && disposition === "undirected") {
+      w.member("undirected", "true");
+    }
+    const weight = p.weights(e);
+    if (weight !== null || anySet(p.edges, e, ATTRIBUTE_SLOTS)) {
+      w.key("attributes");
+      w.open("{");
+      if (weight !== null) {
+        w.member(resolved.weightKey, weight);
+      }
+      writeSlots(c, p.edges, e, ATTRIBUTE_SLOTS);
+      w.close("}");
+    }
+    writeSlots(c, p.edges, e, ELEMENT_SLOTS);
+    w.close("}");
+    yield w.take();
+  }
+  w.close("]");
+  w.close("}");
+  yield w.take();
+}
+function* writeJgf(snapshot, p) {
+  const { resolved } = p;
+  const c = { w: new JsonWriter(resolved.indent), ids: snapshot.ids, nonfinite: { count: 0 } };
+  const { w } = c;
+  const labelSlots = /* @__PURE__ */ new Set(["label"]);
+  const relationSlots = /* @__PURE__ */ new Set(["relation"]);
+  w.open("{");
+  w.key("graph");
+  w.open("{");
+  if (resolved.shape.id !== void 0) {
+    w.member("id", JSON.stringify(resolved.shape.id));
+  }
+  if (snapshot.meta.name !== null) {
+    w.member("label", JSON.stringify(snapshot.meta.name));
+  }
+  if (resolved.shape.type !== void 0) {
+    w.member("type", JSON.stringify(resolved.shape.type));
+  }
+  w.member("directed", p.directed ? "true" : "false");
+  if (p.graph.some((item) => item.column.isSet(0))) {
+    w.key("metadata");
+    writeGraphObject(c, p);
+  }
+  w.key("nodes");
+  w.open("{");
+  yield w.take();
+  for (let i = 0; i < snapshot.nodeCount; i++) {
+    w.key(String(snapshot.ids.idOf(i)));
+    w.open("{");
+    writeSlots(c, p.nodes, i, labelSlots);
+    if (anySet(p.nodes, i, ATTRIBUTE_SLOTS)) {
+      w.key("metadata");
+      w.open("{");
+      writeSlots(c, p.nodes, i, ATTRIBUTE_SLOTS);
+      w.close("}");
+    }
+    writeSlots(c, p.nodes, i, ELEMENT_SLOTS);
+    w.close("}");
+    yield w.take();
+  }
+  w.close("}");
+  w.key("edges");
+  w.open("[");
+  for (let e = 0; e < snapshot.edgeCount; e++) {
+    const disposition = edgeDisposition(p, e);
+    if (disposition === "skip") {
+      continue;
+    }
+    const list = snapshot.edgeList();
+    w.item();
+    w.open("{");
+    const id = edgeIdText(p, e, c);
+    if (id !== null) {
+      w.member("id", id);
+    }
+    w.member("source", JSON.stringify(String(snapshot.ids.idOf(list.src[e]))));
+    w.member("target", JSON.stringify(String(snapshot.ids.idOf(list.dst[e]))));
+    writeSlots(c, p.edges, e, relationSlots);
+    if (p.directed && disposition === "undirected") {
+      w.member("directed", "false");
+    }
+    writeSlots(c, p.edges, e, labelSlots);
+    const weight = p.weights(e);
+    if (weight !== null || anySet(p.edges, e, ATTRIBUTE_SLOTS)) {
+      w.key("metadata");
+      w.open("{");
+      if (weight !== null) {
+        w.member(resolved.weightKey, weight);
+      }
+      writeSlots(c, p.edges, e, ATTRIBUTE_SLOTS);
+      w.close("}");
+    }
+    writeSlots(c, p.edges, e, ELEMENT_SLOTS);
+    w.close("}");
+    yield w.take();
+  }
+  w.close("]");
+  w.close("}");
+  w.close("}");
+  yield w.take();
+}
+function* writeCytoscape(snapshot, p) {
+  const { resolved } = p;
+  const c = { w: new JsonWriter(resolved.indent), ids: snapshot.ids, nonfinite: { count: 0 } };
+  const { w } = c;
+  const parentSlots = /* @__PURE__ */ new Set(["parent"]);
+  const positionSlots = /* @__PURE__ */ new Set(["cytoscapePosition"]);
+  w.open("{");
+  w.key("elements");
+  w.open("{");
+  w.key("nodes");
+  w.open("[");
+  yield w.take();
+  for (let i = 0; i < snapshot.nodeCount; i++) {
+    w.item();
+    w.open("{");
+    w.key("data");
+    w.open("{");
+    w.member("id", idText(snapshot.ids.idOf(i)));
+    writeSlots(c, p.nodes, i, parentSlots);
+    writeSlots(c, p.nodes, i, ATTRIBUTE_SLOTS);
+    w.close("}");
+    for (const item of p.nodes) {
+      if (positionSlots.has(item.slot) && item.column.isSet(i)) {
+        const value = item.column.value(i);
+        const f32 = item.column.dtype === "f32";
+        w.key("position");
+        w.open("{");
+        w.member("x", numberText(value[0], f32, c.nonfinite));
+        w.member("y", numberText(value[1], f32, c.nonfinite));
+        w.close("}");
+      }
+    }
+    writeSlots(c, p.nodes, i, ELEMENT_SLOTS);
+    w.close("}");
+    yield w.take();
+  }
+  w.close("]");
+  w.key("edges");
+  w.open("[");
+  const generated = edgeIdGenerator(snapshot, p);
+  for (let e = 0; e < snapshot.edgeCount; e++) {
+    if (edgeDisposition(p, e) === "skip") {
+      continue;
+    }
+    const list = snapshot.edgeList();
+    w.item();
+    w.open("{");
+    w.key("data");
+    w.open("{");
+    w.member("id", edgeIdText(p, e, c) ?? generated(e));
+    w.member("source", idText(snapshot.ids.idOf(list.src[e])));
+    w.member("target", idText(snapshot.ids.idOf(list.dst[e])));
+    const weight = p.weights(e);
+    if (weight !== null) {
+      w.member(resolved.weightKey, weight);
+    }
+    writeSlots(c, p.edges, e, ATTRIBUTE_SLOTS);
+    w.close("}");
+    writeSlots(c, p.edges, e, ELEMENT_SLOTS);
+    w.close("}");
+    yield w.take();
+  }
+  w.close("]");
+  w.close("}");
+  if (p.graph.some((item) => item.column.isSet(0))) {
+    w.key("data");
+    writeGraphObject(c, p);
+  }
+  const extra = resolved.shape.cytoscape;
+  if (extra !== void 0) {
+    for (const key of Object.keys(extra)) {
+      if (key !== "elements" && key !== "data") {
+        w.member(key, valueText(extra[key], false, c.nonfinite));
+      }
+    }
+  }
+  w.close("}");
+  yield w.take();
+}
+function edgeIdGenerator(snapshot, p) {
+  const used = /* @__PURE__ */ new Set();
+  for (let i = 0; i < snapshot.nodeCount; i++) {
+    used.add(String(snapshot.ids.idOf(i)));
+  }
+  const column = p.edgeIds;
+  if (column !== null) {
+    for (let e = 0; e < snapshot.edgeCount; e++) {
+      if (column.isSet(e)) {
+        used.add(String(column.value(e)));
+      }
+    }
+  }
+  return (e) => {
+    let candidate = `e${e}`;
+    for (let k = 2; used.has(candidate); k++) {
+      candidate = `e${e}_${k}`;
+    }
+    used.add(candidate);
+    return JSON.stringify(candidate);
+  };
+}
+const jsonExporter = Object.freeze({
+  format: "json",
+  capabilities: dialectCapabilities("node-link"),
+  /**
+   * Pre-flight: every loss of the selected dialect, without writing anything.
+   * @param snapshot - the snapshot
+   * @param options - format-specific and common options
+   * @returns the notes, empty when the export is exact
+   */
+  check(snapshot, options) {
+    return Object.freeze([...plan(snapshot, resolve(snapshot, options)).notes]);
+  },
+  /**
+   * Write the document as UTF-8 chunks.
+   * @param snapshot - the snapshot
+   * @param options - format-specific and common options
+   * @returns the chunks
+   */
+  export(snapshot, options) {
+    return encodeChunks(write(snapshot, plan(snapshot, resolve(snapshot, options))));
+  },
+  /**
+   * Write the document as one string.
+   * @param snapshot - the snapshot
+   * @param options - format-specific and common options
+   * @returns the document
+   */
+  exportToString(snapshot, options) {
+    return joinText(write(snapshot, plan(snapshot, resolve(snapshot, options))));
+  }
+});
+function jsonCapabilities(dialect) {
+  return dialectCapabilities(dialect);
+}
+const JSON_ISSUE = Object.freeze({
+  /** The text is empty or whitespace (fatal). */
+  EMPTY_INPUT: EMPTY_INPUT_CODE,
+  /** JSON.parse refused the text (fatal). */
+  SYNTAX: SYNTAX_CODE,
+  /** No dialect matches the document's top-level shape. */
+  DIALECT: "E_JSON_DIALECT",
+  /** A section (nodes, edges, elements, graph) has the wrong JSON type. */
+  SHAPE: "E_JSON_SHAPE",
+  /** A node-link document lacks its nodes or its edges array, or a Cytoscape document its elements. */
+  MISSING_SECTION: "E_MISSING_SECTION",
+  /** A node record or an element is not an object. */
+  BAD_ELEMENT: "E_BAD_ELEMENT",
+  /** A node record has no id. */
+  MISSING_ID: MISSING_ID_CODE,
+  /** A node id is a JSON boolean or null (legal in NetworkX, not a NodeId); coerced only under ids "string". */
+  UNSUPPORTED_ID: "E_UNSUPPORTED_ID",
+  /** An edge record has no source or no target. */
+  MISSING_ENDPOINT: MISSING_ENDPOINT_CODE,
+  /** An index endpoint is not an integer below the node count, or names a skipped node. */
+  BAD_INDEX: "E_BAD_INDEX",
+  /** A declared field has the wrong JSON type (JGF label / relation / metadata, Cytoscape position / classes). */
+  BAD_VALUE: "E_BAD_VALUE",
+  /** A graph-level flag (`directed`, `multigraph`, graphology `options`) has the wrong type; the default is used. */
+  BAD_FLAG: "W_BAD_FLAG",
+  /** A Cytoscape `data.parent` names an unknown node. */
+  UNKNOWN_PARENT: UNKNOWN_PARENT_CODE,
+  /** A node id repeated by a later record; the records are merged (the later attributes win). */
+  DUPLICATE_NODE: DUPLICATE_NODE_CODE,
+  /** An edge id (Cytoscape data.id, graphology key, vis id) repeated by a later edge; the edge is skipped. */
+  DUPLICATE_EDGE_ID: DUPLICATE_EDGE_ID_CODE,
+  /** Two distinct id texts merged into one number under ids "number". */
+  ID_MERGED: ID_MERGED_CODE,
+  /** Edge ids of mixed JSON types were stored as text. */
+  EDGE_ID_STRINGIFIED: "W_EDGE_ID_STRINGIFIED",
+  /** A JGF `graphs` array holds more than one graph; only `graphIndex` is read. */
+  MULTIPLE_GRAPHS: MULTIPLE_GRAPHS_CODE,
+  /** JGF hyperedges under the "error" policy. */
+  HYPEREDGE: HYPEREDGE_CODE,
+  /** JGF hyperedges skipped under the default "skip" policy. */
+  HYPEREDGES_SKIPPED: "W_HYPEREDGES_SKIPPED",
+  /** A JGF hyperedge with neither a nodes array nor source / target arrays. */
+  HYPEREDGE_SHAPE: "E_HYPEREDGE_SHAPE",
+  /** The nodes have no id key at all; array positions became the ids. */
+  POSITIONAL_NODES: "W_POSITIONAL_NODES",
+  /** A builder-policy option (addMissingNodes, duplicateEdges, selfLoops, weightDtype) differs from the sink's (the shared W_SINK_OPTION). */
+  SINK_OPTION: SINK_OPTION_CODE,
+  /** A common option the dialect has no use for (nodeIdFrom outside node-link, long, restoreMangledIds). */
+  OPTION_IGNORED: OPTION_IGNORED_CODE
+});
+const USED_OPTIONS = /* @__PURE__ */ new Set([
+  "ids",
+  "nodeIdFrom",
+  "addMissingNodes",
+  "duplicateEdges",
+  "selfLoops",
+  "onMixedDirection",
+  "defaultDirected",
+  "weightFrom",
+  "weightDtype",
+  "hyperedges",
+  "errorLimit",
+  "signal",
+  "onProgress"
+]);
+const FORMAT_DEFAULTS = { ids: "keep", defaultDirected: false, weightFrom: "weight" };
+const SNIFF_BYTES = 4096;
+const ABORT_CHECK_INTERVAL = 64;
+const SNIFF_KEYS = ['"nodes"', '"links"', '"edges"', '"elements"', '"graph"', '"graphs"'];
+const BOM = String.fromCharCode(65279);
+const JGF_EDGE_KEYS = /* @__PURE__ */ new Set([
+  "id",
+  "source",
+  "target",
+  "relation",
+  "directed",
+  "label",
+  "metadata"
+]);
+const JGF_HYPEREDGE_KEYS = /* @__PURE__ */ new Set([...JGF_EDGE_KEYS, "nodes"]);
+const JGF_NODE_KEYS = /* @__PURE__ */ new Set(["label", "metadata"]);
+const GRAPHOLOGY_NODE_KEYS = /* @__PURE__ */ new Set(["key", "attributes"]);
+const GRAPHOLOGY_EDGE_KEYS = /* @__PURE__ */ new Set(["key", "source", "target", "attributes", "undirected"]);
+const VIS_SOURCE_KEYS = Object.freeze(["from"]);
+const VIS_TARGET_KEYS = Object.freeze(["to"]);
+function resolveJsonOptions(options) {
+  const o = options ?? {};
+  const dialect = o.dialect ?? "auto";
+  if (dialect !== "auto" && !isJsonDialect(dialect)) {
+    throw unsupportedOption("dialect", dialect, [...JSON_DIALECTS, "auto"]);
+  }
+  const indexLinks = o.indexLinks ?? "auto";
+  if (indexLinks !== "auto" && typeof indexLinks !== "boolean") {
+    throw unsupportedOption("indexLinks", indexLinks, ["true", "false", "auto"]);
+  }
+  const graphIndex = o.graphIndex ?? 0;
+  if (!Number.isInteger(graphIndex) || graphIndex < 0) {
+    throw unsupportedOption("graphIndex", graphIndex, ["a non-negative integer"]);
+  }
+  return {
+    dialect,
+    nodeIdKey: keyOption("nodeIdKey", o.nodeIdKey),
+    edgesKey: keyOption("edgesKey", o.edgesKey),
+    sourceKey: keyOption("sourceKey", o.sourceKey),
+    targetKey: keyOption("targetKey", o.targetKey),
+    indexLinks,
+    graphIndex
+  };
+}
+function keyOption(name, value) {
+  if (value === void 0) {
+    return null;
+  }
+  if (typeof value !== "string" || value.length === 0) {
+    throw unsupportedOption(name, value, ["a non-empty key"]);
+  }
+  return value;
+}
+function unsupportedOption(name, found, supported) {
+  return new GraphFormatError(
+    "E_UNSUPPORTED",
+    `option ${name}: ${describe(found)} is not one of ${supported.join(", ")}`,
+    {
+      option: name,
+      found: typeof found === "string" ? found : typeof found,
+      supported: [...supported]
+    }
+  );
+}
+function describe(value) {
+  if (value === null) {
+    return "null";
+  }
+  if (Array.isArray(value)) {
+    return "array";
+  }
+  switch (typeof value) {
+    case "string":
+    case "number":
+    case "boolean":
+      return JSON.stringify(value);
+    default:
+      return typeof value;
+  }
+}
+class AttributeWriter {
+  /**
+   * Create a writer.
+   * @param sink - the sink
+   * @param domain - node or edge
+   */
+  constructor(sink, domain) {
+    this.handles = /* @__PURE__ */ new Map();
+    this.reservedNames = /* @__PURE__ */ new Set();
+    this.sink = sink;
+    this.domain = domain;
+  }
+  /**
+   * Declare a structural column up front; attribute keys with its name are suffixed from now on.
+   * @param decl - the declaration
+   * @returns the handle
+   */
+  declare(decl) {
+    this.reservedNames.add(decl.name);
+    const handle = this.domain === "node" ? this.sink.declareNodeColumn(decl) : this.sink.declareEdgeColumn(decl);
+    this.handles.set(decl.name, handle);
+    return handle;
+  }
+  /**
+   * Declare a structural column only when the file uses it.
+   * @param decl - the declaration
+   * @param present - whether any element carries the field
+   * @returns the handle, or INVALID_INDEX when not declared
+   */
+  declareIf(decl, present) {
+    return present ? this.declare(decl) : INVALID_INDEX;
+  }
+  /**
+   * Whether a name is taken in the sink's table (for the deterministic rename rule).
+   * @param name - the column name
+   * @returns true when a column of that name exists
+   */
+  taken(name) {
+    return this.lookup(name) !== INVALID_INDEX;
+  }
+  /**
+   * Write one attribute cell by its source key; null and undefined leave the row unset.
+   * @param row - the node or edge index
+   * @param key - the source key
+   * @param value - the JSON value
+   * @param suffix - the suffix applied when the key collides with a structural column
+   */
+  write(row, key, value, suffix) {
+    if (value === void 0 || value === null) {
+      return;
+    }
+    const name = this.reservedNames.has(key) ? `${key}${suffix}` : key;
+    const cached = this.handles.get(name);
+    if (cached !== void 0) {
+      this.set(cached, row, value);
+      return;
+    }
+    this.set(name, row, value);
+    const handle = this.lookup(name);
+    if (handle !== INVALID_INDEX) {
+      this.handles.set(name, handle);
+    }
+  }
+  /**
+   * Write through a handle or a name.
+   * @param column - the handle or name
+   * @param row - the row
+   * @param value - the value
+   */
+  set(column, row, value) {
+    if (this.domain === "node") {
+      this.sink.setNodeValue(column, row, value);
+    } else {
+      this.sink.setEdgeValue(column, row, value);
+    }
+  }
+  /**
+   * Look a column up by name.
+   * @param name - the column name
+   * @returns the handle, or INVALID_INDEX
+   */
+  lookup(name) {
+    return this.domain === "node" ? this.sink.nodeColumn(name) : this.sink.edgeColumn(name);
+  }
+}
+class ImportContext {
+  /**
+   * Create the context.
+   * @param sink - the sink
+   * @param report - the report
+   * @param options - the resolved common options
+   * @param json - the resolved format options
+   * @param explicitDefaultDirected - whether the caller passed defaultDirected
+   */
+  constructor(sink, report, options, json, explicitDefaultDirected) {
+    this.elementsSinceCheck = 0;
+    this.fileDirected = false;
+    this.sink = sink;
+    this.report = report;
+    this.options = options;
+    this.json = json;
+    this.ids = new IdCoercer(options.ids);
+    this.direction = new DirectionResolver(sink, report, options.onMixedDirection);
+    this.nodes = new AttributeWriter(sink, "node");
+    this.edges = new AttributeWriter(sink, "edge");
+    this.explicitDefaultDirected = explicitDefaultDirected;
+  }
+  /**
+   * Report a `nodeIdFrom` other than "id" for a dialect whose ids are unambiguous.
+   * @param dialect - the dialect
+   * @param idField - where the dialect's ids come from, for the message
+   */
+  reportNodeIdFrom(dialect, idField) {
+    if (this.options.nodeIdFrom !== "id") {
+      this.report.warning(
+        "unsupported",
+        JSON_ISSUE.OPTION_IGNORED,
+        `nodeIdFrom "${this.options.nodeIdFrom}" does not apply to ${dialect}; ids are read from ${idField}`,
+        { element: "nodeIdFrom" }
+      );
+    }
+  }
+  /**
+   * The direction assumed when the file declares none: the caller's `defaultDirected` when given,
+   * else the dialect's convention.
+   * @param dialect - the dialect
+   * @returns the direction
+   */
+  defaultDirected(dialect) {
+    return this.explicitDefaultDirected ? this.options.defaultDirected : DIALECT_DEFAULT_DIRECTED[dialect];
+  }
+  /**
+   * Rule 1 of design section 8.4: set the sink's direction from the file's header (or the
+   * dialect's default) before the first edge, remembering the file's direction for uniformKind().
+   * @param directed - the file's direction
+   */
+  setHeader(directed) {
+    this.fileDirected = directed;
+    this.direction.setHeader(directed);
+  }
+  /**
+   * The edge kind every edge of a dialect without per-edge direction has: the file's direction
+   * (the resolver expands it when the sink's direction differs).
+   * @returns the kind
+   */
+  uniformKind() {
+    return this.fileDirected ? "directed" : "undirected";
+  }
+  /**
+   * Coerce a node id value per the `ids` option, reporting what cannot be an id. A JSON boolean or
+   * null is `unsupported` unless `ids` is "string" (design section 8.5); anything the rule rejects
+   * is recorded through the per-element catch.
+   * @param raw - the JSON value; undefined when the record has no id key
+   * @param element - the element name for the issue
+   * @returns the id, or null when the value was reported and the element must be skipped
+   */
+  coerceId(raw, element) {
+    if (raw === void 0) {
+      this.report.error("missing-value", JSON_ISSUE.MISSING_ID, `${element} has no id`, { element });
+      return null;
+    }
+    if ((typeof raw === "boolean" || raw === null) && this.options.ids !== "string") {
+      const kind = raw === null ? "null" : "boolean";
+      this.report.error(
+        "unsupported",
+        JSON_ISSUE.UNSUPPORTED_ID,
+        `${element}: a JSON ${kind} is not a node id (pass ids: "string" to coerce it)`,
+        { element }
+      );
+      return null;
+    }
+    let id;
+    try {
+      id = this.ids.value(this.options.ids === "string" && typeof raw === "number" ? String(raw) : raw);
+    } catch (err) {
+      this.report.recordError(err, { element });
+      return null;
+    }
+    const merge = this.ids.lastMerge;
+    if (merge !== null) {
+      this.report.warning(
+        "coercion",
+        JSON_ISSUE.ID_MERGED,
+        `id text ${JSON.stringify(merge.text)} merged with ${JSON.stringify(merge.previousText)} as ${merge.id}`,
+        { element }
+      );
+    }
+    return id;
+  }
+  /**
+   * Coerce an id that must be valid for the caller to proceed (hyperedge members): the rejections
+   * of coerceId() are thrown instead of recorded.
+   * @param raw - the JSON value
+   * @param element - the element name
+   * @returns the id
+   */
+  requireId(raw, element) {
+    if ((typeof raw === "boolean" || raw === null) && this.options.ids !== "string") {
+      const kind = raw === null ? "null" : "boolean";
+      throw new GraphFormatError("E_INVALID_ID", `${element}: a JSON ${kind} is not a node id`, {
+        reason: "unsupported id"
+      });
+    }
+    return this.ids.value(this.options.ids === "string" && typeof raw === "number" ? String(raw) : raw);
+  }
+  /**
+   * Add a node, counting it or recording the failure.
+   * @param id - the node id
+   * @param element - the element name
+   * @returns the node index, or -1 when the sink refused the node
+   */
+  pushNode(id, element) {
+    this.checkAbort();
+    const existing = this.sink.indexOf(id);
+    if (existing !== INVALID_INDEX) {
+      this.report.warning(
+        "merged",
+        JSON_ISSUE.DUPLICATE_NODE,
+        `${element}: node ${JSON.stringify(id)} already exists; its attributes are merged (the later values win)`,
+        { element }
+      );
+      return existing;
+    }
+    let index;
+    try {
+      index = this.sink.addNode(id);
+    } catch (err) {
+      this.skip(err, "node", element);
+      return -1;
+    }
+    this.report.counts.nodes++;
+    return index;
+  }
+  /**
+   * Push one edge through the direction resolver, counting every logical edge the sink gained
+   * (both halves of an expanded edge, and the mirrors of an in-place expansion).
+   * @param source - the source id
+   * @param target - the target id
+   * @param kind - the edge's direction in the file
+   * @param weight - the weight, or undefined
+   * @param element - the element name for issues
+   * @returns the primary edge index
+   */
+  pushEdge(source, target, kind, weight, element) {
+    this.checkAbort();
+    const before = this.sink.edgeCount;
+    let created = this.sink.indexOf(source) === INVALID_INDEX ? 1 : 0;
+    if (source !== target && this.sink.indexOf(target) === INVALID_INDEX) {
+      created++;
+    }
+    const edge = this.direction.addEdge(source, target, kind, weight, { element });
+    this.report.counts.edges += this.sink.edgeCount - before;
+    this.report.counts.nodes += created;
+    return edge;
+  }
+  /**
+   * Check the cancellation signal every ABORT_CHECK_INTERVAL pushed elements, so an abort raised
+   * while the whole in-memory document is being walked rejects promptly.
+   */
+  checkAbort() {
+    if (++this.elementsSinceCheck >= ABORT_CHECK_INTERVAL) {
+      this.elementsSinceCheck = 0;
+      throwIfAborted(this.options.signal);
+    }
+  }
+  /**
+   * Record a per-element failure and count the skipped element.
+   * @param err - the thrown value
+   * @param domain - which counter to bump
+   * @param element - the element name
+   */
+  skip(err, domain, element) {
+    this.report.recordError(err, { element });
+    if (domain === "node") {
+      this.report.counts.skippedNodes++;
+    } else {
+      this.report.counts.skippedEdges++;
+    }
+  }
+  /**
+   * Report an element that is not an object and count it as skipped.
+   * @param domain - node or edge
+   * @param element - the element name
+   * @param what - what was expected
+   */
+  badElement(domain, element, what = "an object") {
+    this.report.error("validation-error", JSON_ISSUE.BAD_ELEMENT, `${element} is not ${what}`, { element });
+    this.countSkipped(domain);
+  }
+  /**
+   * Count a skipped element whose issue was already recorded.
+   * @param domain - node or edge
+   */
+  countSkipped(domain) {
+    if (domain === "node") {
+      this.report.counts.skippedNodes++;
+    } else {
+      this.report.counts.skippedEdges++;
+    }
+  }
+  /**
+   * Report an edge record without an endpoint and count it as skipped.
+   * @param element - the element name
+   * @param field - the missing field
+   */
+  missingEndpoint(element, field) {
+    this.report.error("missing-value", JSON_ISSUE.MISSING_ENDPOINT, `${element} has no ${field}`, { element });
+    this.report.counts.skippedEdges++;
+  }
+  /**
+   * Record the shape metadata, the source format and further metadata fields in one setMeta()
+   * call (the sink replaces `extra` as a whole).
+   * @param shape - the shape record
+   * @param patch - further metadata fields
+   */
+  setMeta(shape, patch = {}) {
+    const extra = {};
+    for (const [key, value] of Object.entries(shape)) {
+      if (value !== void 0) {
+        extra[key] = value;
+      }
+    }
+    this.sink.setMeta({ sourceFormat: "json", ...patch, extra: { [META_KEY]: extra } });
+  }
+  /**
+   * Record which source field the weight came from, so the exporter writes it back under the same
+   * key (design section 3.7, `meta.weightOrigin`).
+   * @returns the metadata patch, empty for an unweighted import
+   */
+  weightOriginPatch() {
+    const { weightFrom } = this.options;
+    if (weightFrom === null) {
+      return {};
+    }
+    return { weightOrigin: { format: "json", id: weightFrom, title: null, type: null, namespace: null } };
+  }
+  /**
+   * Write the graph-level attributes of a dict (NetworkX `graph`, JGF `metadata`, graphology
+   * `attributes`, Cytoscape `data`), one column per key.
+   * @param dict - the dict, or anything else (then reported)
+   * @param what - the dict's name for the issue
+   */
+  writeGraphDict(dict, what) {
+    if (dict === void 0 || dict === null) {
+      return;
+    }
+    if (!isJsonObject(dict)) {
+      this.report.warning("validation-error", JSON_ISSUE.BAD_FLAG, `${what} is not an object; ignored`, {
+        element: what
+      });
+      return;
+    }
+    for (const key of Object.keys(dict)) {
+      const value = dict[key];
+      if (value === void 0 || value === null) {
+        continue;
+      }
+      try {
+        this.sink.setGraphValue(key, value);
+      } catch (err) {
+        this.report.recordError(err, { element: `${what}.${key}` });
+      }
+    }
+  }
+  /**
+   * Read the weight field of an edge record.
+   * @param record - the record holding the attributes
+   * @returns the weight, or undefined when absent or null; E_INVALID_WEIGHT otherwise
+   */
+  weightOf(record) {
+    const { weightFrom } = this.options;
+    if (weightFrom === null || !hasKey(record, weightFrom)) {
+      return void 0;
+    }
+    return weightFromValue(record[weightFrom]);
+  }
+  /**
+   * Write the attributes of a nested dict plus the element-level keys the dialect does not
+   * define (kept with the `#element` suffix).
+   * @param writer - the table writer
+   * @param row - the row
+   * @param record - the element record
+   * @param dict - the nested attribute dict
+   * @param structural - the element keys that are not attributes
+   * @param weightFrom - the weight key to skip in the dict, or null
+   */
+  writeNested(writer, row, record, dict, structural, weightFrom) {
+    for (const key of Object.keys(dict)) {
+      if (key !== weightFrom) {
+        writer.write(row, key, dict[key], SUFFIX.data);
+      }
+    }
+    for (const key of Object.keys(record)) {
+      if (!structural.has(key)) {
+        writer.write(row, `${key}${SUFFIX.element}`, record[key], SUFFIX.data);
+      }
+    }
+  }
+  /**
+   * Write a spec-typed string field (JGF label / relation), reporting a value of another type.
+   * @param writer - the table writer
+   * @param column - the declared column, or INVALID_INDEX when the file has no such field
+   * @param row - the row
+   * @param value - the value
+   * @param field - the field name
+   * @param element - the element name
+   */
+  writeStringField(writer, column, row, value, field, element) {
+    if (column === INVALID_INDEX || value === void 0 || value === null) {
+      return;
+    }
+    if (typeof value !== "string") {
+      this.report.error(
+        "validation-error",
+        JSON_ISSUE.BAD_VALUE,
+        `${element}: ${field} must be a string, found ${describe(value)}`,
+        { element }
+      );
+      return;
+    }
+    writer.set(column, row, value);
+  }
+  /**
+   * Declare an edge id column with role "id" from a scan of the file's edge ids: f64 when every
+   * id is a number, string otherwise (numbers are then stored as their text and reported once).
+   * @param edges - the edge records
+   * @param read - how to read an edge's raw id
+   * @param name - the column name
+   * @param unique - whether uniqueness is enforced at freeze
+   * @returns the column, or null when no edge has an id
+   */
+  declareEdgeIds(edges, read, name, unique) {
+    let numbers = 0;
+    let strings = 0;
+    for (const edge of edges) {
+      if (!isJsonObject(edge)) {
+        continue;
+      }
+      const raw = read(edge);
+      if (typeof raw === "number") {
+        numbers++;
+      } else if (typeof raw === "string") {
+        strings++;
+      }
+    }
+    if (numbers + strings === 0) {
+      return null;
+    }
+    const dtype = strings === 0 ? "f64" : "string";
+    const columnName = uniqueColumnName(name, "id", (candidate) => this.edges.taken(candidate));
+    const handle = this.edges.declare({ name: columnName, dtype, role: "id", nullable: true, unique });
+    const stringify = strings > 0 && numbers > 0;
+    const seen = unique ? /* @__PURE__ */ new Set() : null;
+    if (stringify) {
+      this.report.warning(
+        "coercion",
+        JSON_ISSUE.EDGE_ID_STRINGIFIED,
+        `edge ids mix numbers and strings; ${numbers} numeric id(s) stored as text`,
+        { element: columnName }
+      );
+    }
+    return { handle, stringify, seen };
+  }
+  /**
+   * The value an edge id column stores for a raw id, checked BEFORE the edge is pushed so a bad
+   * id skips the edge without touching the sink (design section 11.1).
+   * @param column - the column, or null when the file has no edge ids
+   * @param raw - the raw id value
+   * @returns the value to store, or null when there is nothing to store
+   */
+  edgeIdValue(column, raw) {
+    if (column === null || raw === void 0 || raw === null) {
+      return null;
+    }
+    let value;
+    if (typeof raw === "number") {
+      value = column.stringify ? String(raw) : raw;
+    } else if (typeof raw === "string") {
+      value = raw;
+    } else {
+      throw new GraphFormatError(
+        "E_COLUMN_TYPE",
+        `an edge id must be a string or a number, found ${describe(raw)}`,
+        { found: typeof raw }
+      );
+    }
+    if (column.seen !== null) {
+      const text = String(value);
+      if (column.seen.has(text)) {
+        throw new GraphFormatError(
+          JSON_ISSUE.DUPLICATE_EDGE_ID,
+          `edge id ${JSON.stringify(value)} is declared more than once; the edge is skipped`,
+          { id: value }
+        );
+      }
+      column.seen.add(text);
+    }
+    return value;
+  }
+  /**
+   * Write an edge id value from edgeIdValue().
+   * @param column - the column, or null
+   * @param edge - the edge index
+   * @param value - the value, or null for none
+   */
+  setEdgeId(column, edge, value) {
+    if (column !== null && value !== null) {
+      this.edges.set(column.handle, edge, value);
+    }
+  }
+}
+function parseDocument(text, report) {
+  if (text.trim().length === 0) {
+    report.fail(JSON_ISSUE.EMPTY_INPUT, "the input is empty");
+  }
+  try {
+    return JSON.parse(text);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return report.fail(JSON_ISSUE.SYNTAX, `invalid JSON: ${message}`);
+  }
+}
+function detectDialect(root, forced, report) {
+  if (forced !== "auto") {
+    return forced;
+  }
+  const dialect = sniffJsonDialect(root);
+  if (dialect !== null) {
+    return dialect;
+  }
+  if (Array.isArray(root)) {
+    return report.fail(
+      JSON_ISSUE.DIALECT,
+      "a top-level array is only read as Cytoscape elements (objects with a data record)"
+    );
+  }
+  if (!isJsonObject(root)) {
+    return report.fail(JSON_ISSUE.DIALECT, `the document is a JSON ${describe(root)}, not a graph object`);
+  }
+  return report.fail(
+    JSON_ISSUE.DIALECT,
+    "no known dialect: expected nodes / links / edges (node-link), elements (Cytoscape) or graph (JGF)"
+  );
+}
+function arraySection(value, what, report) {
+  if (value === void 0 || value === null) {
+    return null;
+  }
+  if (!Array.isArray(value)) {
+    return report.fail(JSON_ISSUE.SHAPE, `${what} must be an array, found ${describe(value)}`, { element: what });
+  }
+  return value;
+}
+function flagOf(value, what, fallback, report) {
+  if (value === void 0 || value === null) {
+    return fallback;
+  }
+  if (typeof value === "boolean") {
+    return value;
+  }
+  report.warning(
+    "validation-error",
+    JSON_ISSUE.BAD_FLAG,
+    `${what} is ${describe(value)}, not a boolean; ${fallback} assumed`,
+    { element: what }
+  );
+  return fallback;
+}
+function endpointOf(record, explicit, defaults) {
+  if (explicit !== null) {
+    return { key: hasKey(record, explicit) ? explicit : null, value: record[explicit] };
+  }
+  for (const key of defaults) {
+    if (hasKey(record, key)) {
+      return { key, value: record[key] };
+    }
+  }
+  return { key: null, value: void 0 };
+}
+function anyHas(items, key) {
+  return items.some((item) => isJsonObject(item) && item[key] !== void 0 && item[key] !== null);
+}
+function isIndexBelow(value, bound) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0 && value < bound;
+}
+function importNodeLink(ctx, root, dialect) {
+  const { report, json } = ctx;
+  let { edgesKey } = json;
+  if (edgesKey === null) {
+    edgesKey = hasKey(root, "edges") || !hasKey(root, "links") ? "edges" : "links";
+  }
+  const nodes = arraySection(root.nodes, "nodes", report);
+  const edges = arraySection(root[edgesKey], edgesKey, report);
+  if (nodes === null) {
+    report.error(
+      "missing-value",
+      JSON_ISSUE.MISSING_SECTION,
+      "the document has no nodes array; nodes come from the edges",
+      { element: "nodes" }
+    );
+  }
+  if (edges === null) {
+    report.error(
+      "missing-value",
+      JSON_ISSUE.MISSING_SECTION,
+      `the document has no ${edgesKey} array; the graph has no edges`,
+      { element: edgesKey }
+    );
+  }
+  const directed = flagOf(root.directed, "directed", ctx.defaultDirected(dialect), report);
+  const multigraph = hasKey(root, "multigraph") ? flagOf(root.multigraph, "multigraph", false, report) : null;
+  ctx.setHeader(directed);
+  ctx.writeGraphDict(root.graph, "graph");
+  const nodeList = nodes ?? [];
+  const edgeList = edges ?? [];
+  ctx.sink.reserve(nodeList.length, edgeList.length);
+  let { nodeIdKey } = json;
+  let positional = ctx.options.nodeIdFrom === "index";
+  if (!positional && nodeIdKey === null) {
+    const candidates = ctx.options.nodeIdFrom === "label" ? ["label", "name", "id"] : ["id", "name"];
+    nodeIdKey = candidates.find((key) => anyHas(nodeList, key)) ?? null;
+    if (ctx.options.nodeIdFrom === "label" && nodeIdKey === "id") {
+      report.warning(
+        "unsupported",
+        JSON_ISSUE.OPTION_IGNORED,
+        'nodeIdFrom "label": no node has a label or name key; ids are read from "id"',
+        { element: "nodeIdFrom" }
+      );
+    }
+    if (nodeIdKey === null) {
+      if (nodeList.length > 0) {
+        positional = true;
+        report.warning(
+          "missing-value",
+          JSON_ISSUE.POSITIONAL_NODES,
+          "no node has an id or name key; array positions are the node ids",
+          { element: "nodes" }
+        );
+      } else {
+        nodeIdKey = "id";
+      }
+    }
+  }
+  if (positional) {
+    nodeIdKey = null;
+  }
+  let indexLinks;
+  if (positional) {
+    indexLinks = true;
+  } else if (json.indexLinks === "auto") {
+    indexLinks = nodeIdKey !== null && looksIndexLinked(nodeList, edgeList, nodeIdKey, json);
+  } else {
+    ({ indexLinks } = json);
+  }
+  const positionIds = indexLinks ? [] : null;
+  for (let i = 0; i < nodeList.length; i++) {
+    const element = `nodes[${i}]`;
+    const record = nodeList[i];
+    let pushed = null;
+    if (!isJsonObject(record)) {
+      ctx.badElement("node", element);
+    } else {
+      let id;
+      if (nodeIdKey === null) {
+        id = i;
+      } else {
+        id = ctx.coerceId(hasKey(record, nodeIdKey) ? record[nodeIdKey] : void 0, element);
+      }
+      if (id === null) {
+        ctx.countSkipped("node");
+      } else {
+        const index = ctx.pushNode(id, element);
+        if (index >= 0) {
+          pushed = id;
+          writeFlat(ctx, ctx.nodes, index, record, id, (key) => key !== nodeIdKey);
+        }
+      }
+    }
+    positionIds?.push(pushed);
+  }
+  throwIfAborted(ctx.options.signal);
+  const endpointKeys = importNodeLinkEdges(ctx, edgeList, edgesKey, positionIds);
+  ctx.setMeta(
+    {
+      dialect,
+      edgesKey,
+      nodeIdKey,
+      indexLinks,
+      sourceKey: endpointKeys.source ?? void 0,
+      targetKey: endpointKeys.target ?? void 0
+    },
+    { declaredMultigraph: multigraph, ...ctx.weightOriginPatch() }
+  );
+}
+function importNodeLinkEdges(ctx, edgeList, edgesKey, positionIds) {
+  const { json } = ctx;
+  const kind = ctx.uniformKind();
+  let sourceKey = null;
+  let targetKey = null;
+  for (let i = 0; i < edgeList.length; i++) {
+    const element = `${edgesKey}[${i}]`;
+    const record = edgeList[i];
+    if (!isJsonObject(record)) {
+      ctx.badElement("edge", element);
+      continue;
+    }
+    const source = endpointOf(record, json.sourceKey, NODE_LINK_SOURCE_KEYS);
+    const target = endpointOf(record, json.targetKey, NODE_LINK_TARGET_KEYS);
+    if (source.key === null || target.key === null) {
+      ctx.missingEndpoint(element, source.key === null ? "source" : "target");
+      continue;
+    }
+    sourceKey ??= source.key;
+    targetKey ??= target.key;
+    try {
+      const u = resolveEndpoint(ctx, source.value, positionIds, element, "source");
+      const v = resolveEndpoint(ctx, target.value, positionIds, element, "target");
+      if (u === null || v === null) {
+        ctx.countSkipped("edge");
+        continue;
+      }
+      const weight = ctx.weightOf(record);
+      const edge = ctx.pushEdge(u, v, kind, weight, element);
+      const { weightFrom } = ctx.options;
+      for (const key of Object.keys(record)) {
+        if (key !== source.key && key !== target.key && key !== weightFrom) {
+          ctx.edges.write(edge, key, record[key], SUFFIX.data);
+        }
+      }
+    } catch (err) {
+      ctx.skip(err, "edge", element);
+    }
+  }
+  return { source: sourceKey, target: targetKey };
+}
+function writeFlat(ctx, writer, index, record, id, keep) {
+  try {
+    for (const key of Object.keys(record)) {
+      if (keep(key)) {
+        writer.write(index, key, record[key], SUFFIX.data);
+      }
+    }
+  } catch (err) {
+    ctx.report.recordError(err, { element: String(id) });
+  }
+}
+function looksIndexLinked(nodes, edges, nodeIdKey, json) {
+  if (edges.length === 0 || nodes.length === 0) {
+    return false;
+  }
+  for (const node of nodes) {
+    if (isJsonObject(node) && typeof node[nodeIdKey] === "number") {
+      return false;
+    }
+  }
+  let seen = 0;
+  for (const edge of edges) {
+    if (!isJsonObject(edge)) {
+      continue;
+    }
+    const s = endpointOf(edge, json.sourceKey, NODE_LINK_SOURCE_KEYS).value;
+    const t = endpointOf(edge, json.targetKey, NODE_LINK_TARGET_KEYS).value;
+    if (!isIndexBelow(s, Infinity) || !isIndexBelow(t, Infinity)) {
+      return false;
+    }
+    seen++;
+  }
+  return seen > 0;
+}
+function resolveEndpoint(ctx, raw, positionIds, element, field) {
+  if (positionIds === null) {
+    return ctx.coerceId(raw, `${element}.${field}`);
+  }
+  if (!isIndexBelow(raw, positionIds.length)) {
+    ctx.report.error(
+      "validation-error",
+      JSON_ISSUE.BAD_INDEX,
+      `${element}: ${field} ${describe(raw)} is not a node index below ${positionIds.length}`,
+      { element }
+    );
+    return null;
+  }
+  const id = positionIds[raw];
+  if (id === null) {
+    ctx.report.error("missing-value", JSON_ISSUE.BAD_INDEX, `${element}: ${field} names a node that was skipped`, {
+      element
+    });
+  }
+  return id;
+}
+function importVis(ctx, root) {
+  const { report, json } = ctx;
+  const nodes = arraySection(root.nodes, "nodes", report) ?? [];
+  const edges = arraySection(root.edges, "edges", report) ?? [];
+  ctx.setHeader(ctx.defaultDirected("vis"));
+  ctx.sink.reserve(nodes.length, edges.length);
+  const nodeIdKey = json.nodeIdKey ?? "id";
+  ctx.reportNodeIdFrom("vis", `the ${JSON.stringify(nodeIdKey)} key`);
+  for (let i = 0; i < nodes.length; i++) {
+    const element = `nodes[${i}]`;
+    const record = nodes[i];
+    if (!isJsonObject(record)) {
+      ctx.badElement("node", element);
+      continue;
+    }
+    const id = ctx.coerceId(hasKey(record, nodeIdKey) ? record[nodeIdKey] : void 0, element);
+    if (id === null) {
+      ctx.countSkipped("node");
+      continue;
+    }
+    const index = ctx.pushNode(id, element);
+    if (index >= 0) {
+      writeFlat(ctx, ctx.nodes, index, record, id, (key) => key !== nodeIdKey);
+    }
+  }
+  throwIfAborted(ctx.options.signal);
+  const ids = ctx.declareEdgeIds(edges, (edge) => edge.id, "id", true);
+  const kind = ctx.uniformKind();
+  let sourceKey = null;
+  let targetKey = null;
+  for (let i = 0; i < edges.length; i++) {
+    const element = `edges[${i}]`;
+    const record = edges[i];
+    if (!isJsonObject(record)) {
+      ctx.badElement("edge", element);
+      continue;
+    }
+    const source = endpointOf(record, json.sourceKey, VIS_SOURCE_KEYS);
+    const target = endpointOf(record, json.targetKey, VIS_TARGET_KEYS);
+    if (source.key === null || target.key === null) {
+      ctx.missingEndpoint(element, source.key === null ? "from" : "to");
+      continue;
+    }
+    sourceKey ??= source.key;
+    targetKey ??= target.key;
+    try {
+      const u = ctx.coerceId(source.value, `${element}.from`);
+      const v = ctx.coerceId(target.value, `${element}.to`);
+      if (u === null || v === null) {
+        ctx.countSkipped("edge");
+        continue;
+      }
+      const idValue = ctx.edgeIdValue(ids, record.id);
+      const edge = ctx.pushEdge(u, v, kind, ctx.weightOf(record), element);
+      ctx.setEdgeId(ids, edge, idValue);
+      const { weightFrom } = ctx.options;
+      for (const key of Object.keys(record)) {
+        if (key !== source.key && key !== target.key && key !== "id" && key !== weightFrom) {
+          ctx.edges.write(edge, key, record[key], SUFFIX.data);
+        }
+      }
+    } catch (err) {
+      ctx.skip(err, "edge", element);
+    }
+  }
+  ctx.setMeta(
+    { dialect: "vis", nodeIdKey, sourceKey: sourceKey ?? void 0, targetKey: targetKey ?? void 0 },
+    ctx.weightOriginPatch()
+  );
+}
+function importGraphology(ctx, root) {
+  const { report } = ctx;
+  const nodes = arraySection(root.nodes, "nodes", report) ?? [];
+  const edges = arraySection(root.edges, "edges", report) ?? [];
+  const options = isJsonObject(root.options) ? root.options : {};
+  if (hasKey(root, "options") && !isJsonObject(root.options)) {
+    report.warning("validation-error", JSON_ISSUE.BAD_FLAG, "options is not an object; ignored", {
+      element: "options"
+    });
+  }
+  let type;
+  if (options.type === "directed" || options.type === "undirected" || options.type === "mixed") {
+    ({ type } = options);
+  } else {
+    if (options.type !== void 0 && options.type !== null) {
+      report.warning(
+        "validation-error",
+        JSON_ISSUE.BAD_FLAG,
+        `options.type ${describe(options.type)} is not directed, undirected or mixed; mixed assumed`,
+        { element: "options.type" }
+      );
+    }
+    type = "mixed";
+  }
+  let directed;
+  if (type === "mixed") {
+    const objects = edges.filter((edge) => isJsonObject(edge));
+    const undirectedEdges = objects.filter((edge) => edge.undirected === true).length;
+    directed = objects.length === 0 ? ctx.defaultDirected("graphology") : undirectedEdges < objects.length;
+  } else {
+    directed = type === "directed";
+  }
+  ctx.setHeader(directed);
+  const multi = hasKey(options, "multi") ? flagOf(options.multi, "options.multi", false, report) : null;
+  const allowSelfLoops = hasKey(options, "allowSelfLoops") ? flagOf(options.allowSelfLoops, "options.allowSelfLoops", true, report) : void 0;
+  ctx.writeGraphDict(root.attributes, "attributes");
+  ctx.reportNodeIdFrom("graphology", "the node key");
+  ctx.sink.reserve(nodes.length, edges.length);
+  for (let i = 0; i < nodes.length; i++) {
+    const element = `nodes[${i}]`;
+    const record = nodes[i];
+    if (!isJsonObject(record)) {
+      ctx.badElement("node", element);
+      continue;
+    }
+    const id = ctx.coerceId(hasKey(record, "key") ? record.key : void 0, element);
+    if (id === null) {
+      ctx.countSkipped("node");
+      continue;
+    }
+    pushNestedNode(ctx, id, record, "attributes", GRAPHOLOGY_NODE_KEYS, element);
+  }
+  throwIfAborted(ctx.options.signal);
+  const ids = ctx.declareEdgeIds(edges, (edge) => edge.key, "key", true);
+  for (let i = 0; i < edges.length; i++) {
+    const element = `edges[${i}]`;
+    const record = edges[i];
+    if (!isJsonObject(record)) {
+      ctx.badElement("edge", element);
+      continue;
+    }
+    if (!hasKey(record, "source") || !hasKey(record, "target")) {
+      ctx.missingEndpoint(element, hasKey(record, "source") ? "target" : "source");
+      continue;
+    }
+    try {
+      const u = ctx.coerceId(record.source, `${element}.source`);
+      const v = ctx.coerceId(record.target, `${element}.target`);
+      if (u === null || v === null) {
+        ctx.countSkipped("edge");
+        continue;
+      }
+      let kind;
+      if (type === "mixed") {
+        kind = flagOf(record.undirected, `${element}.undirected`, false, report) ? "undirected" : "directed";
+      } else {
+        kind = type;
+      }
+      const attributes = isJsonObject(record.attributes) ? record.attributes : {};
+      const idValue = ctx.edgeIdValue(ids, record.key);
+      const edge = ctx.pushEdge(u, v, kind, ctx.weightOf(attributes), element);
+      ctx.setEdgeId(ids, edge, idValue);
+      ctx.writeNested(ctx.edges, edge, record, attributes, GRAPHOLOGY_EDGE_KEYS, ctx.options.weightFrom);
+    } catch (err) {
+      ctx.skip(err, "edge", element);
+    }
+  }
+  ctx.setMeta({ dialect: "graphology", allowSelfLoops }, { declaredMultigraph: multi, ...ctx.weightOriginPatch() });
+}
+function pushNestedNode(ctx, id, record, dictKey, structural, element) {
+  const index = ctx.pushNode(id, element);
+  if (index < 0) {
+    return index;
+  }
+  try {
+    const dict = record[dictKey];
+    if (dict !== void 0 && dict !== null && !isJsonObject(dict)) {
+      ctx.report.error(
+        "validation-error",
+        JSON_ISSUE.BAD_VALUE,
+        `${element}: ${dictKey} must be an object, found ${describe(dict)}`,
+        { element }
+      );
+    }
+    ctx.writeNested(ctx.nodes, index, record, isJsonObject(dict) ? dict : {}, structural, null);
+  } catch (err) {
+    ctx.report.recordError(err, { element: String(id) });
+  }
+  return index;
+}
+function importJgf(ctx, root) {
+  const { report } = ctx;
+  const graph = jgfGraphOf(ctx, root);
+  const edges = arraySection(graph.edges, "graph.edges", report) ?? [];
+  const hyperedges = arraySection(graph.hyperedges, "graph.hyperedges", report) ?? [];
+  const nodesRaw = graph.nodes;
+  if (nodesRaw !== void 0 && nodesRaw !== null && !isJsonObject(nodesRaw) && !Array.isArray(nodesRaw)) {
+    report.fail(
+      JSON_ISSUE.SHAPE,
+      `graph.nodes must be an object keyed by id or an array, found ${describe(nodesRaw)}`
+    );
+  }
+  const nodeRecords = Array.isArray(nodesRaw) ? nodesRaw : Object.values(nodesRaw ?? {});
+  let directed;
+  if (typeof graph.directed === "boolean") {
+    ({ directed } = graph);
+  } else if (ctx.explicitDefaultDirected) {
+    directed = ctx.options.defaultDirected;
+  } else {
+    if (graph.directed !== void 0 && graph.directed !== null) {
+      report.warning(
+        "validation-error",
+        JSON_ISSUE.BAD_FLAG,
+        `graph.directed is ${describe(graph.directed)}, not a boolean`,
+        { element: "graph.directed" }
+      );
+    }
+    const objects = edges.filter((edge) => isJsonObject(edge));
+    directed = objects.length === 0 || !objects.every((edge) => edge.directed === false);
+  }
+  ctx.setHeader(directed);
+  ctx.writeGraphDict(graph.metadata, "graph.metadata");
+  const shape = {
+    dialect: "jgf",
+    id: typeof graph.id === "string" ? graph.id : void 0,
+    type: typeof graph.type === "string" ? graph.type : void 0
+  };
+  const label = typeof graph.label === "string" ? graph.label : null;
+  ctx.reportNodeIdFrom("jgf", "the node keys");
+  ctx.sink.reserve(nodeRecords.length, edges.length);
+  const labelColumn = ctx.nodes.declareIf(
+    { name: "label", dtype: "string", role: "label", nullable: true },
+    anyHas(nodeRecords, "label")
+  );
+  if (isJsonObject(nodesRaw)) {
+    for (const key of Object.keys(nodesRaw)) {
+      const element = `nodes[${JSON.stringify(key)}]`;
+      const record = nodesRaw[key];
+      if (record !== null && !isJsonObject(record)) {
+        ctx.badElement("node", element);
+        continue;
+      }
+      const id = ctx.coerceId(key, element);
+      if (id === null) {
+        ctx.countSkipped("node");
+        continue;
+      }
+      pushJgfNode(ctx, id, record ?? {}, labelColumn, element);
+    }
+  } else {
+    for (let i = 0; i < nodeRecords.length; i++) {
+      const element = `nodes[${i}]`;
+      const record = nodeRecords[i];
+      if (!isJsonObject(record)) {
+        ctx.badElement("node", element);
+        continue;
+      }
+      const id = ctx.coerceId(hasKey(record, "id") ? record.id : void 0, element);
+      if (id === null) {
+        ctx.countSkipped("node");
+        continue;
+      }
+      pushJgfNode(ctx, id, record, labelColumn, element);
+    }
+  }
+  throwIfAborted(ctx.options.signal);
+  const ids = ctx.declareEdgeIds([...edges, ...hyperedges], (edge) => edge.id, "id", false);
+  const relationColumn = ctx.edges.declareIf(
+    { name: "relation", dtype: "string", role: "kind", nullable: true },
+    anyHas(edges, "relation") || anyHas(hyperedges, "relation")
+  );
+  const edgeLabelColumn = ctx.edges.declareIf(
+    { name: "label", dtype: "string", role: "label", nullable: true },
+    anyHas(edges, "label") || anyHas(hyperedges, "label")
+  );
+  const writeJgfEdge = (record, u, v, kind, element, structural = JGF_EDGE_KEYS) => {
+    const { metadata } = record;
+    const dict = isJsonObject(metadata) ? metadata : {};
+    const idValue = ctx.edgeIdValue(ids, record.id);
+    const edge = ctx.pushEdge(u, v, kind, ctx.weightOf(dict), element);
+    ctx.setEdgeId(ids, edge, idValue);
+    ctx.writeStringField(ctx.edges, relationColumn, edge, record.relation, "relation", element);
+    ctx.writeStringField(ctx.edges, edgeLabelColumn, edge, record.label, "label", element);
+    if (metadata !== void 0 && metadata !== null && !isJsonObject(metadata)) {
+      report.error("validation-error", JSON_ISSUE.BAD_VALUE, `${element}: metadata must be an object`, {
+        element
+      });
+    }
+    ctx.writeNested(ctx.edges, edge, record, dict, structural, ctx.options.weightFrom);
+  };
+  for (let i = 0; i < edges.length; i++) {
+    const element = `edges[${i}]`;
+    const record = edges[i];
+    if (!isJsonObject(record)) {
+      ctx.badElement("edge", element);
+      continue;
+    }
+    if (!hasKey(record, "source") || !hasKey(record, "target")) {
+      ctx.missingEndpoint(element, hasKey(record, "source") ? "target" : "source");
+      continue;
+    }
+    try {
+      const u = ctx.coerceId(record.source, `${element}.source`);
+      const v = ctx.coerceId(record.target, `${element}.target`);
+      if (u === null || v === null) {
+        ctx.countSkipped("edge");
+        continue;
+      }
+      const edgeDirected = flagOf(record.directed, `${element}.directed`, directed, report);
+      writeJgfEdge(record, u, v, edgeDirected ? "directed" : "undirected", element);
+    } catch (err) {
+      ctx.skip(err, "edge", element);
+    }
+  }
+  importHyperedges(ctx, hyperedges, directed, writeJgfEdge);
+  ctx.setMeta(shape, { name: label, ...ctx.weightOriginPatch() });
+}
+function jgfGraphOf(ctx, root) {
+  const { report } = ctx;
+  if (isJsonObject(root.graph)) {
+    return root.graph;
+  }
+  const graphs = arraySection(root.graphs, "graphs", report) ?? [];
+  if (graphs.length === 0) {
+    report.fail(JSON_ISSUE.SHAPE, "a JGF document needs a graph object or a non-empty graphs array");
+  }
+  if (graphs.length > 1) {
+    report.warning(
+      "unsupported",
+      JSON_ISSUE.MULTIPLE_GRAPHS,
+      `the document holds ${graphs.length} graphs; only graphs[${ctx.json.graphIndex}] is read`,
+      { element: "graphs" }
+    );
+  }
+  if (ctx.json.graphIndex >= graphs.length) {
+    report.fail(JSON_ISSUE.SHAPE, `graphIndex ${ctx.json.graphIndex} is beyond the ${graphs.length} graph(s)`);
+  }
+  const graph = graphs[ctx.json.graphIndex];
+  if (!isJsonObject(graph)) {
+    return report.fail(JSON_ISSUE.SHAPE, `graphs[${ctx.json.graphIndex}] is not an object`);
+  }
+  return graph;
+}
+function pushJgfNode(ctx, id, record, labelColumn, element) {
+  const index = ctx.pushNode(id, element);
+  if (index < 0) {
+    return;
+  }
+  try {
+    ctx.writeStringField(ctx.nodes, labelColumn, index, record.label, "label", element);
+    const { metadata } = record;
+    if (metadata !== void 0 && metadata !== null && !isJsonObject(metadata)) {
+      ctx.report.error("validation-error", JSON_ISSUE.BAD_VALUE, `${element}: metadata must be an object`, {
+        element
+      });
+    }
+    ctx.writeNested(ctx.nodes, index, record, isJsonObject(metadata) ? metadata : {}, JGF_NODE_KEYS, null);
+  } catch (err) {
+    ctx.report.recordError(err, { element: String(id) });
+  }
+}
+function importHyperedges(ctx, hyperedges, directed, push) {
+  if (hyperedges.length === 0) {
+    return;
+  }
+  const { report } = ctx;
+  const policy = ctx.options.hyperedges;
+  if (policy === "error") {
+    report.error("unsupported", JSON_ISSUE.HYPEREDGE, `${hyperedges.length} hyperedge(s) (hyperedges: "error")`, {
+      element: "hyperedges"
+    });
+    throw report.abort("hyperedges refused", { code: JSON_ISSUE.HYPEREDGE, count: hyperedges.length });
+  }
+  if (policy === "skip") {
+    report.warning("unsupported", JSON_ISSUE.HYPEREDGES_SKIPPED, `${hyperedges.length} hyperedge(s) skipped`, {
+      element: "hyperedges"
+    });
+    report.loss(
+      JSON_ISSUE.HYPEREDGES_SKIPPED,
+      `${hyperedges.length} hyperedge(s) were not imported`,
+      null,
+      hyperedges.length
+    );
+    return;
+  }
+  for (let i = 0; i < hyperedges.length; i++) {
+    const element = `hyperedges[${i}]`;
+    const record = hyperedges[i];
+    if (!isJsonObject(record)) {
+      ctx.badElement("edge", element);
+      continue;
+    }
+    try {
+      if (Array.isArray(record.nodes)) {
+        const members = record.nodes.map((raw) => ctx.requireId(raw, element));
+        if (members.length < 2) {
+          throw new GraphFormatError(
+            "E_INVALID_ID",
+            `${element}: an undirected hyperedge needs two or more nodes`,
+            { reason: "hyperedge shape" }
+          );
+        }
+        const kind = directed ? "directed" : "undirected";
+        if (policy === "star") {
+          for (let k = 1; k < members.length; k++) {
+            push(record, members[0], members[k], kind, element, JGF_HYPEREDGE_KEYS);
+          }
+        } else {
+          for (let a = 0; a < members.length; a++) {
+            for (let b = a + 1; b < members.length; b++) {
+              push(record, members[a], members[b], kind, element, JGF_HYPEREDGE_KEYS);
+            }
+          }
+        }
+      } else if (Array.isArray(record.source) && Array.isArray(record.target)) {
+        const sources = record.source.map((raw) => ctx.requireId(raw, element));
+        const targets = record.target.map((raw) => ctx.requireId(raw, element));
+        if (sources.length === 0 || targets.length === 0) {
+          throw new GraphFormatError(
+            "E_INVALID_ID",
+            `${element}: a directed hyperedge needs sources and targets`,
+            { reason: "hyperedge shape" }
+          );
+        }
+        for (const s of sources) {
+          for (const t of targets) {
+            push(record, s, t, "directed", element, JGF_HYPEREDGE_KEYS);
+          }
+        }
+      } else {
+        report.error(
+          "validation-error",
+          JSON_ISSUE.HYPEREDGE_SHAPE,
+          `${element} has neither a nodes array nor source / target arrays`,
+          { element }
+        );
+        ctx.countSkipped("edge");
+      }
+    } catch (err) {
+      ctx.skip(err, "edge", element);
+    }
+  }
+}
+function importCytoscape(ctx, root) {
+  const { report } = ctx;
+  let elements;
+  let extra;
+  if (Array.isArray(root)) {
+    elements = root;
+  } else if (isJsonObject(root)) {
+    ({ elements } = root);
+    ctx.writeGraphDict(root.data, "data");
+    const rest = {};
+    for (const key of Object.keys(root)) {
+      if (key !== "elements" && key !== "data") {
+        rest[key] = root[key];
+      }
+    }
+    if (Object.keys(rest).length > 0) {
+      extra = rest;
+    }
+  } else {
+    report.fail(JSON_ISSUE.SHAPE, `a Cytoscape document must be an object or an array, found ${describe(root)}`);
+  }
+  const { nodes, edges } = cytoscapeSections(ctx, elements);
+  ctx.setHeader(ctx.defaultDirected("cytoscape"));
+  ctx.reportNodeIdFrom("cytoscape", "data.id");
+  ctx.sink.reserve(nodes.length, edges.length);
+  const dataHas = (items, key) => items.some((item) => isJsonObject(item) && isJsonObject(item.data) && item.data[key] !== void 0);
+  const positionColumn = ctx.nodes.declareIf(
+    {
+      name: POSITION_COLUMN,
+      dtype: "f32",
+      components: 3,
+      role: "position",
+      mutable: true,
+      nullable: true,
+      extra: { sourceDims: 2, units: "file" },
+      origin: { format: "json", namespace: "cytoscape" }
+    },
+    anyHas(nodes, "position")
+  );
+  const classesColumn = ctx.nodes.declareIf(
+    { name: CLASSES_COLUMN, dtype: "list", itemDtype: "string", role: "classes", nullable: true },
+    anyHas(nodes, "classes")
+  );
+  const parentColumn = ctx.nodes.declareIf(
+    { name: PARENT_COLUMN, dtype: "u32", role: "parent", refersTo: "node", nullable: true },
+    dataHas(nodes, "parent")
+  );
+  const edgeClassesColumn = ctx.edges.declareIf(
+    { name: CLASSES_COLUMN, dtype: "list", itemDtype: "string", role: "classes", nullable: true },
+    anyHas(edges, "classes")
+  );
+  const parents = [];
+  const point = [0, 0, 0];
+  for (let i = 0; i < nodes.length; i++) {
+    const element = `nodes[${i}]`;
+    const record = nodes[i];
+    if (!isJsonObject(record) || !isJsonObject(record.data)) {
+      ctx.badElement("node", element, "an element with a data object");
+      continue;
+    }
+    const { data } = record;
+    const id = ctx.coerceId(hasKey(data, "id") ? data.id : void 0, element);
+    if (id === null) {
+      ctx.countSkipped("node");
+      continue;
+    }
+    const index = ctx.pushNode(id, element);
+    if (index < 0) {
+      continue;
+    }
+    try {
+      for (const key of Object.keys(data)) {
+        if (key === "id") {
+          continue;
+        }
+        if (key === "parent") {
+          const raw = data.parent;
+          if (raw !== void 0 && raw !== null) {
+            const parent = ctx.coerceId(raw, `${element}.data.parent`);
+            if (parent !== null) {
+              parents.push({ index, parent, element });
+            }
+          }
+          continue;
+        }
+        ctx.nodes.write(index, key, data[key], SUFFIX.data);
+      }
+      const { position } = record;
+      if (position !== void 0 && position !== null) {
+        if (isJsonObject(position) && typeof position.x === "number" && typeof position.y === "number") {
+          point[0] = position.x;
+          point[1] = position.y;
+          ctx.nodes.set(positionColumn, index, point);
+        } else {
+          report.error(
+            "validation-error",
+            JSON_ISSUE.BAD_VALUE,
+            `${element}: position must be an object with numeric x and y`,
+            { element }
+          );
+        }
+      }
+      writeClasses(ctx, ctx.nodes, classesColumn, index, record.classes, element);
+      writeElementKeys(ctx.nodes, index, record);
+    } catch (err) {
+      report.recordError(err, { element: String(id) });
+    }
+  }
+  for (const { index, parent, element } of parents) {
+    const parentIndex = ctx.sink.indexOf(parent);
+    if (parentIndex === INVALID_INDEX) {
+      report.error(
+        "missing-value",
+        JSON_ISSUE.UNKNOWN_PARENT,
+        `${element}: parent ${JSON.stringify(parent)} is not a node`,
+        { element }
+      );
+      continue;
+    }
+    ctx.nodes.set(parentColumn, index, parentIndex);
+  }
+  throwIfAborted(ctx.options.signal);
+  importCytoscapeEdges(ctx, edges, edgeClassesColumn);
+  ctx.setMeta({ dialect: "cytoscape", cytoscape: extra }, ctx.weightOriginPatch());
+}
+function importCytoscapeEdges(ctx, edges, edgeClassesColumn) {
+  const ids = ctx.declareEdgeIds(edges, (edge) => isJsonObject(edge.data) ? edge.data.id : void 0, "id", true);
+  const kind = ctx.uniformKind();
+  for (let i = 0; i < edges.length; i++) {
+    const element = `edges[${i}]`;
+    const record = edges[i];
+    if (!isJsonObject(record) || !isJsonObject(record.data)) {
+      ctx.badElement("edge", element, "an element with a data object");
+      continue;
+    }
+    const { data } = record;
+    if (!hasKey(data, "source") || !hasKey(data, "target")) {
+      ctx.missingEndpoint(element, `data.${hasKey(data, "source") ? "target" : "source"}`);
+      continue;
+    }
+    try {
+      const u = ctx.coerceId(data.source, `${element}.data.source`);
+      const v = ctx.coerceId(data.target, `${element}.data.target`);
+      if (u === null || v === null) {
+        ctx.countSkipped("edge");
+        continue;
+      }
+      const idValue = ctx.edgeIdValue(ids, data.id);
+      const edge = ctx.pushEdge(u, v, kind, ctx.weightOf(data), element);
+      ctx.setEdgeId(ids, edge, idValue);
+      const { weightFrom } = ctx.options;
+      for (const key of Object.keys(data)) {
+        if (key !== "id" && key !== "source" && key !== "target" && key !== weightFrom) {
+          ctx.edges.write(edge, key, data[key], SUFFIX.data);
+        }
+      }
+      writeClasses(ctx, ctx.edges, edgeClassesColumn, edge, record.classes, element);
+      writeElementKeys(ctx.edges, edge, record);
+    } catch (err) {
+      ctx.skip(err, "edge", element);
+    }
+  }
+}
+function cytoscapeSections(ctx, elements) {
+  const { report } = ctx;
+  if (Array.isArray(elements)) {
+    return {
+      nodes: elements.filter((item) => isJsonObject(item) && isNodeElement(item)),
+      edges: elements.filter((item) => isJsonObject(item) && !isNodeElement(item))
+    };
+  }
+  if (isJsonObject(elements)) {
+    return {
+      nodes: arraySection(elements.nodes, "elements.nodes", report) ?? [],
+      edges: arraySection(elements.edges, "elements.edges", report) ?? []
+    };
+  }
+  if (elements === void 0 || elements === null) {
+    report.error("missing-value", JSON_ISSUE.MISSING_SECTION, "the document has no elements", {
+      element: "elements"
+    });
+    return { nodes: [], edges: [] };
+  }
+  return report.fail(JSON_ISSUE.SHAPE, `elements must be an object or an array, found ${describe(elements)}`);
+}
+function isNodeElement(element) {
+  if (element.group === "nodes") {
+    return true;
+  }
+  if (element.group === "edges") {
+    return false;
+  }
+  const { data } = element;
+  return !(isJsonObject(data) && hasKey(data, "source") && hasKey(data, "target"));
+}
+function writeClasses(ctx, writer, column, row, raw, element) {
+  if (column === INVALID_INDEX || raw === void 0 || raw === null) {
+    return;
+  }
+  let classes;
+  if (typeof raw === "string") {
+    classes = raw.split(/\s+/).filter((c) => c.length > 0);
+  } else if (Array.isArray(raw) && raw.every((c) => typeof c === "string")) {
+    classes = raw;
+  } else {
+    ctx.report.error(
+      "validation-error",
+      JSON_ISSUE.BAD_VALUE,
+      `${element}: classes must be a string or an array of strings`,
+      { element }
+    );
+    return;
+  }
+  writer.set(column, row, classes);
+}
+function writeElementKeys(writer, row, record) {
+  for (const key of Object.keys(record)) {
+    if (CYTOSCAPE_STRUCTURAL_KEYS.has(key)) {
+      continue;
+    }
+    const name = CYTOSCAPE_ELEMENT_KEYS.has(key) ? key : `${key}${SUFFIX.element}`;
+    writer.write(row, name, record[key], SUFFIX.data);
+  }
+}
+const jsonImporter = Object.freeze({
+  format: "json",
+  extensions: Object.freeze([".json"]),
+  mimeTypes: Object.freeze(["application/json"]),
+  /**
+   * Confidence that the head is a JSON graph document: 0 unless it starts with `{` or `[`, 0.5
+   * for any JSON, 0.9 when a graph key (nodes, links, edges, elements, graph, graphs) appears in
+   * the head.
+   * @param head - the first bytes
+   * @returns the confidence
+   */
+  sniff(head) {
+    const text = new TextDecoder("utf-8").decode(head.subarray(0, SNIFF_BYTES));
+    const trimmed = (text.startsWith(BOM) ? text.slice(1) : text).trimStart();
+    if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) {
+      return 0;
+    }
+    return SNIFF_KEYS.some((key) => trimmed.includes(key)) ? 0.9 : 0.5;
+  },
+  /**
+   * Read a JSON graph document into the sink.
+   * @param input - the text, bytes or stream
+   * @param sink - the sink
+   * @param options - format-specific and common options
+   * @returns the import report; ImportError on a fatal error or beyond the error limit
+   */
+  async import(input, sink, options) {
+    const resolved = resolveImportOptions(options, FORMAT_DEFAULTS);
+    const json = resolveJsonOptions(options);
+    const report = new ImportReportBuilder("json", resolved.errorLimit);
+    const text = await readText(input, report, resolved);
+    const root = parseDocument(text, report);
+    const dialect = detectDialect(root, json.dialect, report);
+    const ctx = new ImportContext(sink, report, resolved, json, options?.defaultDirected !== void 0);
+    reportSinkOptions(sink, options, report);
+    reportUnusedOptions(options, report, USED_OPTIONS);
+    if (dialect === "cytoscape") {
+      importCytoscape(ctx, root);
+      throwIfAborted(resolved.signal);
+      return report.finish();
+    }
+    const doc = isJsonObject(root) ? root : report.fail(JSON_ISSUE.SHAPE, `a ${dialect} document must be a JSON object, found ${describe(root)}`);
+    switch (dialect) {
+      case "node-link":
+      case "d3":
+        importNodeLink(ctx, doc, dialect);
+        break;
+      case "jgf":
+        importJgf(ctx, doc);
+        break;
+      case "graphology":
+        importGraphology(ctx, doc);
+        break;
+      case "vis":
+        importVis(ctx, doc);
+        break;
+      default: {
+        const name = dialect;
+        throw new GraphFormatError("E_UNSUPPORTED", `unknown dialect ${name}`, {
+          option: "dialect",
+          found: name
+        });
+      }
+    }
+    throwIfAborted(resolved.signal);
+    return report.finish();
+  }
+});
+export {
+  JSON_DIALECTS as J,
+  JSON_ISSUE as a,
+  JSON_LOSS as b,
+  jsonExporter as c,
+  dialectCapabilities as d,
+  jsonImporter as e,
+  jsonCapabilities as j,
+  sniffJsonDialect as s
+};
+//# sourceMappingURL=importer-CQnJuWJw.js.map