@graphty/graph-io 0.3.42 → 0.3.44

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

@@ -1,9 +1,14 @@
 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-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 { R as ROLE_TAKEN_CODE, C as COLUMN_RENAMED_CODE, k as DUPLICATE_ATTRIBUTE_CODE, c as UNKNOWN_ELEMENT_CODE, ax as EMPTY_COLUMN_DROPPED_CODE, a6 as PARENT_CYCLE_CODE, P as PRECISION_CODE, r as UNKNOWN_ENCODING_CODE, W as JSON_NONSTANDARD_NUMBER_CODE, s as ENCODING_FALLBACK_CODE, t as INVALID_ENCODING_CODE, u as INVALID_UTF8_CODE, O as OPTION_IGNORED_CODE, S as SINK_OPTION_CODE, H as HYPEREDGE_CODE, a1 as TOO_LARGE_CODE, e as DANGLING_REFERENCE_CODE, a2 as AMBIGUOUS_GRAPH_NAME_CODE, a3 as GRAPH_NOT_FOUND_CODE, h as MULTIPLE_GRAPHS_CODE, I as ID_MERGED_CODE, i as DUPLICATE_EDGE_ID_CODE, j as DUPLICATE_NODE_CODE, l as UNKNOWN_PARENT_CODE, Y as BAD_VALUE_CODE, m as MISSING_ENDPOINT_CODE, n as MISSING_ID_CODE, a8 as SYNTAX_CODE, E as EMPTY_INPUT_CODE, x as ELEMENT_ISSUE, y as INPUT_ISSUE, Z as ImportReportBuilder, p as plural, V as agree, ag as GRAPH_COLUMN_AS_METADATA_CODE, ah as TYPEDEF_NODES_CODE, ai as RELATION_ASSUMED_CODE, a9 as COLUMN_AS_PROPERTY_VALUE_CODE, aE as NONFINITE_AS_NULL_CODE, av as DIRECTION_DROPPED_CODE, af as NODE_ORDER_CODE, $ as formatF32, a0 as formatF64 } from "./format-GDmO6m6Q.js";
+import { c as capabilities, g as resolveImportOptions, ab as readText, j as reportSinkOptions, i as reportUnusedOptions, h as throwIfAborted, I as IdCoercer, l as DirectionResolver, w as weightFromValue, u as uniqueColumnName, f as chooseGraph, k as graphChosen, d as declareResolved, p as pairFolding, e as explicitWeights, L as LOSS, a as checkCapabilities, r as resolveExportOptions, ah as otherFormatDialect, ai as countMixedEdges } from "./export-D7IGzTG4.js";
 import { j as joinText, e as encodeChunks, i as indentUnit } from "./writer-DxjgHwSe.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";
