@graphty/graph-io 0.3.40 → 0.3.42

package/dist/chunks/{exporter-Bcp-l4Bo.js → exporter-CpRyHZ3H.js}

@@ -1,9 +1,9 @@
 import { GraphFormatError, INVALID_INDEX } from "@graphty/graph-format";
-import { c as capabilities, R as ROLE_TAKEN_CODE, C as COLUMN_RENAMED_CODE, o as DUPLICATE_ATTRIBUTE_CODE, g as UNKNOWN_ELEMENT_CODE, b5 as EMPTY_COLUMN_DROPPED_CODE, ai as PARENT_CYCLE_CODE, P as PRECISION_CODE, w as UNKNOWN_ENCODING_CODE, a2 as JSON_NONSTANDARD_NUMBER_CODE, x as ENCODING_FALLBACK_CODE, y as INVALID_ENCODING_CODE, z as INVALID_UTF8_CODE, O as OPTION_IGNORED_CODE, S as SINK_OPTION_CODE, H as HYPEREDGE_CODE, ad as TOO_LARGE_CODE, i as DANGLING_REFERENCE_CODE, ae as AMBIGUOUS_GRAPH_NAME_CODE, af as GRAPH_NOT_FOUND_CODE, l as MULTIPLE_GRAPHS_CODE, I as ID_MERGED_CODE, m as DUPLICATE_EDGE_ID_CODE, n as DUPLICATE_NODE_CODE, q as UNKNOWN_PARENT_CODE, a3 as BAD_VALUE_CODE, s as MISSING_ENDPOINT_CODE, t as MISSING_ID_CODE, ak as SYNTAX_CODE, E as EMPTY_INPUT_CODE, F as ELEMENT_ISSUE, G as INPUT_ISSUE, al as resolveImportOptions, a8 as ImportReportBuilder, bB as readText, b as plural, ao as reportSinkOptions, an as reportUnusedOptions, am as throwIfAborted, ar as IdCoercer, aq as DirectionResolver, $ as agree, as as weightFromValue, a0 as uniqueColumnName, a7 as chooseGraph, ap as graphChosen, a1 as declareResolved, aB as GRAPH_COLUMN_AS_METADATA_CODE, aC as TYPEDEF_NODES_CODE, aD as RELATION_ASSUMED_CODE, at as COLUMN_AS_PROPERTY_VALUE_CODE, p as pairFolding, e as explicitWeights, bd as NONFINITE_AS_NULL_CODE, L as LOSS, b3 as DIRECTION_DROPPED_CODE, aA as NODE_ORDER_CODE, r as resolveExportOptions, b_ as otherFormatDialect, a as checkCapabilities, bD as countMixedEdges, aa as formatF32, ab as formatF64 } from "./export-B-aVCwyG.js";
-import { M as MAYBE_UNSAFE_INTEGER, j as MAYBE_INEXACT_EXPONENT, l as rewriteNumbers, m as findDuplicateKeys, f as flipY } from "./json-elements-DpO6AXIc.js";
+import { c as capabilities, R as ROLE_TAKEN_CODE, C as COLUMN_RENAMED_CODE, o as DUPLICATE_ATTRIBUTE_CODE, g as UNKNOWN_ELEMENT_CODE, b5 as EMPTY_COLUMN_DROPPED_CODE, ai as PARENT_CYCLE_CODE, P as PRECISION_CODE, w as UNKNOWN_ENCODING_CODE, a2 as JSON_NONSTANDARD_NUMBER_CODE, x as ENCODING_FALLBACK_CODE, y as INVALID_ENCODING_CODE, z as INVALID_UTF8_CODE, O as OPTION_IGNORED_CODE, S as SINK_OPTION_CODE, H as HYPEREDGE_CODE, ad as TOO_LARGE_CODE, i as DANGLING_REFERENCE_CODE, ae as AMBIGUOUS_GRAPH_NAME_CODE, af as GRAPH_NOT_FOUND_CODE, l as MULTIPLE_GRAPHS_CODE, I as ID_MERGED_CODE, m as DUPLICATE_EDGE_ID_CODE, n as DUPLICATE_NODE_CODE, q as UNKNOWN_PARENT_CODE, a3 as BAD_VALUE_CODE, s as MISSING_ENDPOINT_CODE, t as MISSING_ID_CODE, ak as SYNTAX_CODE, E as EMPTY_INPUT_CODE, F as ELEMENT_ISSUE, G as INPUT_ISSUE, al as resolveImportOptions, a8 as ImportReportBuilder, bB as readText, b as plural, ao as reportSinkOptions, an as reportUnusedOptions, am as throwIfAborted, ar as IdCoercer, aq as DirectionResolver, $ as agree, as as weightFromValue, a0 as uniqueColumnName, a7 as chooseGraph, ap as graphChosen, a1 as declareResolved, aB as GRAPH_COLUMN_AS_METADATA_CODE, aC as TYPEDEF_NODES_CODE, aD as RELATION_ASSUMED_CODE, at as COLUMN_AS_PROPERTY_VALUE_CODE, p as pairFolding, e as explicitWeights, bd as NONFINITE_AS_NULL_CODE, L as LOSS, b3 as DIRECTION_DROPPED_CODE, aA as NODE_ORDER_CODE, r as resolveExportOptions, b_ as otherFormatDialect, a as checkCapabilities, bD as countMixedEdges, aa as formatF32, ab as formatF64 } from "./export-rKLeGQMo.js";
+import { M as MAYBE_UNSAFE_INTEGER, j as MAYBE_INEXACT_EXPONENT, l as rewriteNumbers, m as findDuplicateKeys, f as flipY } from "./json-elements-DKSqpNW1.js";
 import { j as joinText, e as encodeChunks, i as indentUnit } from "./writer-DxjgHwSe.js";
