@graphty/graph-io 0.3.48 → 0.3.50

package/dist/chunks/{exporter-bxxjOrDZ.js → exporter-CQQZFJ2v.js}

@@ -1,16 +1,17 @@
 import { GraphFormatError, INVALID_INDEX } from "@graphty/graph-format";
-import { R as ROLE_TAKEN_CODE, C as COLUMN_RENAMED_CODE, l as DUPLICATE_ATTRIBUTE_CODE, d as UNKNOWN_ELEMENT_CODE, aD as EMPTY_COLUMN_DROPPED_CODE, a1 as PARENT_CYCLE_CODE, P as PRECISION_CODE, s as UNKNOWN_ENCODING_CODE, Z as JSON_NONSTANDARD_NUMBER_CODE, t as ENCODING_FALLBACK_CODE, u as INVALID_ENCODING_CODE, v as INVALID_UTF8_CODE, O as OPTION_IGNORED_CODE, S as SINK_OPTION_CODE, H as HYPEREDGE_CODE, V as TOO_LARGE_CODE, f as DANGLING_REFERENCE_CODE, W as AMBIGUOUS_GRAPH_NAME_CODE, Y as GRAPH_NOT_FOUND_CODE, i as MULTIPLE_GRAPHS_CODE, I as ID_MERGED_CODE, j as DUPLICATE_EDGE_ID_CODE, k as DUPLICATE_NODE_CODE, m as UNKNOWN_PARENT_CODE, T as BAD_VALUE_CODE, n as MISSING_ENDPOINT_CODE, o as MISSING_ID_CODE, Q as SYNTAX_CODE, E as EMPTY_INPUT_CODE, y as ELEMENT_ISSUE, z as INPUT_ISSUE, K as ImportReportBuilder, p as plural, a as agree, ae as GRAPH_COLUMN_AS_METADATA_CODE, af as TYPEDEF_NODES_CODE, ag as RELATION_ASSUMED_CODE, a8 as COLUMN_AS_PROPERTY_VALUE_CODE, aG as NONFINITE_AS_NULL_CODE, aB as DIRECTION_DROPPED_CODE, ad as NODE_ORDER_CODE } from "./report-CgdsL9Hb.js";
-import { c as capabilities, d as resolveImportOptions, g as reportSinkOptions, f as reportUnusedOptions, I as IdCoercer, i as DirectionResolver, w as weightFromValue, u as uniqueColumnName, b as chooseGraph, h as graphChosen, j as declareResolved, p as pairFolding, e as explicitWeights, L as LOSS, a as checkCapabilities, r as resolveExportOptions, S as otherFormatDialect, U as countMixedEdges } from "./export-CZ7VRm4I.js";
-import { f as formatF32, a as formatF64 } from "./format-BMS-1Nxb.js";
+import { R as ROLE_TAKEN_CODE, C as COLUMN_RENAMED_CODE, l as DUPLICATE_ATTRIBUTE_CODE, d as UNKNOWN_ELEMENT_CODE, az as EMPTY_COLUMN_DROPPED_CODE, a1 as PARENT_CYCLE_CODE, P as PRECISION_CODE, s as UNKNOWN_ENCODING_CODE, Z as JSON_NONSTANDARD_NUMBER_CODE, t as ENCODING_FALLBACK_CODE, u as INVALID_ENCODING_CODE, v as INVALID_UTF8_CODE, O as OPTION_IGNORED_CODE, S as SINK_OPTION_CODE, H as HYPEREDGE_CODE, V as TOO_LARGE_CODE, f as DANGLING_REFERENCE_CODE, W as AMBIGUOUS_GRAPH_NAME_CODE, Y as GRAPH_NOT_FOUND_CODE, i as MULTIPLE_GRAPHS_CODE, I as ID_MERGED_CODE, j as DUPLICATE_EDGE_ID_CODE, k as DUPLICATE_NODE_CODE, m as UNKNOWN_PARENT_CODE, T as BAD_VALUE_CODE, n as MISSING_ENDPOINT_CODE, o as MISSING_ID_CODE, Q as SYNTAX_CODE, E as EMPTY_INPUT_CODE, y as ELEMENT_ISSUE, z as INPUT_ISSUE, K as ImportReportBuilder, p as plural, a as agree, ae as GRAPH_COLUMN_AS_METADATA_CODE, af as TYPEDEF_NODES_CODE, ag as RELATION_ASSUMED_CODE, a8 as COLUMN_AS_PROPERTY_VALUE_CODE, aD as NONFINITE_AS_NULL_CODE, ax as DIRECTION_DROPPED_CODE, ad as NODE_ORDER_CODE } from "./report-CwMfYa9J.js";
+import { D as DirectionResolver, p as pairFolding, f as formatF32, a as formatF64 } from "./format-BXiAb-1h.js";
+import { c as capabilities, b as resolveImportOptions, f as reportSinkOptions, d as reportUnusedOptions, I as IdCoercer, w as weightFromValue, u as uniqueColumnName, g as chooseGraph, h as graphChosen, i as declareResolved, e as explicitWeights, L as LOSS, a as checkCapabilities, r as resolveExportOptions, P as otherFormatDialect, G as countMixedEdges } from "./export-Cha4dRFz.js";
 import { j as joinText, e as encodeChunks, i as indentUnit } from "./writer-DxjgHwSe.js";