+import { S as STYLE_BLOCK_NAME, w as toolDefaults, j as StyleNotes, p as parseStyleBlock, k as styleFingerprint, a as STYLE_ISSUE, m as plainCell, g as canonBoolean, h as canonText, b as canonNumber, l as blockStyles, c as canonColor, f as canonEnum, e as canonOpacity, r as resolveStyles } from "./block-JQiwViEt.js";
+import { t as trimTrailingZeros } from "./text-CgzMqHQb.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$1, k as OBO_IN_OWL, b as fitsVocabulary, t as textOf, S as SYNONYM_SCOPES } from "./ontology-export-BSpbY5FL.js";
+import { M as MAYBE_UNSAFE_INTEGER, g as MAYBE_INEXACT_EXPONENT, j as rewriteNumbers, l as findDuplicateKeys, m as keysInTextOrder } from "./json-elements-C4FwgnH5.js";
+import { c as cytoscapeJsStyles, C as CYTOSCAPE_IMPORT_KEY, t as toCytoscapeStylesheet, a as cyjsHoldsExactly, b as CYJS_EDGE_PROPERTIES, d as CYJS_NODE_PROPERTIES } from "./emit-DCwFLts5.js";
+import { S as StyleApproximations } from "./approximations-3Q4TsdTh.js";
+import { f as flipY } from "./convert-BcQ8_jMo.js";
 const JSON_DIALECTS = Object.freeze([
   "node-link",
   "d3",
@@ -357,15 +362,15 @@ function sniffFormat(hints, importers) {
 function sniffJsonDialectHead(head) {
   const text = typeof head === "string" ? head : new TextDecoder("utf-8", { fatal: false }).decode(head);
   const body = text.charCodeAt(0) === 65279 ? text.slice(1) : text;
-  const trimmed = body.trimStart();
-  if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) {
+  const trimmed2 = body.trimStart();
+  if (!trimmed2.startsWith("{") && !trimmed2.startsWith("[")) {
     return null;
   }
   let root;
   try {
-    root = JSON.parse(trimmed);
+    root = JSON.parse(trimmed2);
   } catch {
-    const skeleton = skeletonOf(trimmed);
+    const skeleton = skeletonOf(trimmed2);
     root = skeleton;
     if (typeof skeleton === "object" && skeleton !== null && !Array.isArray(skeleton) && !["edges", "links", "directed", "multigraph", "graph"].some((key) => key in skeleton)) {
       const guess = sniffJsonDialect(skeleton);
@@ -565,6 +570,1367 @@ function clamp(value) {
   }
   return Math.min(value, 1);
 }
+const Y_DOWN_MARKERS = ["vx", "vy", "fx", "fy", "index", "physics"];
+function jsonPositions(snapshot) {
+  if (snapshot.nodes.byRole("position") !== null) {
+    return null;
+  }
+  const x = numeric(snapshot.nodes.get("x"));
+  const y = numeric(snapshot.nodes.get("y"));
+  if (x === null || y === null) {
+    return null;
+  }
+  const z = numeric(snapshot.nodes.get("z"));
+  const down = z === null && Y_DOWN_MARKERS.some((name) => snapshot.nodes.get(name) !== null);
+  return {
+    x: x.meta.name,
+    y: y.meta.name,
+    ...z === null ? {} : { z: z.meta.name },
+    yAxis: down ? "down" : "up",
+    units: down ? "px" : "file"
+  };
+}
+function numeric(column) {
+  const numericDtypes = ["f64", "f32", "i32", "u32", "u8"];
+  return column !== null && column.meta.components === 1 && numericDtypes.includes(column.dtype) ? column : null;
+}
+const TARGETS = ["node", "edge"];
+function jsonStyles(snapshot, context) {
+  const src = context.kept;
+  if (!isJsonObject(src)) {
+    return null;
+  }
+  switch (src.dialect) {
+    case "cytoscape":
+      return cytoscapeStyles(snapshot, src, context);
+    case "graphology":
+      return graphologyStyles(snapshot, src, context);
+    case "vis":
+      return visStyles(snapshot, src, context);
+    case "node-link":
+      if (src.networkx === true) {
+        return networkxStyles(snapshot);
+      }
+      return src.block === null ? null : { canonical: true, block: src.block };
+    default:
+      return src.block === null ? null : { canonical: true, block: src.block };
+  }
+}
+function cytoscapeStyles(snapshot, src, context) {
+  const sheetless = (src.style === void 0 || src.style === null) && src.generatedBy?.startsWith("cytoscape-") === true;
+  const graphty = src.block !== null && parseStyleBlock(src.block, styleFingerprint(snapshot)).ok;
+  const read = cytoscapeJsStyles({
+    elements: withGeneratedIds(src.elements, src.generatedIds),
+    style: sheetless ? [] : src.style ?? [],
+    snapshot,
+    toolDefaults: !graphty && !sheetless,
+    budget: context.budget,
+    signal: context.signal
+  });
+  if (!("canonical" in read)) {
+    return read;
+  }
+  let tool = "cytoscape-js";
+  if (graphty) {
+    tool = null;
+    exactFromBlock(
+      snapshot,
+      src.block,
+      { node: read.node?.values ?? {}, edge: read.edge?.values ?? {} },
+      CYJS_WRITTEN,
+      cyjsHoldsExactly
+    );
+  } else if (sheetless) {
+    tool = "cytoscape";
+  }
+  return { ...read, tool, block: src.block };
+}
+const trimmed = (property) => (want) => {
+  const v = want(property);
+  return typeof v === "string" ? v.trim() : null;
+};
+const CYJS_TEXT = {
+  node: ["label"],
+  edge: ["label", "sourceLabel", "targetLabel"]
+};
+const CYJS_WRITTEN = {
+  node: Object.fromEntries(CYJS_TEXT.node.map((p) => [p, trimmed(p)])),
+  edge: {
+    ...Object.fromEntries(CYJS_TEXT.edge.map((p) => [p, trimmed(p)])),
+    // Cytoscape.js draws a loop curved whatever its curve style says
+    curved: (want, e, snapshot) => snapshot.edgeSource(e) === snapshot.edgeTarget(e) && want("curved") !== null ? true : want("curved")
+  }
+};
+function withGeneratedIds(elements, ids) {
+  if (ids === void 0 || ids.size === 0) {
+    return elements;
+  }
+  const patch = (e) => {
+    const id = isJsonObject(e) ? ids.get(e) : void 0;
+    return id === void 0 || !isJsonObject(e) ? e : { ...e, data: { ...e.data, id } };
+  };
+  if (Array.isArray(elements)) {
+    return elements.map(patch);
+  }
+  if (isJsonObject(elements) && Array.isArray(elements.nodes)) {
+    return { ...elements, nodes: elements.nodes.map(patch) };
+  }
+  return elements;
+}
+function networkxStyles(snapshot) {
+  return {
+    canonical: true,
+    dialect: null,
+    tool: "networkx",
+    units: "px",
+    node: { values: {} },
+    edge: directedArrows(snapshot)
+  };
+}
+function directedArrows(snapshot) {
+  if (!snapshot.directed || snapshot.edgeCount === 0) {
+    return { values: {}, rules: [], columns: /* @__PURE__ */ new Map() };
+  }
+  const col = snapshot.edges.byRole("directed");
+  const flags = Array.from(
+    { length: snapshot.edgeCount },
+    (_v, e) => col === null || plainCell(col.value(e)) !== false ? true : null
+  );
+  return {
+    values: {},
+    rules: [
+      {
+        id: "edge.tool.arrow",
+        target: "edge",
+        role: "group",
+        origin: "tool",
+        where: { has: { style: "directed" } },
+        set: { targetArrow: "triangle" }
+      }
+    ],
+    columns: /* @__PURE__ */ new Map([["directed", flags]])
+  };
+}
+function cells(snapshot, target, name) {
+  const table = target === "node" ? snapshot.nodes : snapshot.edges;
+  return table.has(name) ? (i) => plainCell(table.value(name, i)) : null;
+}
+function valuesOf(n) {
+  const values = {};
+  return {
+    values,
+    put: (p, i, v) => {
+      if (v !== null) {
+        setValue(values, p, n, i, v);
+      }
+    }
+  };
+}
+function setValue(values, property, n, i, v) {
+  values[property] ??= new Array(n).fill(null);
+  values[property][i] = v;
+}
+function graphologyStyles(snapshot, src, context) {
+  const notes = new StyleNotes();
+  const out = { node: {}, edge: {} };
+  const readFrom = { node: [], edge: [] };
+  for (const target of TARGETS) {
+    const n = target === "node" ? snapshot.nodeCount : snapshot.edgeCount;
+    const { values, put } = valuesOf(n);
+    const keys = {
+      color: cells(snapshot, target, "color"),
+      size: cells(snapshot, target, "size"),
+      label: cells(snapshot, target, "label"),
+      hidden: cells(snapshot, target, "hidden")
+    };
+    readFrom[target].push(...Object.entries(keys).flatMap(([name, c]) => c === null ? [] : [name]));
+    for (let i = 0; i < n; i++) {
+      const site = (property) => ({
+        notes,
+        target,
+        property,
+        element: i,
+        budget: context.budget
+      });
+      readSigmaRow(keys, target, i, put, site);
+    }
+    out[target] = values;
+  }
+  exactFromBlock(snapshot, blockText(snapshot, src), out, GRAPHOLOGY_WRITTEN);
+  return {
+    canonical: true,
+    dialect: "graphology",
+    tool: "sigma",
+    opacityInColor: true,
+    units: "relative",
+    node: { values: out.node },
+    edge: { values: out.edge },
+    notes: notes.list(),
+    readFrom
+  };
+}
+function readSigmaRow(keys, target, i, put, site) {
+  const { color, size, label, hidden } = keys;
+  if (color !== null) {
+    const [fill, opacity] = target === "node" ? ["fill", "fillOpacity"] : ["color", "opacity"];
+    putColor(put, fill, opacity, i, color(i), site(fill));
+  }
+  if (size !== null) {
+    const v = canonNumber(size(i), site("width"));
+    put("width", i, v);
+    if (target === "node") {
+      put("height", i, v);
+    }
+  }
+  if (label !== null) {
+    put("label", i, canonText(label(i), site("label")));
+  }
+  if (hidden !== null && canonBoolean(hidden(i), site("visible")) === true) {
+    put("visible", i, false);
+  }
+}
+function putColor(put, property, opacity, i, raw, site) {
+  if (raw === null || raw === void 0 || raw === "") {
+    return;
+  }
+  const c = canonColor(raw, "css", site);
+  if (c === null) {
+    return;
+  }
+  put(property, i, c.color);
+  if (c.alpha < 1) {
+    if (opacity === null) {
+      site.notes.add(STYLE_ISSUE.ALPHA_DROPPED, site.target, property, { sample: raw, element: i });
+    } else {
+      put(opacity, i, c.alpha);
+    }
+  }
+}
+function blockText(snapshot, src) {
+  if (src.block !== null) {
+    return src.block;
+  }
+  if (!snapshot.graph.has(STYLE_BLOCK_NAME)) {
+    return null;
+  }
+  const v = plainCell(snapshot.graph.value(STYLE_BLOCK_NAME, 0));
+  return typeof v === "string" ? v : null;
+}
+function exactFromBlock(snapshot, text, values, written, holdsExactly) {
+  if (text === null) {
+    return;
+  }
+  const parsed = parseStyleBlock(text, styleFingerprint(snapshot));
+  const ex = parsed.ok ? blockStyles(parsed.block, snapshot, "json") : null;
+  if (ex === null) {
+    return;
+  }
+  for (const target of TARGETS) {
+    const n = target === "node" ? snapshot.nodeCount : snapshot.edgeCount;
+    const cache = /* @__PURE__ */ new Map();
+    const resolved = (p) => {
+      let r = cache.get(p);
+      if (r === void 0) {
+        r = resolveStyles(ex, target, p, snapshot);
+        cache.set(p, r);
+      }
+      return r;
+    };
+    if (holdsExactly !== void 0) {
+      const properties = new Set(
+        ex.styles.rules.filter((r) => r.target === target).flatMap((r) => [...Object.keys(r.set ?? {}), ...Object.keys(r.map ?? {})])
+      );
+      for (const property of properties) {
+        const held = (w) => holdsExactly(target, property, w);
+        takeUnheld(values[target], property, resolved(property), n, held);
+      }
+    }
+    for (const [property, write2] of Object.entries(written[target] ?? {})) {
+      takeWritten(values[target], property, n, resolved, write2, snapshot);
+    }
+  }
+}
+function takeWritten(column, property, n, resolved, write2, snapshot) {
+  const want = resolved(property);
+  for (let i = 0; i < n; i++) {
+    const w = want[i];
+    const native = column[property]?.[i] ?? null;
+    if (native !== w && native !== null && native === write2((p) => resolved(p)[i], i, snapshot)) {
+      setValue(column, property, n, i, w);
+    }
+  }
+}
+function takeUnheld(values, property, want, n, held) {
+  for (let i = 0; i < n; i++) {
+    const w = want[i];
+    if (w !== null && !held(w)) {
+      setValue(values, property, n, i, w);
+    }
+  }
+}
+const oneSize = (want) => {
+  const w = want("width");
+  const h = want("height");
+  return typeof w === "number" && typeof h === "number" ? Math.max(w, h) : w ?? h;
+};
+const GRAPHOLOGY_WRITTEN = { node: { width: oneSize, height: oneSize } };
+const VIS_SIZED = /* @__PURE__ */ new Set([
+  "image",
+  "circularImage",
+  "diamond",
+  "dot",
+  "star",
+  "triangle",
+  "triangleDown",
+  "hexagon",
+  "square",
+  "icon"
+]);
+const VIS_GROUP_PALETTE = [
+  ["#2B7CE9", "#97C2FC"],
+  ["#FFA500", "#FFFF00"],
+  ["#FA0A10", "#FB7E81"],
+  ["#41A906", "#7BE141"],
+  ["#E129F0", "#EB7DF4"],
+  ["#7C29F0", "#AD85E4"],
+  ["#C37F00", "#FFA807"],
+  ["#4220FB", "#6E6EFD"],
+  ["#FD5A77", "#FFC0CB"],
+  ["#4AD63A", "#C2FABC"],
+  ["#990000", "#EE0000"],
+  ["#FF6000", "#FF6000"],
+  ["#97C2FC", "#2B7CE9"],
+  ["#399605", "#255C03"],
+  ["#B70054", "#FF007E"],
+  ["#AD85E4", "#7C29F0"],
+  ["#4557FA", "#000EA1"],
+  ["#FFC0CB", "#FD5A77"],
+  ["#C2FABC", "#74D66A"],
+  ["#EE0000", "#990000"]
+];
+const VIS_EDGE_COLOR = "#848484";
+function visParseColor(text) {
+  let hex = text;
+  const rgb = /^rgb\( *(\d{1,3}) *, *(\d{1,3}) *, *(\d{1,3}) *\)$/i.exec(text);
+  if (rgb?.slice(1).every((c) => Number(c) <= 255)) {
+    hex = `#${((1 << 24) + (Number(rgb[1]) << 16) + (Number(rgb[2]) << 8) + Number(rgb[3])).toString(16).slice(1)}`;
+  }
+  if (!/^#([0-9a-f]{6}|[0-9a-f]{3})$/i.test(hex)) {
+    return { background: text, border: text };
+  }
+  const full = hex.length === 4 ? `#${hex[1]}${hex[1]}${hex[2]}${hex[2]}${hex[3]}${hex[3]}` : hex;
+  return { background: full, border: visBorder(full) };
+}
+function visBorder(full) {
+  const n = Number.parseInt(full.slice(1), 16);
+  const [r, g, b] = [n >> 16 & 255, n >> 8 & 255, n & 255].map((c) => c / 255);
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  let h = 0;
+  let s = 0;
+  if (max !== min) {
+    let d = b - r;
+    let k = 5;
+    if (r === min) {
+      d = g - b;
+      k = 3;
+    } else if (b === min) {
+      d = r - g;
+      k = 1;
+    }
+    h = 60 * (k - d / (max - min)) / 360;
+    s = (max - min) / max;
+  }
+  const sv = Math.min(1, s * 1.25);
+  const vv = max * 0.8;
+  const i = Math.floor(h * 6);
+  const f = h * 6 - i;
+  const p = vv * (1 - sv);
+  const q = vv * (1 - f * sv);
+  const t = vv * (1 - (1 - f) * sv);
+  const rgbOut = [
+    [vv, t, p],
+    [q, vv, p],
+    [p, vv, t],
+    [p, q, vv],
+    [t, p, vv],
+    [vv, p, q]
+  ][i % 6].map((c) => Math.floor(c * 255));
+  return `#${((1 << 24) + (rgbOut[0] << 16) + (rgbOut[1] << 8) + rgbOut[2]).toString(16).slice(1)}`;
+}
+function visLayer(o, target) {
+  if (!isJsonObject(o)) {
+    return {};
+  }
+  const layer = {};
+  const set = (k, v) => {
+    if (v !== void 0 && v !== null) {
+      layer[k] = v;
+    }
+  };
+  if (target === "node") {
+    visNodeLayer(o, set);
+  } else {
+    visEdgeLayer(o, set);
+  }
+  set("hidden", o.hidden);
+  set("label", o.label);
+  set("title", o.title);
+  visFontLayer(o.font, set);
+  return layer;
+}
+function visNodeLayer(o, set) {
+  const { color } = o;
+  if (typeof color === "string") {
+    const parsed = visParseColor(color.trim());
+    set("fill", parsed.background);
+    set("border", parsed.border);
+  } else if (isJsonObject(color)) {
+    set("fill", color.background);
+    set("border", color.border);
+  }
+  set("shape", o.shape);
+  set("size", o.size);
+  set("borderWidth", o.borderWidth);
+  set("opacity", o.opacity);
+}
+function visEdgeLayer(o, set) {
+  const { color } = o;
+  if (typeof color === "string") {
+    set("edgeColor", color);
+    set("inherit", false);
+  } else if (isJsonObject(color)) {
+    set("edgeColor", color.color);
+    set("edgeOpacity", color.opacity);
+    const own = color.color !== void 0 || color.highlight !== void 0 || color.hover !== void 0;
+    set("inherit", own ? false : color.inherit);
+  }
+  set("width", o.width);
+  set("dashes", o.dashes);
+  set("arrows", o.arrows);
+}
+function visFontLayer(font, set) {
+  if (isJsonObject(font)) {
+    set("fontColor", font.color);
+    set("fontSize", font.size);
+    set("fontFace", font.face);
+  } else if (typeof font === "string") {
+    const m = /^\s*(\d+(?:\.\d+)?)(?:px)?\s+(\S+)(?:\s+(\S+))?/.exec(font.slice(0, 256));
+    if (m !== null) {
+      set("fontSize", Number(m[1]));
+      set("fontFace", m[2]);
+      set("fontColor", m[3]);
+    }
+  }
+}
+function visValues(layer, target, site, sized) {
+  const out = {};
+  const put = (p, v) => {
+    if (v !== null) {
+      out[p] = v;
+    }
+  };
+  const color = (p, opacity, raw) => {
+    if (raw === void 0 || raw === null || raw === "") {
+      return;
+    }
+    const c = canonColor(raw, "vis", site(p));
+    if (c !== null) {
+      put(p, c.color);
+      if (c.alpha < 1 && opacity !== null) {
+        put(opacity, c.alpha);
+      }
+    }
+  };
+  if (target === "node") {
+    color("fill", "fillOpacity", layer.fill);
+    color("borderColor", null, layer.border);
+    visNodeValues(layer, sized, put, site);
+  } else {
+    color("color", "opacity", layer.edgeColor);
+    visEdgeValues(layer, put, site);
+  }
+  if (layer.hidden !== void 0 && canonBoolean(layer.hidden, site("visible")) === true) {
+    put("visible", false);
+  }
+  if (layer.label !== void 0) {
+    put("label", canonText(layer.label, site("label")));
+  }
+  if (layer.title !== void 0) {
+    put("tooltip", canonText(layer.title, site("tooltip")));
+  }
+  color("labelColor", null, layer.fontColor);
+  if (layer.fontSize !== void 0) {
+    put("labelSize", canonNumber(layer.fontSize, site("labelSize")));
+  }
+  if (layer.fontFace !== void 0) {
+    put("labelFont", canonText(layer.fontFace, site("labelFont")));
+  }
+  return out;
+}
+function visNodeValues(layer, sized, put, site) {
+  if (layer.shape !== void 0) {
+    put("shape", canonEnum("shape", layer.shape, "vis", site("shape")));
+  }
+  if (sized && layer.size !== void 0) {
+    const v = canonNumber(layer.size, site("width"));
+    put("width", v);
+    put("height", v);
+  }
+  if (layer.borderWidth !== void 0) {
+    put("borderWidth", canonNumber(layer.borderWidth, site("borderWidth")));
+  }
+  if (layer.opacity !== void 0) {
+    put("opacity", canonOpacity(layer.opacity, "vis", site("opacity")));
+  }
+}
+function visEdgeValues(layer, put, site) {
+  if (layer.edgeOpacity !== void 0) {
+    put("opacity", canonOpacity(layer.edgeOpacity, "vis", site("opacity")));
+  }
+  if (layer.width !== void 0) {
+    put("width", canonNumber(layer.width, site("width")));
+  }
+  if (layer.dashes !== void 0) {
+    put("lineStyle", layer.dashes === false || layer.dashes === "false" ? "solid" : "dashed");
+  }
+  if (layer.arrows !== void 0) {
+    const [to, from] = visArrows(layer.arrows, site);
+    put("targetArrow", to);
+    put("sourceArrow", from);
+  }
+}
+function visArrows(arrows, site) {
+  const end = (name, property) => {
+    if (typeof arrows === "string") {
+      return new RegExp(String.raw`\b${name}\b`).test(arrows.slice(0, 256)) ? "triangle" : "none";
+    }
+    if (!isJsonObject(arrows)) {
+      return null;
+    }
+    const a = arrows[name];
+    if (a === true) {
+      return "triangle";
+    }
+    if (!isJsonObject(a) || a.enabled === false) {
+      return "none";
+    }
+    return canonEnum("arrow", a.type ?? "arrow", "vis", site(property));
+  };
+  return [end("to", "targetArrow"), end("from", "sourceArrow")];
+}
+function visStyles(snapshot, src, context) {
+  const notes = new StyleNotes();
+  const options = isJsonObject(src.options) ? src.options : {};
+  const n = snapshot.nodeCount;
+  const ruleSite = (target) => (property) => ({ notes, target, property });
+  const nodeRules = [];
+  const nodeColumns = /* @__PURE__ */ new Map();
+  const nodeDefaults = visLayer(options.nodes, "node");
+  const groupCol = cells(snapshot, "node", "group");
+  const groupOf = (i) => {
+    const g = groupCol?.(i);
+    return typeof g === "string" || typeof g === "number" ? String(g) : null;
+  };
+  const { groupLayers, paletteRows } = visGroupLayers(n, groupOf, visGroupDefs(src, options));
+  context.budget.spend("node", n);
+  const node = valuesOf(n);
+  const records = nodeRecords(snapshot);
+  const rawShape = (layer) => typeof layer.shape === "string" ? layer.shape : null;
+  for (let i = 0; i < n; i++) {
+    const g = groupOf(i);
+    const own = records(i);
+    const group = g === null ? {} : groupLayers.get(g) ?? {};
+    const shape = rawShape(own) ?? rawShape(group) ?? rawShape(nodeDefaults) ?? "ellipse";
+    const site = (property) => ({
+      notes,
+      target: "node",
+      property,
+      element: i,
+      budget: context.budget
+    });
+    const merged = { ...nodeDefaults, ...group, ...own };
+    for (const [p, v] of Object.entries(visValues(merged, "node", site, VIS_SIZED.has(shape)))) {
+      node.put(p, i, v);
+    }
+  }
+  const declaredNode = visValues(nodeDefaults, "node", ruleSite("node"), true);
+  if (Object.keys(declaredNode).length > 0) {
+    nodeRules.push(rule("node.vis.defaults", "node", "defaults", "declared", { all: true }, declaredNode));
+  }
+  let k = 0;
+  for (const [g, layer] of groupLayers) {
+    const set = paletteRows.get(g) ?? visValues(layer, "node", ruleSite("node"), true);
+    if (Object.keys(set).length === 0) {
+      continue;
+    }
+    const key = `group.${String(k)}`;
+    nodeColumns.set(
+      key,
+      Array.from({ length: n }, (_v, i) => groupOf(i) === g ? true : null)
+    );
+    const origin = paletteRows.has(g) ? "tool" : "declared";
+    const r = rule(`node.vis.group.${String(k++)}`, "node", "group", origin, { has: { style: key } }, set);
+    nodeRules.push({ ...r, facts: { names: [[key, g]] } });
+  }
+  const toolNode = toolDefaults("vis-network")?.node;
+  const borderOf = (i) => node.values.borderColor?.[i] ?? toolNode?.borderColor?.value ?? "#2b7ce9";
+  const edge = visEdges(snapshot, visLayer(options.edges, "edge"), borderOf, notes, context);
+  const values = { node: node.values, edge: edge.values };
+  exactFromBlock(snapshot, src.block, values, VIS_WRITTEN);
+  return {
+    canonical: true,
+    dialect: "vis",
+    tool: "vis-network",
+    opacityInColor: true,
+    units: "px",
+    node: { values: values.node, rules: nodeRules, columns: nodeColumns },
+    edge: { values: values.edge, rules: edge.rules, columns: edge.columns },
+    notes: notes.list(),
+    block: src.block,
+    readFrom: {
+      node: VIS_KEYS.node.filter((x) => snapshot.nodes.has(x)),
+      edge: VIS_KEYS.edge.filter((x) => snapshot.edges.has(x))
+    }
+  };
+}
+function visGroupDefs(src, options) {
+  if (isJsonObject(options.groups)) {
+    return options.groups;
+  }
+  return isJsonObject(src.groups) ? src.groups : {};
+}
+function visGroupLayers(n, groupOf, groupDefs) {
+  const groupLayers = /* @__PURE__ */ new Map();
+  const paletteRows = /* @__PURE__ */ new Map();
+  let palette = 0;
+  for (let i = 0; i < n; i++) {
+    const g = groupOf(i);
+    if (g === null || groupLayers.has(g)) {
+      continue;
+    }
+    if (Object.hasOwn(groupDefs, g)) {
+      groupLayers.set(g, visLayer(groupDefs[g], "node"));
+    } else {
+      const [border, background] = VIS_GROUP_PALETTE[palette++ % VIS_GROUP_PALETTE.length];
+      groupLayers.set(g, { fill: background, border });
+      paletteRows.set(g, { fill: background.toLowerCase(), borderColor: border.toLowerCase() });
+    }
+  }
+  return { groupLayers, paletteRows };
+}
+function visEdges(snapshot, edgeDefaults, borderOf, notes, context) {
+  const m = snapshot.edgeCount;
+  const edge = valuesOf(m);
+  const edgeRecords = elementRecords(snapshot, "edge");
+  const inherited = new Array(m).fill(null);
+  let inheriting = 0;
+  for (let e = 0; e < m; e++) {
+    const own = edgeRecords(e);
+    const merged = { ...edgeDefaults, ...own };
+    const site = (property) => ({
+      notes,
+      target: "edge",
+      property,
+      element: e,
+      budget: context.budget
+    });
+    const vals = visValues(merged, "edge", site, true);
+    for (const [p, v] of Object.entries(vals)) {
+      edge.put(p, e, v);
+    }
+    const inherit = own.inherit ?? edgeDefaults.inherit ?? "from";
+    if (inherit === false || inherit === "false") {
+      if (vals.color === void 0) {
+        edge.put("color", e, VIS_EDGE_COLOR);
+      }
+      continue;
+    }
+    if (inherit === "both") {
+      notes.add(STYLE_ISSUE.GRADIENT, "edge", "color", { sample: "inherit both", element: e });
+    }
+    inherited[e] = borderOf(inherit === "to" ? snapshot.edgeTarget(e) : snapshot.edgeSource(e));
+    inheriting++;
+  }
+  context.budget.spend("edge", m);
+  const edgeRules = [];
+  const edgeColumns = /* @__PURE__ */ new Map();
+  const declaredEdge = visValues(edgeDefaults, "edge", (property) => ({ notes, target: "edge", property }), true);
+  if (Object.keys(declaredEdge).length > 0) {
+    edgeRules.push(rule("edge.vis.defaults", "edge", "defaults", "declared", { all: true }, declaredEdge));
+  }
+  if (inheriting > 0) {
+    edgeColumns.set("source-color", inherited);
+    edgeRules.push({
+      id: "edge.tool.source-color",
+      target: "edge",
+      role: "passthrough",
+      origin: "tool",
+      where: { has: { style: "source-color" } },
+      map: { color: { kind: "passthrough", by: { style: "source-color" } } },
+      facts: { elements: inheriting, reason: "SOURCE_NODE_COLOR" }
+    });
+  }
+  return { values: edge.values, rules: edgeRules, columns: edgeColumns };
+}
+const VIS_KEYS = {
+  node: ["color", "shape", "size", "borderWidth", "opacity", "hidden", "label", "title", "font"],
+  edge: ["color", "width", "dashes", "arrows", "hidden", "label", "title", "font"]
+};
+function nodeRecords(snapshot) {
+  return elementRecords(snapshot, "node");
+}
+function elementRecords(snapshot, target) {
+  const readers = VIS_KEYS[target].map((name) => [name, cells(snapshot, target, name)]).filter((x) => x[1] !== null);
+  return (i) => {
+    const record = {};
+    for (const [name, read] of readers) {
+      const v = read(i);
+      if (v !== null) {
+        record[name] = v;
+      }
+    }
+    return visLayer(record, target);
+  };
+}
+function rule(id, target, role, origin, where, set) {
+  const values = {};
+  for (const [p, v] of Object.entries(set)) {
+    if (v !== null) {
+      values[p] = v;
+    }
+  }
+  return { id, target, role, origin, where, set: values };
+}
+const VIS_SHAPES = /* @__PURE__ */ new Map([
+  ["ellipse", ["dot", true]],
+  ["rectangle", ["square", true]],
+  ["round-rectangle", ["box", true]],
+  ["triangle", ["triangle", true]],
+  ["diamond", ["diamond", true]],
+  ["star", ["star", true]],
+  ["hexagon", ["hexagon", true]],
+  ["none", ["text", true]],
+  ["pentagon", ["hexagon", false]],
+  ["octagon", ["hexagon", false]],
+  ["parallelogram", ["box", false]],
+  ["trapezoid", ["box", false]],
+  ["vee", ["triangle", false]]
+]);
+const VIS_ARROW_TYPES = /* @__PURE__ */ new Map([
+  ["triangle", ["arrow", true]],
+  ["tee", ["bar", true]],
+  ["circle", ["circle", true]],
+  ["square", ["box", true]],
+  ["crow", ["crow", true]],
+  ["diamond", ["diamond", true]],
+  ["vee", ["vee", true]],
+  ["inverted", ["inv_triangle", true]],
+  ["triangle-open", ["arrow", false]],
+  ["diamond-open", ["diamond", false]],
+  ["circle-open", ["circle", false]],
+  ["half", ["arrow", false]]
+]);
+function visShape(shape) {
+  const known = VIS_SHAPES.get(shape);
+  if (known !== void 0) {
+    return known;
+  }
+  return shape.startsWith("other:") ? [shape.slice(6), true] : ["dot", false];
+}
+function visArrowType(arrow) {
+  if (arrow === "none") {
+    return [null, true];
+  }
+  const known = VIS_ARROW_TYPES.get(arrow);
+  if (known !== void 0) {
+    return known;
+  }
+  return arrow.startsWith("other:") ? [arrow.slice(6), true] : ["arrow", false];
+}
+const visSize = (want) => {
+  const s = want("shape");
+  const shape = typeof s === "string" ? visShape(s)[0] : "ellipse";
+  return VIS_SIZED.has(shape) ? oneSize(want) : null;
+};
+const VIS_WRITTEN = {
+  node: {
+    width: visSize,
+    height: visSize,
+    shape: (want) => {
+      const s = want("shape");
+      if (typeof s !== "string") {
+        return null;
+      }
+      const site = { notes: new StyleNotes(), target: "node", property: "shape" };
+      return canonEnum("shape", visShape(s)[0], "vis", site);
+    }
+  },
+  edge: {
+    lineStyle: (want) => {
+      const s = want("lineStyle");
+      if (s === null) {
+        return null;
+      }
+      return s === "solid" ? "solid" : "dashed";
+    },
+    targetArrow: (want) => arrowBack(want("targetArrow")),
+    sourceArrow: (want) => arrowBack(want("sourceArrow"))
+  }
+};
+function arrowBack(a) {
+  if (typeof a !== "string") {
+    return null;
+  }
+  const [type] = visArrowType(a);
+  const site = { notes: new StyleNotes(), target: "edge", property: "targetArrow" };
+  return type === null ? "none" : canonEnum("arrow", type, "vis", site);
+}
+function cyjsProperties(map, extra) {
+  const out = /* @__PURE__ */ new Set();
+  for (const spec of map.values()) {
+    if (!spec.property.startsWith("_")) {
+      out.add(spec.property);
+    }
+  }
+  for (const p of extra) {
+    out.add(p);
+  }
+  return [...out];
+}
+const NATIVE = {
+  cytoscape: {
+    node: cyjsProperties(CYJS_NODE_PROPERTIES, ["labelPosition", "labelItalic", "visible"]),
+    edge: cyjsProperties(CYJS_EDGE_PROPERTIES, ["curved", "labelItalic", "visible"])
+  },
+  graphology: {
+    node: ["fill", "fillOpacity", "width", "height", "label", "visible"],
+    edge: ["color", "opacity", "width", "label", "visible"]
+  },
+  vis: {
+    node: [
+      "fill",
+      "fillOpacity",
+      "borderColor",
+      "borderWidth",
+      "shape",
+      "width",
+      "height",
+      "opacity",
+      "label",
+      "tooltip",
+      "labelColor",
+      "labelSize",
+      "labelFont",
+      "visible"
+    ],
+    edge: [
+      "color",
+      "opacity",
+      "width",
+      "lineStyle",
+      "targetArrow",
+      "sourceArrow",
+      "label",
+      "tooltip",
+      "labelColor",
+      "labelSize",
+      "labelFont",
+      "visible"
+    ]
+  }
+};
+const JSON_STYLE_CAPABILITIES = Object.freeze({
+  node: Object.freeze([
+    .../* @__PURE__ */ new Set([...NATIVE.cytoscape.node, ...NATIVE.vis.node, ...NATIVE.graphology.node])
+  ]),
+  edge: Object.freeze([
+    .../* @__PURE__ */ new Set([...NATIVE.cytoscape.edge, ...NATIVE.vis.edge, ...NATIVE.graphology.edge])
+  ]),
+  block: "native"
+});
+const BLOCK_AS_ATTRIBUTE = /* @__PURE__ */ new Set(["node-link", "jgf", "graphology"]);
+function jsonStyledExport(snapshot, dialect, input) {
+  if (input === void 0) {
+    return null;
+  }
+  const native = dialect === "cytoscape" || dialect === "graphology" || dialect === "vis" ? NATIVE[dialect] : null;
+  const notes = [...notWritten(input, dialect, native), ...rulesNotKept(snapshot, dialect, input)];
+  if (dialect === "obographs") {
+    return { snapshot, topLevelBlock: null, stylesheet: null, groups: null, notes };
+  }
+  const out = snapshot.withColumns();
+  const read = dataColumnsRead(input.rules.styles.rules);
+  for (const [table, target] of [
+    [out.nodes, "node"],
+    [out.edges, "edge"]
+  ]) {
+    removeEarlierStyleKeys(table, dialect, read[target]);
+    for (const [name, col] of input.tags[target]) {
+      setColumn(table, name, col);
+    }
+  }
+  if (out.graph.has(STYLE_BLOCK_NAME)) {
+    out.graph.remove(STYLE_BLOCK_NAME);
+  }
+  if (BLOCK_AS_ATTRIBUTE.has(dialect)) {
+    out.graph.set(STYLE_BLOCK_NAME, [input.block], { dtype: "string" });
+  }
+  let stylesheet = null;
+  const approximated = new StyleApproximations();
+  const replaced = new Replaced(out.nodes);
+  if (dialect === "cytoscape") {
+    const emitted = writeCytoscapeStyles(out, input);
+    ({ stylesheet } = emitted);
+    notes.push(...emitted.notes.map(lossOf));
+    addUntrimmedText(input, approximated);
+  } else if (dialect === "graphology") {
+    writeGraphology$1(out, input, approximated, replaced);
+  } else if (dialect === "vis") {
+    writeVis$1(out, input, approximated, replaced);
+  }
+  notes.push(...approximated.notes(`the ${dialect} dialect of JSON`), ...replaced.notes(dialect));
+  return {
+    snapshot: out,
+    topLevelBlock: BLOCK_AS_ATTRIBUTE.has(dialect) ? null : input.block,
+    stylesheet,
+    groups: dialect === "vis" ? visGroups(out) : null,
+    notes
+  };
+}
+function rulesNotKept(snapshot, dialect, input) {
+  let message = null;
+  if (dialect === "jgf" && !jgfKeepsNodes(snapshot)) {
+    message = "the style rules are not kept: JGF changes the node ids' type or order (number ids become text, integer-like ids are read first), so the graphty.styles block no longer matches the graph read back";
+  } else if (dialect === "obographs") {
+    message = "the style rules are not kept: OBO Graphs has no place for them";
+  }
+  if (message === null) {
+    return [];
+  }
+  return [
+    Object.freeze({
+      code: STYLE_ISSUE.RULES_NOT_KEPT,
+      message,
+      column: null,
+      count: input.rules.styles.rules.length
+    })
+  ];
+}
+function removeEarlierStyleKeys(table, dialect, read) {
+  for (const name of table.names()) {
+    const styleKey = name.startsWith("graphty.style.") || name.startsWith("graphty_style_") || name === CYTOSCAPE_IMPORT_KEY;
+    if (styleKey && !read.has(name)) {
+      table.remove(name);
+    }
+  }
+  if (dialect === "cytoscape") {
+    for (const name of ["style#element", "css#element"].filter((c) => table.has(c))) {
+      table.remove(name);
+    }
+  }
+}
+function writeCytoscapeStyles(out, input) {
+  const features = {
+    node: input.rules.features.node.filter((f) => !("data" in f.ref) || out.nodes.has(f.ref.data)),
+    edge: input.rules.features.edge.filter((f) => !("data" in f.ref) || out.edges.has(f.ref.data))
+  };
+  const emitted = toCytoscapeStylesheet({ ...input.rules, features });
+  for (const [table, target] of [
+    [out.nodes, "node"],
+    [out.edges, "edge"]
+  ]) {
+    const rows = emitted.elementData[target];
+    const keys = new Set(rows.flatMap((row) => Object.keys(row ?? {})));
+    for (const key of keys) {
+      setColumn(
+        table,
+        key,
+        rows.map((row) => row?.[key] ?? null)
+      );
+    }
+    const bypass = emitted.bypass[target].map((b) => b === null || Object.keys(b).length === 0 ? null : b);
+    if (bypass.some((b) => b !== null)) {
+      setColumn(table, "style#element", bypass);
+    }
+  }
+  return emitted;
+}
+function addUntrimmedText(input, approximated) {
+  for (const target of TARGETS) {
+    for (const property of CYJS_TEXT[target]) {
+      for (const v of input.picture(target, property)) {
+        if (typeof v === "string" && v.trim() !== v) {
+          approximated.add(target, property, JSON.stringify(v));
+        }
+      }
+    }
+  }
+}
+function visGroups(snapshot) {
+  const column = snapshot.nodes.get("group");
+  if (column === null || column === void 0) {
+    return null;
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (let i = 0; i < snapshot.nodeCount; i++) {
+    const value = column.isSet(i) ? column.value(i) : null;
+    if (typeof value === "string" || typeof value === "number") {
+      groups.set(String(value), {});
+    }
+  }
+  return groups.size === 0 ? null : Object.fromEntries(groups);
+}
+function dataColumnsRead(rules) {
+  const out = { node: /* @__PURE__ */ new Set(), edge: /* @__PURE__ */ new Set() };
+  for (const rule2 of rules) {
+    const refs = [
+      ...predicateRefs(rule2.where),
+      ...Object.values(rule2.map ?? {}).flatMap((m) => m === void 0 ? [] : [m.by])
+    ];
+    for (const ref of refs) {
+      if ("data" in ref) {
+        out[rule2.target].add(ref.data);
+      }
+    }
+  }
+  return out;
+}
+function predicateRefs(where) {
+  const refs = [];
+  const stack = [where];
+  while (stack.length > 0) {
+    const p = stack.pop();
+    if ("has" in p) {
+      refs.push(p.has);
+    } else if ("eq" in p) {
+      refs.push(p.eq[0]);
+    } else if ("in" in p) {
+      refs.push(p.in[0]);
+    } else if ("and" in p) {
+      stack.push(...p.and);
+    } else if ("or" in p) {
+      stack.push(...p.or);
+    } else if ("not" in p) {
+      stack.push(p.not);
+    }
+  }
+  return refs;
+}
+function jgfKeepsNodes(snapshot) {
+  let last = -1;
+  let other = false;
+  for (let i = 0; i < snapshot.nodeCount; i++) {
+    const id = snapshot.ids.idOf(i);
+    if (typeof id === "number") {
+      return false;
+    }
+    if (/^(0|[1-9]\d*)$/.test(id) && Number(id) < 4294967295) {
+      if (other || Number(id) <= last) {
+        return false;
+      }
+      last = Number(id);
+    } else {
+      other = true;
+    }
+  }
+  return true;
+}
+function notWritten(input, dialect, native) {
+  const out = [];
+  for (const target of TARGETS) {
+    const all = new Set(JSON_STYLE_CAPABILITIES[target]);
+    const held = new Set(native?.[target] ?? []);
+    const used = /* @__PURE__ */ new Set();
+    for (const r of input.rules.styles.rules) {
+      if (r.target === target) {
+        for (const p of [...Object.keys(r.set ?? {}), ...Object.keys(r.map ?? {})]) {
+          used.add(p);
+        }
+      }
+    }
+    for (const property of used) {
+      if (!all.has(property) || held.has(property)) {
+        continue;
+      }
+      const count = input.picture(target, property).filter((v) => v !== null).length;
+      out.push(
+        Object.freeze({
+          code: STYLE_ISSUE.NOT_WRITTEN,
+          message: `${target} ${property} is not written: the ${dialect} dialect of JSON has no place for it`,
+          column: null,
+          count,
+          style: Object.freeze({ target, property })
+        })
+      );
+    }
+  }
+  return out;
+}
+function lossOf(n) {
+  return Object.freeze({
+    code: n.code,
+    message: n.message,
+    column: null,
+    count: n.params.count,
+    style: n.params.target === null || n.params.property === null ? void 0 : Object.freeze({ target: n.params.target, property: n.params.property })
+  });
+}
+function setColumn(table, name, values) {
+  const kinds = new Set(values.filter((v) => v !== null && v !== void 0).map((v) => typeof v));
+  let dtype = "json";
+  if (kinds.size === 1) {
+    if (kinds.has("number")) {
+      dtype = "f64";
+    } else if (kinds.has("boolean")) {
+      dtype = "bool";
+    } else if (kinds.has("string")) {
+      dtype = "string";
+    }
+  }
+  table.set(
+    name,
+    values.map((v) => v === null ? void 0 : v),
+    { dtype }
+  );
+}
+function writeKey(table, name, values, replaced) {
+  const old = table.get(name);
+  let changed = 0;
+  if (old !== null) {
+    for (let i = 0; i < values.length; i++) {
+      const before = plainCell(old.value(i));
+      const after = values[i] ?? null;
+      if (before !== null && JSON.stringify(before) !== JSON.stringify(after)) {
+        changed++;
+      }
+    }
+  }
+  if (changed > 0) {
+    replaced.add(table === replaced.nodes ? "node" : "edge", name, changed);
+  }
+  if (values.every((v) => v === null || v === void 0)) {
+    if (old !== null) {
+      table.remove(name);
+    }
+    return;
+  }
+  setColumn(table, name, values);
+}
+const STYLE_KEY_REPLACED_CODE = "W_JSON_STYLE_KEY_REPLACED";
+class Replaced {
+  /**
+   * Counts the replaced values of one export.
+   * @param nodes - the node table being written, which tells node columns from edge columns
+   */
+  constructor(nodes) {
+    this.nodes = nodes;
+  }
+  #counts = /* @__PURE__ */ new Map();
+  /**
+   * Counts replaced values.
+   * @param target - nodes or edges
+   * @param key - the key
+   * @param count - how many
+   */
+  add(target, key, count) {
+    this.#counts.set(`${target}\0${key}`, (this.#counts.get(`${target}\0${key}`) ?? 0) + count);
+  }
+  /**
+   * The notes, one per key.
+   * @param dialect - the dialect, for the message
+   * @returns the notes
+   */
+  notes(dialect) {
+    return Array.from(this.#counts, ([key, count]) => {
+      const [target, name] = key.split("\0");
+      return Object.freeze({
+        code: STYLE_KEY_REPLACED_CODE,
+        message: `${target} column "${name}" is the ${dialect} dialect's style key: ${String(count)} ${target}${count === 1 ? "" : "s"} get what graphty draws instead of the value the column held`,
+        column: name,
+        count
+      });
+    });
+  }
+}
+function cssColor(color, alpha) {
+  if (typeof color !== "string") {
+    return null;
+  }
+  if (typeof alpha !== "number" || alpha >= 1) {
+    return color;
+  }
+  const n = Number.parseInt(color.slice(1), 16);
+  return `rgba(${String(n >> 16 & 255)},${String(n >> 8 & 255)},${String(n & 255)},${String(alpha)})`;
+}
+function nodeSizes(width, height, approximated) {
+  return width.map((_v, i) => {
+    const w = width[i];
+    const h = height[i];
+    if (typeof w === "number" && typeof h === "number" && w !== h) {
+      approximated.add("node", w > h ? "height" : "width", `${String(w)} x ${String(h)}`);
+      return Math.max(w, h);
+    }
+    if (typeof w === "number") {
+      return w;
+    }
+    return typeof h === "number" ? h : null;
+  });
+}
+function writeGraphology$1(out, input, approximated, replaced) {
+  const p = (target, property) => input.picture(target, property);
+  for (const [table, target] of [
+    [out.nodes, "node"],
+    [out.edges, "edge"]
+  ]) {
+    const [fill, opacity] = target === "node" ? ["fill", "fillOpacity"] : ["color", "opacity"];
+    const colors = p(target, fill);
+    const alphas = p(target, opacity);
+    writeKey(
+      table,
+      "color",
+      colors.map((c, i) => cssColor(c, alphas[i])),
+      replaced
+    );
+    writeKey(
+      table,
+      "size",
+      target === "node" ? nodeSizes(p("node", "width"), p("node", "height"), approximated) : p("edge", "width"),
+      replaced
+    );
+    writeKey(table, "label", p(target, "label"), replaced);
+    writeKey(
+      table,
+      "hidden",
+      p(target, "visible").map((v) => v === false ? true : null),
+      replaced
+    );
+  }
+}
+function writeVis$1(out, input, approximated, replaced) {
+  const p = (target, property) => input.picture(target, property);
+  const font = (target) => {
+    const color2 = p(target, "labelColor");
+    const size = p(target, "labelSize");
+    const face = p(target, "labelFont");
+    return color2.map((_v, i) => {
+      const f = {};
+      if (color2[i] !== null) {
+        f.color = color2[i];
+      }
+      if (size[i] !== null) {
+        f.size = size[i];
+      }
+      if (face[i] !== null) {
+        f.face = face[i];
+      }
+      return Object.keys(f).length === 0 ? null : f;
+    });
+  };
+  const label = (table, target) => {
+    writeKey(table, "label", p(target, "label"), replaced);
+    writeKey(table, "title", p(target, "tooltip"), replaced);
+    writeKey(table, "font", font(target), replaced);
+    writeKey(
+      table,
+      "hidden",
+      p(target, "visible").map((v) => v === false ? true : null),
+      replaced
+    );
+  };
+  const fill = p("node", "fill");
+  const fillOpacity = p("node", "fillOpacity");
+  const border = p("node", "borderColor");
+  writeKey(
+    out.nodes,
+    "color",
+    fill.map((_v, i) => {
+      const c = {};
+      const bg = cssColor(fill[i], fillOpacity[i]);
+      if (bg !== null) {
+        c.background = bg;
+      }
+      if (typeof border[i] === "string") {
+        c.border = border[i];
+      }
+      return Object.keys(c).length === 0 ? null : c;
+    }),
+    replaced
+  );
+  const sizes = nodeSizes(p("node", "width"), p("node", "height"), approximated);
+  const shapes = p("node", "shape").map((s, i) => {
+    const [shape, exact] = typeof s === "string" ? visShape(s) : [null, true];
+    if (!exact) {
+      approximated.add("node", "shape", s);
+    }
+    if (sizes[i] !== null && !VIS_SIZED.has(shape ?? "ellipse")) {
+      approximated.add("node", "width", `${String(s ?? "ellipse")} sized by its label`);
+    }
+    return shape;
+  });
+  writeKey(out.nodes, "shape", shapes, replaced);
+  writeKey(out.nodes, "size", sizes, replaced);
+  writeKey(out.nodes, "borderWidth", p("node", "borderWidth"), replaced);
+  writeKey(out.nodes, "opacity", p("node", "opacity"), replaced);
+  label(out.nodes, "node");
+  const color = p("edge", "color");
+  const opacity = p("edge", "opacity");
+  writeKey(
+    out.edges,
+    "color",
+    color.map((_v, e) => {
+      const c = {};
+      if (typeof color[e] === "string") {
+        c.color = color[e];
+      }
+      if (typeof opacity[e] === "number") {
+        c.opacity = opacity[e];
+      }
+      return Object.keys(c).length === 0 ? null : c;
+    }),
+    replaced
+  );
+  writeKey(out.edges, "width", p("edge", "width"), replaced);
+  writeKey(
+    out.edges,
+    "dashes",
+    p("edge", "lineStyle").map((s) => {
+      if (typeof s !== "string") {
+        return null;
+      }
+      if (s !== "solid" && s !== "dashed") {
+        approximated.add("edge", "lineStyle", s);
+      }
+      return s !== "solid";
+    }),
+    replaced
+  );
+  const to = p("edge", "targetArrow");
+  const from = p("edge", "sourceArrow");
+  writeKey(
+    out.edges,
+    "arrows",
+    to.map((_v, e) => {
+      const a = {};
+      for (const [end, value, property] of [
+        ["to", to[e], "targetArrow"],
+        ["from", from[e], "sourceArrow"]
+      ]) {
+        if (typeof value !== "string") {
+          continue;
+        }
+        const [type, exact] = visArrowType(value);
+        if (!exact) {
+          approximated.add("edge", property, value);
+        }
+        a[end] = type === null ? { enabled: false } : { enabled: true, type };
+      }
+      return Object.keys(a).length === 0 ? null : a;
+    }),
+    replaced
+  );
+  label(out.edges, "edge");
+}
 const JSON_ISSUE = Object.freeze({
   ...INPUT_ISSUE,
   ...ELEMENT_ISSUE,
@@ -726,9 +2092,12 @@ const JGF_EDGE_KEYS = /* @__PURE__ */ new Set([
   "metadata"
 ]);
 const JGF_HYPEREDGE_KEYS = /* @__PURE__ */ new Set([...JGF_EDGE_KEYS, "nodes"]);
+const ARRAY_INDEX = /^(?:0|[1-9]\d{0,9})$/;
 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 GEPHI_NODE_KEYS = /* @__PURE__ */ new Set(["id", "attributes"]);
+const GEPHI_EDGE_KEYS = /* @__PURE__ */ new Set([...GRAPHOLOGY_EDGE_KEYS, "id"]);
 const VIS_SOURCE_KEYS = Object.freeze(["from"]);
 const VIS_TARGET_KEYS = Object.freeze(["to"]);
 const PATH_DIALECTS = /* @__PURE__ */ new Set([
@@ -1050,11 +2419,13 @@ class ImportContext {
    * @param explicitDefaultDirected - whether the caller passed defaultDirected
    */
   constructor(sink, report, options, json2, explicitDefaultDirected) {
+    this.text = "";
     this.elementsSinceCheck = 0;
     this.fileDirected = false;
     this.danglingIds = [];
     this.danglingCount = 0;
     this.nodesFromEdges = false;
+    this.styleSource = null;
     this.nearMatches = [];
     this.sink = sink;
     this.report = report;
@@ -1213,10 +2584,34 @@ class ImportContext {
     if (missingSource) {
       this.dangling(source);
     }
-    if (missingTarget) {
-      this.dangling(target);
+    if (missingTarget) {
+      this.dangling(target);
+    }
+    return edge;
+  }
+  /**
+   * A Cytoscape.js endpoint or parent id: Cytoscape.js holds every id as text, so an endpoint `0` names the node
+   * `"0"` and an endpoint `"0"` the node `0` when the file has no node of the endpoint's own type.
+   * @param raw - the JSON value
+   * @param element - the element name for issues
+   * @returns the id, or null when the value was reported
+   */
+  textualId(raw, element) {
+    const id = this.coerceId(raw, element);
+    if (id === null || this.sink.indexOf(id) !== INVALID_INDEX) {
+      return id;
+    }
+    let other = null;
+    if (typeof raw === "number" && Number.isFinite(raw)) {
+      other = String(raw);
+    } else if (typeof raw === "string" && /^-?\d+(?:\.\d+)?$/.test(raw)) {
+      other = Number(raw);
     }
-    return edge;
+    if (other === null) {
+      return id;
+    }
+    const alt = this.ids.value(other);
+    return this.sink.indexOf(alt) === INVALID_INDEX ? id : alt;
   }
   /**
    * Count a placeholder node an edge endpoint created.
@@ -1379,10 +2774,14 @@ class ImportContext {
    * @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
    * @param element - the element name for issues
+   * @param how - `weightFrom`: the weight key to skip in the dict; `plain`: write the element-level keys under their
+   * own names, not with the `#element` suffix
+   * @param how.weightFrom - the weight key to skip in the dict, or null (the default)
+   * @param how.plain - write the element-level keys under their own names (default false)
    */
-  writeNested(writer, row, record, dict, structural, weightFrom, element) {
+  writeNested(writer, row, record, dict, structural, element, how = {}) {
+    const { weightFrom = null, plain = false } = how;
     for (const key of Object.keys(dict)) {
       if (key !== weightFrom) {
         writer.write(row, key, dict[key], SUFFIX.data, element);
@@ -1390,7 +2789,7 @@ class ImportContext {
     }
     for (const key of Object.keys(record)) {
       if (!structural.has(key)) {
-        writer.write(row, `${key}${SUFFIX.element}`, record[key], SUFFIX.data, element);
+        writer.write(row, plain ? key : `${key}${SUFFIX.element}`, record[key], SUFFIX.data, element);
       }
     }
   }
@@ -1680,7 +3079,8 @@ function arraySection(value, what, report) {
   if (!Array.isArray(value)) {
     return report.fail(JSON_ISSUE.SHAPE, `${what} must be an array, found ${describe(value)}`, { element: what });
   }
-  return value;
+  const items = value;
+  return items;
 }
 function flagOf(value, what, fallback, report) {
   if (value === void 0 || value === null) {
@@ -1727,8 +3127,14 @@ function reportUnreadKeys(ctx, record, known, prefix) {
     );
   }
 }
-const VIS_DOCUMENT_KEYS = /* @__PURE__ */ new Set(["nodes", "edges"]);
-const GRAPHOLOGY_DOCUMENT_KEYS = /* @__PURE__ */ new Set(["nodes", "edges", "options", "attributes"]);
+const VIS_DOCUMENT_KEYS = /* @__PURE__ */ new Set(["nodes", "edges", STYLE_BLOCK_NAME]);
+const GRAPHOLOGY_DOCUMENT_KEYS = /* @__PURE__ */ new Set([
+  "nodes",
+  "edges",
+  "options",
+  "attributes",
+  STYLE_BLOCK_NAME
+]);
 const JGF_GRAPH_KEYS = /* @__PURE__ */ new Set([
   "id",
   "type",
@@ -1747,10 +3153,46 @@ function isIndexBelow(value, bound) {
 }
 function importNodeLink(ctx, root, dialect) {
   const { report, json: json2 } = ctx;
-  let { edgesKey } = json2;
-  if (edgesKey === null) {
-    edgesKey = hasKey(root, "edges") || !hasKey(root, "links") ? "edges" : "links";
+  const edgesKey = json2.edgesKey ?? (hasKey(root, "edges") || !hasKey(root, "links") ? "edges" : "links");
+  const { nodeList, edgeList } = nodeLinkSections(ctx, root, 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");
+  reportUnreadKeys(ctx, root, /* @__PURE__ */ new Set(["nodes", edgesKey, "directed", "multigraph", "graph", STYLE_BLOCK_NAME]), "");
+  const networkx = hasKey(root, "directed") && hasKey(root, "multigraph") && hasKey(root, "graph");
+  ctx.styleSource = { dialect, block: blockOf(root), networkx };
+  ctx.sink.reserve(nodeList.length, edgeList.length);
+  const nodeIdKey = nodeLinkIdKey(ctx, nodeList);
+  const positional = nodeIdKey === null;
+  let indexLinks;
+  if (positional) {
+    indexLinks = true;
+  } else if (json2.indexLinks === "auto") {
+    indexLinks = looksIndexLinked(nodeList, edgeList, nodeIdKey, json2);
+  } else {
+    ({ indexLinks } = json2);
   }
+  if (indexLinks && !positional && json2.indexLinks === "auto") {
+    reportAmbiguousIndexLinks(ctx, nodeList, edgeList, nodeIdKey);
+  }
+  const positionIds = importNodeLinkNodes(ctx, nodeList, nodeIdKey, indexLinks);
+  throwIfAborted(ctx.options.signal);
+  const endpointKeys = importNodeLinkEdges(ctx, edgeList, edgesKey, positionIds, multigraph);
+  ctx.setMeta(
+    {
+      dialect,
+      edgesKey,
+      nodeIdKey,
+      indexLinks,
+      sourceKey: endpointKeys.source ?? void 0,
+      targetKey: endpointKeys.target ?? void 0
+    },
+    { declaredMultigraph: multigraph, ...ctx.weightOriginPatch() }
+  );
+}
+function nodeLinkSections(ctx, root, edgesKey) {
+  const { report } = ctx;
   const nodes = arraySection(root.nodes, "nodes", report);
   const edges = arraySection(root[edgesKey], edgesKey, report);
   if (nodes === null) {
@@ -1770,94 +3212,67 @@ function importNodeLink(ctx, root, dialect) {
       { 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");
-  reportUnreadKeys(ctx, root, /* @__PURE__ */ new Set(["nodes", edgesKey, "directed", "multigraph", "graph"]), "");
-  const nodeList = nodes ?? [];
-  const edgeList = edges ?? [];
-  ctx.sink.reserve(nodeList.length, edgeList.length);
-  let { nodeIdKey } = json2;
-  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" || nodeIdKey === "name")) {
-      report.warning(
-        "unsupported",
-        JSON_ISSUE.OPTION_IGNORED,
-        nodeIdKey === "id" ? 'nodeIdFrom "label": no node has a label or name key; ids are read from "id"' : 'nodeIdFrom "label": no node has a "label" key; ids are read from "name"',
-        { 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";
-      }
-    }
+  return { nodeList: nodes ?? [], edgeList: edges ?? [] };
+}
+function nodeLinkIdKey(ctx, nodeList) {
+  const { report, json: json2 } = ctx;
+  if (ctx.options.nodeIdFrom === "index") {
+    return null;
   }
-  if (positional) {
-    nodeIdKey = null;
+  if (json2.nodeIdKey !== null) {
+    return json2.nodeIdKey;
   }
-  let indexLinks;
-  if (positional) {
-    indexLinks = true;
-  } else if (json2.indexLinks === "auto") {
-    indexLinks = nodeIdKey !== null && looksIndexLinked(nodeList, edgeList, nodeIdKey, json2);
-  } else {
-    ({ indexLinks } = json2);
+  const byLabel = ctx.options.nodeIdFrom === "label";
+  const candidates = byLabel ? ["label", "name", "id"] : ["id", "name"];
+  const found = candidates.find((key) => anyHas(nodeList, key)) ?? null;
+  if (byLabel && (found === "id" || found === "name")) {
+    report.warning(
+      "unsupported",
+      JSON_ISSUE.OPTION_IGNORED,
+      found === "id" ? 'nodeIdFrom "label": no node has a label or name key; ids are read from "id"' : 'nodeIdFrom "label": no node has a "label" key; ids are read from "name"',
+      { element: "nodeIdFrom" }
+    );
   }
-  const positionIds = indexLinks ? [] : null;
-  if (indexLinks && !positional && json2.indexLinks === "auto" && nodeIdKey !== null) {
-    reportAmbiguousIndexLinks(ctx, nodeList, edgeList, nodeIdKey);
+  if (found !== null || nodeList.length === 0) {
+    return found ?? "id";
   }
+  report.warning(
+    "missing-value",
+    JSON_ISSUE.POSITIONAL_NODES,
+    "no node has an id or name key; array positions are the node ids",
+    { element: "nodes" }
+  );
+  return null;
+}
+function importNodeLinkNodes(ctx, nodeList, nodeIdKey, indexLinks) {
+  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);
+    if (isJsonObject(record)) {
+      pushed = pushNodeLinkNode(ctx, record, i, nodeIdKey);
     } 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.nodes, index, record, id, (key) => key !== nodeIdKey);
-        }
-      }
+      ctx.badElement("node", element);
     }
     positionIds?.push(pushed);
   }
-  throwIfAborted(ctx.options.signal);
-  const endpointKeys = importNodeLinkEdges(ctx, edgeList, edgesKey, positionIds, multigraph);
-  ctx.setMeta(
-    {
-      dialect,
-      edgesKey,
-      nodeIdKey,
-      indexLinks,
-      sourceKey: endpointKeys.source ?? void 0,
-      targetKey: endpointKeys.target ?? void 0
-    },
-    { declaredMultigraph: multigraph, ...ctx.weightOriginPatch() }
-  );
+  return positionIds;
+}
+function pushNodeLinkNode(ctx, record, i, nodeIdKey) {
+  const element = `nodes[${i}]`;
+  const raw = nodeIdKey !== null && hasKey(record, nodeIdKey) ? record[nodeIdKey] : void 0;
+  const id = nodeIdKey === null ? i : ctx.coerceId(raw, 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 !== nodeIdKey);
+  return id;
 }
 function importNodeLinkEdges(ctx, edgeList, edgesKey, positionIds, multigraph) {
   const { json: json2 } = ctx;
@@ -2087,6 +3502,7 @@ function importVis(ctx, root) {
       { element: "arrows" }
     );
   }
+  ctx.styleSource = { dialect: "vis", block: blockOf(root), options: root.options, groups: root.groups };
   ctx.setMeta(
     { dialect: "vis", nodeIdKey, sourceKey: sourceKey ?? void 0, targetKey: targetKey ?? void 0 },
     ctx.weightOriginPatch()
@@ -2352,28 +3768,19 @@ function importGraphology(ctx, root) {
     });
   }
   const type = graphologyType(ctx, options);
-  ctx.setHeader(graphologyDirected(ctx, type, edges));
+  ctx.setHeader(type === "mixed" ? mostlyDirected(ctx, edges) : type === "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");
+  const firstNode = nodes.find((n) => isJsonObject(n));
+  const gephi = isJsonObject(firstNode) && !hasKey(firstNode, "key") && hasKey(firstNode, "id");
+  ctx.styleSource = { dialect: "graphology", block: blockOf(root), gephi };
   ctx.reportNodeIdFrom("graphology", "the node key");
   ctx.sink.reserve(nodes.length, edges.length);
-  for (let i = 0; i < nodes.length; i++) {
-    pushGraphologyNode(ctx, nodes[i], `nodes[${i}]`);
-  }
+  importGraphologyNodes(ctx, nodes, gephi);
   throwIfAborted(ctx.options.signal);
-  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++) {
-    readGraphologyEdge(ctx, reading, edges[i], `edges[${i}]`);
-  }
-  reportGraphologyViolations(ctx, reading.violations, type);
+  const violations = importGraphologyEdges(ctx, edges, { type, gephi, multi, allowSelfLoops });
+  reportGraphologyViolations(ctx, violations, type);
   ctx.setMeta({ dialect: "graphology", allowSelfLoops }, { declaredMultigraph: multi, ...ctx.weightOriginPatch() });
 }
 function graphologyType(ctx, options) {
@@ -2390,81 +3797,101 @@ function graphologyType(ctx, options) {
   }
   return "mixed";
 }
-function graphologyDirected(ctx, type, edges) {
-  if (type !== "mixed") {
-    return type === "directed";
-  }
+function mostlyDirected(ctx, edges) {
   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;
+function importGraphologyNodes(ctx, nodes, gephi) {
+  const nodeKey = gephi ? "id" : "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, nodeKey) ? record[nodeKey] : void 0, element);
+    if (id === null) {
+      ctx.countSkipped("node");
+      continue;
+    }
+    pushNestedNode(ctx, id, record, "attributes", gephi ? GEPHI_NODE_KEYS : GRAPHOLOGY_NODE_KEYS, element, gephi);
   }
-  const id = ctx.coerceId(hasKey(record, "key") ? record.key : void 0, element);
-  if (id === null) {
-    ctx.countSkipped("node");
-    return;
+}
+function importGraphologyEdges(ctx, edges, declared) {
+  const { gephi } = declared;
+  const ids = ctx.declareEdgeIds(edges, (edge) => gephi && !hasKey(edge, "key") ? edge.id : edge.key, "key", true);
+  const violations = { selfLoops: 0, parallels: 0, flags: 0 };
+  const pairs = declared.multi === false ? /* @__PURE__ */ new Set() : null;
+  for (let i = 0; i < edges.length; i++) {
+    const element = `edges[${i}]`;
+    const record = graphologyEdgeRecord(ctx, edges[i], element);
+    if (record === null) {
+      continue;
+    }
+    try {
+      const pushed = pushGraphologyEdge(ctx, record, element, ids, declared, violations);
+      if (pushed !== null && pairs !== null) {
+        violations.parallels += pairs.has(pushed) ? 1 : 0;
+        pairs.add(pushed);
+      }
+    } catch (err) {
+      ctx.skip(err, "edge", element);
+    }
   }
-  pushNestedNode(ctx, id, record, "attributes", GRAPHOLOGY_NODE_KEYS, element);
+  return violations;
 }
-function readGraphologyEdge(ctx, reading, record, element) {
+function graphologyEdgeRecord(ctx, record, element) {
   if (!isJsonObject(record)) {
     ctx.badElement("edge", element);
-    return;
+    return null;
   }
   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 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++;
-    }
-    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);
+    return null;
   }
+  return record;
 }
-function graphologyEdgeKind(ctx, reading, record, element) {
-  const { type } = reading;
-  if (type === "mixed") {
-    return flagOf(record.undirected, `${element}.undirected`, false, ctx.report) ? "undirected" : "directed";
+function pushGraphologyEdge(ctx, record, element, ids, declared, violations) {
+  const { report } = ctx;
+  const { type, gephi } = declared;
+  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 null;
   }
-  if (typeof record.undirected === "boolean" && record.undirected !== (type === "undirected")) {
-    reading.violations.flags++;
+  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++;
+    }
   }
-  return type;
-}
-function graphologyEdgeAttributes(ctx, record, element) {
-  const { attributes } = record;
-  if (attributes !== void 0 && attributes !== null && !isJsonObject(attributes)) {
-    ctx.report.error(
+  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(attributes)}`,
+      `${element}: attributes must be an object, found ${describe(rawAttributes)}`,
       { element }
     );
   }
-  return isJsonObject(attributes) ? attributes : {};
+  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, gephi ? GEPHI_EDGE_KEYS : GRAPHOLOGY_EDGE_KEYS, element, {
+    weightFrom: ctx.options.weightFrom,
+    plain: gephi
+  });
+  if (declared.allowSelfLoops === false && u === v) {
+    violations.selfLoops++;
+  }
+  return `${kind} ${pairKey(u, v, kind === "directed")}`;
 }
 function reportGraphologyViolations(ctx, violations, type) {
   const notes = [];
@@ -2489,7 +3916,7 @@ function reportGraphologyViolations(ctx, violations, type) {
     });
   }
 }
-function pushNestedNode(ctx, id, record, dictKey, structural, element) {
+function pushNestedNode(ctx, id, record, dictKey, structural, element, plain = false) {
   const index = ctx.pushNode(id, element);
   if (index < 0) {
     return index;
@@ -2504,7 +3931,7 @@ function pushNestedNode(ctx, id, record, dictKey, structural, element) {
         { element }
       );
     }
-    ctx.writeNested(ctx.nodes, index, record, isJsonObject(dict) ? dict : {}, structural, null, element);
+    ctx.writeNested(ctx.nodes, index, record, isJsonObject(dict) ? dict : {}, structural, element, { plain });
   } catch (err) {
     ctx.report.recordError(err, { element: String(id) });
   }
@@ -2522,7 +3949,7 @@ function importJgf(ctx, root) {
       `graph.nodes must be an object keyed by id or an array, found ${describe(nodesRaw)}`
     );
   }
-  const nodeRecords = Array.isArray(nodesRaw) ? nodesRaw : Object.values(nodesRaw ?? {});
+  const nodeRecords2 = Array.isArray(nodesRaw) ? nodesRaw : Object.values(nodesRaw ?? {});
   const directed = jgfDirected(ctx, graph, edges);
   ctx.setHeader(directed);
   ctx.writeGraphDict(graph.metadata, "graph.metadata");
@@ -2533,18 +3960,18 @@ function importJgf(ctx, root) {
   };
   const label = typeof graph.label === "string" ? graph.label : null;
   ctx.reportNodeIdFrom("jgf", "the node keys");
-  ctx.sink.reserve(nodeRecords.length, edges.length);
+  ctx.sink.reserve(nodeRecords2.length, edges.length);
   const labelColumn = ctx.nodes.declareIf(
     { name: "label", dtype: "string", role: "label", nullable: true },
-    anyHas(nodeRecords, "label")
+    anyHas(nodeRecords2, "label")
   );
   if (isJsonObject(nodesRaw)) {
-    for (const key of Object.keys(nodesRaw)) {
+    for (const key of jgfNodeKeys(ctx, root, graph, nodesRaw)) {
       pushJgfKeyedNode(ctx, key, nodesRaw[key], labelColumn);
     }
   } else {
-    for (let i = 0; i < nodeRecords.length; i++) {
-      pushJgfListedNode(ctx, nodeRecords[i], labelColumn, `nodes[${i}]`);
+    for (let i = 0; i < nodeRecords2.length; i++) {
+      pushJgfListedNode(ctx, nodeRecords2[i], labelColumn, `nodes[${i}]`);
     }
   }
   throwIfAborted(ctx.options.signal);
@@ -2629,7 +4056,7 @@ function jgfEdgeWriter(ctx, edges, hyperedges) {
         element
       });
     }
-    ctx.writeNested(ctx.edges, edge, record, dict, structural, ctx.options.weightFrom, element);
+    ctx.writeNested(ctx.edges, edge, record, dict, structural, element, { weightFrom: ctx.options.weightFrom });
   };
 }
 function readJgfEdge(ctx, record, element, directed, writeJgfEdge) {
@@ -2654,6 +4081,14 @@ function readJgfEdge(ctx, record, element, directed, writeJgfEdge) {
     ctx.skip(err, "edge", element);
   }
 }
+function jgfNodeKeys(ctx, root, graph, nodes) {
+  const keys = Object.keys(nodes);
+  if (!keys.some((k) => ARRAY_INDEX.test(k))) {
+    return keys;
+  }
+  const path = isJsonObject(root.graph) ? ["graph", "nodes"] : ["graphs", root.graphs.indexOf(graph), "nodes"];
+  return keysInTextOrder(ctx.text, path) ?? keys;
+}
 function jgfGraphOf(ctx, root) {
   const single = isJsonObject(root.graph);
   reportUnreadKeys(ctx, root, /* @__PURE__ */ new Set([single ? "graph" : "graphs"]), "");
@@ -2760,7 +4195,7 @@ function pushJgfNode(ctx, id, record, labelColumn, element) {
         element
       });
     }
-    ctx.writeNested(ctx.nodes, index, record, isJsonObject(metadata) ? metadata : {}, JGF_NODE_KEYS, null, element);
+    ctx.writeNested(ctx.nodes, index, record, isJsonObject(metadata) ? metadata : {}, JGF_NODE_KEYS, element);
   } catch (err) {
     ctx.report.recordError(err, { element: String(id) });
   }
@@ -2909,44 +4344,35 @@ function distinctMembers(ctx, members, element) {
 function importCytoscape(ctx, root) {
   const { elements, extra } = cytoscapeRoot(ctx, root);
   const { nodes, edges } = cytoscapeSections(ctx, elements);
+  const generatedIds = cytoscapeGeneratedIds(nodes);
+  ctx.styleSource = {
+    dialect: "cytoscape",
+    block: blockOf(root),
+    elements: elements ?? [],
+    style: isJsonObject(root) ? root.style : void 0,
+    generatedBy: isJsonObject(root) && typeof root.generated_by === "string" ? root.generated_by : null,
+    generatedIds
+  };
   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 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")
-  );
+  const columns = cytoscapeNodeColumns(ctx, nodes);
   const edgeClassesColumn = ctx.edges.declareIf(
     { name: CLASSES_COLUMN, dtype: "list", itemDtype: "string", role: "classes", nullable: true },
     anyHas(edges, "classes")
   );
+  const parents = [];
   for (let i = 0; i < nodes.length; i++) {
-    readCytoscapeNode(ctx, reading, nodes[i], `nodes[${i}]`);
+    const element = `nodes[${i}]`;
+    const record = nodes[i];
+    if (isJsonObject(record) && isJsonObject(record.data)) {
+      const raw = record.data.id === void 0 ? generatedIds.get(record) : record.data.id;
+      importCytoscapeNode(ctx, record, record.data, raw, element, columns, parents);
+    } else {
+      ctx.badElement("node", element, "an element with a data object");
+    }
   }
-  resolveCytoscapeParents(ctx, reading.parents, parentColumn);
+  resolveCytoscapeParents(ctx, parents, columns.parent);
   throwIfAborted(ctx.options.signal);
   importCytoscapeEdges(ctx, edges, edgeClassesColumn);
   ctx.setMeta({ dialect: "cytoscape", cytoscape: extra }, ctx.weightOriginPatch());
@@ -2961,23 +4387,46 @@ function cytoscapeRoot(ctx, root) {
       `a Cytoscape document must be an object or an array, found ${describe(root)}`
     );
   }
-  ctx.writeGraphDict(root.data, "data");
+  const object = root;
+  ctx.writeGraphDict(object.data, "data");
   const rest = {};
-  for (const key of Object.keys(root)) {
-    if (key !== "elements" && key !== "data") {
-      rest[key] = root[key];
+  for (const key of Object.keys(object)) {
+    if (key !== "elements" && key !== "data" && key !== STYLE_BLOCK_NAME) {
+      rest[key] = object[key];
     }
   }
-  return Object.keys(rest).length > 0 ? { elements: root.elements, extra: rest } : { elements: root.elements };
+  return Object.keys(rest).length > 0 ? { elements: object.elements, extra: rest } : { elements: object.elements };
+}
+function cytoscapeNodeColumns(ctx, nodes) {
+  const dataHas = (items, key) => items.some((item) => isJsonObject(item) && isJsonObject(item.data) && item.data[key] !== void 0);
+  return {
+    position: 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")
+    ),
+    classes: ctx.nodes.declareIf(
+      { name: CLASSES_COLUMN, dtype: "list", itemDtype: "string", role: "classes", nullable: true },
+      anyHas(nodes, "classes")
+    ),
+    parent: ctx.nodes.declareIf(
+      { name: PARENT_COLUMN, dtype: "u32", role: "parent", refersTo: "node", nullable: true },
+      dataHas(nodes, "parent")
+    )
+  };
 }
-function readCytoscapeNode(ctx, reading, record, element) {
+function importCytoscapeNode(ctx, record, data, raw, element, columns, parents) {
   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);
+  const id = ctx.coerceId(raw, element);
   if (id === null) {
     ctx.countSkipped("node");
     return;
@@ -2995,44 +4444,30 @@ function readCytoscapeNode(ctx, reading, record, 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);
+    for (const key of Object.keys(data).filter((k) => k !== "id")) {
+      if (key !== "parent") {
+        ctx.nodes.write(index, key, data[key], SUFFIX.data, element);
+        continue;
+      }
+      const parent = data.parent === null ? null : ctx.coerceId(data.parent, `${element}.data.parent`);
+      if (parent !== null) {
+        parents.push({ index, parent, element });
+      }
+    }
+    writeCytoscapePosition$1(ctx, columns.position, index, record.position, element);
+    writeClasses(ctx, ctx.nodes, columns.classes, 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;
-    }
-    if (key !== "parent") {
-      ctx.nodes.write(index, key, data[key], SUFFIX.data, element);
-      continue;
-    }
-    const raw = data.parent;
-    if (raw === void 0 || raw === null) {
-      continue;
-    }
-    const parent = ctx.coerceId(raw, `${element}.data.parent`);
-    if (parent !== null) {
-      reading.parents.push({ index, parent, element });
-    }
-  }
-}
-function writeCytoscapePosition$1(ctx, reading, index, position, element) {
+function writeCytoscapePosition$1(ctx, column, 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);
+    ctx.nodes.set(column, index, [position.x, flipY(position.y), z]);
   } else {
     ctx.report.error(
       "validation-error",
@@ -3046,7 +4481,11 @@ function resolveCytoscapeParents(ctx, parents, parentColumn) {
   const { report } = ctx;
   const linkOf = /* @__PURE__ */ new Map();
   for (let order = 0; order < parents.length; order++) {
-    const { index, parent, element } = parents[order];
+    const { index, element } = parents[order];
+    let { parent } = parents[order];
+    if (ctx.sink.indexOf(parent) === INVALID_INDEX) {
+      parent = ctx.textualId(parent, element) ?? parent;
+    }
     const parentIndex = ctx.sink.indexOf(parent);
     if (parentIndex === INVALID_INDEX) {
       report.error(
@@ -3121,8 +4560,8 @@ function importCytoscapeEdges(ctx, edges, edgeClassesColumn) {
 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`);
+    const u = ctx.textualId(data.source, `${element}.data.source`);
+    const v = ctx.textualId(data.target, `${element}.data.target`);
     if (u === null || v === null) {
       ctx.countSkipped("edge");
       return;
@@ -3174,6 +4613,36 @@ function cytoscapeSections(ctx, elements) {
   }
   return report.fail(JSON_ISSUE.SHAPE, `elements must be an object or an array, found ${describe(elements)}`);
 }
+function cytoscapeGeneratedIds(nodes) {
+  const out = /* @__PURE__ */ new Map();
+  const missing = nodes.filter(
+    (n) => isJsonObject(n) && isJsonObject(n.data) && n.data.id === void 0
+  );
+  if (missing.length === 0) {
+    return out;
+  }
+  const taken = /* @__PURE__ */ new Set();
+  for (const n of nodes) {
+    const id = isJsonObject(n) && isJsonObject(n.data) ? n.data.id : void 0;
+    if (typeof id === "string" || typeof id === "number") {
+      taken.add(String(id));
+    }
+  }
+  for (let k = 0; k < missing.length; k++) {
+    let id = `n${String(k)}`;
+    let j = 2;
+    while (taken.has(id)) {
+      id = `n${String(k)}_${String(j)}`;
+      j++;
+    }
+    taken.add(id);
+    out.set(missing[k], id);
+  }
+  return out;
+}
+function blockOf(root) {
+  return isJsonObject(root) && typeof root[STYLE_BLOCK_NAME] === "string" ? root[STYLE_BLOCK_NAME] : null;
+}
 function hasPositionZ(element) {
   return isJsonObject(element) && isJsonObject(element.position) && typeof element.position.z === "number";
 }
@@ -3234,6 +4703,7 @@ const jsonImporter = Object.freeze({
     "typedefs"
   ]),
   extensions: Object.freeze([".json"]),
+  positions: jsonPositions,
   mimeTypes: Object.freeze(["application/json"]),
   /**
    * Confidence that the head is a JSON graph document: 0 unless it starts with `{` or `[`, 0.5
@@ -3244,12 +4714,12 @@ const jsonImporter = Object.freeze({
    */
   sniff(head) {
     const text = new TextDecoder("utf-8").decode(headBytes(head).subarray(0, SNIFF_BYTES));
-    const trimmed = (text.startsWith(BOM) ? text.slice(1) : text).trimStart();
-    if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) {
+    const trimmed2 = (text.startsWith(BOM) ? text.slice(1) : text).trimStart();
+    if (!trimmed2.startsWith("{") && !trimmed2.startsWith("[")) {
       return 0;
     }
-    const score = SNIFF_KEYS.some((key) => trimmed.includes(key)) ? 0.9 : 0.5;
-    return trimmed.startsWith("[") && sniffJsonDialectHead(trimmed) !== "cytoscape" ? Math.min(score, 0.3) : score;
+    const score = SNIFF_KEYS.some((key) => trimmed2.includes(key)) ? 0.9 : 0.5;
+    return trimmed2.startsWith("[") && sniffJsonDialectHead(trimmed2) !== "cytoscape" ? Math.min(score, 0.3) : score;
   },
   /**
    * Read a JSON graph document into the sink.
@@ -3264,7 +4734,7 @@ const jsonImporter = Object.freeze({
     const report = new ImportReportBuilder("json", resolved.errorLimit);
     const text = await readText(input, report, { ...resolved, bomlessUtf16: true });
     const { root, dialect } = documentOf(parseDocument(text, report), json2, report);
-    readGraph(root, dialect, sink, report, resolved, json2, options);
+    readGraph({ root, dialect, text }, sink, report, resolved, json2, options);
     return report.finish();
   },
   /**
@@ -3301,17 +4771,35 @@ const jsonImporter = Object.freeze({
     const reports = [];
     for (let i = 0; i < Math.max(graphs, 1); i++) {
       const report = i === 0 ? first : new ImportReportBuilder("json", resolved.errorLimit);
-      readGraph(root, dialect, sinkFor(i), report, resolved, { ...json2, graphIndex: i, all: true }, options);
+      readGraph(
+        { root, dialect, text },
+        sinkFor(i),
+        report,
+        resolved,
+        { ...json2, graphIndex: i, all: true },
+        options
+      );
       reports.push(report.finish());
     }
     return reports;
-  }
+  },
+  /**
+   * The document's styles, read by its dialect's reader (Cytoscape.js stylesheets, graphology and vis.js keys,
+   * NetworkX's defaults); a `graphty.styles` block gives back the rules graphty wrote.
+   * @param snapshot - the graph the import built
+   * @param context - the work budget and what the import kept
+   * @returns the styles, or null when the dialect has none
+   */
+  styles: jsonStyles
 });
-function readGraph(root, dialect, sink, report, resolved, json2, options) {
+function readGraph(doc, sink, report, resolved, json2, options) {
+  const { root, dialect, text } = doc;
   const ctx = new ImportContext(sink, report, resolved, json2, options?.defaultDirected !== void 0);
+  ctx.text = text;
   reportSinkOptions(sink, options, report, dialect === "obographs");
   reportUnusedOptions(options, report, USED_OPTIONS);
   readDialect(ctx, root, dialect);
+  report.keepForStyles(ctx.styleSource ?? { dialect, block: blockOf(root) });
   ctx.reportDangling();
   ctx.nodes.reportNullOnly();
   ctx.edges.reportNullOnly();
@@ -4042,7 +5530,7 @@ function graphPropertyValues(snapshot) {
   const values = [];
   for (const column of snapshot.graph) {
     const dtype = column.dtype === "list" ? column.child.dtype : column.dtype;
-    for (const item of valuesOf(cellOf(column, 0))) {
+    for (const item of valuesOf$1(cellOf(column, 0))) {
       values.push({ pred: column.meta.name, val: typeof item === "string" ? item : textOf(item, dtype) });
     }
   }
@@ -4221,10 +5709,10 @@ ${settings.indent}` : "";
   planIds() {
     const { snapshot } = this;
     const typeColumn = snapshot.nodes.get("type");
-    let numeric = 0;
+    let numeric2 = 0;
     for (let i = 0; i < snapshot.nodeCount; i++) {
       const id = snapshot.ids.idOf(i);
-      numeric += typeof id === "number" ? 1 : 0;
+      numeric2 += typeof id === "number" ? 1 : 0;
       const text = String(id);
       let { iri, exact } = this.iriOf(text);
       const typedef = typeColumn !== null && typeColumn.isSet(i) && typeColumn.value(i) === "Typedef";
@@ -4240,12 +5728,12 @@ ${settings.indent}` : "";
         this.changedRows.add(i);
       }
     }
-    if (numeric > 0) {
+    if (numeric2 > 0) {
       this.note(
         LOSS.ID_TEXT_TYPE,
-        `${numeric} numeric node id${plural(numeric)} ${agree(numeric, "is", "are")} written as text and read back as strings`,
+        `${numeric2} numeric node id${plural(numeric2)} ${agree(numeric2, "is", "are")} written as text and read back as strings`,
         null,
-        numeric
+        numeric2
       );
     }
   }
@@ -4593,7 +6081,7 @@ ${settings.indent}` : "";
     for (const tag of PROPERTY_TAGS) {
       const v = this.at(tag, i);
       const pred = TAG_PREDICATES.get(tag) ?? tag;
-      for (const item of valuesOf(v)) {
+      for (const item of valuesOf$1(v)) {
         const text = String(item);
         values.push({ pred, val: tag === "replaced_by" || tag === "consider" ? this.iriOf(text).iri : text });
       }
@@ -4872,7 +6360,12 @@ const JSON_LOSS = Object.freeze({
    * OBO Graphs: an OBO attribute stored as text where graph-io uses a dictionary (or the other way round); it reads
    * back with graph-io's usual type. The values are the same.
    */
-  DTYPE_UNSUPPORTED: LOSS.DTYPE
+  DTYPE_UNSUPPORTED: LOSS.DTYPE,
+  /**
+   * Saving with styles: a column named like one of the dialect's style keys (graphology's `color`, `size`, `label`,
+   * vis.js's `color`, `shape`, `font`, ...) is written with what graphty draws, so the values it held differ.
+   */
+  STYLE_KEY_REPLACED: STYLE_KEY_REPLACED_CODE
 });
 const SLOT_ROLES = Object.freeze({
   "node-link": /* @__PURE__ */ new Set(),
@@ -5131,7 +6624,9 @@ function plan(snapshot, resolved) {
   const caps = dialectCapabilities(dialect);
   const notes = checkCapabilities(snapshot, caps, resolved.common, {
     roles: SLOT_ROLES[dialect],
-    positionDtype: "f64"
+    positionDtype: "f64",
+    // Deprecated (next major): role columns are written as plain attributes; styles go through the style writer.
+    vizAsAttributes: true
   }).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 }));
@@ -5201,7 +6696,7 @@ function reservedKeys(snapshot, resolved) {
       break;
     case "vis":
       node.add(resolved.nodeIdKey ?? "id");
-      edge.add(resolved.sourceKey).add(resolved.targetKey);
+      edge.add(resolved.sourceKey).add(resolved.targetKey).add("source").add("target");
       break;
     case "cytoscape":
       node.add("id").add("parent");
@@ -5442,7 +6937,7 @@ function countNonZeroZ(column) {
 function jgfIdNotes(snapshot, note) {
   const { ids } = snapshot;
   const seen = /* @__PURE__ */ new Set();
-  let numeric = 0;
+  let numeric2 = 0;
   let collisions = 0;
   let indexLike = 0;
   let lastIndex = -1;
@@ -5452,7 +6947,7 @@ function jgfIdNotes(snapshot, note) {
     const id = ids.idOf(i);
     const text = String(id);
     if (typeof id === "number") {
-      numeric++;
+      numeric2++;
     }
     if (seen.has(text)) {
       collisions++;
@@ -5469,12 +6964,12 @@ function jgfIdNotes(snapshot, note) {
       sawOther = true;
     }
   }
-  if (numeric > 0) {
+  if (numeric2 > 0) {
     note(
       JSON_LOSS.NUMERIC_IDS_STRINGIFIED,
-      `${numeric} numeric node id${plural(numeric)} ${agree(numeric, "becomes", "become")} JGF object keys (strings); pass ids: "canonical" on re-import`,
+      `${numeric2} numeric node id${plural(numeric2)} ${agree(numeric2, "becomes", "become")} JGF object keys (strings); pass ids: "canonical" on re-import`,
       null,
-      numeric
+      numeric2
     );
   }
   if (collisions > 0) {
@@ -5663,9 +7158,20 @@ function* writeNodeLink(snapshot, p) {
     yield w.take();
   }
   w.close("]");
+  writeTopLevelBlock(c, p);
   w.close("}");
   yield w.take();
 }
+function writeTopLevelBlock(c, p) {
+  const groups = p.resolved.styled?.groups ?? null;
+  if (groups !== null) {
+    c.w.member("groups", JSON.stringify(groups));
+  }
+  const block = p.resolved.styled?.topLevelBlock ?? null;
+  if (block !== null) {
+    c.w.member(STYLE_BLOCK_NAME, JSON.stringify(block));
+  }
+}
 function* writeVis(snapshot, p) {
   const { resolved } = p;
   const c = { w: new JsonWriter(resolved.indent), ids: snapshot.ids, nonfinite: { count: 0 } };
@@ -5708,6 +7214,7 @@ function* writeVis(snapshot, p) {
     yield w.take();
   }
   w.close("]");
+  writeTopLevelBlock(c, p);
   w.close("}");
   yield w.take();
 }
@@ -5890,7 +7397,7 @@ function* writeCytoscape(snapshot, p) {
     writeSlots(c, p.nodes, i, parentSlots);
     writeSlots(c, p.nodes, i, ATTRIBUTE_SLOTS);
     w.close("}");
-    writeCytoscapePosition(c, p.nodes, i);
+    writeCytoscapePosition(c, p, i);
     writeSlots(c, p.nodes, i, ELEMENT_SLOTS);
     w.close("}");
     yield w.take();
@@ -5927,13 +7434,14 @@ function* writeCytoscape(snapshot, p) {
     w.key("data");
     writeGraphObject(c, p);
   }
-  writeCytoscapeExtra(c, resolved.shape.cytoscape);
+  writeCytoscapeTopLevel(c, p);
+  writeTopLevelBlock(c, p);
   w.close("}");
   yield w.take();
 }
-function writeCytoscapePosition(c, items, i) {
+function writeCytoscapePosition(c, p, i) {
   const { w } = c;
-  for (const item of items) {
+  for (const item of p.nodes) {
     if (item.slot === "cytoscapePosition" && item.column.isSet(i)) {
       const value = item.column.value(i);
       const f32 = item.column.dtype === "f32";
@@ -5945,15 +7453,18 @@ function writeCytoscapePosition(c, items, i) {
     }
   }
 }
-function writeCytoscapeExtra(c, extra) {
-  if (extra === void 0) {
-    return;
-  }
+function writeCytoscapeTopLevel(c, p) {
+  const { w } = c;
+  const extra = p.resolved.shape.cytoscape ?? {};
+  const stylesheet = p.resolved.styled?.stylesheet ?? null;
   for (const key of Object.keys(extra)) {
-    if (key !== "elements" && key !== "data") {
-      c.w.member(key, valueText(extra[key], false, c.nonfinite));
+    if (key !== "elements" && key !== "data" && !(key === "style" && stylesheet !== null)) {
+      w.member(key, valueText(extra[key], false, c.nonfinite));
     }
   }
+  if (stylesheet !== null) {
+    w.member("style", valueText(stylesheet, false, c.nonfinite));
+  }
 }
 function edgeIdGenerator(snapshot, p) {
   const used = /* @__PURE__ */ new Set();
@@ -5978,7 +7489,13 @@ function edgeIdGenerator(snapshot, p) {
   };
 }
 function parts(snapshot, resolved) {
-  return resolved.dialect === "obographs" ? planObographs(snapshot, resolved).write() : write(snapshot, plan(snapshot, resolved));
+  const s = resolved.styled?.snapshot ?? snapshot;
+  return resolved.dialect === "obographs" ? planObographs(s, resolved).write() : write(s, plan(s, resolved));
+}
+function resolveStyled(snapshot, options) {
+  const resolved = resolve(snapshot, options);
+  const styled = jsonStyledExport(snapshot, resolved.dialect, options?.styles);
+  return styled === null ? resolved : { ...resolved, styled };
 }
 const jsonExporter = Object.freeze({
   format: "json",
@@ -5994,6 +7511,7 @@ const jsonExporter = Object.freeze({
     "weightKey"
   ]),
   capabilities: dialectCapabilities("node-link"),
+  styles: Object.freeze({ capabilities: JSON_STYLE_CAPABILITIES }),
   /**
    * Pre-flight: every loss of the selected dialect, without writing anything.
    * @param snapshot - the snapshot
@@ -6001,9 +7519,10 @@ const jsonExporter = Object.freeze({
    * @returns the notes, empty when the export is exact
    */
   check(snapshot, options) {
-    const resolved = resolve(snapshot, options);
-    const notes = resolved.dialect === "obographs" ? planObographs(snapshot, resolved).notes : plan(snapshot, resolved).notes;
-    return Object.freeze([...notes]);
+    const resolved = resolveStyled(snapshot, options);
+    const s = resolved.styled?.snapshot ?? snapshot;
+    const notes = resolved.dialect === "obographs" ? planObographs(s, resolved).notes : plan(s, resolved).notes;
+    return Object.freeze([...notes, ...resolved.styled?.notes ?? []]);
   },
   /**
    * Write the document as UTF-8 chunks.
@@ -6012,7 +7531,7 @@ const jsonExporter = Object.freeze({
    * @returns the chunks
    */
   export(snapshot, options) {
-    return encodeChunks(parts(snapshot, resolve(snapshot, options)));
+    return encodeChunks(parts(snapshot, resolveStyled(snapshot, options)));
   },
   /**
    * Write the document as one string.
@@ -6021,7 +7540,7 @@ const jsonExporter = Object.freeze({
    * @returns the document
    */
   exportToString(snapshot, options) {
-    return joinText(parts(snapshot, resolve(snapshot, options)));
+    return joinText(parts(snapshot, resolveStyled(snapshot, options)));
   }
 });
 function jsonCapabilities(dialect) {
@@ -6045,4 +7564,4 @@ export {
   rankFormats as r,
   sniffFormat as s
 };
-//# sourceMappingURL=exporter-CpRyHZ3H.js.map
+//# sourceMappingURL=exporter-quPUCBiC.js.map