@graphty/graph-io 0.3.48 → 0.3.49

package/dist/chunks/styles-Cm62yyQX.js

@@ -0,0 +1,2812 @@
+import { f as isWritableDotText } from "./escape-CuCIzNMB.js";
+import { i as inferTextDtype } from "./text-ystE2bYi.js";
+import { f as flattenCubic, c as canonNodeOffsets, d as canonBends } from "./bends-BGXjv_U4.js";
+import { o as styleFingerprint, b as STYLE_ISSUE, z as styleTag, A as writeStyleBlock, B as styleBlockLosses, r as resolveStyles, S as STYLE_BLOCK_NAME, C as canonicalFor, D as degreeValues, E as dataCell, y as toolDefaults, p as plainCell, i as num6, h as StyleNotes, n as noteAt, F as htmlLabelText, G as dotLabelText, H as DOT_POINTS_PER_INCH, M as MAX_STYLE_VALUE_LENGTH, c as canonNumber, a as canonEnum, d as canonColor, e as colorOpacity, I as recordLabelText, J as dotLabelAlign, K as htmlLabelSpans } from "./block-iptrlMBb.js";
+import { S as StyleApproximations } from "./approximations-Bzn3L-je.js";
+import { t as takeFromBlock, e as elementValues } from "./round-trip-Zm3_ivgq.js";
+import { p as plural, a as agree } from "./report-CwMfYa9J.js";
+import { v as valueColumns } from "./styles-yed-UMFdNqze.js";
+import { g as graphvizFont, G as GRAPHVIZ_GLYPH_SHAPES, a as GRAPHVIZ_POLYGON_SHAPES, b as isGraphvizBox, c as graphvizPolygonCorners, d as graphvizGlyph, e as GRAPHVIZ_DECORATED_BOXES, f as graphvizFontName } from "./choose-CczZJaX_.js";
+const DOT_FORMAT = "dot";
+const DOT_ORIGIN = Object.freeze({ format: DOT_FORMAT });
+const CLUSTER_COLUMN = "graphty.cluster";
+const PARENT_COLUMN = "graphty.parent";
+const SOURCE_PORT_COLUMN = "graphty.sourcePort";
+const TARGET_PORT_COLUMN = "graphty.targetPort";
+const LABEL_ATTRIBUTE = "label";
+const POS_ATTRIBUTE = "pos";
+const POSITION_COLUMN = "graphty.position";
+const KEY_ATTRIBUTE = "key";
+const PIN_ATTRIBUTE = "pin";
+const DOT_META_KEY = "dot";
+const STYLE_ROLES = /* @__PURE__ */ new Set(["color", "size", "shape", "thickness", "hidden"]);
+const TARGETS = ["node", "edge"];
+function prepareStyleExport(snapshot, exporter, given, plain) {
+  const fp = styleFingerprint(snapshot);
+  const want = given.fingerprint;
+  if (fp.nodes !== want.nodes || fp.edges !== want.edges || fp.ids !== want.ids) {
+    return {
+      snapshot,
+      input: null,
+      notes: [],
+      refusal: Object.freeze({
+        code: STYLE_ISSUE.MISMATCH,
+        message: `the styles were read from or built for a different graph (${String(want.nodes)} nodes and ${String(want.edges)} edges, this graph has ${String(fp.nodes)} and ${String(fp.edges)}, or other node ids); nothing is written`,
+        column: null,
+        count: null
+      })
+    };
+  }
+  const caps = exporter.styles?.capabilities ?? null;
+  let plan = writePlan(snapshot, exporter, given);
+  if (keepsStyleBlock(exporter)) {
+    let checked;
+    try {
+      checked = exporter.check(plan.snapshot, plan.input === null ? plain : { ...plain, styles: plan.input });
+    } catch {
+      checked = [];
+    }
+    const carried = withLostInputsCarried(given, snapshot, checked);
+    if (carried !== given) {
+      plan = writePlan(snapshot, exporter, carried);
+    }
+  }
+  return {
+    snapshot: plan.snapshot,
+    input: plan.input,
+    notes: lossNotes(plan.extracted, exporter, caps, plan.picture, snapshot),
+    refusal: null
+  };
+}
+const CALL_WORK = /* @__PURE__ */ new WeakMap();
+function sharedInExportCall(input, key, compute) {
+  if (!CALL_WORK.has(input)) {
+    return compute();
+  }
+  const done = CALL_WORK.get(input);
+  if (done?.key.length === key.length && done.key.every((k, i) => k === key[i])) {
+    return done.value;
+  }
+  const value = compute();
+  CALL_WORK.set(input, { key, value });
+  return value;
+}
+function writePlan(snapshot, exporter, extracted) {
+  const caps = exporter.styles?.capabilities ?? null;
+  const pictures = /* @__PURE__ */ new Map();
+  const picture = (target, property) => {
+    const key = `${target}\0${property}`;
+    let values = pictures.get(key);
+    if (values === void 0) {
+      values = resolveStyles(extracted, target, property, snapshot);
+      pictures.set(key, values);
+    }
+    return values;
+  };
+  const tags = { node: /* @__PURE__ */ new Map(), edge: /* @__PURE__ */ new Map() };
+  for (const target of TARGETS) {
+    for (const [key, col] of extracted.columns[target]) {
+      tags[target].set(styleTag(target, key), col);
+    }
+  }
+  const block = writeStyleBlock(extracted, { snapshot });
+  const input = exporter.styles === void 0 ? null : { picture, block, tags, rules: extracted };
+  if (input !== null) {
+    CALL_WORK.set(input, null);
+  }
+  return {
+    snapshot: styledSnapshot(snapshot, caps, tags, block, extracted.styles.rules),
+    input,
+    extracted,
+    picture
+  };
+}
+const VALUES_KEPT = /NODE_TABLE|NAME_CHANGED|ROLE_ASSUMED|STORAGE_CLASS|NUMBER_TYPE|INTEGRAL|WIDENED/;
+function withLostInputsCarried(extracted, snapshot, notes) {
+  const lost = /* @__PURE__ */ new Set();
+  let direction = false;
+  for (const note of notes) {
+    if (!VALUES_KEPT.test(note.code)) {
+      for (const name of note.columns ?? (note.column === null ? [] : [note.column])) {
+        lost.add(name);
+      }
+    }
+    direction ||= /DIRECTION/.test(note.code);
+  }
+  const carrier = new LostInputs(snapshot, lost, direction, extracted.columns);
+  const rules = extracted.styles.rules.map((rule) => carrier.carry(rule));
+  const changed = rules.some((rule, i) => rule !== extracted.styles.rules[i]);
+  return changed ? { ...extracted, styles: { ...extracted.styles, rules }, columns: carrier.columns } : extracted;
+}
+class LostInputs {
+  /**
+   * A carrier for one export.
+   * @param snapshot - the graph
+   * @param lost - the data columns the export drops or changes
+   * @param direction - whether the file loses the edges' direction (and so the in and out degrees)
+   * @param columns - the styles' own style columns
+   * @param columns.node - the node columns
+   * @param columns.edge - the edge columns
+   */
+  constructor(snapshot, lost, direction, columns) {
+    this.snapshot = snapshot;
+    this.lost = lost;
+    this.direction = direction;
+    this.touched = false;
+    this.columns = { node: new Map(columns.node), edge: new Map(columns.edge) };
+  }
+  /**
+   * A rule with every lost input it reads replaced by a copy of its values.
+   * @param rule - the rule
+   * @returns the rule read from copies, or the rule itself when it reads no lost input
+   */
+  carry(rule) {
+    this.touched = false;
+    const { ext, ...given } = rule;
+    const map = this.carryMap(rule);
+    const where = this.walk(rule, given.where);
+    if (!this.touched) {
+      return rule;
+    }
+    const { map: _given, ...unmapped } = given;
+    const plain = Object.keys(map).length === 0 ? { ...unmapped, where } : { ...unmapped, where, map };
+    const moved = JSON.parse(JSON.stringify(plain));
+    return ext === void 0 ? moved : { ...moved, ext };
+  }
+  /**
+   * A rule's mappings with their lost inputs replaced. A passthrough reads a data column as the property's value: its
+   * copy holds those values; one that gives no element a value (a list, text that is not a color) is left out, so
+   * no other value the file reads back in the column (a list written as text) is given either.
+   * @param rule - the rule
+   * @returns the mappings
+   */
+  carryMap(rule) {
+    const map = /* @__PURE__ */ Object.create(null);
+    const { table } = this.tableOf(rule.target);
+    for (const [property, mapping] of Object.entries(rule.map ?? {})) {
+      if (mapping === void 0) {
+        continue;
+      }
+      if (mapping.kind !== "passthrough") {
+        map[property] = this.walk(rule, mapping);
+        continue;
+      }
+      const name = mapping.by.data;
+      const lostColumn = typeof name === "string" && this.lost.has(name) && table.has(name);
+      const values = lostColumn ? this.cells(rule.target, name, canonicalFor(rule.target, property)) : null;
+      if (values !== null && !values.some((v) => v !== null)) {
+        this.touched = true;
+      } else if (values !== null && this.isLost(rule.target, name)) {
+        this.touched = true;
+        map[property] = { ...mapping, by: this.copy(rule.target, `${property}.data.${name}`, () => values) };
+      } else {
+        map[property] = mapping;
+      }
+    }
+    return map;
+  }
+  /**
+   * A value with every other reference to a lost input reading a copy of its values as they are.
+   * @param rule - the rule it belongs to
+   * @param value - the value
+   * @returns the value, references replaced
+   */
+  walk(rule, value) {
+    return JSON.parse(JSON.stringify(value, (_k, v) => this.replaced(rule, v)));
+  }
+  /**
+   * One reference with a lost input replaced by its copy: a data column, or a degree the file does not keep.
+   * @param rule - the rule it belongs to
+   * @param v - a value of the rule
+   * @returns the value, or the reference to the copy
+   */
+  replaced(rule, v) {
+    if (typeof v !== "object" || v === null || Array.isArray(v) || Object.keys(v).length !== 1) {
+      return v;
+    }
+    const ref = v;
+    if (this.isLost(rule.target, ref.data)) {
+      const name = ref.data;
+      this.touched = true;
+      return this.copy(
+        rule.target,
+        `data.${name}`,
+        () => this.cells(rule.target, name, (raw) => isStyleScalar(raw) ? raw : null)
+      );
+    }
+    const which = ref.computed;
+    if ((which === "indegree" || which === "outdegree") && this.direction && rule.target === "node") {
+      this.touched = true;
+      return this.copy(rule.target, `computed.${which}`, () => degreeValues(this.snapshot, which));
+    }
+    return v;
+  }
+  /**
+   * The reference to a copy of an input, made on first use and shared by every rule that reads it.
+   * @param target - nodes or edges
+   * @param base - what is copied
+   * @param values - its values
+   * @returns the reference
+   */
+  copy(target, base, values) {
+    const key = `input.${base}`;
+    const held = this.columns[target];
+    if (!held.has(key)) {
+      held.set(key, values());
+    }
+    return { style: key };
+  }
+  /**
+   * Whether a name is a lost input that can be copied: only a column of plain values can, and a list, or a column with
+   * no value, stays as it is.
+   * @param target - nodes or edges
+   * @param name - the name
+   * @returns true for a lost input
+   */
+  isLost(target, name) {
+    const { table, n } = this.tableOf(target);
+    return typeof name === "string" && this.lost.has(name) && table.has(name) && carriable(table, n, name);
+  }
+  /**
+   * Every element's value of a data column.
+   * @param target - nodes or edges
+   * @param name - the column
+   * @param read - the value of a cell
+   * @returns the values
+   */
+  cells(target, name, read) {
+    const { table, n } = this.tableOf(target);
+    return Array.from({ length: n }, (_u, i) => read(dataCell(table, name, i)));
+  }
+  /**
+   * A target's table and row count.
+   * @param target - nodes or edges
+   * @returns the table and its row count
+   */
+  tableOf(target) {
+    const { snapshot } = this;
+    return target === "node" ? { table: snapshot.nodes, n: snapshot.nodeCount } : { table: snapshot.edges, n: snapshot.edgeCount };
+  }
+}
+function carriable(table, n, name) {
+  let some = false;
+  for (let i = 0; i < n; i++) {
+    const cell = plainCell(table.value(name, i));
+    if (cell !== null && cell !== void 0) {
+      if (!isStyleScalar(cell)) {
+        return false;
+      }
+      some = true;
+    }
+  }
+  return some;
+}
+function isStyleScalar(v) {
+  return typeof v === "string" || typeof v === "boolean" || typeof v === "number" && Number.isFinite(v);
+}
+function keepsStyleBlock(exporter) {
+  const caps = exporter.styles?.capabilities;
+  return caps !== void 0 && (caps.block === "native" || caps.block === "attributes" && exporter.capabilities.graphAttributes);
+}
+function isKeptGraphtyProperty(note, exporter) {
+  return note.style?.property.startsWith("graphty:") === true && keepsStyleBlock(exporter);
+}
+function lossNotes(extracted, exporter, caps, picture, snapshot) {
+  const notes = [];
+  const kept = keepsStyleBlock(exporter);
+  for (const target of TARGETS) {
+    const written = new Set(caps?.[target] ?? []);
+    for (const property of ruleProperties(extracted.styles.rules, target)) {
+      if (written.has(property) || kept && property.startsWith("graphty:")) {
+        if (target === "edge") {
+          notes.push(...pairNotes(snapshot, exporter, property, picture("edge", property)));
+        }
+      } else {
+        const note = notWrittenNote(target, property, exporter, picture);
+        if (note.count !== 0) {
+          notes.push(note);
+        }
+      }
+    }
+  }
+  notes.push(...graphLossNotes(extracted, exporter, caps));
+  if (kept) {
+    notes.push(...styleBlockLosses(writeStyleBlock(extracted, { snapshot }), extracted.styles.rules.length));
+  } else if (extracted.styles.rules.length > 0) {
+    notes.push(
+      Object.freeze({
+        code: STYLE_ISSUE.RULES_NOT_KEPT,
+        message: `the style rules are not kept: the ${exporter.format} format has no place for them; importing the file infers them again from what it holds`,
+        column: null,
+        count: extracted.styles.rules.length
+      })
+    );
+  }
+  return notes;
+}
+function graphLossNotes(extracted, exporter, caps) {
+  const graphWritten = new Set(caps?.graph ?? []);
+  const drawn = (caps?.tool === void 0 ? null : toolDefaults(caps.tool))?.graph ?? {};
+  return Object.entries(extracted.styles.graph).filter(([property, value]) => !graphWritten.has(property) && drawn[property]?.value !== value).map(([property]) => property).map(
+    (property) => Object.freeze({
+      code: STYLE_ISSUE.NOT_WRITTEN,
+      message: `the graph's ${property} is not written: the ${exporter.format} format has no place for it`,
+      column: null,
+      count: 1,
+      style: Object.freeze({ target: "graph", property })
+    })
+  );
+}
+function ruleProperties(rules, target) {
+  return new Set(
+    rules.filter((rule) => rule.target === target).flatMap((rule) => [...Object.keys(rule.set ?? {}), ...Object.keys(rule.map ?? {})])
+  );
+}
+function notWrittenNote(target, property, exporter, picture) {
+  const count = picture(target, property).filter((v) => v !== null).length;
+  return Object.freeze({
+    code: STYLE_ISSUE.NOT_WRITTEN,
+    message: `${target} ${property} is not written: the ${exporter.format} format has no place for it (${String(count)} ${target}${plural(count)} ${agree(count, "has", "have")} a value)`,
+    column: null,
+    count,
+    style: Object.freeze({ target, property })
+  });
+}
+function pairNotes(snapshot, exporter, property, values) {
+  const pair = snapshot.edges.byRole("pair");
+  let count = 0;
+  for (let i = 0; pair !== null && i < values.length; i++) {
+    const other = pair.isSet(i) ? pair.value(i) : i;
+    if (other < i && values[i] !== values[other]) {
+      count++;
+    }
+  }
+  if (count === 0) {
+    return [];
+  }
+  return [
+    Object.freeze({
+      code: STYLE_ISSUE.APPROXIMATED,
+      message: `edge ${property}: ${String(count)} undirected edge${plural(count)} in a directed graph ${agree(count, "has", "have")} another value on each half; the ${exporter.format} format writes the edge once, with the first half's value`,
+      column: null,
+      count,
+      style: Object.freeze({ target: "edge", property })
+    })
+  ];
+}
+function styledSnapshot(snapshot, caps, tags, block, rules) {
+  const attributes = caps?.block === "attributes";
+  const stale = { node: staleTags(snapshot.nodes, rules, "node"), edge: staleTags(snapshot.edges, rules, "edge") };
+  const roles = { node: roledNames(snapshot.nodes, caps, "node"), edge: roledNames(snapshot.edges, caps, "edge") };
+  const staleBlock = snapshot.graph.has(STYLE_BLOCK_NAME);
+  const changes = [stale.node, stale.edge, roles.node, roles.edge].some((names) => names.length > 0);
+  if (!attributes && !staleBlock && !changes) {
+    return snapshot;
+  }
+  const out = snapshot.withColumns();
+  if (staleBlock) {
+    out.graph.remove(STYLE_BLOCK_NAME);
+  }
+  for (const target of TARGETS) {
+    const table = target === "node" ? out.nodes : out.edges;
+    for (const name of stale[target]) {
+      table.remove(name);
+    }
+    for (const name of roles[target]) {
+      const col = table.get(name);
+      if (col !== null) {
+        table.set(name, col, { role: void 0 });
+      }
+    }
+  }
+  if (attributes) {
+    setTagAttributes(out, tags);
+    out.graph.set(STYLE_BLOCK_NAME, [block], { dtype: "string" });
+  }
+  return out;
+}
+function staleTags(table, rules, target) {
+  const read = dataRead$1(rules, target);
+  return table.names().filter((name) => isStyleTagName(name) && !read.has(name));
+}
+function roledNames(table, caps, target) {
+  const writesLabel = (caps?.[target] ?? []).includes("label");
+  return table.names().filter((name) => {
+    const role = table.get(name)?.meta.role ?? "";
+    return STYLE_ROLES.has(role) || role === "label" && writesLabel;
+  });
+}
+function setTagAttributes(out, tags) {
+  for (const target of TARGETS) {
+    const table = target === "node" ? out.nodes : out.edges;
+    const prefix = styleTag(target, "");
+    for (const name of table.names().filter((c) => c.startsWith(prefix))) {
+      table.remove(name);
+    }
+    for (const [name, col] of tags[target]) {
+      const dtype = tagDtype(col);
+      table.set(name, dtype === "string" ? col.map((v) => v === null ? null : String(v)) : col, { dtype });
+    }
+  }
+}
+function isStyleTagName(name) {
+  return name.startsWith("graphty.style.") || name.startsWith("graphty_style_");
+}
+function dataRead$1(rules, target) {
+  const out = /* @__PURE__ */ new Set();
+  for (const { ext: _ext, ...rule } of rules.filter((r) => r.target === target)) {
+    JSON.stringify(rule, (_k, v) => {
+      const data = typeof v === "object" && v !== null && !Array.isArray(v) ? v.data : null;
+      if (typeof data === "string" && Object.keys(v).length === 1) {
+        out.add(data);
+      }
+      return v;
+    });
+  }
+  return out;
+}
+function tagDtype(col) {
+  let kind = null;
+  for (const v of col) {
+    if (v === null) {
+      continue;
+    }
+    if (kind === null) {
+      kind = typeof v;
+    } else if (kind !== typeof v) {
+      return "string";
+    }
+  }
+  if (kind === "number") {
+    return "f64";
+  }
+  return kind === "boolean" ? "bool" : "string";
+}
+const PORT_LABEL_DISTANCE = 10;
+const PORT_LABEL_ANGLE = -25;
+const DEFAULT_SIZE = { w: 0.75, h: 0.5 };
+function readLabelPlaces(snapshot, cx, e, get, put) {
+  const s = snapshot.edgeSource(e);
+  const t = snapshot.edgeTarget(e);
+  const [source, target] = [cx.center(s), cx.center(t)];
+  if (source === null || target === null || s === t) {
+    return;
+  }
+  const route = edgeRoute(source, target, get("pos"));
+  const lp = route.start === null ? null : point(get("lp"));
+  if (lp !== null && get("label") !== null) {
+    const mid = routeMiddle(route.points);
+    put("labelOffsetX", num6(lp[0] - mid[0]));
+    put("labelOffsetY", num6(mid[1] - lp[1]));
+  }
+  readEndLabel(cx, route, { node: t, at: target, other: source }, "head", get, put);
+  readEndLabel(cx, route, { node: s, at: source, other: target }, "tail", get, put);
+}
+function readEndLabel(cx, route, end, which, get, put) {
+  if (get(`${which}label`) === null) {
+    return;
+  }
+  const head = which === "head";
+  const tip = (head ? route.end : route.start) ?? boundary(cx, end.node, end.at, end.other);
+  const back = head ? route.points.slice(0, -1).reverse() : route.points.slice(1);
+  const toward = back.find((p) => Math.hypot(p[0] - tip[0], p[1] - tip[1]) > 1e-6) ?? end.other;
+  const stored = route.start === null ? null : point(get(`${which}_lp`));
+  const at = stored ?? portLabel(get, tip, toward);
+  if (at !== null) {
+    const prefix = head ? "target" : "source";
+    put(`${prefix}LabelOffset`, 0);
+    put(`${prefix}LabelOffsetX`, num6(at[0] - tip[0]));
+    put(`${prefix}LabelOffsetY`, num6(tip[1] - at[1]));
+  }
+}
+function portLabel(get, tip, toward) {
+  const turn = finite(get("labelangle"), PORT_LABEL_ANGLE, -180);
+  const distance = finite(get("labeldistance"), 1, 0);
+  if (turn === PORT_LABEL_ANGLE && distance === 1) {
+    return null;
+  }
+  const angle = Math.atan2(toward[1] - tip[1], toward[0] - tip[0]) + turn * Math.PI / 180;
+  const dist = PORT_LABEL_DISTANCE * distance;
+  return [tip[0] + dist * Math.cos(angle), tip[1] + dist * Math.sin(angle)];
+}
+function finite(raw, fallback, low) {
+  const v = raw === null || raw.trim() === "" ? Number.NaN : Number(raw);
+  return Number.isFinite(v) ? Math.max(low, v) : fallback;
+}
+function point(raw) {
+  const parts = (raw ?? "").replace(/!$/, "").split(",").map(Number);
+  return parts.length >= 2 && Number.isFinite(parts[0]) && Number.isFinite(parts[1]) ? [parts[0], parts[1]] : null;
+}
+function edgeRoute(source, target, pos) {
+  const tokens = (pos ?? "").split(";")[0].trim().split(/\s+/).filter(Boolean);
+  const marked = (flag) => {
+    const token = tokens.find((x) => x.startsWith(`${flag},`));
+    return token === void 0 ? null : point(token.slice(2));
+  };
+  const controls = tokens.filter((x) => !/^[es],/.test(x)).map((x) => point(x));
+  const flat = controls.every((p) => p !== null) && controls.length >= 4 ? flattenCubic(controls) : null;
+  if (flat === null) {
+    return { points: [source, target], start: null, end: null };
+  }
+  return {
+    points: [source, ...flat, target],
+    start: marked("s") ?? flat[0],
+    end: marked("e") ?? flat.at(-1) ?? null
+  };
+}
+function routeMiddle(points) {
+  const lengths = points.slice(1).map((p, i) => Math.hypot(p[0] - points[i][0], p[1] - points[i][1]));
+  let left = lengths.reduce((a, b) => a + b, 0) / 2;
+  for (let i = 0; i < lengths.length; i++) {
+    if (left <= lengths[i] && lengths[i] > 0) {
+      const f = left / lengths[i];
+      return [
+        points[i][0] + f * (points[i + 1][0] - points[i][0]),
+        points[i][1] + f * (points[i + 1][1] - points[i][1])
+      ];
+    }
+    left -= lengths[i];
+  }
+  return points[0];
+}
+function boundary(cx, n, center, toward) {
+  const inch = (name, fallback) => {
+    const v = Number(cx.node(n, name) ?? Number.NaN);
+    return (Number.isFinite(v) && v >= 0 ? v : fallback) * 72;
+  };
+  const [rx, ry] = [inch("width", DEFAULT_SIZE.w) / 2, inch("height", DEFAULT_SIZE.h) / 2];
+  const [dx, dy] = [toward[0] - center[0], toward[1] - center[1]];
+  const len = Math.hypot(dx, dy);
+  if (len === 0 || rx === 0 || ry === 0) {
+    return center;
+  }
+  const r = 1 / Math.hypot(dx / len / rx, dy / len / ry);
+  return [center[0] + dx / len * r, center[1] + dy / len * r];
+}
+const PAD = { x: 16, y: 8 };
+const LINE_SPACING$1 = 1.2;
+const DEJAVU_SANS = [
+  651,
+  821,
+  942,
+  1716,
+  1303,
+  1946,
+  1597,
+  563,
+  799,
+  799,
+  1024,
+  1716,
+  651,
+  739,
+  651,
+  690,
+  1303,
+  1303,
+  1303,
+  1303,
+  1303,
+  1303,
+  1303,
+  1303,
+  1303,
+  1303,
+  690,
+  690,
+  1716,
+  1716,
+  1716,
+  1087,
+  2048,
+  1401,
+  1405,
+  1430,
+  1577,
+  1294,
+  1178,
+  1587,
+  1540,
+  604,
+  604,
+  1343,
+  1141,
+  1767,
+  1532,
+  1612,
+  1235,
+  1612,
+  1423,
+  1300,
+  1251,
+  1499,
+  1401,
+  2025,
+  1403,
+  1251,
+  1403,
+  799,
+  690,
+  799,
+  1716,
+  1024,
+  1024,
+  1255,
+  1300,
+  1126,
+  1300,
+  1260,
+  721,
+  1300,
+  1298,
+  569,
+  569,
+  1186,
+  569,
+  1995,
+  1298,
+  1253,
+  1300,
+  1300,
+  842,
+  1067,
+  803,
+  1298,
+  1212,
+  1675,
+  1212,
+  1212,
+  1075,
+  1303,
+  690,
+  1303,
+  1716
+];
+function textWidth(text, size) {
+  let units = 0;
+  for (const ch of text) {
+    const code = ch.codePointAt(0) ?? 0;
+    units += code >= 32 && code <= 126 ? DEJAVU_SANS[code - 32] : 1229;
+  }
+  return units / 2048 * size;
+}
+function splitLines(text) {
+  const lines = [];
+  let line = "";
+  let i = 0;
+  while (i < text.length) {
+    const c = text[i];
+    const next = text[i + 1];
+    if (c === "\\" && (next === "n" || next === "l" || next === "r")) {
+      lines.push({ text: line, justify: next === "n" ? "c" : next });
+      line = "";
+      i += 2;
+    } else if (c === "\\" && next !== void 0) {
+      line += c + next;
+      i += 2;
+    } else {
+      line += c;
+      i++;
+    }
+  }
+  if (line !== "" || lines.length === 0) {
+    lines.push({ text: line, justify: "c" });
+  }
+  return lines;
+}
+function parseRecord(label, lr) {
+  return parseFields(label, { i: 0 }, lr, true);
+}
+function parentField(children, across) {
+  return { lines: null, port: null, children, lr: across, w: 0, h: 0, x: 0, y: 0 };
+}
+function parseFields(label, cursor, across, top) {
+  const children = [];
+  const pending = { text: "", port: null, sub: null };
+  while (cursor.i < label.length) {
+    const c = label[cursor.i];
+    if (c === "{") {
+      cursor.i++;
+      pending.sub = parseFields(label, cursor, !across, false);
+    } else if (c === "}") {
+      cursor.i++;
+      if (!top) {
+        flushField(children, pending, across);
+        return parentField(children, across);
+      }
+    } else if (c === "|") {
+      cursor.i++;
+      flushField(children, pending, across);
+    } else {
+      readFieldText(label, cursor, pending);
+    }
+  }
+  flushField(children, pending, across);
+  return parentField(children, across);
+}
+function readFieldText(label, cursor, pending) {
+  const c = label[cursor.i];
+  const next = label.at(cursor.i + 1);
+  if (c === "\\" && next !== void 0) {
+    pending.text += "{}|<> ".includes(next) ? next : c + next;
+    cursor.i += 2;
+  } else if (c === "<") {
+    const close = label.indexOf(">", cursor.i + 1);
+    const end = close < 0 ? label.length : close;
+    pending.port = label.slice(cursor.i + 1, end).trim();
+    cursor.i = close < 0 ? label.length : close + 1;
+  } else {
+    pending.text += c;
+    cursor.i++;
+  }
+}
+function flushField(children, pending, across) {
+  const { sub, port } = pending;
+  children.push(
+    sub ?? { lines: splitLines(pending.text.trim()), port, children: [], lr: !across, w: 0, h: 0, x: 0, y: 0 }
+  );
+  if (sub !== null && port !== null) {
+    sub.port = port;
+  }
+  pending.text = "";
+  pending.port = null;
+  pending.sub = null;
+}
+function sizeField(f, size) {
+  if (f.lines !== null) {
+    const w = Math.max(...f.lines.map((l) => textWidth(l.text, size)));
+    const h = f.lines.length * size * LINE_SPACING$1;
+    [f.w, f.h] = w > 0 || h > 0 ? [w + PAD.x, h + PAD.y] : [0, 0];
+    return;
+  }
+  f.w = 0;
+  f.h = 0;
+  for (const c of f.children) {
+    sizeField(c, size);
+    f.w = f.lr ? f.w + c.w : Math.max(f.w, c.w);
+    f.h = f.lr ? Math.max(f.h, c.h) : f.h + c.h;
+  }
+}
+function resizeField(f, w, h) {
+  const inc = (f.lr ? w - f.w : h - f.h) / Math.max(1, f.children.length);
+  f.w = w;
+  f.h = h;
+  f.children.forEach((c, k) => {
+    const amt = Math.trunc((k + 1) * inc) - Math.trunc(k * inc);
+    resizeField(c, f.lr ? c.w + amt : w, f.lr ? h : c.h + amt);
+  });
+}
+function placeField(f, x, y) {
+  f.x = x;
+  f.y = y;
+  let at = f.lr ? x : y;
+  for (const c of f.children) {
+    placeField(c, f.lr ? at : x, f.lr ? y : at);
+    at += f.lr ? c.w : -c.h;
+  }
+}
+function layoutRecord(label, lr, width, height, fixed, fontSize, text) {
+  const root = parseRecord(label, lr);
+  const leaves = (f) => {
+    if (f.lines !== null) {
+      f.lines = f.lines.map((l) => ({ ...l, text: text(l.text) }));
+    }
+    f.children.forEach(leaves);
+  };
+  leaves(root);
+  sizeField(root, fontSize);
+  const w = fixed ? width : Math.max(width, root.w);
+  const h = fixed ? height : Math.max(height, root.h);
+  resizeField(root, w, h);
+  placeField(root, -w / 2, h / 2);
+  const dividers = [];
+  const texts = [];
+  const ports = /* @__PURE__ */ new Map();
+  const lineHeight = fontSize * LINE_SPACING$1;
+  const visit = (f) => {
+    if (f.port !== null && f.port !== "") {
+      ports.set(f.port, { x: f.x + f.w / 2, y: f.y - f.h / 2, hw: f.w / 2, hh: f.h / 2 });
+    }
+    f.children.forEach((c, k) => {
+      if (k > 0) {
+        dividers.push(f.lr ? [c.x, c.y, c.x, c.y - c.h] : [c.x, c.y, c.x + c.w, c.y]);
+      }
+      visit(c);
+    });
+    if (f.lines === null) {
+      return;
+    }
+    const n = f.lines.length;
+    f.lines.forEach((l, k) => {
+      if (l.text === "") {
+        return;
+      }
+      const half = textWidth(l.text, fontSize) / 2;
+      let x = f.x + f.w / 2;
+      if (l.justify === "l") {
+        x = f.x + PAD.x / 2 + half;
+      } else if (l.justify === "r") {
+        x = f.x + f.w - PAD.x / 2 - half;
+      }
+      texts.push({ x, y: f.y - f.h / 2 + ((n - 1) / 2 - k) * lineHeight, text: l.text });
+    });
+  };
+  visit(root);
+  return { width: w, height: h, dividers, texts, ports };
+}
+const DOT_STYLE_CAPABILITIES = Object.freeze({
+  tool: "graphviz",
+  node: Object.freeze([
+    "fill",
+    "fillOpacity",
+    "borderColor",
+    "borderWidth",
+    "borderStyle",
+    "shape",
+    "width",
+    "height",
+    "label",
+    "labelColor",
+    "labelSize",
+    "labelFont",
+    "labelWeight",
+    "labelItalic",
+    "labelPosition",
+    "shapePoints",
+    "shapePointsStretch",
+    "shapeParts",
+    "shapeLines",
+    "shapeLineWidth",
+    "tooltip",
+    "visible"
+  ]),
+  edge: Object.freeze([
+    "color",
+    "opacity",
+    "width",
+    "lineStyle",
+    "sourceArrow",
+    "targetArrow",
+    "sourceArrowColor",
+    "targetArrowColor",
+    "arrowSize",
+    "label",
+    "sourceLabel",
+    "targetLabel",
+    "labelColor",
+    "labelSize",
+    "labelFont",
+    "labelWeight",
+    "labelItalic",
+    "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",
+  "sides",
+  "distortion",
+  "skew",
+  "orientation",
+  "penwidth",
+  "gradientangle",
+  "fontname",
+  "fontsize",
+  "fontcolor",
+  "tooltip"
+];
+const EDGE_ATTRIBUTES = [
+  "colorscheme",
+  "color",
+  "style",
+  "penwidth",
+  "fontname",
+  "fontsize",
+  "fontcolor",
+  "tooltip",
+  "edgetooltip",
+  "arrowhead",
+  "arrowtail",
+  "dir",
+  "arrowsize",
+  "fillcolor",
+  "headlabel",
+  "taillabel",
+  "xlabel"
+];
+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 = /* @__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(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.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 readLabelAlign(raw, names, html, record, put) {
+  if (isHtmlString(raw) || html.has(`<${raw}>`)) {
+    const aligns = new Set(
+      [...raw.matchAll(/<br\b([^>]*)>/gi)].map(
+        (m) => /\balign\s*=\s*["']?(left|right|center)/i.exec(m[1])?.[1].toLowerCase() ?? "center"
+      )
+    );
+    const body = isHtmlString(raw) ? raw.slice(1, -1) : raw;
+    const last = /<br\b[^>]*>(?![\s\S]*<br\b)/i.exec(body);
+    const tail = last === null ? "" : body.slice(last.index + last[0].length);
+    if (stripTags(tail).trim() !== "") {
+      aligns.add("center");
+    }
+    const [only] = aligns;
+    if (aligns.size === 1 && only !== "center") {
+      put("labelTextAlign", only);
+    }
+    return;
+  }
+  if (record) {
+    return;
+  }
+  const align = dotLabelAlign(raw, names);
+  if (align !== null) {
+    put("labelTextAlign", align);
+  }
+}
+function stripTags(text) {
+  let out = "";
+  let i = 0;
+  while (i < text.length) {
+    const open = text.indexOf("<", i);
+    const close = open < 0 ? -1 : text.indexOf(">", open + 1);
+    if (close < 0) {
+      return out + text.slice(i);
+    }
+    out += text.slice(i, open);
+    i = close + 1;
+  }
+  return out;
+}
+function readHtmlRuns(raw, html, scheme, put, at) {
+  if (!isHtmlString(raw) && !html.has(`<${raw}>`)) {
+    return;
+  }
+  const markup = isHtmlString(raw) ? raw : `<${raw}>`;
+  const runs = [];
+  for (const span of htmlLabelSpans(markup)) {
+    const run = { text: span.text, ...htmlRunFont(span.tags, scheme, at("labelRuns")) };
+    const last = runs.at(-1);
+    if (last !== void 0 && JSON.stringify({ ...last, text: "" }) === JSON.stringify({ ...run, text: "" })) {
+      last.text = `${String(last.text)}${run.text}`;
+    } else {
+      runs.push(run);
+    }
+  }
+  trimBlankRuns(runs);
+  if (runs.every((r) => Object.keys(r).length === 1)) {
+    return;
+  }
+  if (runs.length === 1) {
+    const { text: _text, ...font } = runs[0];
+    for (const [property, value] of Object.entries(font)) {
+      put(RUN_PROPERTY[property], value);
+    }
+    return;
+  }
+  runs[0].text = String(runs[0].text).trimStart();
+  const end = runs.at(-1);
+  if (end !== void 0) {
+    end.text = String(end.text).trimEnd();
+  }
+  put("labelRuns", JSON.stringify(runs));
+}
+function trimBlankRuns(runs) {
+  while (runs.length > 0 && String(runs[0].text).trim() === "") {
+    runs.shift();
+  }
+  while (runs.length > 0 && String(runs.at(-1)?.text).trim() === "") {
+    runs.pop();
+  }
+}
+const RUN_PROPERTY = {
+  weight: "labelWeight",
+  italic: "labelItalic",
+  font: "labelFont",
+  size: "labelSize",
+  color: "labelColor"
+};
+function htmlRunFont(tags, scheme, site) {
+  const out = {};
+  for (const tag of tags) {
+    const name = /^<(\w+)/.exec(tag)?.[1].toLowerCase();
+    if (name === "b") {
+      out.weight = "bold";
+    } else if (name === "i") {
+      out.italic = true;
+    } else if (name === "font") {
+      for (const [attr, value] of tagAttributes(tag)) {
+        readFontAttribute(attr.toLowerCase(), value, scheme, site, out);
+      }
+    }
+  }
+  return out;
+}
+function readFontAttribute(attr, value, scheme, site, out) {
+  if (attr === "face" && value.trim() !== "" && value.length <= MAX_STYLE_VALUE_LENGTH) {
+    const drawn = graphvizFont(value);
+    out.font = drawn.family;
+    if (drawn.bold) {
+      out.weight = "bold";
+    }
+    if (drawn.italic) {
+      out.italic = true;
+    }
+  } else if (attr === "point-size" && Number(value) > 0) {
+    out.size = Number(value);
+  } else if (attr === "color") {
+    const c = canonColor(value, "graphviz", site, { scheme, use: "text" });
+    if (c !== null) {
+      out.color = c.color;
+    }
+  }
+}
+const ATTRIBUTE_NAME_CHAR = /^[\w-]$/;
+function tagAttributes(tag) {
+  const attributes = [];
+  let i = 0;
+  while (i < tag.length) {
+    if (!ATTRIBUTE_NAME_CHAR.test(tag[i])) {
+      i++;
+      continue;
+    }
+    let end = i;
+    while (end < tag.length && ATTRIBUTE_NAME_CHAR.test(tag[end])) {
+      end++;
+    }
+    const value = quotedValueAt(tag, end);
+    if (value !== null) {
+      attributes.push([tag.slice(i, end), value.text]);
+    }
+    i = value === null ? end : value.next;
+  }
+  return attributes;
+}
+function quotedValueAt(tag, at) {
+  let i = at;
+  while (i < tag.length && /\s/.test(tag[i])) {
+    i++;
+  }
+  if (tag[i] !== "=") {
+    return null;
+  }
+  i++;
+  while (i < tag.length && /\s/.test(tag[i])) {
+    i++;
+  }
+  const quote = tag[i];
+  const close = quote === '"' || quote === "'" ? tag.indexOf(quote, i + 1) : -1;
+  return close < 0 ? null : { text: tag.slice(i + 1, close), next: close + 1 };
+}
+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 (property === "borderColor") {
+    put("borderOpacity", c.alpha > 0 && c.alpha < 1 ? c.alpha : null);
+  } else if (opacity !== null) {
+    put(opacity, c.alpha);
+  } else {
+    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") || tokens.includes("invisible")) {
+    put("visible", false);
+  }
+  const putFont = (property, value) => {
+    put(property, property === "labelOpacity" && value === 1 ? null : value);
+  };
+  readColor(nonEmpty(get("fontcolor")), scheme, "text", "labelColor", "labelOpacity", putFont, 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) {
+    const drawn = graphvizFont(font);
+    put("labelFont", drawn.family);
+    put("labelWeight", drawn.bold ? "bold" : null);
+    put("labelItalic", drawn.italic ? true : null);
+  }
+  const tip = get("tooltip") ?? get("edgetooltip");
+  if (tip !== null) {
+    put("tooltip", dotLabelText(tip, names, at("tooltip")));
+  }
+}
+function readNodeLabelAndSize(n, names) {
+  const { get, cx, put, at, shape } = n;
+  const label = n.point ? null : get(LABEL_ATTRIBUTE);
+  const shown = label === null ? cx.name : labelText(label, names, cx.html, RECORD.has(shape), at("label"));
+  readNodeLabel(n, label, shown, names);
+  const htmlLabel = label !== null && (isHtmlString(label) || cx.html.has(`<${label}>`));
+  if (shape === "plain" && shown === "" && !htmlLabel) {
+    put("visible", false);
+  }
+  if (cx.cluster) {
+    readClusterBox(get, put);
+  } else {
+    readNodeSize(n, label, shown, htmlLabel, names);
+  }
+}
+function readNodeLabel(n, label, shown, names) {
+  const { get, cx, put, at, shape } = n;
+  if (label !== null && !(cx.cluster && label === "")) {
+    put("label", shown);
+    readLabelAlign(label, names, cx.html, RECORD.has(shape), put);
+    readHtmlRuns(label, cx.html, n.scheme, put, at);
+    if (cx.cluster) {
+      put("labelPosition", clusterLabelPosition(get));
+      readClusterLabelPlace(get, put);
+    }
+  }
+  if (!cx.cluster && !n.point) {
+    const position = nodeLabelPosition(get);
+    put("labelPosition", position === "center" ? null : position);
+  }
+}
+function readNodeSize(n, label, shown, htmlLabel, names) {
+  const { get, put, at, shape } = n;
+  readSize(get, shape, n.point, put, at);
+  if (RECORD.has(shape) && label !== null && !htmlLabel) {
+    readRecord(n, label, names);
+  } else if (!n.point) {
+    readLabelFit(get, shape, label, shown, put);
+    readQuantum(n, label);
+  }
+}
+const DEFAULT_NODE_SIZE = { w: 54, h: 36 };
+function readRecord(n, label, names) {
+  const { get, put, at, cx } = n;
+  const pt = (attr, fallback) => {
+    const v = inches(get(attr), at(attr === "width" ? "width" : "height"));
+    return v === null ? fallback : v * DOT_POINTS_PER_INCH;
+  };
+  const size = Number(get("fontsize") ?? 14);
+  const lay = layoutRecord(
+    label,
+    !cx.flip,
+    pt("width", DEFAULT_NODE_SIZE.w),
+    pt("height", DEFAULT_NODE_SIZE.h),
+    isTrue(get("fixedsize")),
+    Number.isFinite(size) && size > 0 ? size : 14,
+    (line) => dotLabelText(line, names)
+  );
+  const hw = lay.width / 2;
+  const hh = lay.height / 2;
+  const fx = (x) => String(num6(hw > 0 ? x / hw : 0));
+  const fy = (y) => String(num6(hh > 0 ? y / hh : 0));
+  put("width", num6(lay.width));
+  put("height", num6(lay.height));
+  put("label", "");
+  put(
+    "shapeLines",
+    lay.dividers.length === 0 ? null : lay.dividers.map(([x0, y0, x1, y1]) => `${fx(x0)},${fy(y0)} ${fx(x1)},${fy(y1)}`).join("; ")
+  );
+  put(
+    "shapeTexts",
+    lay.texts.length === 0 ? null : JSON.stringify(lay.texts.map((t) => [Number(fx(t.x)), Number(fy(t.y)), t.text]))
+  );
+}
+function readClusterBox(get, put) {
+  const parts = (get("bb") ?? "").split(",").map(Number);
+  if (parts.length === 4 && parts.every(Number.isFinite) && parts[2] >= parts[0] && parts[3] >= parts[1]) {
+    put("width", num6(parts[2] - parts[0]));
+    put("height", num6(parts[3] - parts[1]));
+  }
+}
+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);
+  }
+  readNodeBands(n);
+  readNodeOutline(n);
+  readNodeShape(n);
+  readNodeLabelAndSize(n, names);
+  if (nonEmpty(get("xlabel")) !== null) {
+    noteAt(at("label"), STYLE_ISSUE.NOT_CARRIED, "xlabel");
+  }
+}
+function nodeLabelPosition(get) {
+  const loc = (get("labelloc") ?? "").trim().toLowerCase();
+  if (loc.startsWith("t")) {
+    return "inside-top";
+  }
+  return loc.startsWith("b") ? "inside-bottom" : "center";
+}
+const CLUSTER_LABEL_INSET = 8;
+function readClusterLabelPlace(get, put) {
+  const lp = (get("lp") ?? "").split(",").map(Number);
+  const bb = (get("bb") ?? "").split(",").map(Number);
+  if (lp.length === 2 && bb.length === 4 && [...lp, ...bb].every(Number.isFinite)) {
+    put("labelPosition", "center");
+    put("labelOffsetX", num6(lp[0] - (bb[0] + bb[2]) / 2));
+    put("labelOffsetY", num6((bb[1] + bb[3]) / 2 - lp[1]));
+    return;
+  }
+  const just = (get("labeljust") ?? "").trim().toLowerCase();
+  if (just.startsWith("l")) {
+    put("labelOffsetX", CLUSTER_LABEL_INSET);
+  } else if (just.startsWith("r")) {
+    put("labelOffsetX", -CLUSTER_LABEL_INSET);
+  }
+}
+function clusterLabelPosition(get) {
+  const loc = (get("labelloc") ?? "").trim().toLowerCase().startsWith("b") ? "inside-bottom" : "inside-top";
+  const just = (get("labeljust") ?? "").trim().toLowerCase();
+  if (just.startsWith("l")) {
+    return `${loc}-left`;
+  }
+  return just.startsWith("r") ? `${loc}-right` : loc;
+}
+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);
+  if (!tokens.includes("striped")) {
+    readFillGradient(n, raw);
+  }
+}
+function readFillGradient(n, raw) {
+  const colon = raw === null ? -1 : raw.indexOf(":");
+  if (raw === null || colon < 0) {
+    return;
+  }
+  const radial = n.tokens.includes("radial");
+  if (radial) {
+    n.put("fillGradientKind", "radial");
+  }
+  const frac = Number(raw.slice(0, colon).split(";")[1]);
+  if (frac > 0 && frac < 1) {
+    n.put("fillGradientStops", `${String(num6(frac - 1e-3))} ${String(num6(frac))}`);
+  }
+  const second = raw.slice(colon + 1).split(":")[0].split(";")[0];
+  const c = canonColor(second === "" ? "black" : second, "graphviz", n.at("fillGradient"), {
+    scheme: n.scheme,
+    use: "fill"
+  });
+  if (c === null) {
+    return;
+  }
+  n.put("fillGradient", c.color);
+  if (radial) {
+    return;
+  }
+  const angle = Number(nonEmpty(n.get("gradientangle")) ?? "0");
+  const turned = Number.isFinite(angle) ? (-angle % 360 + 360) % 360 : 0;
+  n.put("fillGradientAngle", num6(turned) + 0);
+}
+function readNodeFill(n) {
+  const { point: point2 } = n;
+  const fillcolor = nonEmpty(n.get("fillcolor"));
+  if (isFilled(n)) {
+    const raw = fillcolor ?? n.color ?? (point2 ? "black" : "lightgrey");
+    readColor(raw, n.scheme, "fill", "fill", "fillOpacity", n.put, n.at);
+    const banded = n.tokens.includes("striped") && BOX_LIKE.has(n.shape) || n.tokens.includes("wedged") && ELLIPSE_LIKE.has(n.shape);
+    if ((n.tokens.includes("filled") || n.tokens.includes("radial")) && !banded) {
+      readFillGradient(n, raw);
+    }
+  } else if (fillcolor !== null) {
+    noteAt(n.at("fill"), STYLE_ISSUE.UNFILLED, fillcolor.slice(0, MAX_STYLE_VALUE_LENGTH));
+  }
+}
+function readNodeBands(n) {
+  const striped = n.tokens.includes("striped") && (n.cx.cluster || BOX_LIKE.has(n.shape));
+  const wedged = !n.cx.cluster && n.tokens.includes("wedged") && ELLIPSE_LIKE.has(n.shape);
+  const list = nonEmpty(n.get("fillcolor")) ?? n.color;
+  if (!striped && !wedged || !list?.includes(":")) {
+    return;
+  }
+  const bands = colorBands(list, n.scheme, "fill", n.at(striped ? "stripeColors" : "pieColors"));
+  if (bands.length === 0) {
+    return;
+  }
+  const order = striped ? bands : [...bands].reverse();
+  const prefix = striped ? "stripe" : "pie";
+  n.put(`${prefix}Colors`, order.map((b) => b.color).join(" "));
+  n.put(`${prefix}Sizes`, order.map((b) => String(b.size)).join(" "));
+  if (striped) {
+    n.put("stripeDirection", "right");
+  } else {
+    n.put("pieFitBox", true);
+    n.put("pieRotation", 90);
+  }
+}
+function colorBands(list, scheme, use, site) {
+  const parts = list.split(":").map((part) => {
+    const [color, fraction] = part.split(";");
+    const c = canonColor(color.trim(), "graphviz", site, { scheme, use });
+    const f = fraction === void 0 ? Number.NaN : Number(fraction);
+    return { color: c?.color ?? null, fraction: Number.isFinite(f) && f >= 0 ? f : null };
+  });
+  const kept = parts.flatMap((p) => p.color === null ? [] : [{ color: p.color, fraction: p.fraction }]);
+  const given = kept.reduce((sum, p) => sum + (p.fraction ?? 0), 0);
+  const unsized = kept.filter((p) => p.fraction === null).length;
+  const share = unsized > 0 ? Math.max(0, 1 - given) / unsized : 0;
+  let used = 0;
+  const bands = kept.flatMap((p) => {
+    const size = Math.min(p.fraction ?? share, 1 - used);
+    used += Math.max(size, 0);
+    return size > 0 ? [{ color: p.color, size: num6(size) }] : [];
+  });
+  const last = bands.at(-1);
+  if (last !== void 0 && unsized === 0 && used < 1) {
+    last.size = num6(last.size + 1 - used);
+  }
+  return bands;
+}
+function isFilled(n) {
+  const { shape, point: point2 } = n;
+  return point2 || n.tokens.some(
+    (t) => t === "filled" || t === "radial" || t === "striped" && BOX_LIKE.has(shape) || t === "wedged" && ELLIPSE_LIKE.has(shape)
+  );
+}
+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 || Number(nonEmpty(get("peripheries")) ?? "1") === 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");
+  }
+  if (!cx.cluster) {
+    readNodeRings(n);
+  }
+}
+const SHAPE_PERIPHERIES = /* @__PURE__ */ new Map([
+  ["doublecircle", 2],
+  ["doubleoctagon", 2],
+  ["tripleoctagon", 3]
+]);
+const PERIPHERY_GAP = 4;
+function readNodeRings(n) {
+  const raw = nonEmpty(n.get("peripheries"));
+  const count = raw === null ? SHAPE_PERIPHERIES.get(n.shape) ?? 1 : Math.trunc(Number(raw));
+  if (Number.isNaN(count) || count <= 1 || NO_OUTLINE.has(n.shape)) {
+    return;
+  }
+  const c = n.color === null ? null : canonColor(n.color, "graphviz", n.at("outerBorderColor"), {
+    scheme: n.scheme,
+    use: "line"
+  });
+  if (c !== null && c.alpha === 0) {
+    return;
+  }
+  const widthRaw = nonEmpty(n.get("penwidth")) ?? setLineWidth(n.tokens);
+  const parsed = widthRaw === null ? Number.NaN : Number(widthRaw);
+  const unset = n.tokens.includes("bold") ? 2 : 1;
+  const pen = Number.isFinite(parsed) ? Math.max(0, parsed) : unset;
+  n.put("outerBorderColor", c?.color ?? "#000000");
+  n.put("outerBorderOpacity", c !== null && c.alpha < 1 ? c.alpha : null);
+  n.put("outerBorderWidth", num6(pen));
+  n.put("outerBorderOffset", num6(Math.max(0, PERIPHERY_GAP - pen)));
+  if (n.tokens.includes("dashed") || n.tokens.includes("dotted")) {
+    n.put("outerBorderStyle", n.tokens.includes("dashed") ? "dashed" : "dotted");
+  }
+  if (count > 2) {
+    noteAt(n.at("outerBorderWidth"), STYLE_ISSUE.NOT_CARRIED, `peripheries=${String(count)}`);
+  }
+}
+function readNodeShape(n) {
+  const rounded = n.tokens.includes("rounded") && !n.tokens.includes("striped");
+  const turned = turnedPolygon(n);
+  if (n.cx.cluster) {
+    n.put("shape", rounded ? "round-rectangle" : "rectangle");
+  } else if (n.shape === "polygon") {
+    readPolygon(n, rounded);
+  } else if (turned !== null) {
+    n.put("shape", "polygon");
+    n.put("shapePoints", cornersText(graphvizDrawnCorners(turned)));
+    n.put("shapePointsStretch", false);
+  } else if (NAMED_OUTLINES.has(n.shape)) {
+    n.put("shape", "polygon");
+    n.put("shapePoints", NAMED_OUTLINES.get(n.shape) ?? null);
+    n.put("shapePointsStretch", false);
+  } else if (GRAPHVIZ_GLYPH_SHAPES.has(n.shape)) {
+    const size = (name) => {
+      const v = inches(n.get(name), n.at(name));
+      return v === null ? null : v * DOT_POINTS_PER_INCH;
+    };
+    putGlyph(
+      n.shape,
+      size("width"),
+      size("height"),
+      n.put,
+      () => {
+        const raw = nonEmpty(n.get("penwidth")) ?? setLineWidth(n.tokens);
+        const pen = raw === null ? Number.NaN : Number(raw);
+        if (Number.isFinite(pen)) {
+          return Math.max(0, pen);
+        }
+        return n.tokens.includes("bold") ? 2 : 1;
+      },
+      () => n.color === null ? null : canonColor(n.color, "graphviz", n.at("outerBorderColor"), { scheme: n.scheme, use: "line" })?.color ?? null
+    );
+  } else if (n.shapeRaw !== null) {
+    const shape = rounded && BOX_LIKE.has(n.shape) ? "round-rectangle" : canonEnum("shape", n.shapeRaw, "graphviz", n.at("shape"));
+    n.put("shape", shape === "none" && isFilled(n) ? "rectangle" : shape);
+  }
+}
+const TURNABLE_POLYGONS = new Map([
+  ...[...BOX_LIKE].map((name) => [name, { sides: 4, orientation: 0 }]),
+  ["diamond", { sides: 4, orientation: 45 }],
+  ["hexagon", { sides: 6, orientation: 0 }],
+  ["octagon", { sides: 8, orientation: 0 }]
+]);
+function turnedPolygon(n) {
+  const turn = Number(nonEmpty(n.get("orientation")) ?? "0");
+  const own = TURNABLE_POLYGONS.get(n.shape) ?? GRAPHVIZ_POLYGON_SHAPES.get(n.shape);
+  if (own === void 0 || !Number.isFinite(turn) || turn % 360 === 0) {
+    return null;
+  }
+  const polygon = {
+    distortion: 0,
+    skew: 0,
+    ...own,
+    orientation: own.orientation + Math.max(-360, turn)
+  };
+  return isGraphvizBox(polygon) ? null : polygon;
+}
+function readPolygon(n, rounded) {
+  const number = (name, fallback, least) => {
+    const raw = nonEmpty(n.get(name));
+    const v = raw === null ? Number.NaN : Number(raw);
+    return Number.isFinite(v) ? Math.max(least, v) : fallback;
+  };
+  const polygon = {
+    sides: Math.trunc(number("sides", 4, 0)),
+    distortion: number("distortion", 0, -100),
+    skew: number("skew", 0, -100),
+    orientation: number("orientation", 0, -360)
+  };
+  if (isGraphvizBox(polygon)) {
+    n.put("shape", rounded ? "round-rectangle" : "rectangle");
+  } else if (polygon.sides < 3) {
+    n.put("shape", "ellipse");
+  } else {
+    n.put("shape", "polygon");
+    n.put("shapePoints", cornersText(graphvizDrawnCorners(polygon)));
+    n.put("shapePointsStretch", false);
+  }
+}
+function graphvizDrawnCorners(polygon) {
+  const corners = graphvizPolygonCorners(polygon);
+  const grow = (axis) => Math.max(1, 1 / Math.max(...corners.map((c) => Math.abs(c[axis]))));
+  const [gx, gy] = [grow(0), grow(1)];
+  return corners.map(([x, y]) => [x * gx, y * gy]);
+}
+function cornersText(corners) {
+  return corners.map(([x, y]) => `${num6(x)},${num6(y)}`).join(" ");
+}
+const NAMED_OUTLINES = new Map(
+  [...GRAPHVIZ_POLYGON_SHAPES].map(([name, polygon]) => [name, cornersText(graphvizDrawnCorners(polygon))])
+);
+function putGlyph(shape, width, height, put, pen, color) {
+  const text = glyphTexts(shape, width, height);
+  if (text === null) {
+    return;
+  }
+  put("shape", "polygon");
+  put("shapePoints", text.outline);
+  put("shapePointsStretch", false);
+  put("shapeParts", text.parts);
+  put("shapeLines", text.lines);
+  if (text.unstroked) {
+    put("shapeLineWidth", pen());
+    put("borderWidth", 0);
+  }
+  if (text.ring !== null) {
+    put("outerBorderColor", color() ?? "#000000");
+    put("outerBorderWidth", num6(pen()));
+    put("outerBorderOffset", num6(Math.max(0, text.ring - pen())));
+  }
+}
+function glyphTexts(shape, width, height) {
+  const glyph = graphvizGlyph(shape, width, height);
+  if (glyph === null) {
+    return null;
+  }
+  const half = (v, fallback) => (v !== null && v > 0 ? v : fallback) / 2;
+  const [W, H] = [half(width, 54), half(height, 36)];
+  const list = (points) => cornersText(points.map(([x, y]) => [x / W, y / H]));
+  const lists = (all) => all.length === 0 ? null : all.map(list).join("; ");
+  return {
+    outline: list(glyph.outline),
+    parts: lists(glyph.parts),
+    lines: lists(glyph.lines),
+    unstroked: glyph.unstroked === true,
+    ring: glyph.ring ?? null
+  };
+}
+function graphvizOutline(shape) {
+  return NAMED_OUTLINES.get(shape);
+}
+function graphvizHasNoOutline(shape) {
+  return NO_OUTLINE.has(shape);
+}
+const OUTLINE_NAMES = new Map([...NAMED_OUTLINES].map(([name, text]) => [text, name]));
+function glyphOf(get, width, height) {
+  const text = (property) => {
+    const v = get(property);
+    return typeof v === "string" ? v.trim() : null;
+  };
+  const outline = text("shapePoints");
+  if (outline === null) {
+    return void 0;
+  }
+  const corners = outline === "" ? 0 : outline.split(/\s+/).length;
+  for (const name of GRAPHVIZ_GLYPH_SHAPES) {
+    if (graphvizGlyph(name, width, height)?.outline.length !== corners) {
+      continue;
+    }
+    const g = glyphTexts(name, width, height);
+    if (g !== null && g.outline === outline && g.parts === text("shapeParts") && g.lines === text("shapeLines")) {
+      return { name, unstroked: g.unstroked };
+    }
+  }
+  return void 0;
+}
+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, point2, put, at) {
+  let w = inches(get("width"), at("width"));
+  let h = inches(get("height"), at("height"));
+  const same = point2 || CIRCLE_LIKE.has(shape) || isTrue(get("regular"));
+  if (shape === "plain") {
+    w = h = 0;
+  } else if (w === null && h === null) {
+    if (point2) {
+      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 (point2) {
+    ww = hh = Math.min(w ?? Infinity, h ?? Infinity);
+  } else if (same) {
+    ww = hh = Math.max(w ?? 0, h ?? 0);
+  }
+  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 readQuantum(n, label) {
+  const { get, put, shape } = n;
+  let scale = BOX_LIKE.has(shape) ? 1 : null;
+  if (ELLIPSE_LIKE.has(shape)) {
+    scale = Math.SQRT2;
+  }
+  const w = Number(get("width") ?? Number.NaN);
+  const h = Number(get("height") ?? Number.NaN);
+  if (n.cx.quantum === 0 || scale === null || label === "" || isTrue(get("fixedsize")) || !(w >= 0 && h >= 0)) {
+    return;
+  }
+  const least = n.cx.quantum * scale;
+  put("width", num6(Math.max(w * DOT_POINTS_PER_INCH, least)));
+  put("height", num6(Math.max(h * DOT_POINTS_PER_INCH, least)));
+}
+const LABEL_PAD = { x: 8, y: 4 };
+const LINE_SPACING = 1.2;
+function readLabelFit(get, shape, label, shown, put) {
+  if (isTrue(get("fixedsize")) || label === "" && !RECORD.has(shape)) {
+    return;
+  }
+  const lines = Math.max(1, shown.replace(/\n$/, "").split("\n").length);
+  const size = Number(get("fontsize") ?? 14);
+  const fontSize = Number.isFinite(size) && size > 0 ? size : 14;
+  const margin = (get("margin") ?? "").split(",").filter((text) => text.trim() !== "").map(Number).filter(isLength);
+  const pad = shape === "plain" ? { x: 0, y: 0 } : LABEL_PAD;
+  const padX = margin.length > 0 ? margin[0] * DOT_POINTS_PER_INCH : pad.x;
+  const padY = margin.length > 0 ? (margin[1] ?? margin[0]) * DOT_POINTS_PER_INCH : pad.y;
+  put("labelFit", GRAPHVIZ_DECORATED_BOXES.has(shape) ? "bounds" : "inside");
+  put("labelPaddingX", num6(padX));
+  put("labelPaddingY", num6(padY + (LINE_SPACING - 1) * fontSize * lines / 2));
+  if (CIRCLE_LIKE.has(shape) || isTrue(get("regular"))) {
+    put("labelFitSquare", true);
+  }
+}
+function isLength(value) {
+  return Number.isFinite(value) && value >= 0;
+}
+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);
+  readEdgeSegments(nonEmpty(get("color")), scheme, 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 = attribute === LABEL_ATTRIBUTE ? get(attribute) ?? nonEmpty(get("xlabel")) : get(attribute);
+    if (raw !== null) {
+      put(property, labelText(raw, cx.names, cx.html, false, at(property)));
+      if (property === "label") {
+        readLabelAlign(raw, cx.names, cx.html, false, put);
+        readHtmlRuns(raw, cx.html, scheme, put, at);
+      }
+    }
+  }
+  if (get(LABEL_ATTRIBUTE) !== null && nonEmpty(get("xlabel")) !== null) {
+    noteAt(at("label"), STYLE_ISSUE.NOT_CARRIED, "xlabel");
+  }
+}
+function readEdgeSegments(list, scheme, put, at) {
+  if (list === null || !list.includes(":") || !list.includes(";")) {
+    return;
+  }
+  const bands = colorBands(list, scheme, "edge", at("gradientColors"));
+  if (bands.length < 2) {
+    return;
+  }
+  const colors = [];
+  const stops = [];
+  let start = 0;
+  for (const band of bands) {
+    colors.push(band.color, band.color);
+    stops.push(num6(start), num6(Math.min(1, start + band.size)));
+    start += band.size;
+  }
+  put("gradientKind", "linear");
+  put("gradientColors", colors.join(" "));
+  put("gradientStops", stops.join(" "));
+}
+function labelPlaceContext(snapshot) {
+  const column = snapshot.nodes.byRole("position");
+  return {
+    center: (i) => {
+      const v = column?.isSet(i) === true ? column.value(i) : null;
+      return v === null ? null : [v[0], v[1]];
+    },
+    node: (i, name) => nonEmpty(cellText(snapshot.nodes, name, i))
+  };
+}
+function splineBends(snapshot, e, pos) {
+  if (pos === null) {
+    return null;
+  }
+  const column = snapshot.nodes.byRole("position");
+  const center = (i) => {
+    const v = column?.isSet(i) === true ? column.value(i) : null;
+    return v === null ? null : [v[0], v[1]];
+  };
+  const [source, target] = [center(snapshot.edgeSource(e)), center(snapshot.edgeTarget(e))];
+  if (source === null || target === null) {
+    return null;
+  }
+  const tip = (spline, flag) => {
+    const token = (spline ?? "").trim().split(/\s+/).find((t) => t.startsWith(`${flag},`));
+    const [x, y] = (token ?? "").slice(2).split(",").map(Number);
+    return token !== void 0 && Number.isFinite(x) && Number.isFinite(y) ? [x, y] : null;
+  };
+  const parts = pos.split(";");
+  const tips = { start: tip(parts[0], "s"), end: tip(parts.at(-1), "e") };
+  const splines = parts.map(
+    (spline) => spline.trim().split(/\s+/).filter((t) => !/^[es],/.test(t)).map((t) => {
+      const [x, y] = t.split(",").map(Number);
+      return [x, y];
+    })
+  );
+  return graphvizRouteBends(source, target, splines, tips);
+}
+const GRAPHVIZ_LOOP_STEP = { x: 18, y: 9 };
+function graphvizLoops(snapshot) {
+  const portless = (get) => nonEmpty(get("tailport")) === null && nonEmpty(get("headport")) === null && nonEmpty(get(POS_ATTRIBUTE)) === null;
+  const onNode = /* @__PURE__ */ new Map();
+  const splines = (nonEmpty(cellText(snapshot.graph, "splines", 0)) ?? "").toLowerCase();
+  const laid = splines !== "ortho" && splines !== "none" && nonEmpty(cellText(snapshot.graph, STYLE_BLOCK_NAME, 0)) === null;
+  for (let e = 0; e < snapshot.edgeCount && laid; e++) {
+    const n = snapshot.edgeSource(e);
+    if (n === snapshot.edgeTarget(e) && portless((name) => cellText(snapshot.edges, name, e))) {
+      onNode.set(n, [...onNode.get(n) ?? [], e]);
+    }
+  }
+  const inches2 = (n, name, fallback) => {
+    const v = Number(nonEmpty(cellText(snapshot.nodes, name, n)) ?? Number.NaN);
+    return (Number.isFinite(v) && v > 0 ? v : fallback) * DOT_POINTS_PER_INCH;
+  };
+  return {
+    bendsOf: (e, get) => {
+      const n = snapshot.edgeSource(e);
+      const list = onNode.get(n);
+      if (n !== snapshot.edgeTarget(e) || list === void 0 || !portless(get)) {
+        return null;
+      }
+      const [w, h] = [inches2(n, "width", 0.75), inches2(n, "height", 0.5)];
+      const k = list.indexOf(e) + 1;
+      const dx = w / 2 + GRAPHVIZ_LOOP_STEP.x * k;
+      const dy = GRAPHVIZ_LOOP_STEP.y * k / list.length;
+      const curve = flattenCubic([
+        [0, 0],
+        [dx / 3, dy],
+        [dx, dy],
+        [dx, 0],
+        [dx, -dy],
+        [dx / 3, -dy],
+        [0, 0]
+      ]);
+      return curve === null ? null : canonNodeOffsets([0, 0], [w, h], curve.slice(1, -1), false);
+    }
+  };
+}
+function graphvizRouteBends(source, target, splines, tips) {
+  const points = [];
+  for (const controls of splines) {
+    const flat = flattenCubic(controls);
+    if (flat === null || flat.some(([x, y]) => !Number.isFinite(x) || !Number.isFinite(y))) {
+      return null;
+    }
+    points.push(...flat);
+  }
+  const apart = (a, b) => b === void 0 || Math.hypot(a[0] - b[0], a[1] - b[1]) > 1e-6;
+  const start = tips?.start ?? null;
+  const end = tips?.end ?? null;
+  if (start !== null && apart(start, points[0])) {
+    points.unshift(start);
+  }
+  if (end !== null && apart(end, points.at(-1))) {
+    points.push(end);
+  }
+  const [dx, dy] = [target[0] - source[0], target[1] - source[1]];
+  const length = Math.hypot(dx, dy);
+  const off = Math.max(...points.map(([x, y]) => Math.abs((x - source[0]) * dy - (y - source[1]) * dx)));
+  return length > 0 && off / (length * length) > 1e-3 ? canonBends(source, target, points, false) : null;
+}
+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();
+    readEdgeArrow("target", head, dir === "forward" || dir === "both", put, at);
+    readEdgeArrow("source", tail, dir === "back" || dir === "both", put, at);
+  }
+  const size = get("arrowsize");
+  if (size !== null) {
+    put("arrowSize", canonNumber(size, at("arrowSize")));
+  }
+  const fill = nonEmpty(get("fillcolor"));
+  for (const property of ["targetArrowColor", "sourceArrowColor"]) {
+    readColor(fill, get("colorscheme"), "fill", property, null, put, at);
+  }
+}
+function readEdgeArrow(end, raw, on, put, at) {
+  const arrow = on ? graphvizArrowValue(raw ?? "normal", at(`${end}Arrow`)) : null;
+  put(`${end}Arrow`, arrow === null ? "none" : arrow.value);
+  if (arrow?.side !== null && arrow?.side !== void 0) {
+    put(`${end}ArrowSide`, arrow.side);
+  }
+}
+const ARROW_SIDES = ["left", "right"];
+const GRAPHVIZ_OPEN_ARROWS = /* @__PURE__ */ new Set(["normal", "diamond", "dot", "box", "inv"]);
+const GRAPHVIZ_OTHER_ARROWS = /* @__PURE__ */ new Map([
+  ["obox", "other:open-square"],
+  ["oinv", "other:open-inverted"]
+]);
+function graphvizArrowValue(raw, site) {
+  const first = graphvizArrow(raw);
+  const other = first === null ? void 0 : GRAPHVIZ_OTHER_ARROWS.get(first.name);
+  return {
+    value: other ?? canonEnum("arrow", first?.name ?? raw, "graphviz", site),
+    side: first?.side ?? null
+  };
+}
+function graphvizArrow(raw) {
+  let rest = raw.trim().toLowerCase();
+  if (rest === "invempty") {
+    rest = "oinv";
+  }
+  while (rest.length > 0) {
+    const m = /^([olr]{0,3})(normal|crow|tee|box|diamond|dot|none|inv|vee|icurve|curve)/.exec(rest);
+    if (m === null) {
+      return null;
+    }
+    rest = rest.slice(m[0].length);
+    const [, mods, shape] = m;
+    if (shape !== "none") {
+      const side = ARROW_SIDES.find((s) => mods.includes(s[0])) ?? null;
+      const open = mods.includes("o") && GRAPHVIZ_OPEN_ARROWS.has(shape) ? "o" : "";
+      return { name: open + shape, side };
+    }
+  }
+  return null;
+}
+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(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 rankdir = (cellText(snapshot.graph, "rankdir", 0) ?? "").trim().toUpperCase();
+  const flip = rankdir === "LR" || rankdir === "RL";
+  const q = Number(cellText(snapshot.graph, "quantum", 0) ?? Number.NaN);
+  const quantum = Number.isFinite(q) && q > 0 ? q * DOT_POINTS_PER_INCH : 0;
+  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, flip, quantum }),
+    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 graphBackground(snapshot, notes) {
+  const graph = {};
+  const bg = nonEmpty(cellText(snapshot.graph, "bgcolor", 0));
+  if (!snapshot.graph.has("bgcolor") || bg === null) {
+    return graph;
+  }
+  readColor(
+    bg,
+    cellText(snapshot.graph, "colorscheme", 0),
+    "fill",
+    "background",
+    null,
+    (p, v) => {
+      if (v !== null) {
+        graph[p] = v;
+      }
+    },
+    (property) => ({ notes, target: "graph", property })
+  );
+  return graph;
+}
+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(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);
+  const loops = graphvizLoops(snapshot);
+  const splines = cellText(snapshot.graph, "splines", 0)?.trim().toLowerCase();
+  const noEdges = splines === "" || splines === "none";
+  const places = labelPlaceContext(snapshot);
+  for (let e = 0; e < snapshot.edgeCount; e++) {
+    context.budget.spend("edge", EDGE_ATTRIBUTES.length);
+    const get = (name) => cellText(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
+    );
+    if (noEdges) {
+      edge.put(e, "visible", false);
+    }
+    const bends = splineBends(snapshot, e, get(POS_ATTRIBUTE)) ?? loops.bendsOf(e, get);
+    if (bends !== null) {
+      edge.put(e, "bends", bends);
+    }
+    readLabelPlaces(snapshot, places, e, get, (p, v) => {
+      edge.put(e, p, v);
+    });
+  }
+  const graph = graphBackground(snapshot, notes);
+  const blockText = cellText(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"],
+  ["inverted", "inv"],
+  ["other:open-square", "obox"],
+  ["other:open-inverted", "oinv"]
+]);
+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");
+  const font = t.labelFont?.value;
+  if (typeof font === "string") {
+    out.set("fontname", graphvizFontName(font, false, false));
+  }
+  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("&", "&amp;").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, approximate, 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");
+  const bold = get("labelWeight") === "bold";
+  const italic = get("labelItalic") === true;
+  if (typeof font === "string") {
+    const name = graphvizFontName(font, bold, italic);
+    out.set("fontname", name);
+    const drawn = graphvizFont(name);
+    if (drawn.bold !== bold) {
+      approximate("labelWeight", get("labelWeight") ?? "normal");
+    }
+    if (drawn.italic !== italic) {
+      approximate("labelItalic", italic);
+    }
+  } else if (bold || italic) {
+    approximate(bold ? "labelWeight" : "labelItalic", bold ? "bold" : true);
+  }
+  const tip = get("tooltip");
+  if (typeof tip === "string") {
+    out.set("tooltip", escapeLabel(tip));
+  }
+  if (get("visible") === false) {
+    tokens.push("invis");
+  }
+}
+function nodeAttributes(get, cx, raw, approximate, notes) {
+  const out = /* @__PURE__ */ new Map();
+  const tokens = [];
+  writeCommon(get, approximate, 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, "");
+  }
+  noteLabelPosition(get("labelPosition"), cx, raw, approximate);
+  if (tokens.length > 0) {
+    out.set("style", tokens.join(","));
+  }
+  return withoutDefaults(out, "node");
+}
+function noteLabelPosition(position, cx, raw, approximate) {
+  if (typeof position === "string" && position !== (cx.cluster ? clusterLabelPosition(raw) : nodeLabelPosition(raw))) {
+    approximate("labelPosition", position);
+  }
+}
+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 size = (name) => {
+    const v = get(name);
+    return typeof v === "number" ? v : null;
+  };
+  const glyph = shape === "polygon" ? glyphOf(get, size("width"), size("height")) : void 0;
+  if (glyph !== void 0) {
+    return writeGlyph(get, glyph, out);
+  }
+  approximateShapeLines(get, approximate);
+  const polygon = shape === "polygon" ? writePolygon(get("shapePoints"), approximate, out) : null;
+  if (polygon !== null) {
+    if (get("shapePointsStretch") !== false) {
+      approximate("shapePointsStretch", true);
+    }
+    return polygon;
+  }
+  const gvShape = spelled(SHAPES, shape, shape === "vee" ? "invtriangle" : "box", "shape", approximate);
+  out.set("shape", gvShape);
+  return gvShape;
+}
+function writeGlyph(get, glyph, out) {
+  out.set("shape", glyph.name);
+  const line = get("shapeLineWidth");
+  if (glyph.unstroked && typeof line === "number") {
+    out.set("penwidth", line);
+  }
+  return glyph.name;
+}
+function approximateShapeLines(get, approximate) {
+  for (const property of ["shapeParts", "shapeLines", "shapeLineWidth"]) {
+    const v = get(property);
+    if (v !== null && v !== void 0) {
+      approximate(property, v);
+    }
+  }
+}
+function writePolygon(points, approximate, out) {
+  if (typeof points !== "string") {
+    return null;
+  }
+  const named = OUTLINE_NAMES.get(points.trim());
+  if (named !== void 0) {
+    out.set("shape", named);
+    return named;
+  }
+  const sides = points.trim().split(/\s+/).length;
+  if (sides < 3) {
+    return null;
+  }
+  out.set("shape", "polygon");
+  out.set("sides", sides);
+  approximate("shapePoints", points);
+  return "polygon";
+}
+function writeNodeSize(get, out) {
+  const width = get("width");
+  const height = get("height");
+  if ((typeof width === "number" || typeof height === "number") && typeof get("labelFit") !== "string") {
+    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, approximate, 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 head = get("targetArrowColor");
+  const tail = get("sourceArrowColor");
+  const fill = head ?? tail;
+  if (typeof fill === "string") {
+    out.set("fillcolor", fill);
+    if (head !== null && tail !== null && head !== tail) {
+      approximate("sourceArrowColor", tail);
+    }
+  }
+  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" && get("targetArrowSide") === null : !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);
+  const arrow = (value, side, property) => {
+    if (value === "half") {
+      approximate(property, value);
+      approximate(`${property}Side`, value);
+      return "lnormal";
+    }
+    const name = spelled(ARROWS, value, "normal", property, approximate);
+    return side === "left" || side === "right" ? `${side[0]}${name}` : name;
+  };
+  if (head) {
+    out.set("arrowhead", arrow(target, get("targetArrowSide"), "targetArrow"));
+  }
+  if (tail) {
+    out.set("arrowtail", arrow(source, get("sourceArrowSide"), "sourceArrow"));
+  }
+}
+function exactFromBlock(snapshot, text, read, cx) {
+  const notes = new StyleNotes();
+  takeFromBlock(snapshot, text, "dot", (target) => ({
+    values: read[target],
+    properties: DOT_STYLE_CAPABILITIES[target],
+    writes: DOT_STYLE_CAPABILITIES[target],
+    readBack: (i, want) => {
+      const raw = (name) => cellText(target === "node" ? snapshot.nodes : snapshot.edges, name, i);
+      const back = writtenAndReadBack(target, i, want, { cx, raw }, notes);
+      return (property) => back.get(property) ?? null;
+    }
+  }));
+}
+function writtenAndReadBack(target, i, want, data, notes) {
+  const { cx, raw } = data;
+  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, raw, ignore, notes);
+    const kept = (name) => name === "labelloc" || name === "labeljust" ? raw(name) : null;
+    readNode((name) => attrs.has(name) ? textOf(attrs.get(name)) : kept(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" && background !== toolDefaults("graphviz")?.graph.background?.value) {
+    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 = elementValues((t, p) => input.picture(t, p), target, DOT_STYLE_CAPABILITIES[target]);
+  const columns = /* @__PURE__ */ new Map();
+  for (let i = 0; i < n; i++) {
+    const attrs = target === "node" ? nodeAttributes(
+      get(i),
+      w.cx.node(i),
+      (name) => cellText(snapshot.nodes, name, i),
+      w.approximate,
+      w.notes
+    ) : edgeAttributes(get(i), w.cx.edge(i).directed, w.approximate);
+    if (target === "edge" && snapshot.edgeSource(i) === snapshot.edgeTarget(i)) {
+      w.approximate("bends", "self-loop");
+    }
+    if (w.read.has(LABEL_ATTRIBUTE) && attrs.get(LABEL_ATTRIBUTE) === "" && get(i)("label") === null) {
+      w.approximate("label", "");
+    }
+    setColumnValues(columns, attrs, i, n);
+  }
+  if (target === "node") {
+    stopInheritance(snapshot, w.cx, columns, input.rules.styles.graph.background);
+  }
+  return columns;
+}
+function setColumnValues(columns, attrs, i, n) {
+  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;
+  }
+}
+const CLUSTER_UNSET = /* @__PURE__ */ new Map([
+  ["style", ""],
+  ["penwidth", 1],
+  ["color", ""],
+  ["pencolor", ""],
+  ["fillcolor", ""],
+  ["bgcolor", ""],
+  ["fontname", "Times-Roman"],
+  ["fontsize", 14],
+  ["fontcolor", "black"],
+  [LABEL_ATTRIBUTE, ""]
+]);
+function stopInheritance(snapshot, cx, columns, background) {
+  const clusters = Array.from({ length: snapshot.nodeCount }, (_, i) => i).filter((i) => cx.node(i).cluster);
+  for (const [name, unset] of CLUSTER_UNSET) {
+    const col = columns.get(name);
+    const enclosing = cellText(snapshot.graph, name, 0) !== null || name === "bgcolor" && typeof background === "string" || clusters.some((i) => (col?.[i] ?? null) !== null);
+    if (!enclosing) {
+      continue;
+    }
+    const filled = col ?? new Array(snapshot.nodeCount).fill(null);
+    for (const i of clusters) {
+      filled[i] ??= unset;
+    }
+    columns.set(name, filled);
+  }
+}
+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;
+}
+export {
+  CLUSTER_COLUMN as C,
+  DOT_STYLE_CAPABILITIES as D,
+  KEY_ATTRIBUTE as K,
+  LABEL_ATTRIBUTE as L,
+  POS_ATTRIBUTE as P,
+  SOURCE_PORT_COLUMN as S,
+  TARGET_PORT_COLUMN as T,
+  DOT_ATTRIBUTE_CLASH_CODE as a,
+  DOT_FORMAT as b,
+  DOT_META_KEY as c,
+  dotStyledExport as d,
+  PARENT_COLUMN as e,
+  dotStyles as f,
+  DOT_ORIGIN as g,
+  PIN_ATTRIBUTE as h,
+  isHtmlString as i,
+  POSITION_COLUMN as j,
+  dataRead$1 as k,
+  graphvizRouteBends as l,
+  graphvizHasNoOutline as m,
+  PERIPHERY_GAP as n,
+  SHAPE_PERIPHERIES as o,
+  graphvizOutline as p,
+  putGlyph as q,
+  graphvizArrowValue as r,
+  prepareStyleExport as s,
+  isKeptGraphtyProperty as t
+};
+//# sourceMappingURL=styles-Cm62yyQX.js.map