-import { t as trimTrailingZeros } from "./text-Bjfa1xYL.js";
-import { d as OBOGRAPHS_PREDICATE_TAGS, g as compactOboIri, o as oboColumnDecl, P as PLACEHOLDER_COLUMN, h as synonymScopeOf, O as OBO_NODE_COLUMNS, c as capabilityNotes, s as slotColumn, e as emptyColumnNotes, j as OBO_PURL, f as framelessNodes, m as movedNodes, U as UNWRITTEN_ROLES, n as notePropertyColumn, a as cellOf, v as valuesOf, k as OBO_IN_OWL, b as fitsVocabulary, t as textOf, S as SYNONYM_SCOPES } from "./ontology-export-50L9DOV4.js";
+import { t as trimTrailingZeros } from "./text-DHOJXnED.js";
+import { d as OBOGRAPHS_PREDICATE_TAGS, g as compactOboIri, o as oboColumnDecl, P as PLACEHOLDER_COLUMN, h as synonymScopeOf, O as OBO_NODE_COLUMNS, c as capabilityNotes, s as slotColumn, e as emptyColumnNotes, j as OBO_PURL, f as framelessNodes, m as movedNodes, U as UNWRITTEN_ROLES, n as notePropertyColumn, a as cellOf, v as valuesOf, k as OBO_IN_OWL, b as fitsVocabulary, t as textOf, S as SYNONYM_SCOPES } from "./ontology-export-CtRXjg_i.js";
 const JSON_DIALECTS = Object.freeze([
   "node-link",
   "d3",
@@ -43,6 +43,10 @@ function sniffJsonDialect(root) {
   if (!isJsonObject(root)) {
     return null;
   }
+  const decided = sniffWrapperDialect(root) ?? sniffEdgelessDialect(root);
+  return decided === void 0 ? sniffEdgeListDialect(root) : decided;
+}
+function sniffWrapperDialect(root) {
   if (hasKey(root, "elements")) {
     return "cytoscape";
   }
@@ -52,33 +56,42 @@ function sniffJsonDialect(root) {
   if (Array.isArray(root.graphs)) {
     return root.graphs.some((g) => isJsonObject(g) && isOboGraph(g)) ? "obographs" : "jgf";
   }
-  if (!hasKey(root, "edges") && !hasKey(root, "links")) {
-    if (hasKey(root, "nodes") && hasKey(root, "adjacency")) {
-      return "adjacency";
-    }
-    if (!hasKey(root, "nodes")) {
-      return hasKey(root, "children") ? "tree" : null;
-    }
+  return void 0;
+}
+function sniffEdgelessDialect(root) {
+  if (hasKey(root, "edges") || hasKey(root, "links")) {
+    return void 0;
+  }
+  if (hasKey(root, "nodes")) {
+    return hasKey(root, "adjacency") ? "adjacency" : void 0;
   }
+  return hasKey(root, "children") ? "tree" : null;
+}
+function sniffEdgeListDialect(root) {
   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";
   }
   const networkx = hasKey(root, "links") || hasKey(root, "directed") || hasKey(root, "multigraph") || hasKey(root, "graph");
-  if (!networkx && firstNode !== null && hasKey(firstNode, "key") && !hasKey(firstNode, "id")) {
+  const record = networkx ? void 0 : sniffRecordDialect(firstNode, firstEdge);
+  if (record !== void 0) {
+    return record;
+  }
+  const bare = !hasKey(root, "directed") && !hasKey(root, "multigraph") && !hasKey(root, "graph");
+  return bare && hasKey(root, "links") ? "d3" : "node-link";
+}
+function sniffRecordDialect(firstNode, firstEdge) {
+  if (firstNode !== null && hasKey(firstNode, "key") && !hasKey(firstNode, "id")) {
     return "graphology";
   }
-  if (!networkx && firstEdge !== null && !hasKey(firstEdge, "from")) {
-    if (hasKey(firstEdge, "undirected") || isJsonObject(firstEdge.attributes)) {
-      return "graphology";
-    }
+  if (firstEdge === null) {
+    return void 0;
   }
-  if (!networkx && firstEdge !== null && hasKey(firstEdge, "from") && hasKey(firstEdge, "to") && !hasKey(firstEdge, "source")) {
-    return "vis";
+  if (!hasKey(firstEdge, "from")) {
+    return hasKey(firstEdge, "undirected") || isJsonObject(firstEdge.attributes) ? "graphology" : void 0;
   }
-  const bare = !hasKey(root, "directed") && !hasKey(root, "multigraph") && !hasKey(root, "graph");
-  return bare && hasKey(root, "links") ? "d3" : "node-link";
+  return hasKey(firstEdge, "to") && !hasKey(firstEdge, "source") ? "vis" : void 0;
 }
 const OBOGRAPHS_NODE_TYPES = /* @__PURE__ */ new Set(["CLASS", "INDIVIDUAL", "PROPERTY"]);
 function isOboGraph(graph) {
@@ -373,38 +386,42 @@ function skeletonOf(text) {
   }
   const root = {};
   for (const key of rootKeys) {
-    switch (key) {
-      case "graph":
-      case "options":
-        root[key] = objectOf(keys.get(key));
-        break;
-      case "graphs": {
-        const nodes = keys.get("graphs[0].nodes[]");
-        const edges = keys.get("graphs[0].edges[]");
-        const graph = {};
-        if (nodes !== void 0) {
-          graph.nodes = [objectOf(nodes)];
-        }
-        if (edges !== void 0) {
-          graph.edges = [objectOf(edges)];
-        }
-        root[key] = nodes === void 0 && edges === void 0 ? [] : [graph];
-        break;
-      }
-      case "nodes":
-      case "edges":
-      case "links": {
-        const first = keys.get(`${key}[0]`);
-        root[key] = first === void 0 ? [] : [objectOf(first)];
-        break;
-      }
-      default:
-        root[key] = true;
-        break;
-    }
+    root[key] = placeholderOf(key, keys);
   }
   return root;
 }
+function placeholderOf(key, keys) {
+  switch (key) {
+    case "graph":
+    case "options":
+      return objectOf(keys.get(key));
+    case "graphs":
+      return graphsPlaceholder(keys);
+    case "nodes":
+    case "edges":
+    case "links": {
+      const first = keys.get(`${key}[0]`);
+      return first === void 0 ? [] : [objectOf(first)];
+    }
+    default:
+      return true;
+  }
+}
+function graphsPlaceholder(keys) {
+  const nodes = keys.get("graphs[0].nodes[]");
+  const edges = keys.get("graphs[0].edges[]");
+  if (nodes === void 0 && edges === void 0) {
+    return [];
+  }
+  const graph = {};
+  if (nodes !== void 0) {
+    graph.nodes = [objectOf(nodes)];
+  }
+  if (edges !== void 0) {
+    graph.edges = [objectOf(edges)];
+  }
+  return [graph];
+}
 function objectOf(names) {
   const out = {};
   if (names !== void 0) {
@@ -421,28 +438,6 @@ function scanKeys(text) {
   const counts = [];
   let pendingKey = null;
   let expectingKey = false;
-  const pathOf = () => {
-    const depth = kinds.length;
-    if (depth === 1) {
-      return kinds[0] === "object" ? "" : null;
-    }
-    if (depth === 2 && kinds[0] === "array" && kinds[1] === "object" && labels[1] === "0") {
-      return "nodes[0]";
-    }
-    if (depth === 2 && kinds[0] === "object" && kinds[1] === "object") {
-      return labels[1] === "graph" || labels[1] === "options" ? labels[1] : null;
-    }
-    if (depth === 5 && kinds.join() === "object,array,object,array,object" && labels[1] === "graphs" && labels[2] === "0" && (labels[3] === "nodes" || labels[3] === "edges")) {
-      return labels[3] === "nodes" ? "graphs[0].nodes[]" : "graphs[0].edges[]";
-    }
-    if (depth === 3 && kinds[0] === "object" && kinds[1] === "array" && kinds[2] === "object") {
-      const section = labels[1];
-      if ((section === "nodes" || section === "edges" || section === "links") && labels[2] === "0") {
-        return `${section}[0]`;
-      }
-    }
-    return null;
-  };
   let i = 0;
   const n = text.length;
   while (i < n) {
@@ -478,7 +473,7 @@ function scanKeys(text) {
       pendingKey = null;
     } else if (ch === ":") {
       if (pendingKey !== null) {
-        const path = pathOf();
+        const path = keyPathOf(kinds, labels);
         if (path !== null) {
           let set = found.get(path);
           if (set === void 0) {
@@ -500,6 +495,45 @@ function scanKeys(text) {
   }
   return found;
 }
+function keyPathOf(kinds, labels) {
+  switch (kinds.length) {
+    case 1:
+      return kinds[0] === "object" ? "" : null;
+    case 2:
+      return nestedObjectPath(kinds, labels);
+    case 3:
+      return sectionElementPath(kinds, labels);
+    case 5:
+      return graphsMemberPath(kinds, labels);
+    default:
+      return null;
+  }
+}
+function nestedObjectPath(kinds, labels) {
+  if (kinds[0] === "array" && kinds[1] === "object" && labels[1] === "0") {
+    return "nodes[0]";
+  }
+  if (kinds[0] === "object" && kinds[1] === "object") {
+    return labels[1] === "graph" || labels[1] === "options" ? labels[1] : null;
+  }
+  return null;
+}
+function sectionElementPath(kinds, labels) {
+  if (kinds[0] !== "object" || kinds[1] !== "array" || kinds[2] !== "object" || labels[2] !== "0") {
+    return null;
+  }
+  const section = labels[1];
+  return section === "nodes" || section === "edges" || section === "links" ? `${section}[0]` : null;
+}
+function graphsMemberPath(kinds, labels) {
+  if (kinds.join() !== "object,array,object,array,object" || labels[1] !== "graphs" || labels[2] !== "0") {
+    return null;
+  }
+  if (labels[3] === "nodes") {
+    return "graphs[0].nodes[]";
+  }
+  return labels[3] === "edges" ? "graphs[0].edges[]" : null;
+}
 function scanString(text, from) {
   let i = from;
   while (i < text.length) {
@@ -2076,18 +2110,7 @@ function importAdjacency(ctx, root) {
   const multigraph = hasKey(root, "multigraph") ? flagOf(root.multigraph, "multigraph", false, report) : null;
   ctx.setHeader(directed);
   ctx.writeGraphDict(isPairList(root.graph) ? Object.fromEntries(root.graph) : root.graph, "graph");
-  for (const key of Object.keys(root)) {
-    if (key !== "nodes" && key !== "adjacency" && key !== "directed" && key !== "multigraph" && key !== "graph") {
-      report.warning(
-        "unsupported",
-        JSON_ISSUE.UNREAD_KEY,
-        `top-level key ${key} (${describe(root[key])}) is not read; dropped`,
-        {
-          element: key
-        }
-      );
-    }
-  }
+  reportUnreadAdjacencyKeys(ctx, root);
   const lists = adjacency ?? [];
   ctx.sink.reserve(
     nodes.length,
@@ -2095,90 +2118,120 @@ function importAdjacency(ctx, root) {
   );
   const idKey = ctx.json.nodeIdKey ?? "id";
   ctx.reportNodeIdFrom("adjacency", `the ${JSON.stringify(idKey)} key`);
-  const owners = [];
-  for (let i = 0; i < nodes.length; i++) {
-    const element = `nodes[${i}]`;
-    const record = nodes[i];
-    let pushed = null;
-    if (!isJsonObject(record)) {
-      ctx.badElement("node", element);
-    } else {
-      const id = ctx.coerceId(hasKey(record, idKey) ? record[idKey] : void 0, element);
-      if (id === null) {
-        ctx.countSkipped("node");
-      } else {
-        const index = ctx.pushNode(id, element);
-        if (index >= 0) {
-          pushed = id;
-          writeFlat(ctx.nodes, index, record, id, (key) => key !== idKey);
-        }
-      }
-    }
-    owners.push(pushed);
-  }
+  const owners = nodes.map((record, i) => pushAdjacencyNode(ctx, record, `nodes[${i}]`, idKey));
   throwIfAborted(ctx.options.signal);
-  const kind = ctx.uniformKind();
-  const { weightFrom } = ctx.options;
-  const pending = /* @__PURE__ */ new Map();
-  let disagreeing = 0;
+  const reading = {
+    owners,
+    nodeCount: nodes.length,
+    directed,
+    kind: ctx.uniformKind(),
+    idKey,
+    // undirected: entries read once whose mirror is still to come, by pair and key, with their attributes
+    pending: /* @__PURE__ */ new Map(),
+    disagreeing: 0
+  };
   for (let i = 0; i < lists.length; i++) {
-    const element = `adjacency[${i}]`;
-    const list = lists[i];
-    if (!Array.isArray(list)) {
-      report.error("validation-error", JSON_ISSUE.BAD_ELEMENT, `${element} is not an array`, { element });
-      continue;
-    }
-    const source = i < owners.length ? owners[i] : null;
-    if (source === null) {
-      const why = i < nodes.length ? `nodes[${i}] was skipped` : `there is no nodes[${i}]`;
-      report.error(
-        "missing-value",
-        JSON_ISSUE.BAD_INDEX,
-        `${element}: ${why}; its ${list.length} edge${plural(list.length)} ${agree(list.length, "is", "are")} skipped`,
+    readAdjacencyList(ctx, reading, i, lists[i]);
+  }
+  reportAdjacencyShape(
+    ctx,
+    nodes.length,
+    adjacency === null ? null : lists.length,
+    reading.disagreeing,
+    reading.pending
+  );
+  ctx.setMeta({}, { declaredMultigraph: multigraph, ...ctx.weightOriginPatch() });
+}
+const ADJACENCY_DOCUMENT_KEYS = /* @__PURE__ */ new Set(["nodes", "adjacency", "directed", "multigraph", "graph"]);
+function reportUnreadAdjacencyKeys(ctx, root) {
+  for (const key of Object.keys(root)) {
+    if (!ADJACENCY_DOCUMENT_KEYS.has(key)) {
+      ctx.report.warning(
+        "unsupported",
+        JSON_ISSUE.UNREAD_KEY,
+        `top-level key ${key} (${describe(root[key])}) is not read; dropped`,
         {
-          element
+          element: key
         }
       );
-      report.counts.skippedEdges += list.length;
-      continue;
     }
-    for (let j = 0; j < list.length; j++) {
-      const entry = `${element}[${j}]`;
-      const record = list[j];
-      if (!isJsonObject(record)) {
-        ctx.badElement("edge", entry);
-        continue;
+  }
+}
+function pushAdjacencyNode(ctx, record, element, idKey) {
+  if (!isJsonObject(record)) {
+    ctx.badElement("node", element);
+    return null;
+  }
+  const id = ctx.coerceId(hasKey(record, idKey) ? record[idKey] : void 0, element);
+  if (id === null) {
+    ctx.countSkipped("node");
+    return null;
+  }
+  const index = ctx.pushNode(id, element);
+  if (index < 0) {
+    return null;
+  }
+  writeFlat(ctx.nodes, index, record, id, (key) => key !== idKey);
+  return id;
+}
+function readAdjacencyList(ctx, reading, i, list) {
+  const { report } = ctx;
+  const element = `adjacency[${i}]`;
+  if (!Array.isArray(list)) {
+    report.error("validation-error", JSON_ISSUE.BAD_ELEMENT, `${element} is not an array`, { element });
+    return;
+  }
+  const source = i < reading.owners.length ? reading.owners[i] : null;
+  if (source === null) {
+    const why = i < reading.nodeCount ? `nodes[${i}] was skipped` : `there is no nodes[${i}]`;
+    report.error(
+      "missing-value",
+      JSON_ISSUE.BAD_INDEX,
+      `${element}: ${why}; its ${list.length} edge${plural(list.length)} ${agree(list.length, "is", "are")} skipped`,
+      {
+        element
       }
-      if (!hasKey(record, idKey)) {
-        ctx.missingEndpoint(entry, idKey);
-        continue;
+    );
+    report.counts.skippedEdges += list.length;
+    return;
+  }
+  for (let j = 0; j < list.length; j++) {
+    readAdjacencyEntry(ctx, reading, source, list[j], element, `${element}[${j}]`);
+  }
+}
+function readAdjacencyEntry(ctx, reading, source, record, element, entry) {
+  const { idKey } = reading;
+  if (!isJsonObject(record)) {
+    ctx.badElement("edge", entry);
+    return;
+  }
+  if (!hasKey(record, idKey)) {
+    ctx.missingEndpoint(entry, idKey);
+    return;
+  }
+  try {
+    const target = ctx.coerceId(record[idKey], `${entry}.${idKey}`);
+    if (target === null) {
+      ctx.countSkipped("edge");
+      return;
+    }
+    if (!reading.directed) {
+      const mirror = mirroredEntry(reading.pending, source, target, record, idKey);
+      reading.disagreeing += mirror === "disagrees" ? 1 : 0;
+      if (mirror !== "new") {
+        return;
       }
-      try {
-        const target = ctx.coerceId(record[idKey], `${entry}.${idKey}`);
-        if (target === null) {
-          ctx.countSkipped("edge");
-          continue;
-        }
-        if (!directed) {
-          const mirror = mirroredEntry(pending, source, target, record, idKey);
-          disagreeing += mirror === "disagrees" ? 1 : 0;
-          if (mirror !== "new") {
-            continue;
-          }
-        }
-        const edge = ctx.pushEdge(source, target, kind, ctx.weightOf(record), entry);
-        for (const key of Object.keys(record)) {
-          if (key !== idKey && key !== weightFrom) {
-            ctx.edges.write(edge, key, record[key], SUFFIX.data, element);
-          }
-        }
-      } catch (err) {
-        ctx.skip(err, "edge", entry);
+    }
+    const edge = ctx.pushEdge(source, target, reading.kind, ctx.weightOf(record), entry);
+    const { weightFrom } = ctx.options;
+    for (const key of Object.keys(record)) {
+      if (key !== idKey && key !== weightFrom) {
+        ctx.edges.write(edge, key, record[key], SUFFIX.data, element);
       }
     }
+  } catch (err) {
+    ctx.skip(err, "edge", entry);
   }
-  reportAdjacencyShape(ctx, nodes.length, adjacency === null ? null : lists.length, disagreeing, pending);
-  ctx.setMeta({}, { declaredMultigraph: multigraph, ...ctx.weightOriginPatch() });
 }
 function reportAdjacencyShape(ctx, nodes, lists, disagreeing, pending) {
   const { report } = ctx;
@@ -2298,107 +2351,120 @@ function importGraphology(ctx, root) {
       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 type = graphologyType(ctx, options);
+  ctx.setHeader(graphologyDirected(ctx, type, edges));
   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);
+    pushGraphologyNode(ctx, nodes[i], `nodes[${i}]`);
   }
   throwIfAborted(ctx.options.signal);
-  const ids = ctx.declareEdgeIds(edges, (edge) => edge.key, "key", true);
-  const violations = { selfLoops: 0, parallels: 0, flags: 0 };
-  const pairs = multi === false ? /* @__PURE__ */ new Set() : null;
+  const reading = {
+    ids: ctx.declareEdgeIds(edges, (edge) => edge.key, "key", true),
+    type,
+    allowSelfLoops,
+    // what the edges do against the declared options: graphology itself refuses such a document
+    violations: { selfLoops: 0, parallels: 0, flags: 0 },
+    pairs: multi === false ? /* @__PURE__ */ new Set() : 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;
+    readGraphologyEdge(ctx, reading, edges[i], `edges[${i}]`);
+  }
+  reportGraphologyViolations(ctx, reading.violations, type);
+  ctx.setMeta({ dialect: "graphology", allowSelfLoops }, { declaredMultigraph: multi, ...ctx.weightOriginPatch() });
+}
+function graphologyType(ctx, options) {
+  if (options.type === "directed" || options.type === "undirected" || options.type === "mixed") {
+    return options.type;
+  }
+  if (options.type !== void 0 && options.type !== null) {
+    ctx.report.warning(
+      "validation-error",
+      JSON_ISSUE.BAD_FLAG,
+      `options.type ${describe(options.type)} is not directed, undirected or mixed; mixed assumed`,
+      { element: "options.type" }
+    );
+  }
+  return "mixed";
+}
+function graphologyDirected(ctx, type, edges) {
+  if (type !== "mixed") {
+    return type === "directed";
+  }
+  const objects = edges.filter((edge) => isJsonObject(edge));
+  const undirectedEdges = objects.filter((edge) => edge.undirected === true).length;
+  return objects.length === 0 ? ctx.defaultDirected("graphology") : undirectedEdges < objects.length;
+}
+function pushGraphologyNode(ctx, record, element) {
+  if (!isJsonObject(record)) {
+    ctx.badElement("node", element);
+    return;
+  }
+  const id = ctx.coerceId(hasKey(record, "key") ? record.key : void 0, element);
+  if (id === null) {
+    ctx.countSkipped("node");
+    return;
+  }
+  pushNestedNode(ctx, id, record, "attributes", GRAPHOLOGY_NODE_KEYS, element);
+}
+function readGraphologyEdge(ctx, reading, record, element) {
+  if (!isJsonObject(record)) {
+    ctx.badElement("edge", element);
+    return;
+  }
+  if (!present(record, "source") || !present(record, "target")) {
+    ctx.missingEndpoint(element, present(record, "source") ? "target" : "source");
+    return;
+  }
+  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");
+      return;
     }
-    if (!present(record, "source") || !present(record, "target")) {
-      ctx.missingEndpoint(element, present(record, "source") ? "target" : "source");
-      continue;
+    const kind = graphologyEdgeKind(ctx, reading, record, element);
+    const attributes = graphologyEdgeAttributes(ctx, record, element);
+    const idValue = ctx.edgeIdValue(reading.ids, record.key);
+    const edge = ctx.pushEdge(u, v, kind, ctx.weightOf(attributes), element);
+    ctx.setEdgeId(reading.ids, edge, idValue);
+    ctx.writeNested(ctx.edges, edge, record, attributes, GRAPHOLOGY_EDGE_KEYS, ctx.options.weightFrom, element);
+    if (reading.allowSelfLoops === false && u === v) {
+      reading.violations.selfLoops++;
     }
-    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;
-        if (typeof record.undirected === "boolean" && record.undirected !== (type === "undirected")) {
-          violations.flags++;
-        }
-      }
-      const { attributes: rawAttributes } = record;
-      if (rawAttributes !== void 0 && rawAttributes !== null && !isJsonObject(rawAttributes)) {
-        report.error(
-          "validation-error",
-          JSON_ISSUE.BAD_VALUE,
-          `${element}: attributes must be an object, found ${describe(rawAttributes)}`,
-          { element }
-        );
-      }
-      const attributes = isJsonObject(rawAttributes) ? rawAttributes : {};
-      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, element);
-      if (allowSelfLoops === false && u === v) {
-        violations.selfLoops++;
-      }
-      if (pairs !== null) {
-        const pair = `${kind} ${pairKey(u, v, kind === "directed")}`;
-        violations.parallels += pairs.has(pair) ? 1 : 0;
-        pairs.add(pair);
-      }
-    } catch (err) {
-      ctx.skip(err, "edge", element);
+    if (reading.pairs !== null) {
+      const pair = `${kind} ${pairKey(u, v, kind === "directed")}`;
+      reading.violations.parallels += reading.pairs.has(pair) ? 1 : 0;
+      reading.pairs.add(pair);
     }
+  } catch (err) {
+    ctx.skip(err, "edge", element);
   }
-  reportGraphologyViolations(ctx, violations, type);
-  ctx.setMeta({ dialect: "graphology", allowSelfLoops }, { declaredMultigraph: multi, ...ctx.weightOriginPatch() });
+}
+function graphologyEdgeKind(ctx, reading, record, element) {
+  const { type } = reading;
+  if (type === "mixed") {
+    return flagOf(record.undirected, `${element}.undirected`, false, ctx.report) ? "undirected" : "directed";
+  }
+  if (typeof record.undirected === "boolean" && record.undirected !== (type === "undirected")) {
+    reading.violations.flags++;
+  }
+  return type;
+}
+function graphologyEdgeAttributes(ctx, record, element) {
+  const { attributes } = record;
+  if (attributes !== void 0 && attributes !== null && !isJsonObject(attributes)) {
+    ctx.report.error(
+      "validation-error",
+      JSON_ISSUE.BAD_VALUE,
+      `${element}: attributes must be an object, found ${describe(attributes)}`,
+      { element }
+    );
+  }
+  return isJsonObject(attributes) ? attributes : {};
 }
 function reportGraphologyViolations(ctx, violations, type) {
   const notes = [];
@@ -2457,23 +2523,7 @@ function importJgf(ctx, root) {
     );
   }
   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);
-  }
+  const directed = jgfDirected(ctx, graph, edges);
   ctx.setHeader(directed);
   ctx.writeGraphDict(graph.metadata, "graph.metadata");
   const shape = {
@@ -2490,44 +2540,73 @@ function importJgf(ctx, root) {
   );
   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;
-      }
-      if (record !== null && hasKey(record, "id") && record.id !== key) {
-        report.warning(
-          "validation-error",
-          JSON_ISSUE.INCONSISTENT,
-          `${element}: the inner id ${describe(record.id)} differs from the key; the key is the id, the inner one is kept as id${SUFFIX.element}`,
-          { element }
-        );
-      }
-      pushJgfNode(ctx, id, record ?? {}, labelColumn, element);
+      pushJgfKeyedNode(ctx, key, nodesRaw[key], labelColumn);
     }
   } 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);
+      pushJgfListedNode(ctx, nodeRecords[i], labelColumn, `nodes[${i}]`);
     }
   }
   throwIfAborted(ctx.options.signal);
+  const writeJgfEdge = jgfEdgeWriter(ctx, edges, hyperedges);
+  for (let i = 0; i < edges.length; i++) {
+    readJgfEdge(ctx, edges[i], `edges[${i}]`, directed, writeJgfEdge);
+  }
+  importHyperedges(ctx, hyperedges, directed, writeJgfEdge);
+  ctx.setMeta(shape, { name: label, ...ctx.weightOriginPatch() });
+}
+function jgfDirected(ctx, graph, edges) {
+  if (typeof graph.directed === "boolean") {
+    return graph.directed;
+  }
+  if (ctx.explicitDefaultDirected) {
+    return ctx.options.defaultDirected;
+  }
+  if (graph.directed !== void 0 && graph.directed !== null) {
+    ctx.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));
+  return objects.length === 0 || !objects.every((edge) => edge.directed === false);
+}
+function pushJgfKeyedNode(ctx, key, record, labelColumn) {
+  const element = `nodes[${JSON.stringify(key)}]`;
+  if (record !== null && !isJsonObject(record)) {
+    ctx.badElement("node", element);
+    return;
+  }
+  const id = ctx.coerceId(key, element);
+  if (id === null) {
+    ctx.countSkipped("node");
+    return;
+  }
+  if (record !== null && hasKey(record, "id") && record.id !== key) {
+    ctx.report.warning(
+      "validation-error",
+      JSON_ISSUE.INCONSISTENT,
+      `${element}: the inner id ${describe(record.id)} differs from the key; the key is the id, the inner one is kept as id${SUFFIX.element}`,
+      { element }
+    );
+  }
+  pushJgfNode(ctx, id, record ?? {}, labelColumn, element);
+}
+function pushJgfListedNode(ctx, record, labelColumn, element) {
+  if (!isJsonObject(record)) {
+    ctx.badElement("node", element);
+    return;
+  }
+  const id = ctx.coerceId(hasKey(record, "id") ? record.id : void 0, element);
+  if (id === null) {
+    ctx.countSkipped("node");
+    return;
+  }
+  pushJgfNode(ctx, id, record, labelColumn, element);
+}
+function jgfEdgeWriter(ctx, edges, hyperedges) {
   const ids = ctx.declareEdgeIds([...edges, ...hyperedges], (edge) => edge.id, "id", false);
   const relationColumn = ctx.edges.declareIf(
     { name: "relation", dtype: "string", role: "kind", nullable: true },
@@ -2537,7 +2616,7 @@ function importJgf(ctx, root) {
     { 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) => {
+  return (record, u, v, kind, element, structural = JGF_EDGE_KEYS) => {
     const { metadata } = record;
     const dict = isJsonObject(metadata) ? metadata : {};
     const idValue = ctx.edgeIdValue(ids, record.id);
@@ -2546,38 +2625,34 @@ function importJgf(ctx, root) {
     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`, {
+      ctx.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, element);
   };
-  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 (!present(record, "source") || !present(record, "target")) {
-      ctx.missingEndpoint(element, present(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);
+}
+function readJgfEdge(ctx, record, element, directed, writeJgfEdge) {
+  if (!isJsonObject(record)) {
+    ctx.badElement("edge", element);
+    return;
+  }
+  if (!present(record, "source") || !present(record, "target")) {
+    ctx.missingEndpoint(element, present(record, "source") ? "target" : "source");
+    return;
+  }
+  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");
+      return;
     }
+    const edgeDirected = flagOf(record.directed, `${element}.directed`, directed, ctx.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 single = isJsonObject(root.graph);
@@ -2832,49 +2907,34 @@ function distinctMembers(ctx, members, element) {
   return distinct;
 }
 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 { elements, extra } = cytoscapeRoot(ctx, 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: "f64",
-      components: 3,
-      role: "position",
-      mutable: true,
-      nullable: true,
-      // 3D layouts written by Cytoscape-compatible tools carry a z
-      extra: { sourceDims: nodes.some(hasPositionZ) ? 3 : 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 reading = {
+    positionColumn: ctx.nodes.declareIf(
+      {
+        name: POSITION_COLUMN,
+        dtype: "f64",
+        components: 3,
+        role: "position",
+        mutable: true,
+        nullable: true,
+        // 3D layouts written by Cytoscape-compatible tools carry a z
+        extra: { sourceDims: nodes.some(hasPositionZ) ? 3 : 2, units: "file" },
+        origin: { format: "json", namespace: "cytoscape" }
+      },
+      anyHas(nodes, "position")
+    ),
+    classesColumn: ctx.nodes.declareIf(
+      { name: CLASSES_COLUMN, dtype: "list", itemDtype: "string", role: "classes", nullable: true },
+      anyHas(nodes, "classes")
+    ),
+    parents: [],
+    point: [0, 0, 0]
+  };
   const parentColumn = ctx.nodes.declareIf(
     { name: PARENT_COLUMN, dtype: "u32", role: "parent", refersTo: "node", nullable: true },
     dataHas(nodes, "parent")
@@ -2883,77 +2943,104 @@ function importCytoscape(ctx, root) {
     { 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;
+    readCytoscapeNode(ctx, reading, nodes[i], `nodes[${i}]`);
+  }
+  resolveCytoscapeParents(ctx, reading.parents, parentColumn);
+  throwIfAborted(ctx.options.signal);
+  importCytoscapeEdges(ctx, edges, edgeClassesColumn);
+  ctx.setMeta({ dialect: "cytoscape", cytoscape: extra }, ctx.weightOriginPatch());
+}
+function cytoscapeRoot(ctx, root) {
+  if (Array.isArray(root)) {
+    return { elements: root };
+  }
+  if (!isJsonObject(root)) {
+    ctx.report.fail(
+      JSON_ISSUE.SHAPE,
+      `a Cytoscape document must be an object or an array, found ${describe(root)}`
+    );
+  }
+  ctx.writeGraphDict(root.data, "data");
+  const rest = {};
+  for (const key of Object.keys(root)) {
+    if (key !== "elements" && key !== "data") {
+      rest[key] = root[key];
     }
-    const { data } = record;
-    const id = ctx.coerceId(hasKey(data, "id") ? data.id : void 0, element);
-    if (id === null) {
-      ctx.countSkipped("node");
+  }
+  return Object.keys(rest).length > 0 ? { elements: root.elements, extra: rest } : { elements: root.elements };
+}
+function readCytoscapeNode(ctx, reading, record, element) {
+  const { report } = ctx;
+  if (!isJsonObject(record) || !isJsonObject(record.data)) {
+    ctx.badElement("node", element, "an element with a data object");
+    return;
+  }
+  const { data } = record;
+  const id = ctx.coerceId(hasKey(data, "id") ? data.id : void 0, element);
+  if (id === null) {
+    ctx.countSkipped("node");
+    return;
+  }
+  const index = ctx.pushNode(id, element);
+  if (index < 0) {
+    return;
+  }
+  if (present(data, "source") && present(data, "target")) {
+    report.warning(
+      "validation-error",
+      JSON_ISSUE.INCONSISTENT,
+      `${element} has data.source and data.target, the shape of an edge, but its section or group says node; read as a node`,
+      { element }
+    );
+  }
+  try {
+    writeCytoscapeData(ctx, reading, index, data, element);
+    writeCytoscapePosition$1(ctx, reading, index, record.position, element);
+    writeClasses(ctx, ctx.nodes, reading.classesColumn, index, record.classes, element);
+    writeElementKeys(ctx.nodes, index, record, element);
+  } catch (err) {
+    report.recordError(err, { element: String(id) });
+  }
+}
+function writeCytoscapeData(ctx, reading, index, data, element) {
+  for (const key of Object.keys(data)) {
+    if (key === "id") {
       continue;
     }
-    const index = ctx.pushNode(id, element);
-    if (index < 0) {
+    if (key !== "parent") {
+      ctx.nodes.write(index, key, data[key], SUFFIX.data, element);
       continue;
     }
-    if (present(data, "source") && present(data, "target")) {
-      report.warning(
-        "validation-error",
-        JSON_ISSUE.INCONSISTENT,
-        `${element} has data.source and data.target, the shape of an edge, but its section or group says node; read as a node`,
-        { element }
-      );
+    const raw = data.parent;
+    if (raw === void 0 || raw === null) {
+      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, element);
-      }
-      const { position } = record;
-      if (position !== void 0 && position !== null) {
-        const z = isJsonObject(position) ? position.z ?? 0 : 0;
-        if (isJsonObject(position) && isCoordinate(position.x) && isCoordinate(position.y) && isCoordinate(z)) {
-          point[0] = position.x;
-          point[1] = flipY(position.y);
-          point[2] = z;
-          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 (and z) that are finite numbers`,
-            { element }
-          );
-        }
-      }
-      writeClasses(ctx, ctx.nodes, classesColumn, index, record.classes, element);
-      writeElementKeys(ctx.nodes, index, record, element);
-    } catch (err) {
-      report.recordError(err, { element: String(id) });
+    const parent = ctx.coerceId(raw, `${element}.data.parent`);
+    if (parent !== null) {
+      reading.parents.push({ index, parent, element });
     }
   }
-  resolveCytoscapeParents(ctx, parents, parentColumn);
-  throwIfAborted(ctx.options.signal);
-  importCytoscapeEdges(ctx, edges, edgeClassesColumn);
-  ctx.setMeta({ dialect: "cytoscape", cytoscape: extra }, ctx.weightOriginPatch());
+}
+function writeCytoscapePosition$1(ctx, reading, index, position, element) {
+  if (position === void 0 || position === null) {
+    return;
+  }
+  const z = isJsonObject(position) ? position.z ?? 0 : 0;
+  if (isJsonObject(position) && isCoordinate(position.x) && isCoordinate(position.y) && isCoordinate(z)) {
+    const { point } = reading;
+    point[0] = position.x;
+    point[1] = flipY(position.y);
+    point[2] = z;
+    ctx.nodes.set(reading.positionColumn, index, point);
+  } else {
+    ctx.report.error(
+      "validation-error",
+      JSON_ISSUE.BAD_VALUE,
+      `${element}: position must be an object with numeric x and y (and z) that are finite numbers`,
+      { element }
+    );
+  }
 }
 function resolveCytoscapeParents(ctx, parents, parentColumn) {
   const { report } = ctx;
@@ -3028,27 +3115,31 @@ function importCytoscapeEdges(ctx, edges, edgeClassesColumn) {
       ctx.missingEndpoint(element, `data.${present(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, element);
-        }
+    importCytoscapeEdge(ctx, { ids, kind, edgeClassesColumn }, record, data, element);
+  }
+}
+function importCytoscapeEdge(ctx, shared, record, data, element) {
+  const { ids, kind, edgeClassesColumn } = shared;
+  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");
+      return;
+    }
+    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, element);
       }
-      writeClasses(ctx, ctx.edges, edgeClassesColumn, edge, record.classes, element);
-      writeElementKeys(ctx.edges, edge, record, element);
-    } catch (err) {
-      ctx.skip(err, "edge", element);
     }
+    writeClasses(ctx, ctx.edges, edgeClassesColumn, edge, record.classes, element);
+    writeElementKeys(ctx.edges, edge, record, element);
+  } catch (err) {
+    ctx.skip(err, "edge", element);
   }
 }
 function cytoscapeSections(ctx, elements) {
@@ -3566,21 +3657,7 @@ function writeNode(ctx, columns, vocabulary, record, row, element) {
 }
 function writeMeta(ctx, columns, vocabulary, meta, row, unrecognized, element) {
   const path = `${element}.meta`;
-  const { definition } = meta;
-  if (isJsonObject(definition)) {
-    const xrefs2 = strings$1(ctx, definition.xrefs, `${path}.definition.xrefs`);
-    if (typeof definition.val === "string") {
-      columns.node("def", row, definition.val);
-      columns.node("def.xrefs", row, xrefs2);
-    } else {
-      badValue(ctx, `${path}.definition has no string val; it is dropped`, `${path}.definition.val`);
-    }
-    if (definition.meta !== void 0) {
-      unrecognized["meta.definition.meta"] = definition.meta;
-    }
-  } else if (definition !== void 0 && definition !== null) {
-    badValue(ctx, `${path}.definition must be an object with a val; it is dropped`, `${path}.definition`);
-  }
+  writeDefinition(ctx, columns, meta.definition, row, unrecognized, path);
   const comments = strings$1(ctx, meta.comments, `${path}.comments`);
   if (comments.length > 0) {
     columns.node("comment", row, comments.join("\n"));
@@ -3609,6 +3686,22 @@ function writeMeta(ctx, columns, vocabulary, meta, row, unrecognized, element) {
     }
   }
 }
+function writeDefinition(ctx, columns, definition, row, unrecognized, path) {
+  if (isJsonObject(definition)) {
+    const xrefs = strings$1(ctx, definition.xrefs, `${path}.definition.xrefs`);
+    if (typeof definition.val === "string") {
+      columns.node("def", row, definition.val);
+      columns.node("def.xrefs", row, xrefs);
+    } else {
+      badValue(ctx, `${path}.definition has no string val; it is dropped`, `${path}.definition.val`);
+    }
+    if (definition.meta !== void 0) {
+      unrecognized["meta.definition.meta"] = definition.meta;
+    }
+  } else if (definition !== void 0 && definition !== null) {
+    badValue(ctx, `${path}.definition must be an object with a val; it is dropped`, `${path}.definition`);
+  }
+}
 function synonymsOf(ctx, vocabulary, value, path) {
   if (value === void 0 || value === null) {
     return [];
@@ -5782,7 +5875,6 @@ function* writeCytoscape(snapshot, 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("{");
@@ -5798,17 +5890,7 @@ function* writeCytoscape(snapshot, p) {
     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(flipY(value[1]), f32, c.nonfinite));
-        w.close("}");
-      }
-    }
+    writeCytoscapePosition(c, p.nodes, i);
     writeSlots(c, p.nodes, i, ELEMENT_SLOTS);
     w.close("}");
     yield w.take();
@@ -5845,17 +5927,34 @@ function* writeCytoscape(snapshot, p) {
     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));
-      }
-    }
-  }
+  writeCytoscapeExtra(c, resolved.shape.cytoscape);
   w.close("}");
   yield w.take();
 }
+function writeCytoscapePosition(c, items, i) {
+  const { w } = c;
+  for (const item of items) {
+    if (item.slot === "cytoscapePosition" && 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(flipY(value[1]), f32, c.nonfinite));
+      w.close("}");
+    }
+  }
+}
+function writeCytoscapeExtra(c, extra) {
+  if (extra === void 0) {
+    return;
+  }
+  for (const key of Object.keys(extra)) {
+    if (key !== "elements" && key !== "data") {
+      c.w.member(key, valueText(extra[key], false, c.nonfinite));
+    }
+  }
+}
 function edgeIdGenerator(snapshot, p) {
   const used = /* @__PURE__ */ new Set();
   for (let i = 0; i < snapshot.nodeCount; i++) {
@@ -5946,4 +6045,4 @@ export {
   rankFormats as r,
   sniffFormat as s
 };
-//# sourceMappingURL=exporter-Bcp-l4Bo.js.map
+//# sourceMappingURL=exporter-CpRyHZ3H.js.map