@graphty/graph-io 0.3.43 → 0.3.45

package/dist/chunks/{importer-BbNb7eNg.js → importer-C7pvJe1L.js}

@@ -1,10 +1,16 @@
 import { GraphFormatError, INVALID_INDEX } from "@graphty/graph-format";
 import { c as childrenCsr } from "./children-CA4coBi0.js";
-import { L as LOSS, r as resolveExportOptions, a as checkCapabilities, c as capabilities, bD as countMixedEdges, e as explicitWeights, p as pairFolding, b as plural, aE as sanitizeIds, aa as formatF32, ab as formatF64, a9 as idText, $ as agree, aF as formatDecimal, aG as formatInteger, aH as canonicalId, M as MIXED_DIRECTION_CODE, D as DIRECTION_FORCED_CODE, d as DIRECTION_REFUSED_CODE, S as SINK_OPTION_CODE, I as ID_MERGED_CODE, O as OPTION_IGNORED_CODE, C as COLUMN_RENAMED_CODE, R as ROLE_TAKEN_CODE, o as DUPLICATE_ATTRIBUTE_CODE, P as PRECISION_CODE, ae as AMBIGUOUS_GRAPH_NAME_CODE, af as GRAPH_NOT_FOUND_CODE, l as MULTIPLE_GRAPHS_CODE, v as ENCODING_CONFLICT_CODE, w as UNKNOWN_ENCODING_CODE, x as ENCODING_FALLBACK_CODE, y as INVALID_ENCODING_CODE, z as INVALID_UTF8_CODE, E as EMPTY_INPUT_CODE, ak as SYNTAX_CODE, F as ELEMENT_ISSUE, G as INPUT_ISSUE, al as resolveImportOptions, a8 as ImportReportBuilder, an as reportUnusedOptions, bB as readText, ao as reportSinkOptions, am as throwIfAborted, ap as graphChosen, ar as IdCoercer, aq as DirectionResolver, aK as parseWeightText, bE as canonicalEncoding, a1 as declareResolved } from "./export-rKLeGQMo.js";
-import { c as quoteDotId, d as isWritableDotText } from "./escape-B62ZGM_a.js";
-import { i as inferTextDtype, W as WIDENING_UNSUPPORTED_CODE, p as parseTextCell, T as TextCellWriter } from "./text-DHOJXnED.js";
+import { L as LOSS, c as capabilities, r as resolveExportOptions, a as checkCapabilities, ai as countMixedEdges, e as explicitWeights, p as pairFolding, G as sanitizeIds, a1 as canonicalId, g as resolveImportOptions, i as reportUnusedOptions, ab as readText, j as reportSinkOptions, h as throwIfAborted, k as graphChosen, I as IdCoercer, l as DirectionResolver, s as parseWeightText, aj as canonicalEncoding, d as declareResolved } from "./export-BvqAXCKh.js";
+import { k as isWritableDotText, m as quoteDotId } from "./escape-CgzxiYPg.js";
+import { p as plural, a as agree, $ as formatF32, a0 as formatF64, _ as idText, aO as formatDecimal, ad as formatInteger, M as MIXED_DIRECTION_CODE, D as DIRECTION_FORCED_CODE, b as DIRECTION_REFUSED_CODE, S as SINK_OPTION_CODE, I as ID_MERGED_CODE, O as OPTION_IGNORED_CODE, C as COLUMN_RENAMED_CODE, R as ROLE_TAKEN_CODE, l as DUPLICATE_ATTRIBUTE_CODE, P as PRECISION_CODE, a2 as AMBIGUOUS_GRAPH_NAME_CODE, a3 as GRAPH_NOT_FOUND_CODE, i as MULTIPLE_GRAPHS_CODE, r as ENCODING_CONFLICT_CODE, s as UNKNOWN_ENCODING_CODE, t as ENCODING_FALLBACK_CODE, u as INVALID_ENCODING_CODE, v as INVALID_UTF8_CODE, E as EMPTY_INPUT_CODE, a8 as SYNTAX_CODE, y as ELEMENT_ISSUE, z as INPUT_ISSUE, Z as ImportReportBuilder } from "./format-BpQBx8MZ.js";
+import { i as inferTextDtype, W as WIDENING_UNSUPPORTED_CODE, p as parseTextCell, T as TextCellWriter } from "./text-CzJNFOS9.js";
 import { j as joinText, e as encodeChunks, i as indentUnit } from "./writer-DxjgHwSe.js";
-import { i as importChosenGraph } from "./choose-DvpbdRuz.js";
+import { i as importChosenGraph } from "./choose--jM0yYCo.js";
+import { m as median } from "./convert-BcQ8_jMo.js";
+import { t as StyleNotes, n as noteAt, a as STYLE_ISSUE, E as htmlLabelText, F as dotLabelText, p as plainCell, g as canonColor, x as colorOpacity, S as STYLE_BLOCK_NAME, u as parseStyleBlock, s as styleFingerprint, v as blockStyles, M as MAX_STYLE_VALUE_LENGTH, h as canonNumber, l as canonEnum, G as recordLabelText, i as num6, r as resolveStyles, H as DOT_POINTS_PER_INCH, C as toolDefaults, w as writeStyleBlock, c as styleBlockLosses } from "./block-CPCHkX42.js";
+import { S as StyleApproximations } from "./approximations-DJMHdDvv.js";
+import { s as sharedInExportCall } from "./writer-gQ8kx99H.js";
+import { v as valueColumns } from "./styles-yed-Cz9rLBCP.js";
 const DOT_FORMAT = "dot";
 const DOT_ORIGIN = Object.freeze({ format: DOT_FORMAT });
 const CLUSTER_COLUMN = "graphty.cluster";
@@ -17,6 +23,1045 @@ const POSITION_COLUMN = "graphty.position";
 const KEY_ATTRIBUTE = "key";
 const PIN_ATTRIBUTE = "pin";
 const DOT_META_KEY = "dot";
