@poe-platform/safe-bash 0.1.806 → 0.1.807

package/dist/safe-bash-command-dot/index.js

@@ -0,0 +1,1298 @@
+import "../safe-bash/command-chunks/chunk-65DS4IOB.js";
+
+// packages/graphviz-ast/src/dot.ts
+var compass = /* @__PURE__ */ new Set(["n", "ne", "e", "se", "s", "sw", "w", "nw", "c", "_"]);
+var whitespace = (c) => c === " " || c === "\n" || c === "\r" || c === "	" || c === "\f";
+var digit = (c) => c >= "0" && c <= "9";
+var letter = (c) => c === "_" || c >= "a" && c <= "z" || c >= "A" && c <= "Z" || c.charCodeAt(0) >= 128;
+function tokenize(source) {
+  const tokens = [];
+  let i = 0;
+  const fail = (message) => {
+    throw new SyntaxError(`${message} at offset ${i}`);
+  };
+  while (i < source.length) {
+    const c = source[i];
+    if (whitespace(c)) {
+      i++;
+      continue;
+    }
+    if (c === "#" || source.startsWith("//", i)) {
+      while (i < source.length && source[i] !== "\n") i++;
+      continue;
+    }
+    if (source.startsWith("/*", i)) {
+      const end = source.indexOf("*/", i + 2);
+      if (end < 0) fail("Unterminated comment");
+      i = end + 2;
+      continue;
+    }
+    const offset = i;
+    if (source.startsWith("->", i) || source.startsWith("--", i)) {
+      tokens.push({ value: source.slice(i, i + 2), kind: "symbol", offset });
+      i += 2;
+      continue;
+    }
+    if ("{}[]=:;, +".includes(c)) {
+      tokens.push({ value: c, kind: "symbol", offset });
+      i++;
+      continue;
+    }
+    if (c === '"') {
+      let value = "";
+      i++;
+      while (i < source.length && source[i] !== '"') {
+        if (source[i] === "\\") {
+          i++;
+          if (i === source.length) fail("Unterminated escape");
+          if (source[i] === "\n") {
+            i++;
+            continue;
+          }
+          if (source[i] === "\r" && source[i + 1] === "\n") {
+            i += 2;
+            continue;
+          }
+          const escaped = source[i];
+          value += escaped === '"' || escaped === "\\" ? escaped : "\\" + escaped;
+          i++;
+        } else value += source[i++];
+      }
+      if (source[i] !== '"') fail("Unterminated string");
+      i++;
+      tokens.push({ value, kind: "quoted", offset });
+      continue;
+    }
+    if (c === "<") {
+      let depth = 0;
+      let quote = "";
+      do {
+        const ch = source[i++];
+        if (quote) {
+          if (ch === quote) quote = "";
+        } else if (ch === '"' || ch === "'") quote = ch;
+        else if (ch === "<") {
+          if (source.startsWith("!--", i)) {
+            const end = source.indexOf("-->", i + 3);
+            if (end < 0) fail("Unterminated HTML comment");
+            i = end + 3;
+          } else depth++;
+        } else if (ch === ">") depth--;
+      } while (i < source.length && depth > 0);
+      if (depth !== 0 || quote) fail("Unterminated HTML ID");
+      tokens.push({ value: source.slice(offset, i), kind: "html", offset });
+      continue;
+    }
+    if (letter(c)) {
+      i++;
+      while (i < source.length && (letter(source[i]) || digit(source[i]))) i++;
+    } else if (digit(c) || c === "." || c === "-") {
+      if (c === "-") i++;
+      let digits = 0;
+      while (i < source.length && digit(source[i])) {
+        i++;
+        digits++;
+      }
+      if (source[i] === ".") {
+        i++;
+        while (i < source.length && digit(source[i])) {
+          i++;
+          digits++;
+        }
+      }
+      if (!digits) fail("Invalid numeric ID");
+    } else fail("Unexpected character");
+    tokens.push({ value: source.slice(offset, i), kind: "id", offset });
+  }
+  tokens.push({ value: "", kind: "eof", offset: source.length });
+  return tokens;
+}
+function parseDot(source) {
+  const tokens = tokenize(source);
+  let position = 0;
+  let nesting = 0;
+  const peek = () => tokens[position];
+  const fail = (message) => {
+    throw new SyntaxError(`${message} at offset ${peek().offset}`);
+  };
+  const accept = (value) => {
+    if (peek().value !== value || peek().kind !== "symbol") return false;
+    position++;
+    return true;
+  };
+  const keyword = (value) => peek().kind === "id" && peek().value.toLowerCase() === value;
+  const expect = (value) => {
+    if (!accept(value)) fail(`Expected ${value}`);
+  };
+  const id = () => {
+    const token = peek();
+    if (!["id", "html", "quoted"].includes(token.kind)) fail("Expected ID");
+    position++;
+    let value = token.value;
+    if (token.kind === "quoted")
+      while (accept("+")) {
+        if (peek().kind !== "quoted") fail("Expected quoted string after +");
+        value += peek().value;
+        position++;
+      }
+    return value;
+  };
+  const attrs = () => {
+    const result = /* @__PURE__ */ Object.create(null);
+    while (accept("[")) {
+      while (!accept("]")) {
+        const key = id();
+        expect("=");
+        result[key] = id();
+        accept(",");
+        accept(";");
+      }
+    }
+    return { ...result };
+  };
+  const ref = (name) => {
+    const result = { id: name };
+    if (accept(":")) {
+      const port = id();
+      if (accept(":")) {
+        result.port = port;
+        result.compass = id();
+        if (!compass.has(result.compass)) fail("Invalid compass point");
+      } else if (compass.has(port)) result.compass = port;
+      else result.port = port;
+    }
+    return result;
+  };
+  let strict = false;
+  if (keyword("strict")) {
+    strict = true;
+    position++;
+  }
+  if (!keyword("digraph") && !keyword("graph")) fail("Expected graph or digraph");
+  const directed = keyword("digraph");
+  position++;
+  const graph = { kind: "graph", directed, strict, statements: [] };
+  if (peek().kind !== "symbol") graph.id = id();
+  function subgraph() {
+    const result = { kind: "subgraph", statements: [] };
+    if (keyword("subgraph")) {
+      position++;
+      if (peek().value !== "{") result.id = id();
+    }
+    result.statements = statements();
+    return result;
+  }
+  function statements() {
+    if (++nesting > 256) fail("DOT nesting exceeds 256");
+    expect("{");
+    const result = [];
+    while (!accept("}")) {
+      if (accept(";") || accept(",")) continue;
+      if (["graph", "node", "edge"].some(keyword) && tokens[position + 1]?.value === "[") {
+        const target = peek().value.toLowerCase();
+        position++;
+        result.push({ kind: "attributes", target, attributes: attrs() });
+        continue;
+      }
+      let endpoint;
+      if (keyword("subgraph") || peek().value === "{") endpoint = subgraph();
+      else {
+        const name = id();
+        if (accept("=")) {
+          result.push({ kind: "attributes", target: "graph", attributes: { [name]: id() } });
+          continue;
+        }
+        endpoint = ref(name);
+      }
+      if (peek().value === "->" || peek().value === "--") {
+        const endpoints = [endpoint];
+        while (peek().value === "->" || peek().value === "--") {
+          if (peek().value !== (directed ? "->" : "--")) fail("Wrong edge operator for graph type");
+          position++;
+          endpoints.push(keyword("subgraph") || peek().value === "{" ? subgraph() : ref(id()));
+        }
+        result.push({ kind: "edge", endpoints, attributes: attrs() });
+      } else if ("kind" in endpoint) result.push(endpoint);
+      else result.push({ kind: "node", node: endpoint, attributes: attrs() });
+      accept(";");
+    }
+    nesting--;
+    return result;
+  }
+  graph.statements = statements();
+  if (peek().kind !== "eof") fail("Trailing input");
+  return graph;
+}
+
+// packages/graphviz-ast/src/model.ts
+function resolveGraph(graph) {
+  const nodes = /* @__PURE__ */ new Map();
+  const edges = [];
+  const strictEdges = /* @__PURE__ */ new Map();
+  const clusters = [];
+  const ranks = [];
+  function walk(statements, inherited, cluster) {
+    const scope = {
+      graph: { ...inherited.graph },
+      node: { ...inherited.node },
+      edge: { ...inherited.edge }
+    };
+    const ids = /* @__PURE__ */ new Set();
+    const node = (ref, attributes = {}) => {
+      let existing = nodes.get(ref.id);
+      if (!existing) {
+        existing = { id: ref.id, attributes: { ...scope.node } };
+        nodes.set(ref.id, existing);
+      }
+      Object.assign(existing.attributes, attributes);
+      ids.add(ref.id);
+      return ref;
+    };
+    const subgraph = (sub) => {
+      const isCluster = sub.id?.startsWith("cluster") ?? false;
+      const nested = walk(sub.statements, scope, isCluster ? sub.id : cluster);
+      for (const id of nested.ids) ids.add(id);
+      if (isCluster)
+        clusters.push({
+          id: sub.id,
+          attributes: nested.attributes,
+          nodes: nested.ids,
+          ...cluster !== void 0 ? { parent: cluster } : {}
+        });
+      if (nested.attributes.rank) ranks.push({ rank: nested.attributes.rank, nodes: nested.ids });
+      return nested.ids.map((id) => ({ id }));
+    };
+    for (const statement of statements) {
+      if (statement.kind === "attributes")
+        Object.assign(scope[statement.target], statement.attributes);
+      else if (statement.kind === "node") node(statement.node, statement.attributes);
+      else if (statement.kind === "subgraph") subgraph(statement);
+      else {
+        const endpoints = statement.endpoints.map(
+          (endpoint) => "kind" in endpoint ? subgraph(endpoint) : [node(endpoint)]
+        );
+        for (let i = 1; i < endpoints.length; i++)
+          for (const tail of endpoints[i - 1])
+            for (const head of endpoints[i]) {
+              const pair2 = graph.directed || tail.id <= head.id ? [tail.id, head.id] : [head.id, tail.id];
+              const key = JSON.stringify(pair2);
+              const existing = strictEdges.get(key);
+              if (graph.strict && existing) {
+                Object.assign(existing.attributes, statement.attributes);
+                continue;
+              }
+              const edge = {
+                tail: { ...tail },
+                head: { ...head },
+                attributes: { ...scope.edge, ...statement.attributes }
+              };
+              edges.push(edge);
+              if (graph.strict) strictEdges.set(key, edge);
+            }
+      }
+    }
+    return { ids: [...ids], attributes: scope.graph };
+  }
+  const root = walk(graph.statements, { graph: {}, node: {}, edge: {} });
+  return { attributes: root.attributes, nodes: [...nodes.values()], edges, clusters, ranks };
+}
+
+// packages/graphviz-ast/src/metrics.ts
+function textWidth(text2, size, font = "Times-Roman") {
+  let width = 0;
+  const mono = font.toLowerCase().includes("mono") || font.toLowerCase().includes("courier");
+  const sans = font.toLowerCase().includes("arial") || font.toLowerCase().includes("helvetica");
+  for (const c of text2) {
+    let advance = 0.5;
+    if (mono) advance = 0.6;
+    else if (" ilI.,'!:;|".includes(c)) advance = 0.278;
+    else if ("mwMW@%&".includes(c)) advance = c === "W" || c === "M" ? 0.944 : 0.778;
+    else if (c >= "A" && c <= "Z") advance = 0.667;
+    else if (c.codePointAt(0) >= 11904) advance = 1;
+    else if ("frt()[]".includes(c)) advance = 0.333;
+    else if (sans) advance = 0.556;
+    width += advance * size;
+  }
+  return width;
+}
+function numeric(value, fallback, min = 0) {
+  const n = Number(value);
+  return value !== void 0 && value.trim() !== "" && Number.isFinite(n) && n >= min ? n : fallback;
+}
+function pair(value, fallback) {
+  const parts = value?.split(",");
+  const x = numeric(parts?.[0], fallback);
+  return [x, numeric(parts?.[1], x)];
+}
+function labelLines(label, id = "") {
+  if (label.startsWith("<") && label.endsWith(">")) {
+    let text2 = "";
+    let i = 1;
+    while (i < label.length - 1) {
+      if (label[i] === "<") {
+        const end = label.indexOf(">", i + 1);
+        if (end < 0) break;
+        const tag = label.slice(i + 1, end).toLowerCase().trim();
+        if (tag.startsWith("br") || tag === "/tr") text2 += "\n";
+        else if (tag === "/td") text2 += " ";
+        i = end + 1;
+      } else text2 += label[i++];
+    }
+    return decodeEntities(text2).trim().split("\n");
+  }
+  return label.split("\\N").join(id).split("\\n").join("\n").split("\\l").join("\n").split("\\r").join("\n").split("\n");
+}
+function decodeEntities(text2) {
+  let result = "";
+  for (let i = 0; i < text2.length; i++) {
+    if (text2[i] !== "&") {
+      result += text2[i];
+      continue;
+    }
+    const end = text2.indexOf(";", i + 1);
+    if (end < 0) {
+      result += "&";
+      continue;
+    }
+    const name = text2.slice(i + 1, end);
+    const known = {
+      amp: "&",
+      lt: "<",
+      gt: ">",
+      quot: '"',
+      apos: "'",
+      nbsp: " "
+    };
+    let value = known[name];
+    if (name.startsWith("#")) {
+      const n = name.startsWith("#x") ? Number.parseInt(name.slice(2), 16) : Number(name.slice(1));
+      if (Number.isInteger(n) && n > 0 && n <= 1114111) value = String.fromCodePoint(n);
+    }
+    if (value === void 0) result += "&";
+    else {
+      result += value;
+      i = end;
+    }
+  }
+  return result;
+}
+function recordFields(label) {
+  let i = 0;
+  const parse = () => {
+    const fields = [];
+    let text2 = "";
+    let port;
+    const flush = () => {
+      fields.push({ label: text2.trim(), ...port !== void 0 ? { port } : {} });
+      text2 = "";
+      port = void 0;
+    };
+    while (i < label.length) {
+      const c = label[i++];
+      if (c === "\\" && i < label.length) text2 += label[i++];
+      else if (c === "{") {
+        if (text2 || port) flush();
+        fields.push({ label: "", children: parse() });
+      } else if (c === "}") {
+        if (text2 || port || !fields.length) flush();
+        return fields;
+      } else if (c === "|") {
+        if (text2 || port || !fields.length) flush();
+      } else if (c === "<") {
+        const end = label.indexOf(">", i);
+        if (end >= 0) {
+          port = label.slice(i, end);
+          i = end + 1;
+        } else text2 += c;
+      } else text2 += c;
+    }
+    if (text2 || port || !fields.length) flush();
+    return fields;
+  };
+  return parse();
+}
+function nodeSize(id, attributes) {
+  const size = numeric(attributes.fontsize, 14, 1);
+  const shape2 = attributes.shape ?? "ellipse";
+  let lines = labelLines(attributes.label ?? id, id);
+  if (shape2 === "record" || shape2 === "Mrecord") {
+    const flatten = (fields) => fields.flatMap((field) => field.children ? flatten(field.children) : [field.label]);
+    lines = [flatten(recordFields(attributes.label ?? id)).join("   ")];
+  }
+  const [mx, my] = pair(attributes.margin, 0.11);
+  let width = Math.max(...lines.map((line) => textWidth(line, size, attributes.fontname)), 0) + mx * 144;
+  let height = lines.length * size * 1.2 + my * 144;
+  if (shape2 === "ellipse" || shape2 === "oval" || shape2 === "diamond") {
+    width *= Math.SQRT2;
+    height *= Math.SQRT2;
+  }
+  width = Math.max(
+    width,
+    numeric(attributes.width, shape2 === "plaintext" || shape2 === "none" ? 0 : 0.75) * 72
+  );
+  height = Math.max(
+    height,
+    numeric(attributes.height, shape2 === "plaintext" || shape2 === "none" ? 0 : 0.5) * 72
+  );
+  if (attributes.fixedsize === "true") {
+    width = numeric(attributes.width, 0.75) * 72;
+    height = numeric(attributes.height, 0.5) * 72;
+  }
+  if (shape2 === "circle" || shape2 === "doublecircle") width = height = Math.max(width, height);
+  return [Math.max(1, width), Math.max(1, height)];
+}
+
+// packages/graphviz-ast/src/layered.ts
+function feedbackOrder(count, arcs) {
+  const remaining = new Set(Array.from({ length: count }, (_, i) => i));
+  const left = [];
+  const right = [];
+  const incoming = Array.from({ length: count }, () => []);
+  const outgoing = Array.from({ length: count }, () => []);
+  for (const arc of arcs)
+    if (arc.from !== arc.to) {
+      incoming[arc.to].push(arc);
+      outgoing[arc.from].push(arc);
+    }
+  while (remaining.size) {
+    let chosen = -1;
+    let best = -Infinity;
+    for (const v of remaining) {
+      const ins = incoming[v].filter((e) => remaining.has(e.from));
+      const outs = outgoing[v].filter((e) => remaining.has(e.to));
+      if (!outs.length) {
+        right.push(v);
+        chosen = v;
+        break;
+      }
+      if (!ins.length) {
+        left.push(v);
+        chosen = v;
+        break;
+      }
+      const score = outs.reduce((s, e) => s + e.weight, 0) - ins.reduce((s, e) => s + e.weight, 0);
+      if (score > best) {
+        chosen = v;
+        best = score;
+      }
+    }
+    if (left.at(-1) !== chosen && right.at(-1) !== chosen) left.push(chosen);
+    remaining.delete(chosen);
+  }
+  return [...left, ...right.reverse()];
+}
+function assignRanks(count, arcs, order) {
+  const rank = Array(count).fill(0);
+  const outgoing = Array.from({ length: count }, () => []);
+  for (const arc of arcs) outgoing[arc.from].push(arc);
+  for (const v of order)
+    for (const e of outgoing[v]) rank[e.to] = Math.max(rank[e.to], rank[v] + e.minlen);
+  const slack = (e) => rank[e.to] - rank[e.from] - e.minlen;
+  const tree = /* @__PURE__ */ new Set();
+  const connected = /* @__PURE__ */ new Set();
+  for (let seed = 0; seed < count; seed++) {
+    if (connected.has(seed)) continue;
+    const component = /* @__PURE__ */ new Set([seed]);
+    while (true) {
+      let boundary2;
+      let least = Infinity;
+      for (const e of arcs)
+        if (component.has(e.from) !== component.has(e.to) && !connected.has(e.from) && !connected.has(e.to)) {
+          if (slack(e) < least) {
+            least = slack(e);
+            boundary2 = e;
+          }
+        }
+      if (!boundary2) break;
+      const shift = component.has(boundary2.from) ? least : -least;
+      for (const v of component) rank[v] = rank[v] + shift;
+      tree.add(boundary2);
+      component.add(boundary2.from);
+      component.add(boundary2.to);
+    }
+    for (const v of component) connected.add(v);
+  }
+  const limit = Math.max(32, count * Math.max(1, arcs.length) * 4);
+  for (let iteration = 0; iteration < limit; iteration++) {
+    let changed = false;
+    for (const leaving of tree) {
+      const adjacency = Array.from({ length: count }, () => []);
+      for (const e of tree)
+        if (e !== leaving) {
+          adjacency[e.from].push(e.to);
+          adjacency[e.to].push(e.from);
+        }
+      const side = /* @__PURE__ */ new Set([leaving.to]);
+      const queue = [leaving.to];
+      for (let i = 0; i < queue.length; i++)
+        for (const v of adjacency[queue[i]])
+          if (!side.has(v)) {
+            side.add(v);
+            queue.push(v);
+          }
+      let cut = 0;
+      for (const e of arcs)
+        if (side.has(e.from) !== side.has(e.to)) cut += side.has(e.to) ? e.weight : -e.weight;
+      if (cut >= -1e-9) continue;
+      let entering;
+      let delta = Infinity;
+      for (const e of arcs)
+        if (side.has(e.from) && !side.has(e.to) && slack(e) < delta) {
+          delta = slack(e);
+          entering = e;
+        }
+      if (!entering || delta <= 1e-9) continue;
+      for (const v of side) rank[v] = rank[v] + delta;
+      tree.delete(leaving);
+      tree.add(entering);
+      changed = true;
+      break;
+    }
+    if (!changed) break;
+  }
+  const min = Math.min(...rank, 0);
+  return rank.map((r) => r - min);
+}
+function crossings(layers, arcs, vertices) {
+  let count = 0;
+  for (let r = 0; r < layers.length - 1; r++) {
+    const between = arcs.filter(
+      (e) => vertices[e.from].rank === r && vertices[e.to].rank === r + 1
+    );
+    for (let i = 0; i < between.length; i++)
+      for (let j = i + 1; j < between.length; j++) {
+        const a = between[i];
+        const b = between[j];
+        if ((vertices[a.from].order - vertices[b.from].order) * (vertices[a.to].order - vertices[b.to].order) < 0)
+          count++;
+      }
+  }
+  return count;
+}
+var median = (values) => {
+  values.sort((a, b) => a - b);
+  const m = Math.floor(values.length / 2);
+  return values.length % 2 ? values[m] : (values[m - 1] + values[m]) / 2;
+};
+function minimizeCrossings(layers, vertices, arcs) {
+  const update = () => layers.forEach(
+    (layer) => layer.forEach((v, i) => {
+      vertices[v].order = i;
+    })
+  );
+  update();
+  let best = layers.map((layer) => [...layer]);
+  let bestCount = crossings(layers, arcs, vertices);
+  const incoming = Array.from({ length: vertices.length }, () => []);
+  const outgoing = Array.from({ length: vertices.length }, () => []);
+  for (const e of arcs) {
+    incoming[e.to].push(e.from);
+    outgoing[e.from].push(e.to);
+  }
+  for (let pass = 0; pass < 12; pass++) {
+    const down = pass % 2 === 0;
+    for (let step = 1; step < layers.length; step++) {
+      const r = down ? step : layers.length - 1 - step;
+      const layer = layers[r];
+      const scores = /* @__PURE__ */ new Map();
+      for (const v of layer) {
+        const neighbors = (down ? incoming[v] : outgoing[v]).map((n) => vertices[n].order);
+        scores.set(
+          v,
+          neighbors.length ? pass % 4 < 2 ? neighbors.reduce((s, n) => s + n, 0) / neighbors.length : median(neighbors) : vertices[v].order
+        );
+      }
+      layer.sort(
+        (a, b) => scores.get(a) - scores.get(b) || vertices[a].order - vertices[b].order
+      );
+      update();
+    }
+    for (let sweep = 0; sweep < 4; sweep++) {
+      let improved = false;
+      for (const layer of layers)
+        for (let i = 1; i < layer.length; i++) {
+          const before = crossings(layers, arcs, vertices);
+          [layer[i - 1], layer[i]] = [layer[i], layer[i - 1]];
+          update();
+          if (crossings(layers, arcs, vertices) < before) improved = true;
+          else {
+            [layer[i - 1], layer[i]] = [layer[i], layer[i - 1]];
+            update();
+          }
+        }
+      if (!improved) break;
+    }
+    const count = crossings(layers, arcs, vertices);
+    if (count < bestCount) {
+      bestCount = count;
+      best = layers.map((layer) => [...layer]);
+    }
+  }
+  layers.splice(0, layers.length, ...best);
+  update();
+}
+function assignCoordinates(layers, vertices, arcs, nodesep, ranksep) {
+  const candidates = [];
+  for (const down of [true, false])
+    for (const right of [false, true]) {
+      const rows = layers.map((layer) => right ? [...layer].reverse() : [...layer]);
+      if (!down) rows.reverse();
+      const root = vertices.map((_, i) => i);
+      const align = [...root];
+      const neighbors = Array.from({ length: vertices.length }, () => []);
+      for (const e of arcs) neighbors[down ? e.to : e.from].push(down ? e.from : e.to);
+      const positions = /* @__PURE__ */ new Map();
+      rows.forEach((row) => row.forEach((v, i) => positions.set(v, i)));
+      const blocked = /* @__PURE__ */ new Set();
+      for (const a of arcs)
+        for (const b of arcs) {
+          if (vertices[a.from].rank !== vertices[b.from].rank) continue;
+          if (vertices[b.from].width !== 0 || vertices[b.to].width !== 0) continue;
+          if ((positions.get(a.from) - positions.get(b.from)) * (positions.get(a.to) - positions.get(b.to)) < 0)
+            blocked.add(`${a.from}:${a.to}`);
+        }
+      for (let r = 1; r < rows.length; r++) {
+        let previous = -1;
+        for (const v of rows[r]) {
+          const ns = neighbors[v].sort((a, b) => positions.get(a) - positions.get(b));
+          for (const m of [Math.floor((ns.length - 1) / 2), Math.floor(ns.length / 2)]) {
+            const u = ns[m];
+            if (u === void 0) continue;
+            const key = down ? `${u}:${v}` : `${v}:${u}`;
+            if (align[v] === v && positions.get(u) > previous && !blocked.has(key)) {
+              align[u] = v;
+              root[v] = root[u];
+              align[v] = root[v];
+              previous = positions.get(u);
+            }
+          }
+        }
+      }
+      const roots = [...new Set(root)];
+      const x = Array(vertices.length).fill(0);
+      const constraints = [];
+      for (const row of rows)
+        for (let i = 1; i < row.length; i++) {
+          const a = row[i - 1];
+          const b = row[i];
+          if (root[a] !== root[b])
+            constraints.push({
+              from: root[a],
+              to: root[b],
+              gap: (vertices[a].width + vertices[b].width) / 2 + nodesep
+            });
+        }
+      for (let iteration = 0; iteration < roots.length; iteration++)
+        for (const e of constraints) x[e.to] = Math.max(x[e.to], x[e.from] + e.gap);
+      const coords = vertices.map((_, v) => (right ? -1 : 1) * x[root[v]]);
+      const min = Math.min(...coords, 0);
+      candidates.push(coords.map((value) => value - min));
+    }
+  const extents = candidates.map((values) => Math.max(...values, 0) - Math.min(...values, 0));
+  const reference = extents.indexOf(Math.min(...extents));
+  const target = candidates[reference];
+  for (const values of candidates) {
+    const delta = (Math.min(...target, 0) + Math.max(...target, 0) - Math.min(...values, 0) - Math.max(...values, 0)) / 2;
+    for (let i = 0; i < values.length; i++) values[i] = values[i] + delta;
+  }
+  for (let v = 0; v < vertices.length; v++)
+    vertices[v].x = median(candidates.map((values) => values[v]));
+  for (const layer of layers)
+    for (let i = 1; i < layer.length; i++) {
+      const a = vertices[layer[i - 1]];
+      const b = vertices[layer[i]];
+      b.x = Math.max(b.x, a.x + (a.width + b.width) / 2 + nodesep);
+    }
+  let y = 0;
+  let previousHeight = 0;
+  for (const layer of layers) {
+    const height = Math.max(...layer.map((v) => vertices[v].height), 0);
+    y += previousHeight / 2 + height / 2 + (y ? ranksep : 0);
+    for (const v of layer) vertices[v].y = y;
+    previousHeight = height;
+  }
+}
+
+// packages/graphviz-ast/src/layout.ts
+var fmt = (n) => String(Math.round(n * 1e3) / 1e3);
+var xy = (p) => `${fmt(p.x)},${fmt(p.y)}`;
+function splinePath(points) {
+  if (points.length < 2) return "";
+  if (points.length === 2) {
+    const a = points[0];
+    const b = points[1];
+    return `M${xy(a)}C${xy({ x: a.x, y: (a.y + b.y) / 2 })} ${xy({ x: b.x, y: (a.y + b.y) / 2 })} ${xy(b)}`;
+  }
+  const p = [points[0], points[0], ...points, points.at(-1), points.at(-1)];
+  let result = `M${xy(points[0])}`;
+  for (let i = 0; i + 3 < p.length; i++) {
+    const a = p[i];
+    const b = p[i + 1];
+    const c = p[i + 2];
+    const d = p[i + 3];
+    const c1 = { x: (2 * b.x + c.x) / 3, y: (2 * b.y + c.y) / 3 };
+    const c2 = { x: (b.x + 2 * c.x) / 3, y: (b.y + 2 * c.y) / 3 };
+    const end = { x: (b.x + 4 * c.x + d.x) / 6, y: (b.y + 4 * c.y + d.y) / 6 };
+    if (i > 0) result += `C${xy(c1)} ${xy(c2)} ${xy(end)}`;
+    void a;
+  }
+  return result;
+}
+function boundary(node, toward, ref) {
+  const center = ref.port !== void 0 && node.ports[ref.port] ? node.ports[ref.port] : node;
+  let dx = toward.x - center.x;
+  let dy = toward.y - center.y;
+  const directions = {
+    n: [0, -1],
+    ne: [1, -1],
+    e: [1, 0],
+    se: [1, 1],
+    s: [0, 1],
+    sw: [-1, 1],
+    w: [-1, 0],
+    nw: [-1, -1]
+  };
+  if (ref.compass === "c") return { x: center.x, y: center.y };
+  if (ref.compass && directions[ref.compass]) [dx, dy] = directions[ref.compass];
+  if (!dx && !dy) dy = 1;
+  const rx = node.width / 2;
+  const ry = node.height / 2;
+  const shape2 = node.attributes.shape ?? "ellipse";
+  let scale;
+  if (["ellipse", "oval", "circle", "doublecircle"].includes(shape2))
+    scale = 1 / Math.sqrt(dx * dx / (rx * rx) + dy * dy / (ry * ry));
+  else if (shape2 === "diamond") scale = 1 / (Math.abs(dx) / rx + Math.abs(dy) / ry);
+  else scale = Math.min(dx ? rx / Math.abs(dx) : Infinity, dy ? ry / Math.abs(dy) : Infinity);
+  if (ref.port && !ref.compass) return { x: center.x, y: center.y };
+  return { x: center.x + dx * scale, y: center.y + dy * scale };
+}
+function ports(node) {
+  if (!["record", "Mrecord"].includes(node.attributes.shape ?? "")) return;
+  const walk = (fields, x, y, w, h, horizontal) => {
+    fields.forEach((field, i) => {
+      const width = horizontal ? w / fields.length : w;
+      const height = horizontal ? h : h / fields.length;
+      const left = x + (horizontal ? i * width : 0);
+      const top = y + (horizontal ? 0 : i * height);
+      if (field.port !== void 0)
+        node.ports[field.port] = { x: left + width / 2, y: top + height / 2 };
+      if (field.children) walk(field.children, left, top, width, height, !horizontal);
+    });
+  };
+  walk(
+    recordFields(node.attributes.label ?? node.id),
+    node.x - node.width / 2,
+    node.y - node.height / 2,
+    node.width,
+    node.height,
+    true
+  );
+}
+function layoutGraph(graph, options = {}) {
+  const model = resolveGraph(graph);
+  const attributes = { ...model.attributes, ...options.graph };
+  const rankdir = attributes.rankdir ?? "TB";
+  const horizontal = rankdir === "LR" || rankdir === "RL";
+  const nodes = model.nodes.map((n) => {
+    const attrs = { ...n.attributes, ...options.node };
+    const [width, height] = nodeSize(n.id, attrs);
+    return { id: n.id, attributes: attrs, width, height, x: 0, y: 0, rank: 0, ports: {} };
+  });
+  const index = new Map(nodes.map((n, i) => [n.id, i]));
+  const parent = nodes.map((_, i) => i);
+  const find = (i) => {
+    while (parent[i] !== i) {
+      parent[i] = parent[parent[i]];
+      i = parent[i];
+    }
+    return i;
+  };
+  for (const group of model.ranks)
+    for (const id of group.nodes.slice(1))
+      parent[find(index.get(id))] = find(index.get(group.nodes[0]));
+  const representatives = [...new Set(parent.map((_, i) => find(i)))];
+  const groupIndex = new Map(representatives.map((r, i) => [r, i]));
+  const groupOf = nodes.map((_, i) => groupIndex.get(find(i)));
+  const edgeAttributes = model.edges.map((e) => ({ ...e.attributes, ...options.edge }));
+  const originalArcs = model.edges.flatMap((e, i) => {
+    const from = groupOf[index.get(e.tail.id)];
+    const to = groupOf[index.get(e.head.id)];
+    if (from === to || edgeAttributes[i].constraint === "false") return [];
+    return [
+      {
+        from,
+        to,
+        minlen: Math.max(1, Math.round(numeric(edgeAttributes[i].minlen, 1))),
+        weight: numeric(edgeAttributes[i].weight, 1)
+      }
+    ];
+  });
+  let order = feedbackOrder(representatives.length, originalArcs);
+  const minGroups = /* @__PURE__ */ new Set();
+  const maxGroups = /* @__PURE__ */ new Set();
+  for (const group of model.ranks) {
+    const target = group.rank === "min" || group.rank === "source" ? minGroups : group.rank === "max" || group.rank === "sink" ? maxGroups : void 0;
+    if (target) for (const id of group.nodes) target.add(groupOf[index.get(id)]);
+  }
+  order = [
+    ...order.filter((v) => minGroups.has(v)),
+    ...order.filter((v) => !minGroups.has(v) && !maxGroups.has(v)),
+    ...order.filter((v) => !minGroups.has(v) && maxGroups.has(v))
+  ];
+  const ordinal = new Map(order.map((v, i) => [v, i]));
+  const arcs = originalArcs.map(
+    (e) => ordinal.get(e.from) < ordinal.get(e.to) ? { ...e } : { ...e, from: e.to, to: e.from }
+  );
+  for (const min of minGroups)
+    for (let v = 0; v < representatives.length; v++)
+      if (v !== min && !minGroups.has(v)) arcs.push({ from: min, to: v, minlen: 1, weight: 0 });
+  for (const max of maxGroups)
+    for (let v = 0; v < representatives.length; v++)
+      if (v !== max && !maxGroups.has(v)) arcs.push({ from: v, to: max, minlen: 1, weight: 0 });
+  const ranks = assignRanks(representatives.length, arcs, order);
+  const vertices = nodes.map((n, i) => ({
+    rank: ranks[groupOf[i]] ?? 0,
+    width: horizontal ? n.height : n.width,
+    height: horizontal ? n.width : n.height,
+    x: 0,
+    y: 0,
+    order: 0
+  }));
+  const segments = [];
+  const routes = [];
+  model.edges.forEach((e, i) => {
+    let from = index.get(e.tail.id);
+    let to = index.get(e.head.id);
+    const reverse = vertices[from].rank > vertices[to].rank;
+    if (reverse) [from, to] = [to, from];
+    const route = [from];
+    for (let rank = vertices[from].rank + 1; rank < vertices[to].rank; rank++) {
+      route.push(vertices.length);
+      vertices.push({ rank, width: 0, height: 0, x: 0, y: 0, order: 0 });
+    }
+    route.push(to);
+    for (let j = 1; j < route.length; j++)
+      if (vertices[route[j - 1]].rank !== vertices[route[j]].rank)
+        segments.push({
+          from: route[j - 1],
+          to: route[j],
+          minlen: 1,
+          weight: numeric(edgeAttributes[i].weight, 1)
+        });
+    routes.push(reverse ? route.reverse() : route);
+  });
+  const layers = Array.from(
+    { length: Math.max(...vertices.map((v) => v.rank), 0) + 1 },
+    () => []
+  );
+  vertices.forEach((v, i) => layers[v.rank].push(i));
+  const clusterOf = /* @__PURE__ */ new Map();
+  model.clusters.forEach((c, i) => c.nodes.forEach((id) => clusterOf.set(id, i)));
+  for (const layer of layers)
+    layer.sort(
+      (a, b) => (clusterOf.get(nodes[a]?.id ?? "") ?? -1) - (clusterOf.get(nodes[b]?.id ?? "") ?? -1)
+    );
+  minimizeCrossings(layers, vertices, segments);
+  assignCoordinates(
+    layers,
+    vertices,
+    segments,
+    numeric(attributes.nodesep, 0.25) * 72,
+    numeric(attributes.ranksep?.split(" ")[0], 0.5) * 72
+  );
+  const maxY = Math.max(...vertices.map((v) => v.y), 0);
+  const transform = (p) => {
+    const y = rankdir === "BT" || rankdir === "RL" ? maxY - p.y : p.y;
+    return horizontal ? { x: y, y: p.x } : { x: p.x, y };
+  };
+  nodes.forEach((n, i) => {
+    Object.assign(n, transform(vertices[i]));
+    n.rank = vertices[i].rank;
+    ports(n);
+  });
+  const clusters = model.clusters.map((c) => {
+    const members = c.nodes.map((id) => nodes[index.get(id)]);
+    const margin = numeric(c.attributes.margin, 8);
+    const x = (members.length ? Math.min(...members.map((n) => n.x - n.width / 2)) : 0) - margin;
+    const y = (members.length ? Math.min(...members.map((n) => n.y - n.height / 2)) : 0) - margin - (c.attributes.label ? 24 : 0);
+    const right = Math.max(...members.map((n) => n.x + n.width / 2), x) + margin;
+    const bottom = Math.max(...members.map((n) => n.y + n.height / 2), y) + margin;
+    return { ...c, x, y, width: right - x, height: bottom - y };
+  });
+  for (const c of clusters)
+    if (c.parent) {
+      const p = clusters.find((item) => item.id === c.parent);
+      if (!p) continue;
+      const right = Math.max(p.x + p.width, c.x + c.width + 8);
+      const bottom = Math.max(p.y + p.height, c.y + c.height + 8);
+      p.x = Math.min(p.x, c.x - 8);
+      p.y = Math.min(p.y, c.y - 8);
+      p.width = right - p.x;
+      p.height = bottom - p.y;
+    }
+  const splines = attributes.splines ?? "true";
+  const parallels = /* @__PURE__ */ new Map();
+  const edges = model.edges.map((e, i) => {
+    const tail = nodes[index.get(e.tail.id)];
+    const head = nodes[index.get(e.head.id)];
+    let points = routes[i].map((v) => transform(vertices[v]));
+    const key = JSON.stringify([e.tail.id, e.head.id]);
+    const parallel = parallels.get(key) ?? 0;
+    parallels.set(key, parallel + 1);
+    if (tail === head) {
+      points = [
+        { x: tail.x + tail.width / 2, y: tail.y },
+        { x: tail.x + tail.width / 2 + 32 + parallel * 12, y: tail.y - tail.height },
+        { x: tail.x + tail.width / 2 + 32 + parallel * 12, y: tail.y + tail.height },
+        { x: tail.x + tail.width / 2, y: tail.y + tail.height / 4 }
+      ];
+    } else {
+      if (tail.rank === head.rank) {
+        const offset = 30 + parallel * 12;
+        points = [
+          tail,
+          horizontal ? { x: tail.x - tail.width / 2 - offset, y: tail.y } : { x: tail.x, y: tail.y - tail.height / 2 - offset },
+          horizontal ? { x: head.x - head.width / 2 - offset, y: head.y } : { x: head.x, y: head.y - head.height / 2 - offset },
+          head
+        ];
+      } else if (points.length === 2 && parallel)
+        points.splice(1, 0, {
+          x: (tail.x + head.x) / 2 + (horizontal ? 0 : parallel * 16),
+          y: (tail.y + head.y) / 2 + (horizontal ? parallel * 16 : 0)
+        });
+      points[0] = boundary(tail, points[1], e.tail);
+      points[points.length - 1] = boundary(head, points.at(-2), e.head);
+    }
+    if (splines === "line" || splines === "false") points = [points[0], points.at(-1)];
+    if (splines === "ortho") {
+      const orthogonal = [points[0]];
+      for (let j = 1; j < points.length; j++) {
+        const a = points[j - 1];
+        const b = points[j];
+        if (horizontal)
+          orthogonal.push({ x: (a.x + b.x) / 2, y: a.y }, { x: (a.x + b.x) / 2, y: b.y });
+        else orthogonal.push({ x: a.x, y: (a.y + b.y) / 2 }, { x: b.x, y: (a.y + b.y) / 2 });
+        orthogonal.push(b);
+      }
+      points = orthogonal;
+    }
+    return {
+      ...e,
+      attributes: edgeAttributes[i],
+      reversed: tail.rank > head.rank,
+      points,
+      path: "",
+      label: points[Math.floor(points.length / 2)]
+    };
+  });
+  const [mx, my] = pair(attributes.margin, 0);
+  const [px, py] = pair(attributes.pad, 0.0555);
+  const all = [
+    ...nodes.flatMap((n) => [
+      { x: n.x - n.width / 2, y: n.y - n.height / 2 },
+      { x: n.x + n.width / 2, y: n.y + n.height / 2 }
+    ]),
+    ...clusters.flatMap((c) => [
+      { x: c.x, y: c.y },
+      { x: c.x + c.width, y: c.y + c.height }
+    ]),
+    ...edges.flatMap((e) => e.points)
+  ];
+  const minX = Math.min(...all.map((p) => p.x), 0);
+  const minY = Math.min(...all.map((p) => p.y), 0);
+  const maxX = Math.max(...all.map((p) => p.x), 0);
+  const maxExtentY = Math.max(...all.map((p) => p.y), 0);
+  const dx = (mx + px) * 72 - minX;
+  const dy = (my + py) * 72 - minY;
+  for (const n of nodes) {
+    n.x += dx;
+    n.y += dy;
+    for (const p of Object.values(n.ports)) {
+      p.x += dx;
+      p.y += dy;
+    }
+  }
+  for (const c of clusters) {
+    c.x += dx;
+    c.y += dy;
+  }
+  for (const e of edges) {
+    e.points = e.points.map((p) => ({ x: p.x + dx, y: p.y + dy }));
+    e.label = { x: e.label.x + dx, y: e.label.y + dy };
+    e.path = splines === "none" || splines === "" ? "" : splines === "true" || splines === "spline" ? splinePath(e.points) : e.points.map((p, i) => `${i ? "L" : "M"}${xy(p)}`).join("");
+  }
+  const labelHeight = attributes.label ? numeric(attributes.fontsize, 14) * 1.2 + 12 : 0;
+  return {
+    ...graph.id !== void 0 ? { id: graph.id } : {},
+    directed: graph.directed,
+    strict: graph.strict,
+    attributes,
+    nodes,
+    edges,
+    clusters,
+    width: Math.max(1, maxX - minX + (mx + px) * 144),
+    height: Math.max(1, maxExtentY - minY + (my + py) * 144 + labelHeight)
+  };
+}
+
+// packages/graphviz-ast/src/svg.ts
+var f = (n) => String(Math.round(n * 1e3) / 1e3);
+var escape = (s) => s.split("&").join("&amp;").split("<").join("&lt;").split(">").join("&gt;").split('"').join("&quot;");
+function style(a, filled = false) {
+  const parts = [
+    `fill="${escape(filled || a.style?.includes("filled") ? a.fillcolor ?? "lightgrey" : "none")}"`,
+    `stroke="${escape(a.color ?? "black")}"`
+  ];
+  if (a.penwidth) parts.push(`stroke-width="${f(numeric(a.penwidth, 1))}"`);
+  if (a.style?.includes("dashed")) parts.push('stroke-dasharray="5,3"');
+  if (a.style?.includes("dotted")) parts.push('stroke-dasharray="1,3"');
+  return parts.join(" ");
+}
+function text(label, x, y, a, id = "") {
+  const size = numeric(a.fontsize, 14, 1);
+  const lines = labelLines(label, id);
+  return lines.map(
+    (line, i) => `<text text-anchor="middle" x="${f(x)}" y="${f(y + (i - (lines.length - 1) / 2) * size * 1.2 + size * 0.35)}" font-family="${escape(a.fontname ?? "Times,serif")}" font-size="${f(size)}" fill="${escape(a.fontcolor ?? "black")}">${escape(line)}</text>`
+  ).join("");
+}
+function shape(node) {
+  const { x, y, width: w, height: h, attributes: a } = node;
+  const s = a.shape ?? "ellipse";
+  const left = x - w / 2;
+  const top = y - h / 2;
+  const right = x + w / 2;
+  const bottom = y + h / 2;
+  const path = (d) => `<path ${style(a)} d="${d}"/>`;
+  const polygon = (points) => `<polygon ${style(a)} points="${points.map((p) => `${f(p.x)},${f(p.y)}`).join(" ")}"/>`;
+  const rect = (radius = 0) => `<rect ${style(a)} x="${f(left)}" y="${f(top)}" width="${f(w)}" height="${f(h)}"${radius ? ` rx="${f(radius)}"` : ""}/>`;
+  const ellipse = (rx, ry) => `<ellipse ${style(a)} cx="${f(x)}" cy="${f(y)}" rx="${f(rx)}" ry="${f(ry)}"/>`;
+  if (s === "plaintext" || s === "none") return "";
+  if (s === "ellipse" || s === "oval" || s === "circle") return ellipse(w / 2, h / 2);
+  if (s === "doublecircle")
+    return ellipse(w / 2, h / 2) + ellipse(Math.max(1, w / 2 - 4), Math.max(1, h / 2 - 4));
+  if (s === "diamond")
+    return polygon([
+      { x, y: top },
+      { x: right, y },
+      { x, y: bottom },
+      { x: left, y }
+    ]);
+  if (s === "cylinder") {
+    const arc = Math.min(10, h / 5);
+    return path(
+      `M${f(left)},${f(top + arc)}C${f(left)},${f(top - arc / 3)} ${f(right)},${f(top - arc / 3)} ${f(right)},${f(top + arc)}L${f(right)},${f(bottom - arc)}C${f(right)},${f(bottom + arc / 3)} ${f(left)},${f(bottom + arc / 3)} ${f(left)},${f(bottom - arc)}Z`
+    ) + path(
+      `M${f(left)},${f(top + arc)}C${f(left)},${f(top + arc * 2)} ${f(right)},${f(top + arc * 2)} ${f(right)},${f(top + arc)}`
+    );
+  }
+  if (s === "folder" || s === "tab")
+    return polygon([
+      { x: left, y: top + 8 },
+      { x: left, y: top },
+      { x: left + w * 0.35, y: top },
+      { x: left + w * 0.35 + 8, y: top + 8 },
+      { x: right, y: top + 8 },
+      { x: right, y: bottom },
+      { x: left, y: bottom }
+    ]);
+  if (s === "note")
+    return polygon([
+      { x: left, y: top },
+      { x: right - 10, y: top },
+      { x: right, y: top + 10 },
+      { x: right, y: bottom },
+      { x: left, y: bottom }
+    ]) + path(`M${f(right - 10)},${f(top)}L${f(right - 10)},${f(top + 10)}L${f(right)},${f(top + 10)}`);
+  if (s === "component")
+    return rect() + `<rect ${style(a)} x="${f(left - 4)}" y="${f(top + h * 0.2)}" width="8" height="${f(h * 0.2)}"/><rect ${style(a)} x="${f(left - 4)}" y="${f(top + h * 0.6)}" width="8" height="${f(h * 0.2)}"/>`;
+  return rect(s === "Mrecord" || a.style?.includes("rounded") ? 8 : 0);
+}
+function record(node) {
+  const walk = (fields, x, y, w, h, horizontal) => fields.map((field, i) => {
+    const width = horizontal ? w / fields.length : w;
+    const height = horizontal ? h : h / fields.length;
+    const left = x + (horizontal ? i * width : 0);
+    const top = y + (horizontal ? 0 : i * height);
+    const divider = i ? `<path fill="none" stroke="${escape(node.attributes.color ?? "black")}" d="M${f(left)},${f(top)}L${f(horizontal ? left : left + width)},${f(horizontal ? top + height : top)}"/>` : "";
+    return divider + (field.children ? walk(field.children, left, top, width, height, !horizontal) : text(field.label, left + width / 2, top + height / 2, node.attributes, node.id));
+  }).join("");
+  return walk(
+    recordFields(node.attributes.label ?? node.id),
+    node.x - node.width / 2,
+    node.y - node.height / 2,
+    node.width,
+    node.height,
+    true
+  );
+}
+function arrow(point, previous, attributes) {
+  const size = numeric(attributes.arrowsize, 1) * 10;
+  let dx = point.x - previous.x;
+  let dy = point.y - previous.y;
+  const length = Math.hypot(dx, dy) || 1;
+  dx /= length;
+  dy /= length;
+  const base = { x: point.x - size * dx, y: point.y - size * dy };
+  return `<polygon fill="${escape(attributes.color ?? "black")}" stroke="${escape(attributes.color ?? "black")}" points="${f(point.x)},${f(point.y)} ${f(base.x + dy * size * 0.4)},${f(base.y - dx * size * 0.4)} ${f(base.x - dy * size * 0.4)},${f(base.y + dx * size * 0.4)}"/>`;
+}
+function renderSvg(layout) {
+  const content = [
+    `<svg xmlns="http://www.w3.org/2000/svg" width="${f(layout.width)}pt" height="${f(layout.height)}pt" viewBox="0 0 ${f(layout.width)} ${f(layout.height)}"><g class="graph"><title>${escape(layout.id ?? "G")}</title>`
+  ];
+  if (layout.attributes.bgcolor)
+    content.push(
+      `<rect x="0" y="0" width="${f(layout.width)}" height="${f(layout.height)}" fill="${escape(layout.attributes.bgcolor)}"/>`
+    );
+  for (const c of [...layout.clusters].reverse()) {
+    content.push(
+      `<g class="cluster"><title>${escape(c.id)}</title><rect ${style(c.attributes)} x="${f(c.x)}" y="${f(c.y)}" width="${f(c.width)}" height="${f(c.height)}"/>${c.attributes.label ? text(c.attributes.label, c.x + c.width / 2, c.y + 12, c.attributes) : ""}</g>`
+    );
+  }
+  for (const e of layout.edges) {
+    if (e.attributes.style?.includes("invis")) continue;
+    content.push(
+      `<g class="edge"><title>${escape(e.tail.id)}${layout.directed ? "-&gt;" : "--"}${escape(e.head.id)}</title>`
+    );
+    if (e.path) {
+      content.push(`<path ${style({ ...e.attributes, fillcolor: "none" })} d="${e.path}"/>`);
+      if ((layout.directed && e.attributes.dir !== "none" && e.attributes.dir !== "back" || e.attributes.dir === "both" || e.attributes.dir === "forward") && e.attributes.arrowhead !== "none")
+        content.push(arrow(e.points.at(-1), e.points.at(-2), e.attributes));
+      if ((e.attributes.dir === "back" || e.attributes.dir === "both") && e.attributes.arrowtail !== "none")
+        content.push(arrow(e.points[0], e.points[1], e.attributes));
+    }
+    if (e.attributes.label)
+      content.push(text(e.attributes.label, e.label.x, e.label.y - 8, e.attributes));
+    content.push("</g>");
+  }
+  for (const n of layout.nodes) {
+    if (n.attributes.style?.includes("invis")) continue;
+    content.push(
+      `<g class="node"><title>${escape(n.id)}</title>${shape(n)}${n.attributes.shape === "record" || n.attributes.shape === "Mrecord" ? record(n) : text(n.attributes.label ?? n.id, n.x, n.y, n.attributes, n.id)}</g>`
+    );
+  }
+  if (layout.attributes.label)
+    content.push(
+      text(layout.attributes.label, layout.width / 2, layout.height - 12, layout.attributes)
+    );
+  content.push("</g></svg>");
+  return content.join("");
+}
+
+// packages/safe-bash-command-dot/src/index.ts
+import { commandRuntimeIdentity, getCommandArguments } from "../safe-bash-contracts/index.js";
+import { InputByteBudget, collectBytes, writeBytes } from "../safe-bash-contracts/io.js";
+import { resolvePath } from "../safe-bash-contracts/path.js";
+import { createOutputOperation } from "../safe-bash-contracts/output.js";
+import { writeFileOutput } from "../safe-bash-contracts/filesystem-output-budget.js";
+import { inheritYieldCheckpoint, yieldTurn } from "../safe-bash-contracts/yield.js";
+function createDotCommand(options = {}) {
+  const maxInputBytes = InputByteBudget.limit(options.limits?.maxInputBytes ?? 1024 * 1024);
+  const maxNodes = InputByteBudget.limit(options.limits?.maxNodes ?? 1e4);
+  const maxPixels = InputByteBudget.limit(options.limits?.maxPixels ?? 16e6);
+  const maxLayoutCost = InputByteBudget.limit(options.limits?.maxLayoutCost ?? 1e8);
+  return { name: "dot", runtimeIdentity: commandRuntimeIdentity, async execute(context) {
+    return new InputByteBudget(maxInputBytes, context.inputBudget).run(context, async (context2) => {
+      const operation = createOutputOperation(context2, { write: async () => {
+      } });
+      inheritYieldCheckpoint(context2.signal, operation.signal);
+      try {
+        const args = getCommandArguments(context2).args;
+        let format = "svg";
+        let output;
+        let input;
+        let positional = false;
+        const diagnostic = async (message) => {
+          await writeBytes(context2.stderr, new TextEncoder().encode(`dot: ${message}
+`), operation.signal);
+          return { exitCode: 1 };
+        };
+        for (let i = 0; i < args.length; i++) {
+          const arg = args[i];
+          if (!positional && arg === "--") {
+            positional = true;
+            continue;
+          }
+          if (!positional && (arg === "--help" || arg === "-?")) {
+            await writeBytes(operation.child(context2.stdout).output, new TextEncoder().encode("Usage: dot -Tsvg|-Tpdf|-Tpng [-o OUTPUT] [INPUT]\n"), operation.signal);
+            return { exitCode: 0 };
+          }
+          if (!positional && arg.startsWith("-T")) {
+            format = arg.slice(2) || args[++i] || "";
+            continue;
+          }
+          if (!positional && arg === "-o") {
+            output = args[++i];
+            if (!output) return diagnostic("missing output path");
+            continue;
+          }
+          if (!positional && arg.startsWith("-") && arg !== "-") return diagnostic(`unsupported option ${arg}`);
+          if (input !== void 0) return diagnostic("expected at most one input");
+          input = arg;
+        }
+        if (format !== "svg" && format !== "pdf" && format !== "png") return diagnostic(`unsupported format ${format}`);
+        const bytes = !input || input === "-" ? await collectBytes(context2.stdin, { signal: operation.signal }) : await context2.fs.readFile(resolvePath(context2.cwd, input), { signal: operation.signal });
+        await yieldTurn(operation.signal);
+        let svg;
+        try {
+          const graph = parseDot(new TextDecoder().decode(bytes));
+          let count = 0;
+          let edges = 0;
+          let minlen = 1;
+          let extremalRank = false;
+          const visit = (value) => {
+            if (value === null || typeof value !== "object") return 0;
+            if (++count > maxNodes) throw new RangeError("graph node limit exceeded");
+            const record2 = value;
+            if (typeof record2.minlen === "string" && Number.isFinite(Number(record2.minlen))) minlen = Math.max(minlen, Math.round(Number(record2.minlen)));
+            if (["min", "max", "source", "sink"].includes(String(record2.rank))) extremalRank = true;
+            let references = typeof record2.id === "string" && !("kind" in record2) ? 1 : 0;
+            for (const [key, child] of Object.entries(record2)) {
+              if (Array.isArray(child)) {
+                let previous = 0;
+                for (const item of child) {
+                  const current = visit(item);
+                  if (key === "endpoints") {
+                    edges += previous * current;
+                    previous = current;
+                  }
+                  references += current;
+                }
+              } else references += visit(child);
+            }
+            return references;
+          };
+          visit(graph);
+          const rankSpan = count * minlen;
+          const expanded = count + (edges + (extremalRank ? count * count : 0)) * rankSpan;
+          const cost = expanded * expanded;
+          if (!Number.isSafeInteger(cost) || cost > maxLayoutCost) throw new RangeError("graph layout cost limit exceeded");
+          svg = renderSvg(layoutGraph(graph));
+        } catch (error) {
+          operation.signal.throwIfAborted();
+          return diagnostic(error instanceof Error ? error.message : "invalid graph");
+        }
+        await yieldTurn(operation.signal);
+        const rendered = format === "svg" ? new TextEncoder().encode(svg) : await (await import("../safe-bash-svg-engine/index.js")).renderSvgDocument(svg, format, { signal: operation.signal, maxNodes, maxPixels });
+        if (output && output !== "-") await writeFileOutput(context2, rendered, (data) => context2.fs.writeFile(resolvePath(context2.cwd, output), data, { signal: operation.signal }));
+        else await writeBytes(operation.child(context2.stdout).output, rendered, operation.signal);
+        return { exitCode: 0 };
+      } finally {
+        await operation.close();
+      }
+    });
+  } };
+}
+function createDotCommands(options = {}) {
+  return [createDotCommand(options)];
+}
+function dotCommands(options = {}) {
+  const commands = createDotCommands(options);
+  return { name: "dot", setup(host) {
+    for (const command of commands) host.commands.register(command, { replace: options.replace ?? false });
+  } };
+}
+export {
+  createDotCommand,
+  createDotCommands,
+  dotCommands
+};