-import { S as STYLE_BLOCK_NAME, t as toolDefaults, u as StyleNotes, v as parseStyleBlock, s as styleFingerprint, a as STYLE_ISSUE, p as plainCell, m as canonBoolean, o as canonText, h as canonNumber, x as blockStyles, g as canonColor, l as canonEnum, j as canonOpacity, r as resolveStyles } from "./block-Cu22ewuS.js";
-import { t as trimTrailingZeros } from "./text-BuKQVMz2.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-BwgMyuF0.js";
-import { r as readText, b as throwIfAborted } from "./input-Ccg9I22A.js";
-import { M as MAYBE_UNSAFE_INTEGER, g as MAYBE_INEXACT_EXPONENT, j as rewriteNumbers, l as findDuplicateKeys, m as keysInTextOrder } from "./json-elements-By172SVq.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-CD8xnY8s.js";
-import { S as StyleApproximations } from "./approximations-C2riR4NT.js";
-import { f as flipY } from "./convert-BcQ8_jMo.js";
+import { S as STYLE_BLOCK_NAME, y as toolDefaults, h as StyleNotes, m as parseStyleBlock, o as styleFingerprint, b as STYLE_ISSUE, p as plainCell, k as canonBoolean, f as canonText, c as canonNumber, d as canonColor, a as canonEnum, j as canonOpacity } from "./block-yl0f_qLO.js";
+import { t as trimTrailingZeros } from "./text-ystE2bYi.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-OMo91mb0.js";
+import { r as readText, b as throwIfAborted } from "./input-CAxt_aV-.js";
+import { M as MAYBE_UNSAFE_INTEGER, g as MAYBE_INEXACT_EXPONENT, j as rewriteNumbers, l as findDuplicateKeys, m as keysInTextOrder } from "./json-elements-Cq76WjnZ.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-7Jkpg0yd.js";
+import { S as StyleApproximations } from "./approximations-BRXsll0T.js";
+import { t as takeFromBlock } from "./round-trip-Cy3_SHRZ.js";
+import { f as flipY } from "./convert-Ct2zelbQ.js";
 const JSON_DIALECTS = Object.freeze([
   "node-link",
   "d3",
@@ -85,15 +86,37 @@ function sniffEdgeListDialect(root) {
   if (record !== void 0) {
     return record;
   }
+  if (!networkx && firstEdge === null && isVisOptions(root.options)) {
+    return "vis";
+  }
   const bare = !hasKey(root, "directed") && !hasKey(root, "multigraph") && !hasKey(root, "graph");
   return bare && hasKey(root, "links") ? "d3" : "node-link";
 }
+const VIS_OPTION_GROUPS = [
+  "nodes",
+  "edges",
+  "groups",
+  "physics",
+  "layout",
+  "interaction",
+  "manipulation",
+  "configure",
+  "autoResize",
+  "clickToUse",
+  "locale",
+  "locales",
+  "height",
+  "width"
+];
+function isVisOptions(options) {
+  return isJsonObject(options) && VIS_OPTION_GROUPS.some((k) => hasKey(options, k));
+}
 function sniffRecordDialect(firstNode, firstEdge) {
   if (firstNode !== null && hasKey(firstNode, "key") && !hasKey(firstNode, "id")) {
     return "graphology";
   }
   if (firstEdge === null) {
-    return void 0;
+    return firstNode !== null && hasKey(firstNode, "id") && isJsonObject(firstNode.attributes) ? "graphology" : void 0;
   }
   if (!hasKey(firstEdge, "from")) {
     return hasKey(firstEdge, "undirected") || isJsonObject(firstEdge.attributes) ? "graphology" : void 0;
@@ -251,8 +274,8 @@ function exponentIfUnsafe(text) {
   }
   const [, sign, digits] = match;
   const mantissa = trimTrailingZeros(digits);
-  const fraction = mantissa.length > 1 ? `.${mantissa.slice(1)}` : "";
-  return `${sign}${mantissa[0]}${fraction}e+${digits.length - 1}`;
+  const fraction2 = mantissa.length > 1 ? `.${mantissa.slice(1)}` : "";
+  return `${sign}${mantissa[0]}${fraction2}e+${digits.length - 1}`;
 }
 const GRAPH_FORMATS = Object.freeze([
   "json",
@@ -572,10 +595,11 @@ function clamp(value) {
   }
   return Math.min(value, 1);
 }
+const SIGMA_FIT = { padding: 30 };
 const Y_DOWN_MARKERS = ["vx", "vy", "fx", "fy", "index", "physics"];
 function jsonPositions(snapshot) {
   if (snapshot.nodes.byRole("position") !== null) {
-    return null;
+    return jsonShapeOf(snapshot)?.dialect === "cytoscape" ? { containersFollowChildren: true } : null;
   }
   const x = numeric(snapshot.nodes.get("x"));
   const y = numeric(snapshot.nodes.get("y"));
@@ -583,19 +607,23 @@ function jsonPositions(snapshot) {
     return null;
   }
   const z = numeric(snapshot.nodes.get("z"));
-  const down = z === null && Y_DOWN_MARKERS.some((name) => snapshot.nodes.get(name) !== null);
+  const dialect = jsonShapeOf(snapshot)?.dialect;
+  const markers = dialect !== "graphology" && Y_DOWN_MARKERS.some((name) => snapshot.nodes.get(name) !== null);
+  const down = z === null && (dialect === "vis" || markers);
   return {
     x: x.meta.name,
     y: y.meta.name,
     ...z === null ? {} : { z: z.meta.name },
     yAxis: down ? "down" : "up",
-    units: down ? "px" : "file"
+    units: down ? "px" : "file",
+    ...dialect === "graphology" ? { viewerFit: SIGMA_FIT } : {}
   };
 }
 function numeric(column) {
   const numericDtypes = ["f64", "f32", "i32", "u32", "u8"];
   return column !== null && column.meta.components === 1 && numericDtypes.includes(column.dtype) ? column : null;
 }
+const SIGMA_DEFAULT_SETTINGS = { renderEdgeLabels: false, edgeLabelAnchors: "nodeLabels" };
 const TARGETS = ["node", "edge"];
 function jsonStyles(snapshot, context) {
   const src = context.kept;
@@ -736,14 +764,17 @@ function graphologyStyles(snapshot, src, context) {
   const notes = new StyleNotes();
   const out = { node: {}, edge: {} };
   const readFrom = { node: [], edge: [] };
+  const edgeLabel = sigmaEdgeLabels(snapshot, src.sigma ?? SIGMA_DEFAULT_SETTINGS);
   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")
+      // sigma 4's default styles bind nothing else: it draws an element marked `hidden: true` (sigma 3's key)
+      // or `visibility: "hidden"` (its own display-data name) like any other (specimen sheets
+      // graphology-specimen-node-sizes-opacity, -edges-lines)
+      label: cells(snapshot, target, "label")
     };
     readFrom[target].push(...Object.entries(keys).flatMap(([name, c]) => c === null ? [] : [name]));
     for (let i = 0; i < n; i++) {
@@ -754,7 +785,7 @@ function graphologyStyles(snapshot, src, context) {
         element: i,
         budget: context.budget
       });
-      readSigmaRow(keys, target, i, put, site);
+      readSigmaRow(keys, target, target === "node" || edgeLabel(i), i, put, site);
     }
     out[target] = values;
   }
@@ -771,31 +802,50 @@ function graphologyStyles(snapshot, src, context) {
     readFrom
   };
 }
-function readSigmaRow(keys, target, i, put, site) {
-  const { color, size, label, hidden } = keys;
+function sigmaEdgeLabels(snapshot, settings) {
+  if (!settings.renderEdgeLabels) {
+    return () => false;
+  }
+  if (settings.edgeLabelAnchors === "allNodes") {
+    return () => true;
+  }
+  const label = cells(snapshot, "node", "label");
+  const shows = (node) => {
+    const text = label?.(node);
+    return typeof text === "string" ? text !== "" : text !== null && text !== void 0;
+  };
+  return (i) => shows(snapshot.edgeSource(i)) && shows(snapshot.edgeTarget(i));
+}
+function readSigmaRow(keys, target, labeled, i, put, site) {
+  const { color, size, label } = 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);
-    }
+    putSigmaSize(put, target, i, size(i), site);
   }
-  if (label !== null) {
-    put("label", i, canonText(label(i), site("label")));
+  if (label !== null && labeled) {
+    const text = canonText(label(i), site("label"));
+    put("label", i, text === null ? null : text.replaceAll(/[\t\n\f\r]/g, " "));
   }
-  if (hidden !== null && canonBoolean(hidden(i), site("visible")) === true) {
-    put("visible", i, false);
+}
+function putSigmaSize(put, target, i, raw, site) {
+  if (target === "node") {
+    const v = Number(raw) < 0 ? 0 : canonNumber(raw, site("width"));
+    const d = v === null ? null : v * 2;
+    put("width", i, d);
+    put("height", i, d);
+  } else {
+    const w = canonNumber(raw, site("width"));
+    put("width", i, w === null ? null : w / 2);
   }
 }
 function putColor(put, property, opacity, i, raw, site) {
-  if (raw === null || raw === void 0 || raw === "") {
+  if (raw === null || raw === void 0) {
     return;
   }
-  const c = canonColor(raw, "css", site);
+  const c = canonColor(raw, "graphology", site);
   if (c === null) {
     return;
   }
@@ -819,48 +869,27 @@ function blockText(snapshot, src) {
   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) {
+  takeFromBlock(snapshot, text, "json", (target, block, ex) => {
     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);
+        takeUnheld(values[target], property, block(target, 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);
-    }
-  }
+    const writes = written[target] ?? {};
+    return {
+      values: values[target],
+      properties: Object.keys(writes),
+      // a native value the writer made from the block's other values (vis.js's one size for a width) is the
+      // block's own value, none included
+      readBack: (i, want) => (property) => writes[property](want, i, snapshot),
+      take: (_property, _wanted, native) => native !== null
+    };
+  });
 }
 function takeUnheld(values, property, want, n, held) {
   for (let i = 0; i < n; i++) {
@@ -888,6 +917,15 @@ const VIS_SIZED = /* @__PURE__ */ new Set([
   "square",
   "icon"
 ]);
+const VIS_LABEL_FIT = /* @__PURE__ */ new Map([
+  ["box", { square: false, ellipse: false }],
+  ["text", { square: false, ellipse: false }],
+  ["circle", { square: true, ellipse: false }],
+  ["database", { square: true, ellipse: false }],
+  ["ellipse", { square: false, ellipse: true }]
+]);
+const VIS_MARGIN = 5;
+const VIS_FONT_SIZE = 14;
 const VIS_GROUP_PALETTE = [
   ["#2B7CE9", "#97C2FC"],
   ["#FFA500", "#FFFF00"],
@@ -910,6 +948,8 @@ const VIS_GROUP_PALETTE = [
   ["#C2FABC", "#74D66A"],
   ["#EE0000", "#990000"]
 ];
+const VIS_NODE_FILL = "#97C2FC";
+const VIS_NODE_BORDER = "#2B7CE9";
 const VIS_EDGE_COLOR = "#848484";
 function visParseColor(text) {
   let hex = text;
@@ -978,7 +1018,14 @@ function visLayer(o, target) {
   set("hidden", o.hidden);
   set("label", o.label);
   set("title", o.title);
+  set("wrapWidth", isJsonObject(o.widthConstraint) ? o.widthConstraint.maximum : o.widthConstraint);
+  if (isJsonObject(o.scaling)) {
+    set("scalingLabel", o.scaling.label);
+  }
   visFontLayer(o.font, set);
+  if (target === "edge" && o.font !== void 0 && o.font !== null) {
+    set("fontText", typeof o.font === "string");
+  }
   return layer;
 }
 function visNodeLayer(o, set) {
@@ -993,8 +1040,104 @@ function visNodeLayer(o, set) {
   }
   set("shape", o.shape);
   set("size", o.size);
+  set("value", o.value);
+  if (isJsonObject(o.scaling)) {
+    set("scalingMin", o.scaling.min);
+    set("scalingMax", o.scaling.max);
+  }
   set("borderWidth", o.borderWidth);
   set("opacity", o.opacity);
+  set("margin", o.margin);
+  set("widthMin", isJsonObject(o.widthConstraint) ? o.widthConstraint.minimum : o.widthConstraint);
+  set("heightMin", isJsonObject(o.heightConstraint) ? o.heightConstraint.minimum : o.heightConstraint);
+  set("valign", isJsonObject(o.heightConstraint) ? o.heightConstraint.valign : void 0);
+  set("image", isJsonObject(o.image) ? o.image.unselected : o.image);
+  set("brokenImage", o.brokenImage);
+  set("imagePadding", o.imagePadding);
+  if (isJsonObject(o.icon)) {
+    set("iconCode", o.icon.code);
+    set("iconFace", o.icon.face);
+    set("iconSize", o.icon.size);
+    set("iconColor", o.icon.color);
+    set("iconWeight", o.icon.weight);
+  }
+  if (isJsonObject(o.shapeProperties)) {
+    set("useImageSize", o.shapeProperties.useImageSize);
+    set("useBorderWithImage", o.shapeProperties.useBorderWithImage);
+    set("interpolation", o.shapeProperties.interpolation);
+    set("coordinateOrigin", o.shapeProperties.coordinateOrigin);
+    set("borderDashes", o.shapeProperties.borderDashes);
+    set("borderRadius", o.shapeProperties.borderRadius);
+  }
+}
+function visImage(layer, shape, box) {
+  const text = (v) => typeof v === "string" && v !== "" ? v : null;
+  const [own, broken] = [text(layer.image), text(layer.brokenImage)];
+  const src = own ?? broken;
+  if (shape !== "image" && shape !== "circularImage" || src === null) {
+    return {};
+  }
+  const circular = shape === "circularImage";
+  const row = {
+    image: src,
+    ...own !== null && broken !== null ? { imageFallback: broken } : {},
+    imageFit: layer.useImageSize === true ? "none" : "cover",
+    imageClip: circular ? "node" : "none",
+    shape: "ellipse"
+  };
+  if (!circular) {
+    row.shape = layer.useBorderWithImage === true ? "rectangle" : "none";
+  }
+  if (layer.interpolation === false) {
+    row.imageSmoothing = false;
+  }
+  const opacity = typeof layer.opacity === "number" && layer.opacity >= 0 && layer.opacity < 1 ? layer.opacity : null;
+  if (opacity !== null) {
+    row.imageOpacity = opacity;
+  }
+  visImagePlace(row, layer, box);
+  return row;
+}
+function visImagePlace(row, layer, box) {
+  const pad = visImagePadding(layer.imagePadding);
+  if (pad !== null && layer.useImageSize !== true) {
+    row.imageFit = "none";
+    row.imageWidth = Math.max(0, box.width - pad.left - pad.right);
+    row.imageHeight = Math.max(0, box.height - pad.top - pad.bottom);
+    row.imageOffsetX = (pad.left - pad.right) / 2;
+    row.imageOffsetY = (pad.top - pad.bottom) / 2;
+  }
+  if (layer.coordinateOrigin === "top-left" && row.shape === "none") {
+    row.imageOffsetX = box.width / 2 + (typeof row.imageOffsetX === "number" ? row.imageOffsetX : 0);
+    row.imageOffsetY = box.height / 2 + (typeof row.imageOffsetY === "number" ? row.imageOffsetY : 0);
+  }
+}
+function visIcon(layer, site) {
+  const code = typeof layer.iconCode === "string" && layer.iconCode !== "" ? layer.iconCode : null;
+  if (code === null) {
+    return {};
+  }
+  const size = typeof layer.iconSize === "number" && layer.iconSize >= 0 ? layer.iconSize : 50;
+  const color = typeof layer.iconColor === "string" ? canonColor(layer.iconColor, "vis", site) : null;
+  const weight = layer.iconWeight;
+  const bold = weight === "bold" || weight === "bolder" || typeof weight === "number" && weight >= 600;
+  return {
+    glyph: code,
+    glyphFont: typeof layer.iconFace === "string" && layer.iconFace !== "" ? layer.iconFace : "FontAwesome",
+    glyphSize: size,
+    glyphColor: color?.color ?? "#2b7ce9",
+    glyphWeight: bold ? "bold" : "normal"
+  };
+}
+function visImagePadding(raw) {
+  const side = (v) => typeof v === "number" && Number.isFinite(v) && v > 0 ? v : 0;
+  let pad = null;
+  if (typeof raw === "number") {
+    pad = { top: side(raw), right: side(raw), bottom: side(raw), left: side(raw) };
+  } else if (isJsonObject(raw)) {
+    pad = { top: side(raw.top), right: side(raw.right), bottom: side(raw.bottom), left: side(raw.left) };
+  }
+  return pad === null || pad.top + pad.right + pad.bottom + pad.left === 0 ? null : pad;
 }
 function visEdgeLayer(o, set) {
   const { color } = o;
@@ -1008,14 +1151,35 @@ function visEdgeLayer(o, set) {
     set("inherit", own ? false : color.inherit);
   }
   set("width", o.width);
+  set("value", o.value);
+  if (isJsonObject(o.scaling)) {
+    set("scalingMin", o.scaling.min);
+    set("scalingMax", o.scaling.max);
+  }
   set("dashes", o.dashes);
   set("arrows", o.arrows);
+  set("background", o.background);
+  set("smooth", o.smooth);
+  set("selfReference", o.selfReference);
+  set("selfReferenceSize", o.selfReferenceSize);
+  set("physics", o.physics);
+  set("length", o.length);
 }
 function visFontLayer(font, set) {
   if (isJsonObject(font)) {
+    set("fontMulti", font.multi);
+    set("fontStrokeWidth", font.strokeWidth);
+    set("fontStrokeColor", font.strokeColor);
+    set("fontBackground", font.background);
+    set("fontAlign", font.align);
     set("fontColor", font.color);
     set("fontSize", font.size);
     set("fontFace", font.face);
+    set("fontVadjust", font.vadjust);
+    const mods = ["bold", "ital", "boldital", "mono"].filter((m) => font[m] !== void 0 && font[m] !== null);
+    if (mods.length > 0) {
+      set("fontMods", Object.fromEntries(mods.map((m) => [m, font[m]])));
+    }
   } else if (typeof font === "string") {
     const m = /^\s*(\d+(?:\.\d+)?)(?:px)?\s+(\S+)(?:\s+(\S+))?/.exec(font.slice(0, 256));
     if (m !== null) {
@@ -1046,44 +1210,328 @@ function visValues(layer, target, site, sized) {
   };
   if (target === "node") {
     color("fill", "fillOpacity", layer.fill);
-    color("borderColor", null, layer.border);
+    color("borderColor", "borderOpacity", layer.border);
     visNodeValues(layer, sized, put, site);
   } else {
     color("color", "opacity", layer.edgeColor);
     visEdgeValues(layer, put, site);
+    visEdgeBackground(layer, put, color);
   }
   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")));
+  visLabelValues(layer, target, put, color, site);
+  return out;
+}
+function visEdgeBackground(layer, put, color) {
+  if (!isJsonObject(layer.background)) {
+    return;
   }
-  if (layer.title !== void 0) {
-    put("tooltip", canonText(layer.title, site("tooltip")));
+  const bg = layer.background;
+  const straight = layer.smooth === false || isJsonObject(layer.smooth) && layer.smooth.enabled === false;
+  color("outlineColor", "outlineOpacity", bg.color);
+  if (bg.enabled !== void 0) {
+    const size = typeof bg.size === "number" ? bg.size : 10;
+    const width = typeof layer.width === "number" ? layer.width : 1;
+    put("outlineWidth", bg.enabled === true && !straight ? Math.max(0, size - width) : 0);
   }
-  color("labelColor", null, layer.fontColor);
+  const band = visBandStyle(bg, false);
+  if (band !== null) {
+    put("outlineStyle", band);
+  }
+}
+function visLabelValues(layer, target, put, color, site) {
   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;
+  if (layer.label !== void 0) {
+    visLabelText(layer, target, put, site);
+  }
+  if (typeof layer.wrapWidth === "number" && Number.isFinite(layer.wrapWidth) && layer.wrapWidth > 0) {
+    put("labelWrapWidth", layer.wrapWidth);
+    put("labelWrapSpaceCount", 3);
+  }
+  if (layer.title !== void 0) {
+    put("tooltip", canonText(layer.title, site("tooltip")));
+  }
+  const threshold = isJsonObject(layer.scalingLabel) ? layer.scalingLabel.drawThreshold : void 0;
+  if (typeof threshold === "number" && Number.isFinite(threshold)) {
+    put("labelMinScreenSize", Math.max(0, threshold - 1));
+  }
+  visLabelLook(layer, target, put, color, site);
+}
+function visLabelText(layer, target, put, site) {
+  const text = target === "edge" && layer.fontText === true ? "" : canonText(layer.label, site("label"));
+  const marked = typeof text === "string" ? visMarkup(text, layer.fontMulti) : null;
+  put("label", marked?.text ?? text);
+  if (marked !== null) {
+    const runs = visRuns(marked.runs, layer, site("labelRuns"));
+    put("labelRuns", runs);
+    if (runs !== null) {
+      put("labelRunAlign", visRunAlign(layer, target));
+    }
+  }
+  for (const [p, v] of Object.entries(VIS_MOD_VALUES[marked?.mod ?? "normal"] ?? {})) {
+    put(p, v);
+  }
+}
+function visLabelLook(layer, target, put, color, site) {
+  color("labelColor", null, layer.fontColor);
+  color("labelBackground", null, layer.fontBackground === "none" ? void 0 : layer.fontBackground);
+  if (typeof layer.fontBackground === "string" && layer.fontBackground !== "none") {
+    put("labelPadding", 0);
+    put("labelLineHeight", 1);
+  }
+  const stroked = typeof layer.fontStrokeWidth === "number" && layer.fontStrokeWidth > 0;
+  color("labelOutlineColor", null, layer.fontStrokeColor ?? (stroked ? "#ffffff" : void 0));
+  if (layer.fontStrokeWidth !== void 0) {
+    put("labelOutlineWidth", canonNumber(layer.fontStrokeWidth, site("labelOutlineWidth")));
+  }
+  if (target === "edge" && typeof layer.fontAlign === "string") {
+    put("labelPosition", layer.fontAlign === "top" || layer.fontAlign === "bottom" ? layer.fontAlign : "center");
+  } else if (target === "node" && typeof layer.fontAlign === "string") {
+    put("labelTextAlign", { center: "center", right: "right" }[layer.fontAlign] ?? "left");
+  }
+  if (typeof layer.fontVadjust === "number" && Number.isFinite(layer.fontVadjust) && layer.fontVadjust !== 0) {
+    put("labelOffsetY", layer.fontVadjust);
+  }
+}
+const VIS_MOD_VALUES = {
+  bold: { labelWeight: "bold" },
+  ital: { labelItalic: true },
+  boldital: { labelWeight: "bold", labelItalic: true },
+  mono: { labelFont: "monospace" }
+};
+function visTakesOpacity(color) {
+  if (color === void 0) {
+    return true;
+  }
+  return typeof color === "string" && !color.includes("rgba") && (color.includes("rgb") || /^#?(?:[0-9a-f]{3}|[0-9a-f]{6})$/i.test(color.trim()));
+}
+function visBandStyle(bg, round) {
+  if (bg.dashes === void 0 || bg.dashes === false) {
+    return null;
+  }
+  return visDashStyle(bg.dashes === true ? [5, 5] : bg.dashes, typeof bg.size === "number" ? bg.size : 10, round);
+}
+function visDashStyle(dashes, width, round) {
+  if (!Array.isArray(dashes)) {
+    return dashes === false ? "solid" : "dashed";
+  }
+  const lengths = dashes.filter((d) => typeof d === "number" && Number.isFinite(d));
+  const pairs = lengths.length % 2 === 1 ? [...lengths, ...lengths] : lengths;
+  const grow = round ? width : 0;
+  const on = pairs.filter((_d, i) => i % 2 === 0).map((d) => Math.max(0, d) + grow);
+  const off = pairs.filter((_d, i) => i % 2 === 1).map((d) => Math.max(0, d - grow));
+  const sum = (xs) => xs.reduce((a, b) => a + b, 0);
+  if (on.length === 0 || sum(off) < 0.1 * (sum(on) + sum(off))) {
+    return "solid";
+  }
+  if (on.every((d) => d <= 1.5 * Math.max(1, width))) {
+    return "dotted";
+  }
+  return Math.max(...on) >= 2 * Math.min(...on) ? "dash-dot" : "dashed";
+}
+function visMarkup(text, multi) {
+  const system = VIS_MARKUP_SYSTEM.get(multi);
+  if (system === void 0) {
+    return null;
+  }
+  const state = { bold: false, ital: false, mono: false };
+  const runs = [];
+  const source = text.slice(0, 4096);
+  let i = 0;
+  while (i < source.length) {
+    const tagged = visMarkTag(source, i, system, state);
+    if (tagged > 0) {
+      i += tagged;
+      continue;
+    }
+    const [ch, next] = visMarkChar(source, i, system);
+    runs.push({ text: ch, mod: visMarkMod(state) });
+    i = next;
+  }
+  const mods = new Set(runs.filter((r) => /\S/.test(r.text)).map((r) => r.mod));
+  const only = mods.size === 1 ? [...mods][0] : null;
+  const merged = [];
+  for (const r of runs) {
+    const last = merged.at(-1);
+    if (last?.mod === r.mod) {
+      last.text += r.text;
+    } else {
+      merged.push({ ...r });
+    }
+  }
+  return { text: runs.map((r) => r.text).join(""), mod: only === "normal" ? null : only, runs: merged };
+}
+const VIS_MOD_DEFAULTS = {
+  bold: { mod: "bold" },
+  ital: { mod: "italic" },
+  boldital: { mod: "bold italic" },
+  mono: { mod: "", face: "monospace", size: 15, vadjust: 2 }
+};
+function visRuns(runs, layer, site) {
+  const own = {
+    face: typeof layer.fontFace === "string" ? layer.fontFace : "arial",
+    size: typeof layer.fontSize === "number" ? layer.fontSize : VIS_FONT_SIZE,
+    color: typeof layer.fontColor === "string" ? layer.fontColor : null,
+    vadjust: typeof layer.fontVadjust === "number" && Number.isFinite(layer.fontVadjust) ? layer.fontVadjust : 0
+  };
+  const mods = isJsonObject(layer.fontMods) ? layer.fontMods : {};
+  let differs = false;
+  const out = runs.map((r) => {
+    const run = { text: r.text };
+    const base = VIS_MOD_DEFAULTS[r.mod];
+    if (base === void 0) {
+      return run;
+    }
+    const given = visModOptions(mods[r.mod]);
+    const modText = typeof given.mod === "string" ? given.mod : base.mod;
+    const face = typeof given.face === "string" ? given.face : base.face ?? own.face;
+    const size = typeof given.size === "number" ? given.size : base.size ?? own.size;
+    const vadjust = typeof given.vadjust === "number" ? given.vadjust : base.vadjust ?? own.vadjust;
+    const color = typeof given.color === "string" ? canonColor(given.color, "vis", site)?.color : null;
+    if (modText.includes("bold")) {
+      run.weight = "bold";
+    }
+    if (modText.includes("italic")) {
+      run.italic = true;
+    }
+    if (face !== null && face !== own.face) {
+      run.font = face;
+    }
+    if (size !== own.size) {
+      run.size = size;
+    }
+    if (Number.isFinite(vadjust) && vadjust !== own.vadjust) {
+      run.shift = vadjust - own.vadjust;
+    }
+    if (typeof color === "string") {
+      run.color = color;
+    }
+    differs ||= Object.keys(run).length > 1;
+    return run;
+  });
+  return differs ? JSON.stringify(out) : null;
+}
+function visRunAlign(layer, target) {
+  if (target === "edge") {
+    return { top: "baseline", bottom: "hanging" }[String(layer.fontAlign)] ?? "middle";
+  }
+  const shape = typeof layer.shape === "string" ? layer.shape : "ellipse";
+  return VIS_SIZED.has(shape) ? "hanging" : "middle";
+}
+function visBelowGap(size) {
+  return 2 + size / 6;
+}
+function visRunsDrop(runs, size) {
+  let parsed;
+  try {
+    parsed = JSON.parse(runs);
+  } catch {
+    return 0;
+  }
+  if (!Array.isArray(parsed)) {
+    return 0;
+  }
+  const lines = [size];
+  for (const run of parsed) {
+    const runSize = typeof run.size === "number" ? run.size : size;
+    (typeof run.text === "string" ? run.text : "").split("\n").forEach((piece, i) => {
+      if (i > 0) {
+        lines.push(size);
+      }
+      if (piece !== "") {
+        lines[lines.length - 1] = Math.max(lines.at(-1) ?? size, runSize);
+      }
+    });
+  }
+  return lines.reduce((sum, h) => sum + h - size, 0) / 2;
+}
+function visModOptions(raw) {
+  if (isJsonObject(raw)) {
+    return raw;
+  }
+  if (typeof raw === "string") {
+    const m = /^\s*(\d+(?:\.\d+)?)(?:px)?\s+(\S+)(?:\s+(\S+))?/.exec(raw.slice(0, 256));
+    if (m !== null) {
+      return { size: Number(m[1]), face: m[2], ...m[3] === void 0 ? {} : { color: m[3] } };
+    }
+  }
+  return {};
+}
+const VIS_MARKUP_SYSTEM = /* @__PURE__ */ new Map([
+  [true, "html"],
+  ["html", "html"],
+  ["markdown", "md"],
+  ["md", "md"]
+]);
+const VIS_MARKS = {
+  html: { "<b>": "bold", "</b>": "bold", "<i>": "ital", "</i>": "ital", "<code>": "mono", "</code>": "mono" },
+  md: { "*": "bold", _: "ital", "`": "mono" }
+};
+function visMarkTag(source, i, system, state) {
+  const marks = VIS_MARKS[system];
+  const tag = Object.keys(marks).find((m) => source.startsWith(m, i));
+  if (tag === void 0) {
+    return 0;
+  }
+  const key = marks[tag];
+  const toggles = system === "html" ? state[key] === tag.startsWith("</") : state[key] || i === 0 || /\s/.test(source[i - 1]);
+  if (!toggles) {
+    return 0;
+  }
+  state[key] = !state[key];
+  return tag.length;
+}
+function visMarkChar(source, i, system) {
+  if (system === "md") {
+    return source[i] === "\\" && i + 1 < source.length ? [source[i + 1], i + 2] : [source[i], i + 1];
+  }
+  const entity = [
+    ["&lt;", "<"],
+    ["&amp;", "&"]
+  ].find(([e]) => source.startsWith(e, i));
+  return entity === void 0 ? [source[i], i + 1] : [entity[1], i + entity[0].length];
+}
+function visMarkMod(state) {
+  if (state.mono) {
+    return "mono";
+  }
+  if (state.bold) {
+    return state.ital ? "boldital" : "bold";
+  }
+  return state.ital ? "ital" : "normal";
 }
 function visNodeValues(layer, sized, put, site) {
   if (layer.shape !== void 0) {
     put("shape", canonEnum("shape", layer.shape, "vis", site("shape")));
+    if (typeof layer.shape === "string") {
+      put("labelPosition", VIS_SIZED.has(layer.shape) ? "bottom" : "center");
+    }
   }
   if (sized && layer.size !== void 0) {
     const v = canonNumber(layer.size, site("width"));
-    put("width", v);
-    put("height", v);
+    put("width", v === null ? null : 2 * v);
+    put("height", v === null ? null : 2 * v);
   }
   if (layer.borderWidth !== void 0) {
     put("borderWidth", canonNumber(layer.borderWidth, site("borderWidth")));
   }
+  visNodeOpacityAndDashes(layer, put, site);
+}
+function visNodeOpacityAndDashes(layer, put, site) {
   if (layer.opacity !== void 0) {
-    put("opacity", canonOpacity(layer.opacity, "vis", site("opacity")));
+    const opacity = canonOpacity(layer.opacity, "vis", site("opacity"));
+    put("opacity", visTakesOpacity(layer.fill) ? opacity : null);
+    put("borderOpacity", visTakesOpacity(layer.border) ? opacity : null);
+  }
+  if (layer.borderDashes !== void 0) {
+    const width = typeof layer.borderWidth === "number" ? layer.borderWidth : 1;
+    put("borderStyle", visDashStyle(layer.borderDashes === true ? [5, 15] : layer.borderDashes, width, false));
   }
 }
 function visEdgeValues(layer, put, site) {
@@ -1094,18 +1542,52 @@ function visEdgeValues(layer, put, site) {
     put("width", canonNumber(layer.width, site("width")));
   }
   if (layer.dashes !== void 0) {
-    put("lineStyle", layer.dashes === false || layer.dashes === "false" ? "solid" : "dashed");
+    const width = typeof layer.width === "number" ? layer.width : 1;
+    const dashes = layer.dashes === true ? [5, 5] : layer.dashes;
+    put("lineStyle", layer.dashes === "false" ? "solid" : visDashStyle(dashes, width, true));
   }
   if (layer.arrows !== void 0) {
-    const [to, from] = visArrows(layer.arrows, site);
+    const [to, from, middle] = visArrows(layer.arrows, site);
     put("targetArrow", to);
     put("sourceArrow", from);
+    put("midTargetArrow", middle);
+    const scaled = (name) => {
+      const a = isJsonObject(layer.arrows) ? layer.arrows[name] : void 0;
+      return isJsonObject(a) ? a.scaleFactor : void 0;
+    };
+    const scale = scaled("to") ?? scaled("from") ?? scaled("middle");
+    if (scale !== void 0) {
+      put("arrowSize", canonNumber(scale, site("arrowSize")));
+    }
+    visArrowImages(layer.arrows, put, site);
+  }
+}
+function visArrowImages(arrows, put, site) {
+  if (!isJsonObject(arrows)) {
+    return;
+  }
+  for (const [name, property] of [
+    ["to", "targetArrow"],
+    ["from", "sourceArrow"],
+    ["middle", "midTargetArrow"]
+  ]) {
+    const a = arrows[name];
+    if (!isJsonObject(a) || a.type !== "image" || typeof a.src !== "string" || a.src === "") {
+      continue;
+    }
+    put(`${property}Image`, a.src);
+    if (a.imageWidth !== void 0) {
+      put(`${property}ImageWidth`, canonNumber(a.imageWidth, site(`${property}ImageWidth`)));
+    }
+    if (a.imageHeight !== void 0) {
+      put(`${property}ImageHeight`, canonNumber(a.imageHeight, site(`${property}ImageHeight`)));
+    }
   }
 }
 function visArrows(arrows, site) {
-  const end = (name, property) => {
+  const end = (name, property, absent = "none") => {
     if (typeof arrows === "string") {
-      return new RegExp(String.raw`\b${name}\b`).test(arrows.slice(0, 256)) ? "triangle" : "none";
+      return new RegExp(String.raw`\b${name}\b`).test(arrows.slice(0, 256)) ? "triangle" : absent;
     }
     if (!isJsonObject(arrows)) {
       return null;
@@ -1114,12 +1596,15 @@ function visArrows(arrows, site) {
     if (a === true) {
       return "triangle";
     }
+    if (a === void 0) {
+      return absent;
+    }
     if (!isJsonObject(a) || a.enabled === false) {
       return "none";
     }
     return canonEnum("arrow", a.type ?? "arrow", "vis", site(property));
   };
-  return [end("to", "targetArrow"), end("from", "sourceArrow")];
+  return [end("to", "targetArrow"), end("from", "sourceArrow"), end("middle", "midTargetArrow", null)];
 }
 function visStyles(snapshot, src, context) {
   const notes = new StyleNotes();
@@ -1137,13 +1622,17 @@ function visStyles(snapshot, src, context) {
   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;
+  const shapes = [];
+  const rawRecords = elementRaw(snapshot, "node");
+  const range = visNodeValueRange(n, groupOf, rawRecords, groupLayers, nodeDefaults);
+  const ownGroup = visOwnGroup(groupLayers, visGroupDefs(src, options));
   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 raw = rawRecords(i);
+    const own = visLayer(raw, "node");
+    const group = g === null ? {} : ownGroup(g, raw);
+    const shape = visShapeOf(own) ?? visShapeOf(group) ?? visShapeOf(nodeDefaults) ?? "ellipse";
+    shapes.push(shape);
     const site = (property) => ({
       notes,
       target: "node",
@@ -1151,8 +1640,8 @@ function visStyles(snapshot, src, context) {
       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)))) {
+    const merged = visMergedNode(nodeDefaults, group, own, g !== null && raw.color !== void 0);
+    for (const [p, v] of Object.entries(visNodeRow(merged, shape, range, site))) {
       node.put(p, i, v);
     }
   }
@@ -1160,26 +1649,15 @@ function visStyles(snapshot, src, context) {
   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]] } });
-  }
+  visGroupRules(n, groupOf, groupLayers, paletteRows, ruleSite("node"), nodeRules, nodeColumns);
   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 geometry = visGeometry(snapshot, node.values, shapes);
+  const support = visSupport(options.physics, options.layout);
+  const edges = visLayer(options.edges, "edge");
+  const edge = visEdges(snapshot, edges, borderOf, { ...geometry, support }, notes, context);
   const values = { node: node.values, edge: edge.values };
-  exactFromBlock(snapshot, src.block, values, VIS_WRITTEN);
+  exactFromBlock(snapshot, src.block, values, visWritten(snapshot, values.edge));
   return {
     canonical: true,
     dialect: "vis",
@@ -1196,6 +1674,202 @@ function visStyles(snapshot, src, context) {
     }
   };
 }
+function visShapeOf(layer) {
+  return typeof layer.shape === "string" ? layer.shape : null;
+}
+function visNodeValueRange(n, groupOf, rawRecords, groupLayers, nodeDefaults) {
+  return visValueRange(n, (i) => {
+    const g = groupOf(i);
+    const own = visLayer(rawRecords(i), "node").value;
+    const value = own ?? (g === null ? void 0 : groupLayers.get(g)?.value) ?? nodeDefaults.value;
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+  });
+}
+function visMergedNode(nodeDefaults, group, own, ownColorInGroup) {
+  const merged = { ...nodeDefaults, ...group, ...own };
+  if (ownColorInGroup) {
+    merged.fill ??= VIS_NODE_FILL;
+    merged.border ??= VIS_NODE_BORDER;
+  }
+  return merged;
+}
+function visNodeRow(merged, shape, range, site) {
+  const sized = VIS_SIZED.has(shape);
+  const row = visValues(merged, "node", site, sized);
+  const shaped = sized ? visSizedShape(merged, shape, visRadius(merged, range, site), site) : visFitShape(merged, shape);
+  if (sized && merged.label !== void 0) {
+    const size = visLabelScaled(merged, range) ?? (typeof merged.fontSize === "number" ? merged.fontSize : VIS_FONT_SIZE);
+    const drop = typeof row.labelRuns === "string" ? visRunsDrop(row.labelRuns, size) : 0;
+    const below = typeof row.labelOffsetY === "number" ? row.labelOffsetY : 0;
+    row.labelOffsetY = below + drop + visBelowGap(size);
+  }
+  for (const p of ["labelOffsetX", "labelOffsetY"]) {
+    const [a, b] = [row[p], shaped[p]];
+    if (typeof a === "number" && typeof b === "number") {
+      shaped[p] = a + b;
+    }
+  }
+  Object.assign(row, shaped);
+  const labelSize = visLabelScaled(merged, range);
+  if (labelSize !== null) {
+    row.labelSize = labelSize;
+  }
+  return row;
+}
+function visGroupRules(n, groupOf, groupLayers, paletteRows, site, rules, columns) {
+  let k = 0;
+  for (const [g, layer] of groupLayers) {
+    const set = paletteRows.get(g) ?? visValues(layer, "node", site, true);
+    if (Object.keys(set).length === 0) {
+      continue;
+    }
+    const key = `group.${String(k)}`;
+    columns.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);
+    rules.push({ ...r, facts: { names: [[key, g]] } });
+  }
+}
+function visSizedShape(merged, shape, radius, site) {
+  const row = { width: 2 * radius, height: 2 * radius };
+  if (shape === "hexagon") {
+    row.height = Math.sqrt(3) * radius;
+    row.labelOffsetY = (2 - Math.sqrt(3)) * radius / 2;
+  }
+  Object.assign(row, visImage(merged, shape, { width: 2 * radius, height: 2 * radius }));
+  if (shape === "icon") {
+    Object.assign(row, { shape: "none" }, visIcon(merged, site("glyphColor")));
+  }
+  if (shape === "triangleDown") {
+    row.shape = "polygon";
+    row.shapePoints = "-1,1 0,-1 1,1";
+  }
+  return row;
+}
+function visFitShape(merged, shape) {
+  const row = visLabelFit(merged, shape);
+  if (merged.margin === 0 && (shape === "box" || shape === "circle" || shape === "database")) {
+    row.visible = false;
+  }
+  if (merged.valign === "top" || merged.valign === "bottom") {
+    row.labelPosition = `inside-${merged.valign}`;
+  } else if (shape === "database") {
+    const m = merged.margin;
+    const top = isJsonObject(m) ? m.top : m;
+    row.labelPosition = "inside-top";
+    row.labelOffsetY = typeof top === "number" && Number.isFinite(top) && top >= 0 ? top : VIS_MARGIN;
+  }
+  if (shape === "box" && typeof merged.borderRadius === "number" && Number.isFinite(merged.borderRadius)) {
+    row.cornerRadius = Math.max(0, merged.borderRadius);
+  }
+  return row;
+}
+function visLabelFit(layer, shape) {
+  const fit = VIS_LABEL_FIT.get(shape);
+  if (fit === void 0) {
+    return {};
+  }
+  const length = (v) => typeof v === "number" && Number.isFinite(v) && v >= 0 ? v : null;
+  const fontSize = length(layer.fontSize) ?? VIS_FONT_SIZE;
+  const lines = typeof layer.label === "string" ? Math.max(1, layer.label.split("\n").length) : 1;
+  const minW = length(layer.widthMin) ?? 0;
+  const minH = length(layer.heightMin) ?? 0;
+  let padX;
+  let padY;
+  let offset = {};
+  if (fit.ellipse) {
+    padX = Math.max(lines * fontSize, minH) / 2;
+    padY = padX;
+  } else {
+    ({ padX, padY, offset } = visMarginPads(layer.margin, fit.square));
+  }
+  const empty = typeof layer.label !== "string" || layer.label === "";
+  const [boxW, boxH] = empty ? [Math.max(minW, 14), Math.max(minH, 14)] : [minW, minH];
+  if (empty && fit.ellipse) {
+    padX = boxH / 2;
+    padY = padX;
+  }
+  const row = {
+    ...offset,
+    labelFit: "bounds",
+    labelPaddingX: padX,
+    labelPaddingY: padY,
+    width: boxW > 0 ? boxW + 2 * padX : 0,
+    height: boxH > 0 ? boxH + 2 * padY : 0
+  };
+  if (fit.square) {
+    row.labelFitSquare = true;
+  }
+  return row;
+}
+function visMarginPads(m, square) {
+  const length = (v) => typeof v === "number" && Number.isFinite(v) && v >= 0 ? v : null;
+  const side = (key) => (isJsonObject(m) ? length(m[key]) : length(m)) ?? VIS_MARGIN;
+  const offset = {};
+  if (!square && side("left") !== side("right")) {
+    offset.labelOffsetX = (side("left") - side("right")) / 2;
+  }
+  if (!square && side("top") !== side("bottom")) {
+    offset.labelOffsetY = (side("top") - side("bottom")) / 2;
+  }
+  return { padX: (side("left") + side("right")) / 2, padY: (side("top") + side("bottom")) / 2, offset };
+}
+function visLabelScaled(layer, range) {
+  const value = finiteValue(layer.value);
+  const label = layer.scalingLabel;
+  if (value === null || range === null || !isJsonObject(label) || label.enabled !== true) {
+    return null;
+  }
+  const min = typeof label.min === "number" ? label.min : 14;
+  const max = typeof label.max === "number" ? label.max : 30;
+  return visScaled(value, range, min, max);
+}
+const VIS_SIZE = 25;
+const VIS_SCALING = [10, 30];
+function visValueRange(n, valueOf) {
+  let min = Infinity;
+  let max = -Infinity;
+  for (let i = 0; i < n; i++) {
+    const v = valueOf(i);
+    if (v !== null) {
+      min = Math.min(min, v);
+      max = Math.max(max, v);
+    }
+  }
+  return min <= max ? [min, max] : null;
+}
+const finiteValue = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
+function visScaled(value, range, min, max) {
+  const [lo, hi] = range;
+  const scale = hi === lo ? 0.5 : Math.max(0, (value - lo) / (hi - lo));
+  return min + scale * (max - min);
+}
+const VIS_EDGE_SCALING = [1, 15];
+function visEdgeWidth(layer, defaults, range, site) {
+  if (range === null) {
+    return {};
+  }
+  const value = finiteValue(layer.value);
+  if (value !== null) {
+    const min = typeof layer.scalingMin === "number" ? layer.scalingMin : VIS_EDGE_SCALING[0];
+    const max = typeof layer.scalingMax === "number" ? layer.scalingMax : VIS_EDGE_SCALING[1];
+    return { width: visScaled(value, range, min, max) };
+  }
+  return { width: (defaults.width === void 0 ? null : canonNumber(defaults.width, site("width"))) ?? 1 };
+}
+function visRadius(layer, range, site) {
+  const value = finiteValue(layer.value);
+  if (value !== null && range !== null) {
+    const min = typeof layer.scalingMin === "number" ? layer.scalingMin : VIS_SCALING[0];
+    const max = typeof layer.scalingMax === "number" ? layer.scalingMax : VIS_SCALING[1];
+    return visScaled(value, range, min, max);
+  }
+  const size = layer.size === void 0 ? null : canonNumber(layer.size, site("width"));
+  return size ?? VIS_SIZE;
+}
 function visGroupDefs(src, options) {
   if (isJsonObject(options.groups)) {
     return options.groups;
@@ -1221,15 +1895,38 @@ function visGroupLayers(n, groupOf, groupDefs) {
   }
   return { groupLayers, paletteRows };
 }
-function visEdges(snapshot, edgeDefaults, borderOf, notes, context) {
+function visOwnGroup(groupLayers, groupDefs) {
+  const cache = /* @__PURE__ */ new Map();
+  return (g, own) => {
+    const whole = groupLayers.get(g) ?? {};
+    const def = Object.hasOwn(groupDefs, g) ? groupDefs[g] : null;
+    const skip = Object.keys(own).filter(
+      (k) => k !== "font" && (isJsonObject(def) ? Object.hasOwn(def, k) : k === "color")
+    );
+    if (skip.length === 0) {
+      return whole;
+    }
+    const key = `${g}\0${skip.join("\0")}`;
+    let layer = cache.get(key);
+    if (layer === void 0) {
+      layer = isJsonObject(def) ? visLayer(Object.fromEntries(Object.entries(def).filter(([k]) => !skip.includes(k))), "node") : {};
+      cache.set(key, layer);
+    }
+    return layer;
+  };
+}
+function visEdges(snapshot, edgeDefaults, borderOf, geometry, 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;
+  const range = visValueRange(m, (e) => finiteValue({ ...edgeDefaults, ...edgeRecords(e) }.value));
+  let roundCaps = false;
   for (let e = 0; e < m; e++) {
     const own = edgeRecords(e);
-    const merged = { ...edgeDefaults, ...own };
+    const bridged = own.dashes === void 0 && Array.isArray(edgeDefaults.dashes) ? { dashes: true } : {};
+    const merged = { ...edgeDefaults, ...own, ...bridged };
     const site = (property) => ({
       notes,
       target: "edge",
@@ -1237,24 +1934,49 @@ function visEdges(snapshot, edgeDefaults, borderOf, notes, context) {
       element: e,
       budget: context.budget
     });
-    const vals = visValues(merged, "edge", site, true);
+    const [s, t] = [snapshot.edgeSource(e), snapshot.edgeTarget(e)];
+    const vals = {
+      ...visValues(merged, "edge", site, true),
+      ...visEdgeWidth(merged, edgeDefaults, range, site),
+      ...visRoute(edgeDefaults, own, s, t, geometry),
+      ...visEdgeLabel(merged, range, geometry.at(s), geometry.at(t))
+    };
+    roundCaps ||= merged.hidden !== true && ![void 0, false, "false"].includes(merged.dashes);
+    const band = roundCaps && isJsonObject(merged.background) ? visBandStyle(merged.background, true) : null;
+    if (band !== null) {
+      vals.outlineStyle = band;
+    }
+    const from = visEdgeInherit(vals, own.inherit ?? edgeDefaults.inherit ?? "from", borderOf, s, t);
     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 });
+    if (from !== null) {
+      inherited[e] = from;
+      inheriting++;
     }
-    inherited[e] = borderOf(inherit === "to" ? snapshot.edgeTarget(e) : snapshot.edgeSource(e));
-    inheriting++;
   }
   context.budget.spend("edge", m);
+  const { rules, columns } = visEdgeRules(edgeDefaults, notes, inherited, inheriting);
+  return { values: edge.values, rules, columns };
+}
+function visEdgeInherit(vals, inherit, borderOf, s, t) {
+  const inherits = inherit !== false && inherit !== "false";
+  if (inherits) {
+    delete vals.color;
+  }
+  if (inherit === "both") {
+    vals.gradientKind = "linear";
+    vals.gradientColors = `${String(borderOf(s))} ${String(borderOf(t))}`;
+  }
+  if (!inherits) {
+    if (vals.color === void 0) {
+      vals.color = VIS_EDGE_COLOR;
+    }
+    return null;
+  }
+  return borderOf(inherit === "to" ? t : s);
+}
+function visEdgeRules(edgeDefaults, notes, inherited, inheriting) {
   const edgeRules = [];
   const edgeColumns = /* @__PURE__ */ new Map();
   const declaredEdge = visValues(edgeDefaults, "edge", (property) => ({ notes, target: "edge", property }), true);
@@ -1273,16 +1995,317 @@ function visEdges(snapshot, edgeDefaults, borderOf, notes, context) {
       facts: { elements: inheriting, reason: "SOURCE_NODE_COLOR" }
     });
   }
-  return { values: edge.values, rules: edgeRules, columns: edgeColumns };
+  return { 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 visGeometry(snapshot, nodeValues, shapes) {
+  const whole = (v) => {
+    if (typeof v === "string") {
+      return Number.parseInt(v, 10);
+    }
+    return typeof v === "number" && Number.isFinite(v) ? Math.trunc(v) : Number.NaN;
+  };
+  const [xs, ys] = [cells(snapshot, "node", "x"), cells(snapshot, "node", "y")];
+  const num = (v) => typeof v === "number" && v > 0 ? v : null;
+  return {
+    at: (i) => {
+      const p = [whole(xs?.(i)), whole(ys?.(i))];
+      return Number.isNaN(p[0]) || Number.isNaN(p[1]) ? null : p;
+    },
+    box: (i) => {
+      const [w, h] = [num(nodeValues.width?.[i]), num(nodeValues.height?.[i])];
+      const bw = nodeValues.borderWidth?.[i];
+      return w === null || h === null ? null : [w / 2, h / 2, typeof bw === "number" ? bw : 1, shapes[i]];
+    }
+  };
+}
+function visSmooth(...layers) {
+  const s = { enabled: true, type: "dynamic", roundness: 0.5, forceDirection: "none" };
+  for (const l of layers) {
+    if (typeof l === "boolean") {
+      s.enabled = l;
+    } else if (isJsonObject(l)) {
+      s.enabled = typeof l.enabled === "boolean" ? l.enabled : s.enabled;
+      s.type = typeof l.type === "string" ? l.type : s.type;
+      s.roundness = typeof l.roundness === "number" && Number.isFinite(l.roundness) ? l.roundness : s.roundness;
+      s.forceDirection = l.forceDirection ?? s.forceDirection;
+    }
+  }
+  return s;
+}
+function visEdgeLabel(merged, range, a, b) {
+  const row = {};
+  const size = visLabelScaled(merged, range);
+  if (size !== null) {
+    row.labelSize = size;
+  }
+  const turn = visLabelTurn(merged.fontAlign, a, b);
+  if (turn !== null) {
+    row.labelRotation = turn;
+  }
+  return row;
+}
+function visLabelTurn(align, a, b) {
+  if (typeof align !== "string" || align === "horizontal" || a === null || b === null) {
+    return null;
+  }
+  const [dx, dy] = [a[0] - b[0], a[1] - b[1]];
+  let angle = Math.atan2(dy, dx);
+  if (angle < -1 && dx < 0 || angle > 0 && dx < 0) {
+    angle += Math.PI;
+  }
+  const degrees = Math.round(angle * 180 / Math.PI * 1e4) / 1e4;
+  return degrees < 0 ? degrees + 360 : degrees;
+}
+function visStaticVia(from, to, smooth) {
+  const f = smooth.roundness;
+  const [fx, fy] = from;
+  const [tx, ty] = to;
+  const dx = Math.abs(fx - tx);
+  const dy = Math.abs(fy - ty);
+  const step = f * Math.max(dx, dy);
+  const sx = step * (Math.sign(tx - fx) || 1);
+  const sy = step * (Math.sign(ty - fy) || -1);
+  const backX = (1 - f) * dx * (Math.sign(fx - tx) || 1);
+  const backY = (1 - f) * dy * (Math.sign(fy - ty) || 1);
+  switch (smooth.type) {
+    case "discrete":
+      return visDiscreteVia(from, [fx + sx, fy + sy], dx, dy, f);
+    case "diagonalCross":
+      return [fx + sx, fy + sy];
+    case "straightCross":
+      return dx <= dy ? [tx, ty + backY] : [tx + backX, ty];
+    case "horizontal":
+      return [tx + backX, fy];
+    case "vertical":
+      return [fx, ty + backY];
+    case "curvedCW":
+      return visCurvedVia(from, to, f, f * 0.5 + 0.5);
+    case "curvedCCW":
+      return visCurvedVia(from, to, f, -f * 0.5 + 0.5);
+    default:
+      return dx <= dy ? [fx + Math.sign(sx) * Math.min(step, dx), fy + sy] : [fx + sx, fy + Math.sign(sy) * Math.min(step, dy)];
+  }
+}
+function visDiscreteVia(from, diagonal, dx, dy, f) {
+  if (dx <= dy) {
+    return [dx < f * dy ? from[0] : diagonal[0], diagonal[1]];
+  }
+  return [diagonal[0], dy < f * dx ? from[1] : diagonal[1]];
+}
+function visCurvedVia(from, to, f, turn) {
+  const ex = to[0] - from[0];
+  const ey = from[1] - to[1];
+  const r = (f * 0.5 + 0.5) * Math.hypot(ex, ey);
+  const angle = (Math.atan2(ey, ex) + turn * Math.PI) % (2 * Math.PI);
+  return [from[0] + r * Math.sin(angle), from[1] + r * Math.cos(angle)];
+}
+function visCubicVia(from, to, smooth) {
+  const [dx, dy] = [from[0] - to[0], from[1] - to[1]];
+  const r = smooth.roundness;
+  const force = smooth.forceDirection;
+  const across = (Math.abs(dx) > Math.abs(dy) || force === true || force === "horizontal") && force !== "vertical";
+  return across ? [
+    [from[0] - r * dx, from[1]],
+    [to[0] + r * dx, to[1]]
+  ] : [
+    [from[0], from[1] - r * dy],
+    [to[0], to[1] + r * dy]
+  ];
+}
+function alongAcross(a, b, p) {
+  const [dx, dy] = [b[0] - a[0], b[1] - a[1]];
+  const [qx, qy] = [p[0] - a[0], p[1] - a[1]];
+  const l2 = dx * dx + dy * dy;
+  return `${fraction((qx * dx + qy * dy) / l2)},${fraction((dy * qx - dx * qy) / l2)}`;
+}
+const fraction = (v) => String(Math.round(v * 1e4) / 1e4 || 0);
+function visRoute(defaults, own, s, t, g) {
+  if (s === t) {
+    return visLoop(defaults, own, g.box(s));
+  }
+  const smooth = visSmooth(defaults.smooth, own.smooth);
+  if (smooth.enabled && smooth.type === "dynamic") {
+    return visDynamic(defaults, own, g.support ?? null);
+  }
+  const [a, b] = [g.at(s), g.at(t)];
+  if (!smooth.enabled || a === null || b === null || a[0] === b[0] && a[1] === b[1]) {
+    return {};
+  }
+  const controls = smooth.type === "cubicBezier" ? visCubicVia(a, b, smooth) : [visStaticVia(a, b, smooth)];
+  return { curved: true, bendCurve: "bezier", bends: controls.map((p) => alongAcross(a, b, p)).join(" ") };
+}
+function visDynamic(defaults, own, support) {
+  if (support === null || own.physics === false || own.physics === void 0 && defaults.physics === false) {
+    return {};
+  }
+  const length = [own.length, defaults.length].find((v) => typeof v === "number" && Number.isFinite(v) && v >= 0);
+  return { curved: true, ...support, ...length === void 0 ? {} : { supportSpringLength: length } };
+}
+const VIS_SOLVERS = {
+  barnesHut: { model: "barnesHut", g: -2e3, cg: 0.3, length: 95, k: 0.04 },
+  forceAtlas2Based: { model: "forceAtlas2", g: -50, cg: 0.01, length: 100, k: 0.08 }
 };
-function nodeRecords(snapshot) {
-  return elementRecords(snapshot, "node");
+function visSupport(physics, layout) {
+  const hierarchical = isJsonObject(layout) ? layout.hierarchical : void 0;
+  if (hierarchical === true || isJsonObject(hierarchical) && hierarchical.enabled !== false) {
+    return null;
+  }
+  if (physics === false || isJsonObject(physics) && physics.enabled === false) {
+    return null;
+  }
+  const o = isJsonObject(physics) ? physics : {};
+  const solver = typeof o.solver === "string" ? o.solver : "barnesHut";
+  const base = VIS_SOLVERS[solver];
+  if (base === void 0) {
+    return null;
+  }
+  const given = isJsonObject(o[solver]) ? o[solver] : {};
+  const num = (v, fallback) => typeof v === "number" && Number.isFinite(v) ? v : fallback;
+  return {
+    supportModel: base.model,
+    supportSpringLength: Math.max(0, num(given.springLength, base.length)),
+    supportSpringConstant: Math.max(0, num(given.springConstant, base.k)),
+    supportRepulsion: Math.max(0, -num(given.gravitationalConstant, base.g)),
+    supportCentralGravity: Math.max(0, num(given.centralGravity, base.cg))
+  };
 }
+function visLoop(defaults, own, box) {
+  if (box === null) {
+    return {};
+  }
+  const field = (layer, key) => isJsonObject(layer.selfReference) ? layer.selfReference[key] : void 0;
+  const pick = (...vs) => vs.find((v) => typeof v === "number" && Number.isFinite(v)) ?? null;
+  const radius = pick(field(own, "size"), own.selfReferenceSize, field(defaults, "size"), defaults.selfReferenceSize) ?? 20;
+  const angle = pick(field(own, "angle"), field(defaults, "angle")) ?? Math.PI / 4;
+  const [hw, hh] = box;
+  const reach = visToBorder(box, angle);
+  const [cx, cy] = [Math.cos(angle) * reach, Math.sin(angle) * reach];
+  const behind = [field(own, "renderBehindTheNode"), field(defaults, "renderBehindTheNode")].find(
+    (v) => typeof v === "boolean"
+  );
+  if (behind === false) {
+    return visFrontArc(cx, cy, radius, angle, box);
+  }
+  const round = box[3] === "dot" || box[3] === "circle" || box[3] === "circularImage";
+  if (reach + (round ? hw : Math.hypot(hw, hh)) < radius) {
+    return visRing(cx, cy, radius, angle, box);
+  }
+  const corners = [];
+  for (let k = 0; k <= 4; k++) {
+    const a = angle + Math.PI + k % 4 * Math.PI / 2;
+    const [x, y] = [cx + Math.SQRT2 * radius * Math.cos(a), cy + Math.SQRT2 * radius * Math.sin(a)];
+    corners.push(`${fraction(x / hw)},${fraction(y / hh)}`);
+  }
+  return { curved: true, bendCurve: "midpoints", bends: corners.join(" ") };
+}
+const VIS_RING_STEPS = 96;
+function visRing(cx, cy, radius, angle, box) {
+  const [hw, hh] = box;
+  const points = [];
+  for (let k = 0; k <= VIS_RING_STEPS; k++) {
+    const a = angle + Math.PI + 2 * Math.PI * (k % VIS_RING_STEPS) / VIS_RING_STEPS;
+    points.push(`${fraction((cx + radius * Math.cos(a)) / hw)},${fraction((cy + radius * Math.sin(a)) / hh)}`);
+  }
+  return { curved: false, bends: points.join(" ") };
+}
+function visFrontArc(cx, cy, radius, angle, box) {
+  const [x, y] = [cx, -cy];
+  const search = (direction) => {
+    let [low, high] = [angle, angle + Math.PI];
+    let pos = [x, y];
+    for (let iteration = 0; low <= high && iteration < 10; iteration++) {
+      const middle = (low + high) * 0.5;
+      const turn = middle * 2 * Math.PI;
+      pos = [x + radius * Math.cos(turn), y - radius * Math.sin(turn)];
+      const difference = visToBorder(box, Math.atan2(-pos[1], -pos[0])) - Math.hypot(pos[0], pos[1]);
+      if (Math.abs(difference) < 0.05) {
+        break;
+      }
+      if (difference > 0 === direction > 0) {
+        low = middle;
+      } else {
+        high = middle;
+      }
+    }
+    return pos;
+  };
+  const [from, to] = [search(-1), search(1)];
+  const start = Math.atan2(from[1] - y, from[0] - x);
+  let end = Math.atan2(to[1] - y, to[0] - x);
+  if (end < start) {
+    end += 2 * Math.PI;
+  }
+  const [hw, hh] = box;
+  const steps = Math.max(2, Math.ceil((end - start) / (2 * Math.PI) * VIS_RING_STEPS));
+  const points = [];
+  for (let k = 0; k <= steps; k++) {
+    const a = start + (end - start) * k / steps;
+    points.push(`${fraction((x + radius * Math.cos(a)) / hw)},${fraction(-(y + radius * Math.sin(a)) / hh)}`);
+  }
+  return {
+    curved: false,
+    sourcePort: points[0],
+    bends: points.slice(1, -1).join(" "),
+    targetPort: points.at(-1) ?? points[0]
+  };
+}
+function visToBorder(box, angle) {
+  const [hw, hh, bw, shape] = box;
+  if (shape === "dot" || shape === "circle" || shape === "circularImage") {
+    return hw;
+  }
+  if (shape === "ellipse") {
+    return hw * hh / Math.hypot(Math.sin(angle) * hw, Math.cos(angle) * hh);
+  }
+  return Math.min(Math.abs(hw / Math.cos(angle)), Math.abs(hh / Math.sin(angle))) + bw;
+}
+const VIS_KEYS = {
+  node: [
+    "color",
+    "shape",
+    "size",
+    "value",
+    "scaling",
+    "borderWidth",
+    "opacity",
+    "hidden",
+    "label",
+    "title",
+    "font",
+    "margin",
+    "widthConstraint",
+    "heightConstraint",
+    "image",
+    "brokenImage",
+    "imagePadding",
+    "icon",
+    "shapeProperties"
+  ],
+  edge: [
+    "color",
+    "width",
+    "value",
+    "scaling",
+    "dashes",
+    "arrows",
+    "hidden",
+    "label",
+    "title",
+    "font",
+    "background",
+    "smooth",
+    "selfReference",
+    "selfReferenceSize",
+    "physics",
+    "length",
+    "widthConstraint"
+  ]
+};
 function elementRecords(snapshot, target) {
+  const raw = elementRaw(snapshot, target);
+  return (i) => visLayer(raw(i), target);
+}
+function elementRaw(snapshot, target) {
   const readers = VIS_KEYS[target].map((name) => [name, cells(snapshot, target, name)]).filter((x) => x[1] !== null);
   return (i) => {
     const record = {};
@@ -1292,7 +2315,7 @@ function elementRecords(snapshot, target) {
         record[name] = v;
       }
     }
-    return visLayer(record, target);
+    return record;
   };
 }
 function rule(id, target, role, origin, where, set) {
@@ -1355,10 +2378,59 @@ const visSize = (want) => {
   const shape = typeof s === "string" ? visShape(s)[0] : "ellipse";
   return VIS_SIZED.has(shape) ? oneSize(want) : null;
 };
+const visShapeBack = (want) => {
+  const s = want("shape");
+  return typeof s === "string" ? visShape(s)[0] : "ellipse";
+};
+const visShapeFactBack = (property) => (want) => {
+  const shape = visShapeBack(want);
+  const size = visSize(want);
+  if (shape === "hexagon" && typeof size === "number") {
+    return property === "height" ? Math.sqrt(3) * size / 2 : (2 - Math.sqrt(3)) * size / 4;
+  }
+  return property === "labelOffsetY" && shape === "database" ? VIS_MARGIN : null;
+};
+const visFitBack = (property) => (want) => {
+  const s = want("shape");
+  const shape = typeof s === "string" ? visShape(s)[0] : "ellipse";
+  return visLabelFit({ fontSize: want("labelSize"), label: want("label") }, shape)[property] ?? null;
+};
+function visWritten(snapshot, edgeValues) {
+  const isLoop = (i) => snapshot.edgeSource(i) === snapshot.edgeTarget(i);
+  const loop = (property) => (want, i) => isLoop(i) ? edgeValues[property]?.[i] ?? null : want(property);
+  const dynamic = visSupport(void 0, void 0) ?? {};
+  const support = (property) => (_want, i) => isLoop(i) ? edgeValues[property]?.[i] ?? null : dynamic[property] ?? null;
+  const supports = Object.fromEntries(Object.keys(dynamic).map((property) => [property, support(property)]));
+  const lengths = cells(snapshot, "edge", "length");
+  supports.supportSpringLength = (want, i) => {
+    const own = lengths?.(i);
+    return typeof own === "number" && Number.isFinite(own) && own >= 0 && !isLoop(i) ? own : support("supportSpringLength")(want, i);
+  };
+  return {
+    node: VIS_WRITTEN.node,
+    edge: {
+      ...VIS_WRITTEN.edge,
+      ...supports,
+      bends: loop("bends"),
+      bendCurve: loop("bendCurve"),
+      curved: (_want, i) => isLoop(i) ? edgeValues.curved?.[i] ?? null : true
+    }
+  };
+}
 const VIS_WRITTEN = {
   node: {
-    width: visSize,
-    height: visSize,
+    width: (want) => visSize(want) ?? visFitBack("width")(want),
+    height: (want) => visShapeFactBack("height")(want) ?? visSize(want) ?? visFitBack("height")(want),
+    labelOffsetY: visShapeFactBack("labelOffsetY"),
+    labelFit: visFitBack("labelFit"),
+    labelPaddingX: visFitBack("labelPaddingX"),
+    labelPaddingY: visFitBack("labelPaddingY"),
+    labelFitSquare: visFitBack("labelFitSquare"),
+    // the writer writes hex colors, whose alpha vis-network's node opacity replaces, the border's too
+    borderOpacity: (want) => {
+      const opacity = want("opacity");
+      return typeof opacity === "number" ? opacity : want("borderOpacity");
+    },
     shape: (want) => {
       const s = want("shape");
       if (typeof s !== "string") {
@@ -1366,6 +2438,17 @@ const VIS_WRITTEN = {
       }
       const site = { notes: new StyleNotes(), target: "node", property: "shape" };
       return canonEnum("shape", visShape(s)[0], "vis", site);
+    },
+    labelPosition: (want) => {
+      const s = want("shape");
+      if (typeof s !== "string") {
+        return null;
+      }
+      const shape = visShape(s)[0];
+      if (shape === "database") {
+        return "inside-top";
+      }
+      return VIS_SIZED.has(shape) ? "bottom" : "center";
     }
   },
   edge: {
@@ -1374,7 +2457,11 @@ const VIS_WRITTEN = {
       if (s === null) {
         return null;
       }
-      return s === "solid" ? "solid" : "dashed";
+      if (s === "solid") {
+        return "solid";
+      }
+      const width = want("width");
+      return visDashStyle([5, 5], typeof width === "number" ? width : 1, true);
     },
     targetArrow: (want) => arrowBack(want("targetArrow")),
     sourceArrow: (want) => arrowBack(want("sourceArrow"))
@@ -1406,8 +2493,8 @@ const NATIVE = {
     edge: cyjsProperties(CYJS_EDGE_PROPERTIES, ["curved", "labelItalic", "visible"])
   },
   graphology: {
-    node: ["fill", "fillOpacity", "width", "height", "label", "visible"],
-    edge: ["color", "opacity", "width", "label", "visible"]
+    node: ["fill", "fillOpacity", "width", "height", "label"],
+    edge: ["color", "opacity", "width", "label"]
   },
   vis: {
     node: [
@@ -1797,18 +2884,27 @@ function writeGraphology$1(out, input, approximated, replaced) {
     writeKey(
       table,
       "size",
-      target === "node" ? nodeSizes(p("node", "width"), p("node", "height"), approximated) : p("edge", "width"),
+      target === "node" ? nodeSizes(p("node", "width"), p("node", "height"), approximated).map(
+        (d) => d === null ? null : d / 2
+      ) : (
+        // sigma draws an edge half as wide as its size (readSigmaRow)
+        p("edge", "width").map((w) => typeof w === "number" ? w * 2 : w)
+      ),
       replaced
     );
     writeKey(table, "label", p(target, "label"), replaced);
-    writeKey(
-      table,
-      "hidden",
-      p(target, "visible").map((v) => v === false ? true : null),
-      replaced
-    );
   }
 }
+function keepScaled(table, sizes, replaced) {
+  const value = table.get("value");
+  if (value === null) {
+    return;
+  }
+  const scaling = sizes.map(
+    (v, i) => typeof v !== "number" || typeof plainCell(value.value(i)) !== "number" ? null : { min: v, max: v }
+  );
+  writeKey(table, "scaling", scaling, replaced);
+}
 function writeVis$1(out, input, approximated, replaced) {
   const p = (target, property) => input.picture(target, property);
   const font = (target) => {
@@ -1861,7 +2957,8 @@ function writeVis$1(out, input, approximated, 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];
+    const [written, exact] = typeof s === "string" ? visShape(s) : [null, true];
+    const shape = written === "dot" && s === "ellipse" && sizes[i] === null ? "ellipse" : written;
     if (!exact) {
       approximated.add("node", "shape", s);
     }
@@ -1871,7 +2968,9 @@ function writeVis$1(out, input, approximated, replaced) {
     return shape;
   });
   writeKey(out.nodes, "shape", shapes, replaced);
-  writeKey(out.nodes, "size", sizes, replaced);
+  const radii = sizes.map((d) => d === null ? null : d / 2);
+  writeKey(out.nodes, "size", radii, replaced);
+  keepScaled(out.nodes, radii, replaced);
   writeKey(out.nodes, "borderWidth", p("node", "borderWidth"), replaced);
   writeKey(out.nodes, "opacity", p("node", "opacity"), replaced);
   label(out.nodes, "node");
@@ -1892,7 +2991,9 @@ function writeVis$1(out, input, approximated, replaced) {
     }),
     replaced
   );
-  writeKey(out.edges, "width", p("edge", "width"), replaced);
+  const widths = p("edge", "width");
+  writeKey(out.edges, "width", widths, replaced);
+  keepScaled(out.edges, widths, replaced);
   writeKey(
     out.edges,
     "dashes",
@@ -2100,6 +3201,8 @@ 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 GEPHI_NODE_DISPLAY_KEYS = /* @__PURE__ */ new Set(["label", "x", "y", "size", "color"]);
+const GEPHI_EDGE_DISPLAY_KEYS = /* @__PURE__ */ new Set(["label", "size", "color"]);
 const VIS_SOURCE_KEYS = Object.freeze(["from"]);
 const VIS_TARGET_KEYS = Object.freeze(["to"]);
 const PATH_DIALECTS = /* @__PURE__ */ new Set([
@@ -2147,9 +3250,26 @@ function resolveJsonOptions(options) {
     oboIds,
     typedefs,
     nodesPath,
-    edgesPath
+    edgesPath,
+    sigma: sigmaSettingsOption(o.sigmaSettings)
   };
 }
+function sigmaSettingsOption(value) {
+  if (value === void 0) {
+    return SIGMA_DEFAULT_SETTINGS;
+  }
+  if (!isJsonObject(value)) {
+    throw unsupportedOption("sigmaSettings", value, ["an object of sigma.js settings"]);
+  }
+  const { renderEdgeLabels = false, edgeLabelAnchors = "nodeLabels" } = value;
+  if (typeof renderEdgeLabels !== "boolean") {
+    throw unsupportedOption("sigmaSettings.renderEdgeLabels", renderEdgeLabels, ["true", "false"]);
+  }
+  if (edgeLabelAnchors !== "nodeLabels" && edgeLabelAnchors !== "allNodes") {
+    throw unsupportedOption("sigmaSettings.edgeLabelAnchors", edgeLabelAnchors, ["nodeLabels", "allNodes"]);
+  }
+  return { renderEdgeLabels, edgeLabelAnchors };
+}
 function pathOption(name, value) {
   if (value === void 0) {
     return null;
@@ -2778,15 +3898,17 @@ class ImportContext {
    * @param structural - the element keys that are not attributes
    * @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
+   * own names, not with the `#element` suffix; `dataKeys`: the dict keys written with the `#data` 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)
+   * @param how.dataKeys - the dict keys that name an element-level key, written as `<key>#data` (default none)
    */
   writeNested(writer, row, record, dict, structural, element, how = {}) {
-    const { weightFrom = null, plain = false } = how;
+    const { weightFrom = null, plain = false, dataKeys } = how;
     for (const key of Object.keys(dict)) {
       if (key !== weightFrom) {
-        writer.write(row, key, dict[key], SUFFIX.data, element);
+        const name = dataKeys?.has(key) === true ? `${key}${SUFFIX.data}` : key;
+        writer.write(row, name, dict[key], SUFFIX.data, element);
       }
     }
     for (const key of Object.keys(record)) {
@@ -3776,7 +4898,7 @@ function importGraphology(ctx, root) {
   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.styleSource = { dialect: "graphology", block: blockOf(root), gephi, sigma: ctx.json.sigma };
   ctx.reportNodeIdFrom("graphology", "the node key");
   ctx.sink.reserve(nodes.length, edges.length);
   importGraphologyNodes(ctx, nodes, gephi);
@@ -3888,7 +5010,8 @@ function pushGraphologyEdge(ctx, record, element, ids, declared, violations) {
   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
+    plain: gephi,
+    dataKeys: gephi ? GEPHI_EDGE_DISPLAY_KEYS : void 0
   });
   if (declared.allowSelfLoops === false && u === v) {
     violations.selfLoops++;
@@ -3933,7 +5056,10 @@ function pushNestedNode(ctx, id, record, dictKey, structural, element, plain = f
         { element }
       );
     }
-    ctx.writeNested(ctx.nodes, index, record, isJsonObject(dict) ? dict : {}, structural, element, { plain });
+    ctx.writeNested(ctx.nodes, index, record, isJsonObject(dict) ? dict : {}, structural, element, {
+      plain,
+      dataKeys: plain ? GEPHI_NODE_DISPLAY_KEYS : void 0
+    });
   } catch (err) {
     ctx.report.recordError(err, { element: String(id) });
   }
@@ -3951,7 +5077,7 @@ function importJgf(ctx, root) {
       `graph.nodes must be an object keyed by id or an array, found ${describe(nodesRaw)}`
     );
   }
-  const nodeRecords2 = Array.isArray(nodesRaw) ? nodesRaw : Object.values(nodesRaw ?? {});
+  const nodeRecords = Array.isArray(nodesRaw) ? nodesRaw : Object.values(nodesRaw ?? {});
   const directed = jgfDirected(ctx, graph, edges);
   ctx.setHeader(directed);
   ctx.writeGraphDict(graph.metadata, "graph.metadata");
@@ -3962,18 +5088,18 @@ function importJgf(ctx, root) {
   };
   const label = typeof graph.label === "string" ? graph.label : null;
   ctx.reportNodeIdFrom("jgf", "the node keys");
-  ctx.sink.reserve(nodeRecords2.length, edges.length);
+  ctx.sink.reserve(nodeRecords.length, edges.length);
   const labelColumn = ctx.nodes.declareIf(
     { name: "label", dtype: "string", role: "label", nullable: true },
-    anyHas(nodeRecords2, "label")
+    anyHas(nodeRecords, "label")
   );
   if (isJsonObject(nodesRaw)) {
     for (const key of jgfNodeKeys(ctx, root, graph, nodesRaw)) {
       pushJgfKeyedNode(ctx, key, nodesRaw[key], labelColumn);
     }
   } else {
-    for (let i = 0; i < nodeRecords2.length; i++) {
-      pushJgfListedNode(ctx, nodeRecords2[i], labelColumn, `nodes[${i}]`);
+    for (let i = 0; i < nodeRecords.length; i++) {
+      pushJgfListedNode(ctx, nodeRecords[i], labelColumn, `nodes[${i}]`);
     }
   }
   throwIfAborted(ctx.options.signal);
@@ -4700,6 +5826,7 @@ const jsonImporter = Object.freeze({
     "nodeIdKey",
     "nodesPath",
     "oboIds",
+    "sigmaSettings",
     "sourceKey",
     "targetKey",
     "typedefs"
@@ -7560,10 +8687,11 @@ export {
   jsonShapeOf as f,
   extensionOf as g,
   headBytes as h,
-  sniffJsonDialectHead as i,
+  sniffFormat as i,
   jsonCapabilities as j,
+  sniffJsonDialectHead as k,
   normalizeMimeType as n,
   rankFormats as r,
-  sniffFormat as s
+  sniffJsonDialect as s
 };
-//# sourceMappingURL=exporter-bxxjOrDZ.js.map
+//# sourceMappingURL=exporter-CQQZFJ2v.js.map