+const DOT_STYLE_CAPABILITIES = Object.freeze({
+  node: Object.freeze([
+    "fill",
+    "fillOpacity",
+    "borderColor",
+    "borderWidth",
+    "borderStyle",
+    "shape",
+    "width",
+    "height",
+    "label",
+    "labelColor",
+    "labelSize",
+    "labelFont",
+    "tooltip",
+    "visible"
+  ]),
+  edge: Object.freeze([
+    "color",
+    "opacity",
+    "width",
+    "lineStyle",
+    "sourceArrow",
+    "targetArrow",
+    "arrowSize",
+    "label",
+    "sourceLabel",
+    "targetLabel",
+    "labelColor",
+    "labelSize",
+    "labelFont",
+    "tooltip",
+    "visible"
+  ]),
+  graph: Object.freeze(["background"]),
+  block: "native"
+});
+const NAME_KEY = "name";
+const DIRECTED_KEY = "directed";
+const CLUSTER_KEY = "cluster";
+const NODE_ATTRIBUTES = [
+  "colorscheme",
+  "color",
+  "fillcolor",
+  "bgcolor",
+  "pencolor",
+  "style",
+  "shape",
+  "width",
+  "height",
+  "fixedsize",
+  "regular",
+  "penwidth",
+  "fontname",
+  "fontsize",
+  "fontcolor",
+  "tooltip"
+];
+const EDGE_ATTRIBUTES = [
+  "colorscheme",
+  "color",
+  "style",
+  "penwidth",
+  "fontname",
+  "fontsize",
+  "fontcolor",
+  "tooltip",
+  "edgetooltip",
+  "arrowhead",
+  "arrowtail",
+  "dir",
+  "arrowsize",
+  "headlabel",
+  "taillabel"
+];
+const NOTED_ATTRIBUTES = ["peripheries", "xlabel"];
+const CIRCLE_LIKE = /* @__PURE__ */ new Set(["circle", "doublecircle", "mcircle", "square", "msquare"]);
+const BOX_LIKE = /* @__PURE__ */ new Set(["box", "rect", "rectangle", "square"]);
+const ELLIPSE_LIKE = /* @__PURE__ */ new Set(["", "ellipse", "oval", "circle"]);
+const NO_OUTLINE = /* @__PURE__ */ new Set(["plain", "plaintext", "none"]);
+const RECORD = /* @__PURE__ */ new Set(["record", "mrecord"]);
+const TRUE_TEXTS$1 = /* @__PURE__ */ new Set(["true", "yes", "shape"]);
+const POINT_SIZE = 0.05;
+const REGULAR_SIZE = 0.5;
+function isHtmlString(text) {
+  if (text.length < 2 || !text.startsWith("<") || !text.endsWith(">")) {
+    return false;
+  }
+  let depth = 0;
+  for (let i = 0; i < text.length; i++) {
+    const c = text.codePointAt(i);
+    if (c === 60) {
+      depth++;
+    } else if (c === 62) {
+      depth--;
+      if (depth === 0 && i !== text.length - 1) {
+        return false;
+      }
+    }
+  }
+  return depth === 0;
+}
+function cellText$1(table, name, i) {
+  if (!table.has(name)) {
+    return null;
+  }
+  const v = plainCell(table.value(name, i));
+  if (typeof v === "string") {
+    return v;
+  }
+  return typeof v === "number" || typeof v === "boolean" ? String(v) : null;
+}
+function nonEmpty(v) {
+  return v === null || v === "" ? null : v;
+}
+function styleTokens(raw, at) {
+  if (raw === null) {
+    return [];
+  }
+  if (raw.length > MAX_STYLE_VALUE_LENGTH) {
+    noteAt(at, STYLE_ISSUE.VALUE_TOO_LONG, `${String(raw.length)} characters`);
+    return [];
+  }
+  return raw.toLowerCase().split(",").map((t) => t.replace(/^[ \t\r\n]+/, "")).filter((t) => t !== "");
+}
+function setLineWidth(tokens) {
+  for (const t of tokens) {
+    if (t.startsWith("setlinewidth(") && t.endsWith(")")) {
+      return t.slice("setlinewidth(".length, -1).trim();
+    }
+  }
+  return null;
+}
+function isTrue(raw) {
+  if (raw === null) {
+    return false;
+  }
+  const t = raw.trim().toLowerCase();
+  return TRUE_TEXTS$1.has(t) || /^-?\d+$/.test(t) && Number(t) !== 0;
+}
+function labelText(raw, names, html, record, at) {
+  if (isHtmlString(raw)) {
+    return htmlLabelText(raw, at);
+  }
+  if (html.has(`<${raw}>`)) {
+    return htmlLabelText(`<${raw}>`, at);
+  }
+  return dotLabelText(record ? recordLabelText(raw, at) : raw, names, at);
+}
+function readColor(raw, scheme, use, property, opacity, put, at) {
+  if (raw === null) {
+    return null;
+  }
+  const c = canonColor(raw, "graphviz", at(property), { scheme, use });
+  if (c === null) {
+    return null;
+  }
+  put(property, c.color);
+  if (opacity !== null) {
+    put(opacity, c.alpha);
+  } else if (c.alpha > 0 || property !== "borderColor") {
+    colorOpacity(c, null, at(property), false);
+  }
+  return c.alpha;
+}
+function inchesOf(points) {
+  const want = num6(points);
+  for (let digits = 6; digits < 17; digits++) {
+    const inches2 = Number((points / DOT_POINTS_PER_INCH).toPrecision(digits));
+    if (num6(inches2 * DOT_POINTS_PER_INCH) === want) {
+      return inches2 + 0;
+    }
+  }
+  return points / DOT_POINTS_PER_INCH;
+}
+function inches(raw, at) {
+  if (raw === null) {
+    return null;
+  }
+  const v = raw.trim() === "" ? Number.NaN : Number(raw);
+  if (!Number.isFinite(v) || v < 0) {
+    noteAt(at, STYLE_ISSUE.BAD_VALUE, raw.slice(0, MAX_STYLE_VALUE_LENGTH));
+    return null;
+  }
+  return v;
+}
+function readCommon(get, tokens, scheme, names, put, at) {
+  if (tokens.includes("invis")) {
+    put("visible", false);
+  }
+  readColor(nonEmpty(get("fontcolor")), scheme, "line", "labelColor", null, put, at);
+  const size = get("fontsize");
+  put("labelSize", size === null ? null : canonNumber(size, at("labelSize")));
+  const font = get("fontname");
+  if (font !== null && font.length <= MAX_STYLE_VALUE_LENGTH) {
+    put("labelFont", font);
+  }
+  const tip = get("tooltip") ?? get("edgetooltip");
+  if (tip !== null) {
+    put("tooltip", dotLabelText(tip, names, at("tooltip")));
+  }
+}
+function readNode(get, cx, put, at) {
+  const tokens = styleTokens(get("style"), at("visible"));
+  const shapeRaw = nonEmpty(get("shape"));
+  const shape = (shapeRaw ?? "").toLowerCase();
+  const n = {
+    get,
+    cx,
+    put,
+    at,
+    tokens,
+    shapeRaw,
+    shape,
+    point: !cx.cluster && shape === "point",
+    scheme: get("colorscheme"),
+    color: nonEmpty(get("color"))
+  };
+  const names = cx.cluster ? { graph: cx.name } : { node: cx.name, graph: cx.graph, edge: "" };
+  readCommon(get, tokens, n.scheme, names, put, at);
+  if (cx.cluster) {
+    readClusterFill(n);
+  } else {
+    readNodeFill(n);
+  }
+  readNodeOutline(n);
+  readNodeShape(n);
+  const label = n.point ? null : get(LABEL_ATTRIBUTE);
+  if (label !== null) {
+    put("label", labelText(label, names, cx.html, RECORD.has(shape), at("label")));
+  }
+  if (!cx.cluster) {
+    readSize(get, shape, n.point, label ?? (n.point ? null : cx.name), put, at);
+  }
+  if (Number(get("peripheries")) > 1 || nonEmpty(get("xlabel")) !== null) {
+    noteAt(at("label"), STYLE_ISSUE.NOT_CARRIED, nonEmpty(get("xlabel")) === null ? "peripheries" : "xlabel");
+  }
+}
+function readClusterFill(n) {
+  const { get, tokens } = n;
+  const filled = tokens.includes("filled") || tokens.includes("radial") || tokens.includes("striped");
+  const bg = nonEmpty(get("bgcolor"));
+  const raw = filled ? nonEmpty(get("fillcolor")) ?? n.color ?? bg ?? "lightgrey" : bg;
+  readColor(raw, n.scheme, "fill", "fill", "fillOpacity", n.put, n.at);
+}
+function readNodeFill(n) {
+  const { shape, point } = n;
+  const fillcolor = nonEmpty(n.get("fillcolor"));
+  const filled = point || n.tokens.some(
+    (t) => t === "filled" || t === "radial" || t === "striped" && BOX_LIKE.has(shape) || t === "wedged" && ELLIPSE_LIKE.has(shape)
+  );
+  if (filled) {
+    const raw = fillcolor ?? n.color ?? (point ? "black" : "lightgrey");
+    readColor(raw, n.scheme, "fill", "fill", "fillOpacity", n.put, n.at);
+  } else if (fillcolor !== null) {
+    noteAt(n.at("fill"), STYLE_ISSUE.UNFILLED, fillcolor.slice(0, MAX_STYLE_VALUE_LENGTH));
+  }
+}
+function readNodeOutline(n) {
+  const { get, cx, put, at, tokens } = n;
+  if (!cx.cluster && NO_OUTLINE.has(n.shape)) {
+    put("borderWidth", 0);
+  } else {
+    const outline = cx.cluster ? nonEmpty(get("pencolor")) ?? n.color : n.color;
+    const alpha = readColor(outline, n.scheme, "line", "borderColor", null, put, at);
+    const width = nonEmpty(get("penwidth")) ?? setLineWidth(tokens);
+    if (alpha === 0) {
+      put("borderWidth", 0);
+    } else if (width !== null) {
+      put("borderWidth", penWidth(width, get("penwidth") !== null, at("borderWidth")));
+    } else if (tokens.includes("bold")) {
+      put("borderWidth", 2);
+    }
+  }
+  if (tokens.includes("dashed")) {
+    put("borderStyle", "dashed");
+  } else if (tokens.includes("dotted")) {
+    put("borderStyle", "dotted");
+  }
+}
+function readNodeShape(n) {
+  const rounded = n.tokens.includes("rounded");
+  if (n.cx.cluster) {
+    n.put("shape", rounded ? "round-rectangle" : "rectangle");
+  } else if (n.shapeRaw !== null) {
+    n.put(
+      "shape",
+      rounded && BOX_LIKE.has(n.shape) ? "round-rectangle" : canonEnum("shape", n.shapeRaw, "graphviz", n.at("shape"))
+    );
+  }
+}
+function penWidth(raw, attribute, site) {
+  const value = Number(raw.trim());
+  if (attribute && Number.isFinite(value) && value < 0) {
+    noteAt(site, STYLE_ISSUE.BAD_VALUE, raw.slice(0, MAX_STYLE_VALUE_LENGTH));
+    return 0;
+  }
+  return canonNumber(raw, site);
+}
+function readSize(get, shape, point, label, put, at) {
+  let w = inches(get("width"), at("width"));
+  let h = inches(get("height"), at("height"));
+  const same = point || CIRCLE_LIKE.has(shape) || isTrue(get("regular"));
+  if (shape === "plain") {
+    w = h = 0;
+  } else if (w === null && h === null) {
+    if (point) {
+      put("width", num6(POINT_SIZE * DOT_POINTS_PER_INCH));
+      put("height", num6(POINT_SIZE * DOT_POINTS_PER_INCH));
+      return;
+    }
+    if (!same) {
+      return;
+    }
+    w = h = REGULAR_SIZE;
+  }
+  let ww = w;
+  let hh = h;
+  if (point) {
+    ww = hh = Math.min(w ?? Infinity, h ?? Infinity);
+  } else if (same) {
+    ww = hh = Math.max(w ?? 0, h ?? 0);
+  }
+  const exact = point || isTrue(get("fixedsize")) || label === "" && !RECORD.has(shape);
+  if (!exact) {
+    noteAt(at("width"), STYLE_ISSUE.SIZE_MINIMUM, "grows to fit its label");
+  }
+  put("width", ww === null ? null : canonNumber(ww, at("width"), DOT_POINTS_PER_INCH));
+  put("height", hh === null ? null : canonNumber(hh, at("height"), DOT_POINTS_PER_INCH));
+}
+function readEdge(get, cx, put, at) {
+  const tokens = styleTokens(get("style"), at("visible"));
+  const scheme = get("colorscheme");
+  readCommon(get, tokens, scheme, cx.names, put, at);
+  readColor(nonEmpty(get("color")), scheme, "edge", "color", "opacity", put, at);
+  readEdgeLine(get, tokens, put, at);
+  readEdgeArrows(get, cx, put, at);
+  for (const [attribute, property] of [
+    [LABEL_ATTRIBUTE, "label"],
+    ["headlabel", "targetLabel"],
+    ["taillabel", "sourceLabel"]
+  ]) {
+    const raw = get(attribute);
+    if (raw !== null) {
+      put(property, labelText(raw, cx.names, cx.html, false, at(property)));
+    }
+  }
+  if (nonEmpty(get("xlabel")) !== null) {
+    noteAt(at("label"), STYLE_ISSUE.NOT_CARRIED, "xlabel");
+  }
+}
+function readEdgeLine(get, tokens, put, at) {
+  const width = nonEmpty(get("penwidth")) ?? setLineWidth(tokens);
+  if (width !== null) {
+    put("width", penWidth(width, get("penwidth") !== null, at("width")));
+  } else if (tokens.includes("bold")) {
+    put("width", 2);
+  }
+  if (tokens.includes("dashed")) {
+    put("lineStyle", "dashed");
+  } else if (tokens.includes("dotted")) {
+    put("lineStyle", "dotted");
+  } else if (tokens.includes("solid") || tokens.includes("bold")) {
+    put("lineStyle", "solid");
+  } else if (tokens.includes("tapered")) {
+    put("lineStyle", "other:tapered");
+  }
+}
+function readEdgeArrows(get, cx, put, at) {
+  const dirRaw = nonEmpty(get("dir"));
+  const head = nonEmpty(get("arrowhead"));
+  const tail = nonEmpty(get("arrowtail"));
+  if (dirRaw !== null || head !== null || tail !== null) {
+    const dir = (dirRaw ?? (cx.directed ? "forward" : "none")).trim().toLowerCase();
+    const forward = dir === "forward" || dir === "both";
+    const back = dir === "back" || dir === "both";
+    put("targetArrow", forward ? canonEnum("arrow", head ?? "normal", "graphviz", at("targetArrow")) : "none");
+    put("sourceArrow", back ? canonEnum("arrow", tail ?? "normal", "graphviz", at("sourceArrow")) : "none");
+  }
+  const size = get("arrowsize");
+  if (size !== null) {
+    put("arrowSize", canonNumber(size, at("arrowSize")));
+  }
+}
+function htmlStrings(snapshot) {
+  const out = /* @__PURE__ */ new Set();
+  for (let i = 0; i < snapshot.nodeCount; i++) {
+    const id = snapshot.ids.idOf(i);
+    if (typeof id === "string" && isHtmlString(id)) {
+      out.add(id);
+    }
+  }
+  for (const [table, n] of [
+    [snapshot.nodes, snapshot.nodeCount],
+    [snapshot.edges, snapshot.edgeCount]
+  ]) {
+    for (const name of [LABEL_ATTRIBUTE, "headlabel", "taillabel"].filter((c) => table.has(c))) {
+      addHtmlCells(table, name, n, out);
+    }
+  }
+  return out;
+}
+function addHtmlCells(table, name, n, out) {
+  for (let i = 0; i < n; i++) {
+    const v = cellText$1(table, name, i);
+    if (v !== null && isHtmlString(v)) {
+      out.add(v);
+    }
+  }
+}
+function directedEdges(snapshot) {
+  const out = new Array(snapshot.edgeCount).fill(snapshot.directed);
+  const col = snapshot.directed ? snapshot.edges.byRole("directed") : null;
+  if (col !== null) {
+    for (let e = 0; e < snapshot.edgeCount; e++) {
+      const v = plainCell(col.value(e));
+      if (typeof v === "boolean") {
+        out[e] = v;
+      }
+    }
+  }
+  return out;
+}
+function isCluster(snapshot, i) {
+  return snapshot.nodes.has(CLUSTER_COLUMN) && snapshot.nodes.value(CLUSTER_COLUMN, i) === true;
+}
+function contexts(snapshot, written = null) {
+  const html = htmlStrings(snapshot);
+  const graph = snapshot.meta.name ?? "";
+  const own = directedEdges(snapshot);
+  const directed = written === null || own.every((d) => d === snapshot.directed) ? own : own.map(() => written);
+  const name = (i) => String(snapshot.ids.idOf(i));
+  return {
+    node: (i) => ({ name: name(i), graph, cluster: isCluster(snapshot, i), html }),
+    edge: (e) => {
+      const tail = name(snapshot.edgeSource(e));
+      const head = name(snapshot.edgeTarget(e));
+      return {
+        names: { graph, tail, head, edge: `${tail}${directed[e] ? "->" : "--"}${head}` },
+        directed: directed[e],
+        html
+      };
+    }
+  };
+}
+function defaultLabel(cx, shape, notes) {
+  if (cx.cluster || shape === "point") {
+    return null;
+  }
+  const at = { notes, target: "node", property: "label" };
+  return isHtmlString(cx.name) ? htmlLabelText(cx.name, at) : dotLabelText(String.raw`\N`, { node: cx.name, graph: cx.graph }, at);
+}
+function styleColumns(table, attributes) {
+  const own = /* @__PURE__ */ new Set([...attributes, ...NOTED_ATTRIBUTES]);
+  return [...table.names()].filter((c) => own.has(c) || c.startsWith("graphty.style."));
+}
+function dotStyles(snapshot, context) {
+  const notes = new StyleNotes();
+  const cx = contexts(snapshot);
+  const node = valueColumns(snapshot.nodeCount);
+  const nameColumn = new Array(snapshot.nodeCount).fill(null);
+  const clusterColumn = new Array(snapshot.nodeCount).fill(null);
+  let named = 0;
+  let clusters = 0;
+  for (let i = 0; i < snapshot.nodeCount; i++) {
+    context.budget.spend("node", NODE_ATTRIBUTES.length);
+    const get = (name) => cellText$1(snapshot.nodes, name, i);
+    const ncx = cx.node(i);
+    const at = (property) => ({ notes, target: "node", property, element: i, budget: context.budget });
+    readNode(
+      get,
+      ncx,
+      (p, v) => {
+        node.put(i, p, v);
+      },
+      at
+    );
+    const shown = defaultLabel(ncx, (get("shape") ?? "").toLowerCase(), notes);
+    if (shown !== null) {
+      nameColumn[i] = shown;
+      named++;
+    }
+    if (ncx.cluster) {
+      clusterColumn[i] = true;
+      clusters++;
+    }
+  }
+  const edge = valueColumns(snapshot.edgeCount);
+  for (let e = 0; e < snapshot.edgeCount; e++) {
+    context.budget.spend("edge", EDGE_ATTRIBUTES.length);
+    const get = (name) => cellText$1(snapshot.edges, name, e);
+    const at = (property) => ({ notes, target: "edge", property, element: e, budget: context.budget });
+    readEdge(
+      get,
+      cx.edge(e),
+      (p, v) => {
+        edge.put(e, p, v);
+      },
+      at
+    );
+  }
+  const graph = {};
+  const bg = nonEmpty(cellText$1(snapshot.graph, "bgcolor", 0));
+  if (snapshot.graph.has("bgcolor") && bg !== null) {
+    readColor(
+      bg,
+      cellText$1(snapshot.graph, "colorscheme", 0),
+      "fill",
+      "background",
+      null,
+      (p, v) => {
+        if (v !== null) {
+          graph[p] = v;
+        }
+      },
+      (property) => ({ notes, target: "graph", property })
+    );
+  }
+  const blockText = cellText$1(snapshot.graph, STYLE_BLOCK_NAME, 0);
+  if (blockText !== null) {
+    exactFromBlock(snapshot, blockText, { node: node.values, edge: edge.values }, cx);
+  }
+  const nodeRules = [];
+  const nodeColumns = /* @__PURE__ */ new Map();
+  if (named > 0) {
+    nodeColumns.set(NAME_KEY, nameColumn);
+    nodeRules.push({
+      id: "node.tool.name-label",
+      target: "node",
+      role: "passthrough",
+      origin: "tool",
+      where: { has: { style: NAME_KEY } },
+      map: { label: { kind: "passthrough", by: { style: NAME_KEY } } },
+      facts: { elements: named, reason: "NODE_NAME" }
+    });
+  }
+  const features = clusters > 0 ? [{ ref: { style: CLUSTER_KEY }, values: clusterColumn }] : [];
+  const edgeRules = [];
+  const edgeColumns = /* @__PURE__ */ new Map();
+  const directed = directedEdges(snapshot);
+  if (directed.some(Boolean)) {
+    edgeColumns.set(
+      DIRECTED_KEY,
+      directed.map((d) => d ? true : null)
+    );
+    edgeRules.push({
+      id: "edge.tool.arrow",
+      target: "edge",
+      role: "group",
+      origin: "tool",
+      where: { has: { style: DIRECTED_KEY } },
+      set: { targetArrow: "triangle" }
+    });
+  }
+  return {
+    canonical: true,
+    dialect: "graphviz",
+    tool: "graphviz",
+    units: "px",
+    node: { values: node.values, rules: nodeRules, columns: nodeColumns, features },
+    edge: { values: edge.values, rules: edgeRules, columns: edgeColumns },
+    graph,
+    notes: notes.list(),
+    readFrom: {
+      node: styleColumns(snapshot.nodes, NODE_ATTRIBUTES),
+      edge: styleColumns(snapshot.edges, EDGE_ATTRIBUTES)
+    }
+  };
+}
+const SHAPES = /* @__PURE__ */ new Map([
+  ["ellipse", "ellipse"],
+  ["rectangle", "box"],
+  ["round-rectangle", "box"],
+  ["triangle", "triangle"],
+  ["diamond", "diamond"],
+  ["pentagon", "pentagon"],
+  ["hexagon", "hexagon"],
+  ["octagon", "octagon"],
+  ["parallelogram", "parallelogram"],
+  ["trapezoid", "trapezium"],
+  ["star", "star"],
+  ["none", "none"]
+]);
+const ARROWS = /* @__PURE__ */ new Map([
+  ["none", "none"],
+  ["triangle", "normal"],
+  ["triangle-open", "onormal"],
+  ["vee", "vee"],
+  ["tee", "tee"],
+  ["diamond", "diamond"],
+  ["diamond-open", "odiamond"],
+  ["circle", "dot"],
+  ["circle-open", "odot"],
+  ["square", "box"],
+  ["crow", "crow"],
+  ["half", "lnormal"],
+  ["inverted", "inv"]
+]);
+const STROKES = /* @__PURE__ */ new Map([
+  ["dashed", "dashed"],
+  ["dotted", "dotted"]
+]);
+function graphvizDefaults(target) {
+  const t = toolDefaults("graphviz")?.[target];
+  const out = /* @__PURE__ */ new Map();
+  const add = (attribute, property, scale = 1) => {
+    const v = t[property]?.value;
+    if (typeof v === "number") {
+      out.set(attribute, num6(v / scale));
+    } else if (typeof v === "string") {
+      out.set(attribute, v);
+    }
+  };
+  add("fontcolor", "labelColor");
+  add("fontsize", "labelSize");
+  add("fontname", "labelFont");
+  if (target === "node") {
+    add("color", "borderColor");
+    add("pencolor", "borderColor");
+    add("penwidth", "borderWidth");
+    add("shape", "shape");
+    add("width", "width", DOT_POINTS_PER_INCH);
+    add("height", "height", DOT_POINTS_PER_INCH);
+  } else {
+    add("color", "color");
+    add("penwidth", "width");
+    add("arrowsize", "arrowSize");
+  }
+  return out;
+}
+const DEFAULT_ATTRIBUTES = {
+  node: graphvizDefaults("node"),
+  edge: graphvizDefaults("edge")
+};
+function withoutDefaults(out, target) {
+  for (const [attribute, value] of DEFAULT_ATTRIBUTES[target]) {
+    if (out.get(attribute) === value) {
+      out.delete(attribute);
+    }
+  }
+  if (!out.has("width") && !out.has("height")) {
+    out.delete("fixedsize");
+  }
+  return out;
+}
+function gvColor(color, opacity) {
+  if (typeof opacity !== "number" || opacity >= 1) {
+    return color;
+  }
+  const a = Math.max(0, Math.min(255, Math.round(opacity * 255)));
+  return color + a.toString(16).padStart(2, "0");
+}
+function escapeLabel(text) {
+  return text.replaceAll("\\", String.raw`\\`).replaceAll("\n", String.raw`\n`);
+}
+function spelled(table, value, nearest, property, approximate) {
+  const exact = table.get(value);
+  if (exact !== void 0) {
+    return exact;
+  }
+  if (value.startsWith("other:")) {
+    return value.slice("other:".length);
+  }
+  approximate(property, value);
+  return nearest;
+}
+function writeCommon(get, out, tokens) {
+  const color = get("labelColor");
+  if (typeof color === "string") {
+    out.set("fontcolor", color);
+  }
+  const size = get("labelSize");
+  if (typeof size === "number") {
+    out.set("fontsize", size);
+  }
+  const font = get("labelFont");
+  if (typeof font === "string") {
+    out.set("fontname", font);
+  }
+  const tip = get("tooltip");
+  if (typeof tip === "string") {
+    out.set("tooltip", escapeLabel(tip));
+  }
+  if (get("visible") === false) {
+    tokens.push("invis");
+  }
+}
+function nodeAttributes(get, cx, approximate, notes) {
+  const out = /* @__PURE__ */ new Map();
+  const tokens = [];
+  writeCommon(get, out, tokens);
+  writeNodeOutline(get, cx, approximate, out, tokens);
+  const gvShape = writeNodeShape(get, cx, approximate, out, tokens);
+  if (!cx.cluster) {
+    writeNodeSize(get, out);
+  }
+  const label = get("label");
+  const shown = defaultLabel(cx, gvShape, notes);
+  if (typeof label === "string" && label !== shown) {
+    out.set(LABEL_ATTRIBUTE, escapeLabel(label));
+  } else if (label === null && shown !== null) {
+    out.set(LABEL_ATTRIBUTE, "");
+  }
+  if (tokens.length > 0) {
+    out.set("style", tokens.join(","));
+  }
+  return withoutDefaults(out, "node");
+}
+function writeNodeOutline(get, cx, approximate, out, tokens) {
+  const fill = get("fill");
+  const fillOpacity = get("fillOpacity");
+  if (typeof fill === "string" && fillOpacity !== 0) {
+    tokens.push("filled");
+    out.set("fillcolor", gvColor(fill, fillOpacity));
+  }
+  const border = get("borderColor");
+  if (typeof border === "string") {
+    out.set(cx.cluster ? "pencolor" : "color", border);
+  }
+  const borderWidth = get("borderWidth");
+  if (typeof borderWidth === "number") {
+    out.set("penwidth", borderWidth);
+  }
+  const borderStyle = get("borderStyle");
+  if (typeof borderStyle === "string" && borderStyle !== "solid") {
+    const nearest = borderStyle.includes("dash") ? "dashed" : "solid";
+    tokens.push(spelled(STROKES, borderStyle, nearest, "borderStyle", approximate));
+  }
+}
+function writeNodeShape(get, cx, approximate, out, tokens) {
+  const shape = get("shape");
+  if (typeof shape !== "string") {
+    return "";
+  }
+  if (shape === "round-rectangle") {
+    tokens.push("rounded");
+  }
+  if (cx.cluster) {
+    if (shape !== "rectangle" && shape !== "round-rectangle") {
+      approximate("shape", shape);
+    }
+    return "";
+  }
+  const gvShape = spelled(SHAPES, shape, shape === "vee" ? "invtriangle" : "box", "shape", approximate);
+  out.set("shape", gvShape);
+  return gvShape;
+}
+function writeNodeSize(get, out) {
+  const width = get("width");
+  const height = get("height");
+  if (typeof width === "number" || typeof height === "number") {
+    out.set("fixedsize", "true");
+  }
+  if (typeof width === "number") {
+    out.set("width", inchesOf(width));
+  }
+  if (typeof height === "number") {
+    out.set("height", inchesOf(height));
+  }
+}
+function edgeAttributes(get, directed, approximate) {
+  const out = /* @__PURE__ */ new Map();
+  const tokens = [];
+  writeCommon(get, out, tokens);
+  const color = get("color");
+  if (typeof color === "string") {
+    out.set("color", gvColor(color, get("opacity")));
+  }
+  const width = get("width");
+  if (typeof width === "number") {
+    out.set("penwidth", width);
+  }
+  const line = get("lineStyle");
+  if (typeof line === "string" && line !== "solid") {
+    tokens.push(spelled(STROKES, line, line.includes("dash") ? "dashed" : "solid", "lineStyle", approximate));
+  }
+  writeEdgeArrows(get, directed, approximate, out);
+  const arrowSize = get("arrowSize");
+  if (typeof arrowSize === "number") {
+    out.set("arrowsize", arrowSize);
+  }
+  for (const [property, attribute] of [
+    ["label", LABEL_ATTRIBUTE],
+    ["targetLabel", "headlabel"],
+    ["sourceLabel", "taillabel"]
+  ]) {
+    const v = get(property);
+    if (typeof v === "string") {
+      out.set(attribute, escapeLabel(v));
+    }
+  }
+  if (tokens.length > 0) {
+    out.set("style", tokens.join(","));
+  }
+  return withoutDefaults(out, "edge");
+}
+function writeEdgeArrows(get, directed, approximate, out) {
+  const source = get("sourceArrow");
+  const target = get("targetArrow");
+  const tail = typeof source === "string" && source !== "none";
+  const head = typeof target === "string" && target !== "none";
+  const plain = directed ? head && !tail && target === "triangle" : !head && !tail;
+  if (plain || source === null && target === null) {
+    return;
+  }
+  let dir = "none";
+  if (head && tail) {
+    dir = "both";
+  } else if (head) {
+    dir = "forward";
+  } else if (tail) {
+    dir = "back";
+  }
+  out.set("dir", dir);
+  if (head) {
+    out.set("arrowhead", spelled(ARROWS, target, "normal", "targetArrow", approximate));
+  }
+  if (tail) {
+    out.set("arrowtail", spelled(ARROWS, source, "normal", "sourceArrow", approximate));
+  }
+}
+function getter(picture, target) {
+  const columns = /* @__PURE__ */ new Map();
+  for (const p of DOT_STYLE_CAPABILITIES[target]) {
+    columns.set(p, picture(target, p));
+  }
+  return (i) => (property) => columns.get(property)?.[i] ?? null;
+}
+function exactFromBlock(snapshot, text, read, cx) {
+  const parsed = parseStyleBlock(text, styleFingerprint(snapshot));
+  const ex = parsed.ok ? blockStyles(parsed.block, snapshot, "dot") : null;
+  if (ex === null) {
+    return;
+  }
+  const notes = new StyleNotes();
+  for (const target of ["node", "edge"]) {
+    const n = target === "node" ? snapshot.nodeCount : snapshot.edgeCount;
+    const get = getter((t, p) => resolveStyles(ex, t, p, snapshot), target);
+    const values = read[target];
+    for (let i = 0; i < n; i++) {
+      const want = get(i);
+      const back = writtenAndReadBack(target, i, want, cx, notes);
+      for (const property of DOT_STYLE_CAPABILITIES[target]) {
+        const native = values[property]?.[i] ?? null;
+        const w = want(property);
+        if (native !== w && native === (back.get(property) ?? null)) {
+          values[property] ??= new Array(n).fill(null);
+          values[property][i] = w;
+        }
+      }
+    }
+  }
+}
+function writtenAndReadBack(target, i, want, cx, notes) {
+  const ignore = () => void 0;
+  const back = /* @__PURE__ */ new Map();
+  const put = (property, value) => {
+    if (value !== null) {
+      back.set(property, value);
+    }
+  };
+  const at = (property) => ({ notes, target, property });
+  if (target === "node") {
+    const ncx = cx.node(i);
+    const attrs = nodeAttributes(want, ncx, ignore, notes);
+    readNode((name) => textOf(attrs.get(name)), ncx, put, at);
+  } else {
+    const ecx = cx.edge(i);
+    const attrs = edgeAttributes(want, ecx.directed, ignore);
+    readEdge((name) => textOf(attrs.get(name)), ecx, put, at);
+  }
+  return back;
+}
+function textOf(v) {
+  return v === void 0 ? null : String(v);
+}
+function readsBack(col) {
+  const vals = col.filter((v) => v !== null);
+  if (vals.every((v) => typeof v === "number")) {
+    return vals.every((v) => Number.isFinite(v));
+  }
+  if (vals.every((v) => typeof v === "boolean")) {
+    return true;
+  }
+  if (vals.every((v) => typeof v === "string")) {
+    return vals.some((v) => inferTextDtype(v) === "string") && vals.every((v) => isWritableDotText(v));
+  }
+  return false;
+}
+function dotSafeJson(json) {
+  return json.replaceAll(/\\(["\\])/g, (_m, c) => c === '"' ? String.raw`\u0022` : String.raw`\u005c`);
+}
+function dotStyledExport(snapshot, input, onMixedDirection) {
+  if (input === void 0) {
+    return null;
+  }
+  return sharedInExportCall(
+    input,
+    [snapshot, onMixedDirection],
+    () => styledExport(snapshot, input, onMixedDirection)
+  );
+}
+function styledExport(snapshot, input, onMixedDirection) {
+  const approximated = new StyleApproximations();
+  const replaced = [];
+  const out = snapshot.withColumns();
+  const written = onMixedDirection === "directed" || onMixedDirection === "undirected";
+  const cx = contexts(snapshot, written ? onMixedDirection === "directed" : null);
+  const notes = new StyleNotes();
+  for (const target of ["node", "edge"]) {
+    const table = target === "node" ? out.nodes : out.edges;
+    const read = dataRead(input.rules.styles.rules, target);
+    const approximate = (property, value) => {
+      approximated.add(target, property, value);
+    };
+    const columns = attributeColumns(snapshot, input, target, { cx, approximate, notes, read });
+    replaced.push(...removeStyleAttributes(table, target, columns, read));
+    setAttributeColumns(table, columns);
+  }
+  const { background } = input.rules.styles.graph;
+  if (out.graph.has("bgcolor")) {
+    out.graph.remove("bgcolor");
+  }
+  if (typeof background === "string") {
+    out.graph.set("bgcolor", [background], { dtype: "string" });
+  }
+  const inline = [...input.tags.node.values(), ...input.tags.edge.values()].some((col) => !readsBack(col));
+  if (!inline) {
+    setTagColumns(out, input);
+  }
+  const block = inline ? writeStyleBlock(input.rules, { inlineColumns: true, snapshot }) : input.block;
+  out.graph.set(STYLE_BLOCK_NAME, [dotSafeJson(block)], { dtype: "string" });
+  const losses = approximated.notes("Graphviz");
+  if (inline) {
+    losses.push(...styleBlockLosses(block, input.rules.styles.rules.length, "size"));
+  }
+  return { snapshot: out, notes: [...replaced, ...losses] };
+}
+function attributeColumns(snapshot, input, target, w) {
+  const n = target === "node" ? snapshot.nodeCount : snapshot.edgeCount;
+  const get = getter((t, p) => input.picture(t, p), target);
+  const columns = /* @__PURE__ */ new Map();
+  for (let i = 0; i < n; i++) {
+    const attrs = target === "node" ? nodeAttributes(get(i), w.cx.node(i), w.approximate, w.notes) : edgeAttributes(get(i), w.cx.edge(i).directed, w.approximate);
+    if (w.read.has(LABEL_ATTRIBUTE) && attrs.get(LABEL_ATTRIBUTE) === "" && get(i)("label") === null) {
+      w.approximate("label", "");
+    }
+    for (const [name, value] of attrs) {
+      let col = columns.get(name);
+      if (col === void 0) {
+        col = new Array(n).fill(null);
+        columns.set(name, col);
+      }
+      col[i] = value;
+    }
+  }
+  return columns;
+}
+function removeStyleAttributes(table, target, columns, read) {
+  const attributes = target === "node" ? NODE_ATTRIBUTES : EDGE_ATTRIBUTES;
+  const replaced = [];
+  for (const name of table.names()) {
+    if (!attributes.includes(name) && name !== LABEL_ATTRIBUTE && !name.startsWith("graphty.style.")) {
+      continue;
+    }
+    const differs = read.has(name) ? replacedRows(table, name, columns.get(name)) : 0;
+    if (differs > 0) {
+      replaced.push(
+        Object.freeze({
+          code: DOT_ATTRIBUTE_CLASH_CODE,
+          message: `${target} column "${name}" is not written: the ${name} attribute holds what graphty draws (${String(differs)} ${target}${differs === 1 ? "" : "s"} differ)`,
+          column: name,
+          count: differs
+        })
+      );
+    }
+    table.remove(name);
+  }
+  return replaced;
+}
+function setAttributeColumns(table, columns) {
+  for (const [name, col] of columns) {
+    if (name === LABEL_ATTRIBUTE) {
+      table.set(name, col, { dtype: "string", role: "label" }, { replaceRole: true });
+    } else if (col.every((v) => v === null || typeof v === "number")) {
+      table.set(name, col, { dtype: "f64" });
+    } else {
+      table.set(
+        name,
+        col.map((v) => v === null ? null : String(v)),
+        { dtype: "string" }
+      );
+    }
+  }
+}
+function setTagColumns(out, input) {
+  for (const target of ["node", "edge"]) {
+    const table = target === "node" ? out.nodes : out.edges;
+    for (const [name, col] of input.tags[target]) {
+      const kinds = new Set(col.filter((v) => v !== null).map((v) => typeof v));
+      let dtype = "string";
+      if (kinds.has("number")) {
+        dtype = "f64";
+      } else if (kinds.has("boolean")) {
+        dtype = "bool";
+      }
+      table.set(name, col, { dtype });
+    }
+  }
+}
+function dataRead(rules, target) {
+  const out = /* @__PURE__ */ new Set();
+  for (const { ext: _ext, ...rule } of rules.filter((r) => r.target === target)) {
+    JSON.stringify(rule, (_k, v) => {
+      if (typeof v === "object" && v !== null && !Array.isArray(v) && Object.keys(v).length === 1) {
+        const { data } = v;
+        if (typeof data === "string") {
+          out.add(data);
+        }
+      }
+      return v;
+    });
+  }
+  return out;
+}
+const DOT_ATTRIBUTE_CLASH_CODE = "W_DOT_ATTRIBUTE_CLASH";
+function replacedRows(table, name, written) {
+  const column = table.get(name);
+  let n = 0;
+  for (let i = 0; column !== null && i < column.length; i++) {
+    const cell = column.isSet(i) ? plainCell(column.value(i)) : null;
+    const w = written?.[i] ?? null;
+    const text = typeof cell === "string" ? cell : JSON.stringify(cell);
+    if (cell !== null && (w === null || String(w) !== text)) {
+      n++;
+    }
+  }
+  return n;
+}
 const DOT_LOSS = Object.freeze({
   /**
    * An id, name or text with a backslash before a quote or a line break, or at its end, cannot be written as a DOT
@@ -31,7 +1076,7 @@ const DOT_LOSS = Object.freeze({
    */
   TEXT_INFERRED: LOSS.TEXT_INFERRED,
   /** A plain column named like an attribute the exporter writes for a role (weight, key, pos) is not written. */
-  ATTRIBUTE_CLASH: "W_DOT_ATTRIBUTE_CLASH",
+  ATTRIBUTE_CLASH: DOT_ATTRIBUTE_CLASH_CODE,
   /** A mutual pair is written as two directed edges. */
   MUTUAL_EXPANDED: LOSS.MUTUAL_EXPANDED,
   /** A parents (multi-parent) column cannot be written; DOT clusters nest. */
@@ -48,8 +1093,28 @@ const DOT_LOSS = Object.freeze({
    */
   ROLE_ASSUMED: LOSS.ROLE_ASSUMED,
   /** A parent that is a plain node is written as a node and a cluster of one name; it reads back marked as a cluster. */
-  CLUSTER_MARKED: "W_DOT_CLUSTER_MARKED"
+  CLUSTER_MARKED: "W_DOT_CLUSTER_MARKED",
+  /** The file is written in UTF-8, so a graph `charset` naming another encoding is written as `UTF-8`. */
+  CHARSET_REWRITTEN: "W_DOT_CHARSET_REWRITTEN"
 });
+const UTF8_CHARSET = /^utf-?8$/i;
+function charsetNotes(column) {
+  const declared = isCharset(column) && column.isSet(0) ? cellText(column, 0) : null;
+  if (declared === null || UTF8_CHARSET.test(declared)) {
+    return [];
+  }
+  return [
+    Object.freeze({
+      code: DOT_LOSS.CHARSET_REWRITTEN,
+      message: `graph attribute charset ${JSON.stringify(declared)} is written as "UTF-8", the encoding the file is written in`,
+      column: column.meta.name,
+      count: 1
+    })
+  ];
+}
+function isCharset(column) {
+  return column.meta.name.toLowerCase() === "charset";
+}
 const KEPT_ROLES = /* @__PURE__ */ new Set(["label", "id", "sourcePort", "targetPort", "parent"]);
 const ROLE_NAMES = Object.freeze({
   label: LABEL_ATTRIBUTE,
@@ -131,21 +1196,20 @@ const dotExporter = Object.freeze({
   format: DOT_FORMAT,
   options: Object.freeze(["indent", "name", "strict"]),
   capabilities: CAPABILITIES,
+  styles: Object.freeze({ capabilities: DOT_STYLE_CAPABILITIES }),
   /**
-   * Pre-flight: every loss the DOT text would incur, without writing anything.
+   * Pre-flight: every loss the DOT text would incur, without writing anything; with styles, also the values
+   * written as the nearest ones Graphviz has.
    * @param snapshot - the snapshot to check
    * @param options - format-specific and common options
    * @returns the notes, empty when the export is exact
    */
   check(snapshot, options) {
-    const resolved = resolveExportOptions(options);
-    const notes = checkCapabilities(snapshot, CAPABILITIES, resolved, {
-      positionDtype: "f64",
-      roles: KEPT_ROLES,
-      roleNames: ROLE_NAMES
-    });
-    const plan = new ExportPlan(snapshot, resolved, options);
-    return [...notes, ...plan.notes()];
+    const styled = dotStyledExport(snapshot, options?.styles, options?.onMixedDirection);
+    if (styled === null) {
+      return checkPlain(snapshot, options);
+    }
+    return Object.freeze([...checkPlain(styled.snapshot, options), ...styled.notes]);
   },
   /**
    * Write the snapshot as UTF-8 chunks.
@@ -154,7 +1218,12 @@ const dotExporter = Object.freeze({
    * @returns the encoded chunks
    */
   export(snapshot, options) {
-    return encodeChunks(writeDot(snapshot, options));
+    return encodeChunks(
+      writeDot(
+        dotStyledExport(snapshot, options?.styles, options?.onMixedDirection)?.snapshot ?? snapshot,
+        options
+      )
+    );
   },
   /**
    * Write the snapshot as one string.
@@ -163,9 +1232,24 @@ const dotExporter = Object.freeze({
    * @returns the whole document
    */
   exportToString(snapshot, options) {
-    return joinText(writeDot(snapshot, options));
+    return joinText(
+      writeDot(
+        dotStyledExport(snapshot, options?.styles, options?.onMixedDirection)?.snapshot ?? snapshot,
+        options
+      )
+    );
   }
 });
+function checkPlain(snapshot, options) {
+  const resolved = resolveExportOptions(options);
+  const notes = checkCapabilities(snapshot, CAPABILITIES, resolved, {
+    positionDtype: "f64",
+    roles: KEPT_ROLES,
+    roleNames: ROLE_NAMES
+  });
+  const plan = new ExportPlan(snapshot, resolved, options);
+  return [...notes, ...plan.notes()];
+}
 function* writeDot(snapshot, options) {
   const resolved = resolveExportOptions(options);
   const plan = new ExportPlan(snapshot, resolved, options);
@@ -175,24 +1259,6 @@ function* writeDot(snapshot, options) {
 function endsWithBackslash(text) {
   return !isWritableDotText(text);
 }
-function isHtmlString(text) {
-  if (text.length < 2 || !text.startsWith("<") || !text.endsWith(">")) {
-    return false;
-  }
-  let depth = 0;
-  for (let i = 0; i < text.length; i++) {
-    const c = text.charCodeAt(i);
-    if (c === 60) {
-      depth++;
-    } else if (c === 62) {
-      depth--;
-      if (depth === 0 && i !== text.length - 1) {
-        return false;
-      }
-    }
-  }
-  return depth === 0;
-}
 function writeId(text) {
   return isHtmlString(text) ? text : quoteDotId(text);
 }
@@ -216,6 +1282,69 @@ function badOption(option, found, expected) {
     }
   );
 }
+function columnNotes(label, column, note) {
+  const { name, role } = column.meta;
+  const text = column.dtype === "string" || column.dtype === "dict";
+  if (label !== "graph" && column.nullCount === column.length) {
+    note(
+      DOT_LOSS.EMPTY_COLUMN_DROPPED,
+      `${label} column "${name}" has no set cell and is not written: DOT writes cells, never declarations`,
+      name,
+      0
+    );
+    return;
+  }
+  if (label !== "graph" && role === null && name === LABEL_ATTRIBUTE && text) {
+    note(
+      DOT_LOSS.ROLE_ASSUMED,
+      `${label} column "${name}" reads back with the label role`,
+      name,
+      column.length - column.nullCount
+    );
+  }
+  const bad = column.dtype === "f32" || column.dtype === "f64" ? countNonFinite(column) : 0;
+  if (bad > 0) {
+    note(
+      DOT_LOSS.NON_FINITE,
+      `${label} column "${name}" holds ${bad} non-finite value${plural(bad)} with no numeric DOT spelling; they read back as text`,
+      name,
+      bad
+    );
+  }
+  const typed = text && (role === null || !TEXT_ROLES.has(role)) ? countTypedLookingText(column) : 0;
+  if (typed > 0) {
+    note(
+      DOT_LOSS.TEXT_INFERRED,
+      `${label} column "${name}" holds ${typed} text value${plural(typed)} that look like numbers or booleans; DOT values are untyped and they read back as such`,
+      name,
+      typed
+    );
+  }
+}
+function positionNotes(snapshot, position, note) {
+  if (position !== null && position.meta.components !== 2 && position.meta.components !== 3) {
+    note(
+      DOT_LOSS.POSITION_SHAPE,
+      `node column "${position.meta.name}" (position) has ${position.meta.components} components and is not written; pos takes 2 or 3`,
+      position.meta.name,
+      position.length - position.nullCount
+    );
+  }
+  for (const [label, table] of [
+    ["edge", snapshot.edges],
+    ["graph", snapshot.graph]
+  ]) {
+    const column = table.byRole("position");
+    if (column !== null) {
+      note(
+        DOT_LOSS.POSITION_SHAPE,
+        `${label} column "${column.meta.name}" (position) is not written; only node positions map to pos`,
+        column.meta.name,
+        column.length - column.nullCount
+      );
+    }
+  }
+}
 class ExportPlan {
   /**
    * Plan one export.
@@ -264,6 +1393,49 @@ class ExportPlan {
     this.children = childrenCsr(snapshot, {
       column: this.parent !== null && this.parent.dtype === "u32" ? this.parent : null
     });
+    this.nodeColumns = firstSeenOrder(this.nodeColumns, this.nodeTextOrder());
+    const edgeRows = [];
+    for (let e = 0; e < snapshot.edgeCount; e++) {
+      if (!this.folding.folded(e)) {
+        edgeRows.push(e);
+      }
+    }
+    this.edgeColumns = firstSeenOrder(this.edgeColumns, edgeRows);
+  }
+  /**
+   * The nodes in the order a reader of the document takes their attributes: a node's statement before the members
+   * of its cluster, and a cluster's own `graph [...]` attributes when its subgraph closes, after its members.
+   * @returns the node indices
+   */
+  nodeTextOrder() {
+    const order = [];
+    const seen = new Uint8Array(this.snapshot.nodeCount);
+    const stack = [];
+    for (let root = this.snapshot.nodeCount - 1; root >= 0; root--) {
+      stack.push(root);
+    }
+    while (stack.length > 0) {
+      const i = stack.pop();
+      if (i < 0) {
+        order.push(-i - 1);
+        continue;
+      }
+      if (seen[i] === 1) {
+        continue;
+      }
+      seen[i] = 1;
+      const marked = this.cluster !== null && this.cluster.isSet(i) && this.cluster.value(i) === true;
+      if (marked) {
+        stack.push(-i - 1);
+      } else {
+        order.push(i);
+      }
+      const kids = this.children.childrenOf(i);
+      for (let k = kids.length - 1; k >= 0; k--) {
+        stack.push(kids[k]);
+      }
+    }
+    return order;
   }
   /**
    * Whether a node column is written as node attributes.
@@ -363,50 +1535,34 @@ class ExportPlan {
       ["graph", this.graphColumns]
     ]) {
       for (const column of columns) {
-        if (label !== "graph" && column.nullCount === column.length) {
-          note(
-            DOT_LOSS.EMPTY_COLUMN_DROPPED,
-            `${label} column "${column.meta.name}" has no set cell and is not written: DOT writes cells, never declarations`,
-            column.meta.name,
-            0
-          );
-          continue;
-        }
-        if (label !== "graph" && column.meta.role === null && column.meta.name === LABEL_ATTRIBUTE && (column.dtype === "string" || column.dtype === "dict")) {
-          note(
-            DOT_LOSS.ROLE_ASSUMED,
-            `${label} column "${column.meta.name}" reads back with the label role`,
-            column.meta.name,
-            column.length - column.nullCount
-          );
-        }
-        if (column.dtype === "f32" || column.dtype === "f64") {
-          const bad = countNonFinite(column);
-          if (bad > 0) {
-            note(
-              DOT_LOSS.NON_FINITE,
-              `${label} column "${column.meta.name}" holds ${bad} non-finite value${plural(bad)} with no numeric DOT spelling; they read back as text`,
-              column.meta.name,
-              bad
-            );
-          }
-        }
-        if ((column.dtype === "string" || column.dtype === "dict") && (column.meta.role === null || !TEXT_ROLES.has(column.meta.role))) {
-          const typed = countTypedLookingText(column);
-          if (typed > 0) {
-            note(
-              DOT_LOSS.TEXT_INFERRED,
-              `${label} column "${column.meta.name}" holds ${typed} text value${plural(typed)} that look like numbers or booleans; DOT values are untyped and they read back as such`,
-              column.meta.name,
-              typed
-            );
-          }
+        if (label === "graph") {
+          notes.push(...charsetNotes(column));
         }
+        columnNotes(label, column, note);
       }
     }
+    this.structureNotes(note);
+    positionNotes(snapshot, this.position, note);
+    const textIds = countTextIds(snapshot);
+    if (textIds > 0) {
+      note(
+        DOT_LOSS.ID_TEXT_TYPE,
+        `${textIds} node id${plural(textIds)} ${agree(textIds, "reads", "read")} back as the other type under ids: "canonical" (a string "1" becomes 1, a number 1.5 becomes "1.5")`,
+        null,
+        textIds
+      );
+    }
+    return notes;
+  }
+  /**
+   * The notes of the graph's structure DOT changes: parents written as clusters, mutual pairs and parents lists.
+   * @param note - the recorder
+   */
+  structureNotes(note) {
+    const { snapshot } = this;
     let unmarked = 0;
     for (let i = 0; i < snapshot.nodeCount; i++) {
-      const marked = this.cluster !== null && this.cluster.isSet(i) && this.cluster.value(i) === true;
+      const marked = this.cluster?.isSet(i) === true && this.cluster.value(i) === true;
       if (!marked && this.children.childrenOf(i).length > 0) {
         unmarked++;
       }
@@ -437,38 +1593,6 @@ class ExportPlan {
         parents.length - parents.nullCount
       );
     }
-    if (this.position !== null && this.position.meta.components !== 2 && this.position.meta.components !== 3) {
-      note(
-        DOT_LOSS.POSITION_SHAPE,
-        `node column "${this.position.meta.name}" (position) has ${this.position.meta.components} components and is not written; pos takes 2 or 3`,
-        this.position.meta.name,
-        this.position.length - this.position.nullCount
-      );
-    }
-    for (const [label, table] of [
-      ["edge", snapshot.edges],
-      ["graph", snapshot.graph]
-    ]) {
-      const column = table.byRole("position");
-      if (column !== null) {
-        note(
-          DOT_LOSS.POSITION_SHAPE,
-          `${label} column "${column.meta.name}" (position) is not written; only node positions map to pos`,
-          column.meta.name,
-          column.length - column.nullCount
-        );
-      }
-    }
-    const textIds = countTextIds(snapshot);
-    if (textIds > 0) {
-      note(
-        DOT_LOSS.ID_TEXT_TYPE,
-        `${textIds} node id${plural(textIds)} ${agree(textIds, "reads", "read")} back as the other type under ids: "canonical" (a string "1" becomes 1, a number 1.5 becomes "1.5")`,
-        null,
-        textIds
-      );
-    }
-    return notes;
   }
   /**
    * Throw for the conditions check() reports as errors: mixed direction under "error", and an
@@ -700,7 +1824,10 @@ class ExportPlan {
       if (!column.isSet(row)) {
         continue;
       }
-      const text = cellText(column, row);
+      let text = cellText(column, row);
+      if (text !== null && columns === this.graphColumns && isCharset(column) && !UTF8_CHARSET.test(text)) {
+        text = "UTF-8";
+      }
       if (text !== null) {
         out.push(`${quoteDotId(this.attributeName(column))}=${writeId(text)}`);
       }
@@ -787,6 +1914,22 @@ function positionDims(column) {
   }
   return column.meta.components === 2 ? 2 : 3;
 }
+function firstSeenOrder(columns, rows) {
+  const left = new Set(columns);
+  const out = [];
+  for (const row of rows) {
+    if (left.size === 0) {
+      break;
+    }
+    for (const column of columns) {
+      if (left.has(column) && column.isSet(row) && cellText(column, row) !== null) {
+        out.push(column);
+        left.delete(column);
+      }
+    }
+  }
+  return [...out, ...left];
+}
 function cellText(column, row) {
   switch (column.dtype) {
     case "bool":
@@ -867,6 +2010,53 @@ function countTextIds(snapshot) {
   }
   return count;
 }
+const POINTS_PER_INCH = 72;
+function dotPositions(snapshot) {
+  if (snapshot.nodes.byRole("position") === null) {
+    return null;
+  }
+  const bb = snapshot.graph.get("bb");
+  const laidOut = bb !== null && bb.isSet(0) && boxOf(bb.value(0)) !== null;
+  const width = snapshot.nodes.get("width");
+  const widths = [];
+  for (let row = 0; width !== null && row < width.length; row++) {
+    const w = width.isSet(row) ? Number(width.value(row)) : Number.NaN;
+    if (Number.isFinite(w)) {
+      widths.push(laidOut ? w * POINTS_PER_INCH : w);
+    }
+  }
+  return {
+    units: laidOut ? "px" : "file",
+    // input inches are drawn beside the styles' point lengths at 72 points each
+    ...laidOut ? {} : { pxPerUnit: POINTS_PER_INCH },
+    yAxis: "up",
+    groups: clusterBoxes(snapshot),
+    medianNodeSize: median(widths),
+    ...laidOut ? { tool: "graphviz" } : {}
+  };
+}
+function clusterBoxes(snapshot) {
+  const bb = snapshot.nodes.get("bb");
+  const out = [];
+  for (let node = 0; bb !== null && node < bb.length; node++) {
+    const box = bb.isSet(node) ? boxOf(bb.value(node)) : null;
+    if (box !== null) {
+      out.push({ node, box });
+    }
+  }
+  return out;
+}
+function boxOf(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const parts = value.split(",").map(Number);
+  if (parts.length !== 4 || !parts.every(Number.isFinite)) {
+    return null;
+  }
+  const [llx, lly, urx, ury] = parts;
+  return { x: (llx + urx) / 2, y: (lly + ury) / 2, width: urx - llx, height: ury - lly };
+}
 class DotSyntaxError extends Error {
   /**
    * Create a syntax error.
@@ -1354,6 +2544,8 @@ const dotImporter = Object.freeze({
   options: Object.freeze(["keepPositionSource", "mismatchedEdgeOperator", "positions"]),
   extensions: EXTENSIONS,
   mimeTypes: MIME_TYPES,
+  styles: dotStyles,
+  positions: dotPositions,
   /**
    * Confidence that the head of an input is DOT: the `[strict] graph | digraph` header after
    * optional comments.
@@ -1765,22 +2957,41 @@ class DotParser {
       }
       throw new DotSyntaxError(`unexpected ${describeToken(token)} at the start of a statement`, token.line);
     }
-    if (!token.quoted && !token.html) {
-      const keyword = token.text.toLowerCase();
-      if (keyword === "node" || keyword === "edge" || keyword === "graph") {
-        lexer.next();
-        this.attributeStatement(scope, keyword, token.line);
-        return;
-      }
-      if (keyword === "subgraph") {
-        const group = this.subgraph(scope);
-        this.maybeEdgeStatement(scope, group, token.line);
-        return;
-      }
-      if (keyword === "digraph" || keyword === "strict") {
-        throw new DotSyntaxError(`unexpected keyword ${describeToken(token)} inside a graph`, token.line);
-      }
+    if (!token.quoted && !token.html && this.keywordStatement(scope, token)) {
+      return;
+    }
+    this.idStatement(scope);
+  }
+  /**
+   * Parse a statement that starts with a keyword: an attribute statement or a subgraph.
+   * @param scope - the scope
+   * @param token - the statement's first token, not yet read
+   * @returns false when the token is no statement keyword (an ID)
+   */
+  keywordStatement(scope, token) {
+    const keyword = token.text.toLowerCase();
+    if (keyword === "node" || keyword === "edge" || keyword === "graph") {
+      this.lexer.next();
+      this.attributeStatement(scope, keyword, token.line);
+      return true;
     }
+    if (keyword === "subgraph") {
+      const group = this.subgraph(scope);
+      this.maybeEdgeStatement(scope, group, token.line);
+      return true;
+    }
+    if (keyword === "digraph" || keyword === "strict") {
+      throw new DotSyntaxError(`unexpected keyword ${describeToken(token)} inside a graph`, token.line);
+    }
+    return false;
+  }
+  /**
+   * Parse a statement that starts with an ID: `ID = ID`, a node statement, or an edge statement starting with a
+   * node.
+   * @param scope - the scope
+   */
+  idStatement(scope) {
+    const { lexer } = this;
     const id = this.identifier();
     if (isPunct(lexer.peek(), "=")) {
       lexer.next();
@@ -1789,6 +3000,10 @@ class DotParser {
       return;
     }
     const port = this.port();
+    if (isPunct(lexer.peek(), ",")) {
+      this.nodeListStatement(scope, [{ id, port }, ...this.moreNodes()]);
+      return;
+    }
     if (isEdgeOp(lexer.peek())) {
       const endpoint = this.mentionEndpoint(scope, id, port);
       this.edgeStatement(scope, endpoint === null ? [] : [endpoint], id.line);
@@ -1796,6 +3011,35 @@ class DotParser {
     }
     this.nodeStatement(scope, id, port);
   }
+  /**
+   * Read the rest of a node list after its first node: `, ID [port]` repeated (`a, b, c`).
+   * @returns the further nodes, in order
+   */
+  moreNodes() {
+    const out = [];
+    while (isPunct(this.lexer.peek(), ",")) {
+      this.lexer.next();
+      const id = this.identifier();
+      out.push({ id, port: this.port() });
+    }
+    return out;
+  }
+  /**
+   * A statement starting with a node list (`a, b [attrs]` or `a, b -> c`): an edge statement from every node of
+   * the list, or a node statement for each.
+   * @param scope - the scope
+   * @param nodes - the listed nodes with their ports
+   */
+  nodeListStatement(scope, nodes) {
+    if (isEdgeOp(this.lexer.peek())) {
+      this.edgeStatement(scope, this.mentionAll(scope, nodes), nodes[0].id.line);
+      return;
+    }
+    const attributes = this.attributeList();
+    for (const n of nodes) {
+      this.applyNodeStatement(scope, n.id, n.port, attributes);
+    }
+  }
   /**
    * Read an ID, concatenating quoted strings joined by `+`.
    * @returns the id token (the concatenation keeps the first token's line and quoted flag)
@@ -2128,7 +3372,16 @@ class DotParser {
    * @param port - the port, if any (dropped with a warning)
    */
   nodeStatement(scope, id, port) {
-    const attributes = this.attributeList();
+    this.applyNodeStatement(scope, id, port, this.attributeList());
+  }
+  /**
+   * Mention a node of a node statement and apply the statement's attributes to it.
+   * @param scope - the scope
+   * @param id - the id token
+   * @param port - the port, if any (dropped with a warning)
+   * @param attributes - the statement's attributes
+   */
+  applyNodeStatement(scope, id, port, attributes) {
     const endpoint = this.mentionEndpoint(scope, id, null);
     if (endpoint === null) {
       return;
@@ -2174,20 +3427,35 @@ class DotParser {
         groups.push(this.subgraph(scope));
       } else {
         const id = this.identifier();
-        const port = this.port();
-        const endpoint = this.mentionEndpoint(scope, id, port);
-        groups.push(endpoint === null ? [] : [endpoint]);
+        groups.push(this.mentionAll(scope, [{ id, port: this.port() }, ...this.moreNodes()]));
       }
     }
     const attributes = this.attributeList();
     for (let k = 0; k < kinds.length; k++) {
+      const targets = groups[k + 1];
       for (const source of groups[k]) {
-        for (const target of groups[k + 1]) {
+        for (const target of targets) {
           this.pushEdge(scope, source, target, kinds[k], attributes, line);
         }
       }
     }
   }
+  /**
+   * Mention each listed node as an edge endpoint.
+   * @param scope - the scope
+   * @param nodes - the nodes with their ports
+   * @returns the endpoints of the nodes that could be created
+   */
+  mentionAll(scope, nodes) {
+    const group = [];
+    for (const n of nodes) {
+      const endpoint = this.mentionEndpoint(scope, n.id, n.port);
+      if (endpoint !== null) {
+        group.push(endpoint);
+      }
+    }
+    return group;
+  }
   /**
    * The direction of an edge from its operator, checked against the graph keyword.
    * @param op - the operator token
@@ -2718,7 +3986,8 @@ class DotParser {
 export {
   DOT_ISSUE as D,
   DOT_LOSS as a,
-  dotImporter as b,
+  DOT_STYLE_CAPABILITIES as b,
+  dotImporter as c,
   dotExporter as d
 };
-//# sourceMappingURL=importer-BbNb7eNg.js.map
+//# sourceMappingURL=importer-C7pvJe1L.js.map