@graphty/graph-io 0.0.0 → 0.2.0

package/dist/chunks/importer-DbnGYr3_.js

@@ -0,0 +1,2342 @@
+import { GraphFormatError, INVALID_INDEX } from "@graphty/graph-format";
+import { c as childrenCsr } from "./children-CL3Cy0ez.js";
+import { L as LOSS, au as joinText, ah as encodeChunks, aB as resolveExportOptions, aa as checkCapabilities, a9 as capabilities, aG as countMixedEdges, ai as explicitWeights, aw as pairFolding, aD as sanitizeIds, ak as formatF32, al as formatF64, aj as formatDecimal, an as formatInteger, a8 as canonicalId, x as MIXED_DIRECTION_CODE, g as DIRECTION_FORCED_CODE, h as DIRECTION_REFUSED_CODE, W as SINK_OPTION_CODE, n as ID_MERGED_CODE, J as OPTION_IGNORED_CODE, C as COLUMN_RENAMED_CODE, V as ROLE_TAKEN_CODE, y as MULTIPLE_GRAPHS_CODE, r as INVALID_UTF8_CODE, m as EMPTY_INPUT_CODE, Z as SYNTAX_CODE, aC as resolveImportOptions, I as ImportReportBuilder, aA as reportUnusedOptions, az as reportSinkOptions, ay as readText, a as throwIfAborted, s as IdCoercer, l as DirectionResolver, ax as parseWeightText, af as declareResolved } from "./writer-DxSKC7TL.js";
+import { b as quoteDotId, c as isWritableDotText } from "./escape-DyI8JofU.js";
+import { i as inferTextDtype, W as WIDENING_UNSUPPORTED_CODE, p as parseTextCell, T as TextCellWriter } from "./text-CajMdVFy.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 KEY_ATTRIBUTE = "key";
+const PIN_ATTRIBUTE = "pin";
+const DOT_META_KEY = "dot";
+const DOT_LOSS = Object.freeze({
+  /** An id, name or text with a backslash before a quote or at its end cannot be written as a DOT quoted string; export() throws. */
+  TRAILING_BACKSLASH: "E_DOT_TRAILING_BACKSLASH",
+  /** A non-finite f32 / f64 cell has no numeric DOT spelling and reads back as text. */
+  NON_FINITE: "W_DOT_NON_FINITE",
+  /** Text cells that look like numbers or booleans read back as such (DOT attribute values are untyped). */
+  TEXT_INFERRED: LOSS.TEXT_INFERRED,
+  /** A plain column named like an attribute the exporter writes for a role (weight, key, pos) is not written. */
+  ATTRIBUTE_CLASH: "W_DOT_ATTRIBUTE_CLASH",
+  /** A mutual pair is written as two directed edges. */
+  MUTUAL_EXPANDED: LOSS.MUTUAL_EXPANDED,
+  /** A parents (multi-parent) column cannot be written; DOT clusters nest. */
+  PARENTS_DROPPED: LOSS.PARENTS,
+  /** A position column that is not a node column of 2 or 3 components is not written. */
+  POSITION_SHAPE: "W_DOT_POSITION_SHAPE",
+  /** An id whose text reads back as the other type under ids: "canonical" (1.5 as text, "1" as 1). */
+  ID_TEXT_TYPE: LOSS.ID_TEXT_TYPE,
+  /** A declared column whose every row is unset is not written (DOT writes cells, never declarations). */
+  EMPTY_COLUMN_DROPPED: LOSS.EMPTY_COLUMN,
+  /** A role-less column named `label` reads back with the label role. */
+  ROLE_ASSUMED: LOSS.ROLE_ASSUMED
+});
+const KEPT_ROLES = /* @__PURE__ */ new Set(["label", "id", "sourcePort", "targetPort", "parent"]);
+const ROLE_NAMES = Object.freeze({
+  label: LABEL_ATTRIBUTE,
+  id: KEY_ATTRIBUTE,
+  sourcePort: SOURCE_PORT_COLUMN,
+  targetPort: TARGET_PORT_COLUMN,
+  parent: PARENT_COLUMN,
+  position: POS_ATTRIBUTE
+});
+const CAPABILITIES = capabilities({
+  mixedDirection: false,
+  multiEdges: true,
+  selfLoops: true,
+  edgeIds: "optional",
+  idCharset: "any",
+  dtypes: ["bool", "i32", "f64", "string"],
+  components: false,
+  lists: false,
+  json: false,
+  defaults: false,
+  options: false,
+  hierarchy: true,
+  temporal: "none",
+  graphAttributes: true,
+  positions: true,
+  viz: false
+});
+const DEFAULT_INDENT = "    ";
+const CLUSTER_PREFIX$1 = "cluster";
+const COMPASS_POINTS = /* @__PURE__ */ new Set(["n", "ne", "e", "se", "s", "sw", "w", "nw", "c", "_"]);
+const SKIPPED_NODE_ROLES = /* @__PURE__ */ new Set([
+  "parent",
+  "parents",
+  "position",
+  "color",
+  "size",
+  "shape",
+  "thickness",
+  "start",
+  "end",
+  "timestamp",
+  "timestamps",
+  "spells",
+  "open",
+  "timeText",
+  "directed",
+  "pair",
+  "mutual",
+  "weight"
+]);
+const SKIPPED_EDGE_ROLES = /* @__PURE__ */ new Set([
+  "id",
+  "weight",
+  "directed",
+  "pair",
+  "mutual",
+  "sourcePort",
+  "targetPort",
+  "position",
+  "color",
+  "size",
+  "shape",
+  "thickness",
+  "start",
+  "end",
+  "timestamp",
+  "timestamps",
+  "spells",
+  "open",
+  "timeText",
+  "parent",
+  "parents"
+]);
+const SKIPPED_GRAPH_ROLES = /* @__PURE__ */ new Set(["position", "color", "size", "shape", "thickness"]);
+const TEXT_ROLES = /* @__PURE__ */ new Set(["label", "id", "sourcePort", "targetPort"]);
+const dotExporter = Object.freeze({
+  format: DOT_FORMAT,
+  capabilities: CAPABILITIES,
+  /**
+   * Pre-flight: every loss the DOT text would incur, without writing anything.
+   * @param snapshot - the snapshot to check
+   * @param options - format-specific and common options
+   * @returns the notes, empty when the export is exact
+   */
+  check(snapshot, options) {
+    const resolved = resolveExportOptions(options);
+    const notes = checkCapabilities(snapshot, CAPABILITIES, resolved, {
+      positionDtype: "f32",
+      roles: KEPT_ROLES,
+      roleNames: ROLE_NAMES
+    });
+    const plan = new ExportPlan(snapshot, resolved, options);
+    return [...notes, ...plan.notes()];
+  },
+  /**
+   * Write the snapshot as UTF-8 chunks.
+   * @param snapshot - the snapshot to write
+   * @param options - format-specific and common options
+   * @returns the encoded chunks
+   */
+  export(snapshot, options) {
+    return encodeChunks(writeDot(snapshot, options));
+  },
+  /**
+   * Write the snapshot as one string.
+   * @param snapshot - the snapshot to write
+   * @param options - format-specific and common options
+   * @returns the whole document
+   */
+  exportToString(snapshot, options) {
+    return joinText(writeDot(snapshot, options));
+  }
+});
+function* writeDot(snapshot, options) {
+  const resolved = resolveExportOptions(options);
+  const plan = new ExportPlan(snapshot, resolved, options);
+  plan.refuse();
+  yield* plan.write();
+}
+function endsWithBackslash(text) {
+  return !isWritableDotText(text);
+}
+function isHtmlString(text) {
+  if (text.length < 2 || !text.startsWith("<") || !text.endsWith(">")) {
+    return false;
+  }
+  let depth = 0;
+  for (let i = 0; i < text.length; i++) {
+    const c = text.charCodeAt(i);
+    if (c === 60) {
+      depth++;
+    } else if (c === 62) {
+      depth--;
+      if (depth === 0 && i !== text.length - 1) {
+        return false;
+      }
+    }
+  }
+  return depth === 0;
+}
+function writeId(text) {
+  return isHtmlString(text) ? text : quoteDotId(text);
+}
+function writePort(port) {
+  const colon = port.lastIndexOf(":");
+  if (colon > 0 && COMPASS_POINTS.has(port.slice(colon + 1))) {
+    return `:${quoteDotId(port.slice(0, colon))}:${port.slice(colon + 1)}`;
+  }
+  return `:${quoteDotId(port)}`;
+}
+function isTextualDtype(column) {
+  return column.dtype !== "list" && column.dtype !== "json";
+}
+class ExportPlan {
+  /**
+   * Plan one export.
+   * @param snapshot - the snapshot
+   * @param resolved - the resolved common options
+   * @param options - the caller's options (format-specific fields read here)
+   */
+  constructor(snapshot, resolved, options) {
+    this.extraNotes = [];
+    this.snapshot = snapshot;
+    this.resolved = resolved;
+    this.indent = options?.indent ?? DEFAULT_INDENT;
+    this.name = options?.name === void 0 ? snapshot.meta.name : options.name;
+    this.strict = options?.strict ?? isStrictMeta(snapshot);
+    this.mixed = countMixedEdges(snapshot);
+    if (this.mixed > 0 && resolved.onMixedDirection !== "error") {
+      this.directed = resolved.onMixedDirection === "directed";
+    } else {
+      this.directed = snapshot.directed;
+    }
+    const { nodes, edges, graph } = snapshot;
+    this.position = nodes.byRole("position");
+    this.positionDims = positionDims(this.position);
+    this.parent = nodes.byRole("parent");
+    const cluster = nodes.get(CLUSTER_COLUMN);
+    this.cluster = cluster !== null && cluster.dtype === "bool" ? cluster : null;
+    this.edgeId = edges.byRole("id");
+    this.weights = explicitWeights(snapshot);
+    this.folding = pairFolding(snapshot);
+    this.sourcePort = edges.byRole("sourcePort");
+    this.targetPort = edges.byRole("targetPort");
+    this.nodeColumns = [...nodes].filter((c) => this.writesNodeColumn(c));
+    this.edgeColumns = [...edges].filter((c) => this.writesEdgeColumn(c));
+    this.graphColumns = [...graph].filter(
+      (c) => isTextualDtype(c) && (c.meta.role === null || !SKIPPED_GRAPH_ROLES.has(c.meta.role))
+    );
+    this.children = childrenCsr(snapshot, {
+      column: this.parent !== null && this.parent.dtype === "u32" ? this.parent : null
+    });
+  }
+  /**
+   * Whether a node column is written as node attributes.
+   * @param column - the column
+   * @returns true when written
+   */
+  writesNodeColumn(column) {
+    const { name, role } = column.meta;
+    if (!isTextualDtype(column) || name === CLUSTER_COLUMN) {
+      return false;
+    }
+    if (role !== null && SKIPPED_NODE_ROLES.has(role)) {
+      return false;
+    }
+    if (name === POS_ATTRIBUTE && role !== "position") {
+      this.clash("node", name, "the position role is written as pos");
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Whether an edge column is written as edge attributes.
+   * @param column - the column
+   * @returns true when written
+   */
+  writesEdgeColumn(column) {
+    const { name, role } = column.meta;
+    if (!isTextualDtype(column)) {
+      return false;
+    }
+    if (role !== null && SKIPPED_EDGE_ROLES.has(role)) {
+      return false;
+    }
+    if (name === KEY_ATTRIBUTE && this.edgeId !== null) {
+      this.clash("edge", name, "the edge id role is written as key");
+      return false;
+    }
+    if (name === "weight") {
+      this.clash("edge", name, "the weight is written as weight");
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Record a column not written because its name is an attribute the exporter writes for a role.
+   * @param domain - the table
+   * @param name - the column name
+   * @param reason - why
+   */
+  clash(domain, name, reason) {
+    this.extraNotes.push(
+      Object.freeze({
+        code: DOT_LOSS.ATTRIBUTE_CLASH,
+        message: `${domain} column "${name}" has no role and is not written: ${reason}`,
+        column: name,
+        count: null
+      })
+    );
+  }
+  /**
+   * The format-specific loss notes (the generic ones come from checkCapabilities).
+   * @returns the notes
+   */
+  notes() {
+    const notes = [...this.extraNotes];
+    const note = (code, message, column = null, count = null) => {
+      notes.push(Object.freeze({ code, message, column, count }));
+    };
+    const { snapshot } = this;
+    const unwritable = this.countUnwritable();
+    if (unwritable > 0) {
+      note(
+        DOT_LOSS.TRAILING_BACKSLASH,
+        `${unwritable} id(s), name(s) or text value(s) hold a backslash before a quote or at the end, which a DOT quoted string cannot carry; export() will throw`,
+        null,
+        unwritable
+      );
+    }
+    for (const [label, columns] of [
+      ["node", this.nodeColumns],
+      ["edge", this.edgeColumns],
+      ["graph", this.graphColumns]
+    ]) {
+      for (const column of columns) {
+        if (label !== "graph" && column.nullCount === column.length) {
+          note(
+            DOT_LOSS.EMPTY_COLUMN_DROPPED,
+            `${label} column "${column.meta.name}" has no set cell and is not written: DOT writes cells, never declarations`,
+            column.meta.name,
+            0
+          );
+          continue;
+        }
+        if (label !== "graph" && column.meta.role === null && column.meta.name === LABEL_ATTRIBUTE && (column.dtype === "string" || column.dtype === "dict")) {
+          note(
+            DOT_LOSS.ROLE_ASSUMED,
+            `${label} column "${column.meta.name}" reads back with the label role`,
+            column.meta.name,
+            column.length - column.nullCount
+          );
+        }
+        if (column.dtype === "f32" || column.dtype === "f64") {
+          const bad = countNonFinite(column);
+          if (bad > 0) {
+            note(
+              DOT_LOSS.NON_FINITE,
+              `${label} column "${column.meta.name}" holds ${bad} non-finite value(s) with no numeric DOT spelling; they read back as text`,
+              column.meta.name,
+              bad
+            );
+          }
+        }
+        if ((column.dtype === "string" || column.dtype === "dict") && (column.meta.role === null || !TEXT_ROLES.has(column.meta.role))) {
+          const typed = countTypedLookingText(column);
+          if (typed > 0) {
+            note(
+              DOT_LOSS.TEXT_INFERRED,
+              `${label} column "${column.meta.name}" holds ${typed} text value(s) that look like numbers or booleans; DOT values are untyped and they read back as such`,
+              column.meta.name,
+              typed
+            );
+          }
+        }
+      }
+    }
+    const mutual = this.folding.mutualCount;
+    if (mutual > 0) {
+      note(
+        DOT_LOSS.MUTUAL_EXPANDED,
+        `${mutual} mutual pair(s) are written as two directed edges each; the mutual mark is lost`,
+        null,
+        mutual
+      );
+    }
+    const parents = snapshot.nodes.byRole("parents");
+    if (parents !== null) {
+      note(
+        DOT_LOSS.PARENTS_DROPPED,
+        `node column "${parents.meta.name}" (parents) cannot be written: a DOT node is in one cluster`,
+        parents.meta.name,
+        parents.length - parents.nullCount
+      );
+    }
+    if (this.position !== null && this.position.meta.components !== 2 && this.position.meta.components !== 3) {
+      note(
+        DOT_LOSS.POSITION_SHAPE,
+        `node column "${this.position.meta.name}" (position) has ${this.position.meta.components} components and is not written; pos takes 2 or 3`,
+        this.position.meta.name,
+        this.position.length - this.position.nullCount
+      );
+    }
+    for (const [label, table] of [
+      ["edge", snapshot.edges],
+      ["graph", snapshot.graph]
+    ]) {
+      const column = table.byRole("position");
+      if (column !== null) {
+        note(
+          DOT_LOSS.POSITION_SHAPE,
+          `${label} column "${column.meta.name}" (position) is not written; only node positions map to pos`,
+          column.meta.name,
+          column.length - column.nullCount
+        );
+      }
+    }
+    const textIds = countTextIds(snapshot);
+    if (textIds > 0) {
+      note(
+        DOT_LOSS.ID_TEXT_TYPE,
+        `${textIds} node id(s) read back as the other type under ids: "canonical" (a string "1" becomes 1, a number 1.5 becomes "1.5")`,
+        null,
+        textIds
+      );
+    }
+    return notes;
+  }
+  /**
+   * Throw for the conditions check() reports as errors: mixed direction under "error", and an
+   * unwritable id / name / text.
+   */
+  refuse() {
+    if (this.mixed > 0 && this.resolved.onMixedDirection === "error") {
+      throw new GraphFormatError(
+        "E_DIRECTED",
+        `${this.mixed} undirected edge(s) in a directed graph; DOT has no mixed direction and onMixedDirection is "error"`,
+        { reason: LOSS.MIXED_DIRECTION_ERROR, count: this.mixed }
+      );
+    }
+    const first = this.firstUnwritable();
+    if (first !== null) {
+      throw new GraphFormatError(
+        first.kind === "id" ? "E_INVALID_ID" : "E_COLUMN_TYPE",
+        `${first.kind} ${JSON.stringify(first.text)} ends in a backslash, which a DOT quoted string cannot carry`,
+        { reason: "trailing backslash", kind: first.kind, value: first.text }
+      );
+    }
+    sanitizeIds(this.snapshot, CAPABILITIES.idCharset, this.resolved.sanitizeIds);
+  }
+  /**
+   * How many ids, names and text values end in a backslash.
+   * @returns the count
+   */
+  countUnwritable() {
+    let count = 0;
+    this.forEachText((text) => {
+      if (endsWithBackslash(text)) {
+        count++;
+      }
+    });
+    return count;
+  }
+  /**
+   * The first id, name or text value ending in a backslash.
+   * @returns what it is and its text, or null
+   */
+  firstUnwritable() {
+    let found = null;
+    this.forEachText((text, kind) => {
+      if (found === null && endsWithBackslash(text)) {
+        found = { kind, text };
+      }
+    });
+    return found;
+  }
+  /**
+   * Visit every text the document writes as a quoted string: the graph name, node ids, column
+   * names and string / dict cells.
+   * @param visit - the visitor
+   */
+  forEachText(visit) {
+    const { snapshot } = this;
+    if (this.name !== null) {
+      visit(this.name, "graph name");
+    }
+    for (let i = 0; i < snapshot.nodeCount; i++) {
+      const id = snapshot.ids.idOf(i);
+      if (typeof id === "string") {
+        visit(id, "id");
+      }
+    }
+    for (const columns of [this.nodeColumns, this.edgeColumns, this.graphColumns]) {
+      for (const column of columns) {
+        visit(column.meta.name, "attribute name");
+        if (column.dtype === "string" || column.dtype === "dict") {
+          for (let r = 0; r < column.length; r++) {
+            if (column.isSet(r)) {
+              visit(column.value(r), "value");
+            }
+          }
+        }
+      }
+    }
+    for (const column of [this.edgeId, this.sourcePort, this.targetPort]) {
+      if (column !== null && (column.dtype === "string" || column.dtype === "dict")) {
+        for (let r = 0; r < column.length; r++) {
+          if (column.isSet(r)) {
+            visit(column.value(r), "value");
+          }
+        }
+      }
+    }
+  }
+  /**
+   * The document, one statement per part.
+   * @yields the parts
+   * @returns nothing
+   */
+  *write() {
+    const { snapshot, indent } = this;
+    const keyword = this.directed ? "digraph" : "graph";
+    const name = this.name === null ? "" : ` ${quoteDotId(this.name)}`;
+    yield `${this.strict ? "strict " : ""}${keyword}${name} {
+`;
+    const graphAttributes = this.attributesOf(this.graphColumns, 0);
+    if (graphAttributes.length > 0) {
+      yield `${indent}graph [${graphAttributes.join(", ")}];
+`;
+    }
+    const emitted = new Uint8Array(snapshot.nodeCount);
+    for (let i = 0; i < snapshot.nodeCount; i++) {
+      yield* this.writeNode(i, 1, emitted);
+    }
+    yield* this.writeEdges();
+    yield "}\n";
+  }
+  /**
+   * Write one node (and, for a container, its cluster block with the members nested).
+   * @param i - the node index
+   * @param depth - the nesting depth
+   * @param emitted - which nodes were written already
+   * @yields the statements
+   * @returns nothing
+   */
+  *writeNode(i, depth, emitted) {
+    if (emitted[i] === 1) {
+      return;
+    }
+    emitted[i] = 1;
+    const pad = this.indent.repeat(depth);
+    const idText = this.idText(i);
+    const kids = this.children.childrenOf(i);
+    const marked = this.cluster !== null && this.cluster.isSet(i) && this.cluster.value(i) === true;
+    if (kids.length === 0 && !marked) {
+      yield `${pad}${this.nodeStatement(i, idText)};
+`;
+      return;
+    }
+    if (!marked) {
+      yield `${pad}${this.nodeStatement(i, idText)};
+`;
+    }
+    const inner = `${pad}${this.indent}`;
+    yield `${pad}subgraph ${writeId(idText)} {
+`;
+    if (!idText.startsWith(CLUSTER_PREFIX$1)) {
+      yield `${inner}cluster=true;
+`;
+    }
+    if (marked) {
+      const attributes = this.nodeAttributes(i);
+      if (attributes.length > 0) {
+        yield `${inner}graph [${attributes.join(", ")}];
+`;
+      }
+    }
+    for (const child of kids) {
+      if (emitted[child] === 1) {
+        yield `${inner}${writeId(this.idText(child))};
+`;
+      } else {
+        yield* this.writeNode(child, depth + 1, emitted);
+      }
+    }
+    yield `${pad}}
+`;
+  }
+  /**
+   * A node statement without its terminator.
+   * @param i - the node index
+   * @param idText - the id text
+   * @returns `id` or `id [attrs]`
+   */
+  nodeStatement(i, idText) {
+    const attributes = this.nodeAttributes(i);
+    return attributes.length === 0 ? writeId(idText) : `${writeId(idText)} [${attributes.join(", ")}]`;
+  }
+  /**
+   * The attributes of a node: its set cells plus `pos` from the position column.
+   * @param i - the node index
+   * @returns the attribute texts
+   */
+  nodeAttributes(i) {
+    const attributes = this.attributesOf(this.nodeColumns, i);
+    const pos = this.positionText(i);
+    if (pos !== null) {
+      attributes.push(`${POS_ATTRIBUTE}=${quoteDotId(pos)}`);
+    }
+    return attributes;
+  }
+  /**
+   * The `pos` text of a node, or null when it has none.
+   * @param i - the node index
+   * @returns `x,y` or `x,y,z`
+   */
+  positionText(i) {
+    const column = this.position;
+    if (column === null || !column.isSet(i)) {
+      return null;
+    }
+    if (column.dtype !== "f32" && column.dtype !== "f64" && column.dtype !== "i32") {
+      return null;
+    }
+    const { components } = column.meta;
+    if (components !== 2 && components !== 3) {
+      return null;
+    }
+    const format = column.dtype === "f32" ? formatF32 : formatF64;
+    const base = i * components;
+    const { data } = column;
+    const parts = [format(data[base]), format(data[base + 1])];
+    if (this.positionDims === 3) {
+      parts.push(format(components === 3 ? data[base + 2] : 0));
+    }
+    return parts.join(",");
+  }
+  /**
+   * The `name=value` attributes of one row over a column list (set cells only).
+   * @param columns - the columns
+   * @param row - the row
+   * @returns the attribute texts
+   */
+  attributesOf(columns, row) {
+    const out = [];
+    for (const column of columns) {
+      if (!column.isSet(row)) {
+        continue;
+      }
+      const text = cellText(column, row);
+      if (text !== null) {
+        out.push(`${quoteDotId(column.meta.name)}=${writeId(text)}`);
+      }
+    }
+    return out;
+  }
+  /**
+   * Every logical edge in index order, mirror halves of expanded undirected pairs folded away.
+   * @yields the edge statements
+   * @returns nothing
+   */
+  *writeEdges() {
+    const { snapshot, indent } = this;
+    const list = snapshot.edgeList();
+    const op = this.directed ? "->" : "--";
+    for (let e = 0; e < snapshot.edgeCount; e++) {
+      if (this.folding.folded(e)) {
+        continue;
+      }
+      const attributes = this.attributesOf(this.edgeColumns, e);
+      const weight = this.weights.text(e);
+      if (weight !== null) {
+        attributes.unshift(`weight=${quoteDotId(weight)}`);
+      }
+      const key = this.keyText(e);
+      if (key !== null) {
+        attributes.unshift(`${KEY_ATTRIBUTE}=${writeId(key)}`);
+      }
+      const source = `${writeId(this.idText(list.src[e]))}${this.portText(this.sourcePort, e)}`;
+      const target = `${writeId(this.idText(list.dst[e]))}${this.portText(this.targetPort, e)}`;
+      const tail = attributes.length === 0 ? "" : ` [${attributes.join(", ")}]`;
+      yield `${indent}${source} ${op} ${target}${tail};
+`;
+    }
+  }
+  /**
+   * The edge id of an edge as `key` text, or null.
+   * @param e - the edge index
+   * @returns the text
+   */
+  keyText(e) {
+    const column = this.edgeId;
+    if (column === null || !column.isSet(e)) {
+      return null;
+    }
+    if (column.dtype === "f32" || column.dtype === "f64") {
+      return formatF64(column.data[e]);
+    }
+    return cellText(column, e);
+  }
+  /**
+   * The port suffix of an endpoint.
+   * @param column - the port column, or null
+   * @param e - the edge index
+   * @returns `:port` or ""
+   */
+  portText(column, e) {
+    if (column === null || !column.isSet(e)) {
+      return "";
+    }
+    const text = cellText(column, e);
+    return text === null || text.length === 0 ? "" : writePort(text);
+  }
+  /**
+   * The id text of a node.
+   * @param i - the node index
+   * @returns String(id)
+   */
+  idText(i) {
+    return idToText(this.snapshot.ids.idOf(i));
+  }
+}
+function idToText(id) {
+  return typeof id === "string" ? id : formatF64(id);
+}
+function isStrictMeta(snapshot) {
+  const dot = snapshot.meta.extra[DOT_META_KEY];
+  return typeof dot === "object" && dot !== null && dot.strict === true;
+}
+function positionDims(column) {
+  if (column === null) {
+    return 2;
+  }
+  const dims = column.meta.extra.sourceDims;
+  if (dims === 2 || dims === 3) {
+    return dims;
+  }
+  return column.meta.components === 2 ? 2 : 3;
+}
+function cellText(column, row) {
+  switch (column.dtype) {
+    case "bool":
+      return column.value(row) === true ? "true" : "false";
+    case "i32":
+    case "u32":
+    case "u8":
+      return numericText(column, row, formatInteger);
+    case "f32":
+      return numericText(column, row, (v) => formatDecimal(v, "f32"));
+    case "f64":
+      return numericText(column, row, (v) => formatDecimal(v, "f64"));
+    case "dict":
+    case "string":
+      return column.value(row) ?? "";
+    case "list":
+    case "json":
+      return null;
+    default: {
+      const name = column.dtype;
+      throw new GraphFormatError("E_COLUMN_TYPE", `unknown dtype ${name}`, { dtype: name });
+    }
+  }
+}
+function numericText(column, row, format) {
+  const { components } = column.meta;
+  if (components === 1) {
+    return format(column.data[row]);
+  }
+  const parts = [];
+  for (let k = 0; k < components; k++) {
+    parts.push(format(column.data[row * components + k]));
+  }
+  return parts.join(",");
+}
+function countNonFinite(column) {
+  if (column.dtype !== "f32" && column.dtype !== "f64") {
+    return 0;
+  }
+  const { components } = column.meta;
+  let count = 0;
+  for (let r = 0; r < column.length; r++) {
+    if (!column.isSet(r)) {
+      continue;
+    }
+    for (let k = 0; k < components; k++) {
+      if (!Number.isFinite(column.data[r * components + k])) {
+        count++;
+        break;
+      }
+    }
+  }
+  return count;
+}
+function countTypedLookingText(column) {
+  if (column.dtype !== "string" && column.dtype !== "dict") {
+    return 0;
+  }
+  let count = 0;
+  for (let r = 0; r < column.length; r++) {
+    if (column.isSet(r) && inferTextDtype(column.value(r) ?? "") !== "string") {
+      count++;
+    }
+  }
+  return count;
+}
+function countTextIds(snapshot) {
+  const { ids } = snapshot;
+  if (ids.kind === "identity" || ids.kind === "dense") {
+    return 0;
+  }
+  let count = 0;
+  for (let i = 0; i < ids.size; i++) {
+    const id = ids.idOf(i);
+    if (canonicalId(idToText(id)) !== id) {
+      count++;
+    }
+  }
+  return count;
+}
+class DotSyntaxError extends Error {
+  /**
+   * Create a syntax error.
+   * @param message - a plain-ASCII message
+   * @param line - the 1-based line
+   */
+  constructor(message, line) {
+    super(message);
+    this.name = "DotSyntaxError";
+    this.line = line;
+  }
+}
+const EOF_TOKEN_TEXT = "";
+function isIdentifierStart(c) {
+  return c >= 65 && c <= 90 || c >= 97 && c <= 122 || c === 95 || c >= 128;
+}
+function isIdentifierPart(c) {
+  return isIdentifierStart(c) || isDigit(c);
+}
+function isDigit(c) {
+  return c >= 48 && c <= 57;
+}
+class DotTokenizer {
+  /**
+   * Create a lexer over a whole document.
+   * @param text - the DOT text (BOM already removed)
+   * @param onAmbiguity - called for a badly delimited numeral (`1e3`, which Graphviz splits into
+   * `1` and `e3` with a warning), with the numeral text and its line
+   */
+  constructor(text, onAmbiguity = null) {
+    this.pos = 0;
+    this.line = 1;
+    this.lookahead = [];
+    this.text = text;
+    this.onAmbiguity = onAmbiguity;
+  }
+  /**
+   * Look at a token without consuming it.
+   * @param n - how far ahead (0 = the next token)
+   * @returns the token; an "eof" token past the end
+   */
+  peek(n = 0) {
+    while (this.lookahead.length <= n) {
+      this.lookahead.push(this.lex());
+    }
+    return this.lookahead[n];
+  }
+  /**
+   * Consume the next token.
+   * @returns the token; an "eof" token past the end
+   */
+  next() {
+    const ahead = this.lookahead.shift();
+    return ahead ?? this.lex();
+  }
+  /**
+   * Produce the next token from the text.
+   * @returns the token
+   */
+  lex() {
+    this.skipTrivia();
+    const { text } = this;
+    if (this.pos >= text.length) {
+      return { kind: "eof", text: EOF_TOKEN_TEXT, quoted: false, html: false, line: this.line };
+    }
+    const start = this.pos;
+    const { line } = this;
+    const c = text.charCodeAt(start);
+    switch (c) {
+      case 123:
+      // {
+      case 125:
+      // }
+      case 91:
+      // [
+      case 93:
+      // ]
+      case 59:
+      // ;
+      case 44:
+      // ,
+      case 61:
+      // =
+      case 58:
+      // :
+      case 43:
+        this.pos++;
+        return { kind: "punct", text: text[start], quoted: false, html: false, line };
+      case 45: {
+        const d = text.charCodeAt(start + 1);
+        if (d === 62 || d === 45) {
+          this.pos += 2;
+          return { kind: "punct", text: text.slice(start, start + 2), quoted: false, html: false, line };
+        }
+        if (isDigit(d) || d === 46 && isDigit(text.charCodeAt(start + 2))) {
+          return this.numeral(start, line);
+        }
+        throw new DotSyntaxError("unexpected '-': not an edge operator or a numeral", line);
+      }
+      case 34:
+        return this.quoted(start, line);
+      case 60:
+        return this.html(start, line);
+    }
+    if (isIdentifierStart(c)) {
+      let end = start + 1;
+      while (end < text.length && isIdentifierPart(text.charCodeAt(end))) {
+        end++;
+      }
+      this.pos = end;
+      return { kind: "id", text: text.slice(start, end), quoted: false, html: false, line };
+    }
+    if (isDigit(c) || c === 46 && isDigit(text.charCodeAt(start + 1))) {
+      return this.numeral(start, line);
+    }
+    throw new DotSyntaxError(`unexpected character ${JSON.stringify(text[start])}`, line);
+  }
+  /**
+   * Lex a numeral `-?(.[0-9]+ | [0-9]+(.[0-9]*)?)` starting at `start`.
+   * @param start - the offset of the first character (a sign, a digit or a dot)
+   * @param line - the line
+   * @returns the id token holding the numeral text
+   */
+  numeral(start, line) {
+    const { text } = this;
+    let end = start;
+    if (text.charCodeAt(end) === 45) {
+      end++;
+    }
+    while (end < text.length && isDigit(text.charCodeAt(end))) {
+      end++;
+    }
+    if (text.charCodeAt(end) === 46) {
+      end++;
+      while (end < text.length && isDigit(text.charCodeAt(end))) {
+        end++;
+      }
+    }
+    this.pos = end;
+    const numeral = text.slice(start, end);
+    if (end < text.length && isIdentifierStart(text.charCodeAt(end)) && this.onAmbiguity !== null) {
+      this.onAmbiguity(numeral, line);
+    }
+    return { kind: "id", text: numeral, quoted: false, html: false, line };
+  }
+  /**
+   * Lex a double-quoted string starting at the opening quote: `\"` is the only escape, a
+   * backslash followed by a line break is a continuation (both removed), every other backslash is
+   * kept as written, and raw line breaks are allowed inside.
+   * @param start - the offset of the opening quote
+   * @param line - the line of the opening quote
+   * @returns the id token holding the decoded text
+   */
+  quoted(start, line) {
+    const { text } = this;
+    let out = "";
+    let segment = start + 1;
+    let i = start + 1;
+    for (; ; ) {
+      if (i >= text.length) {
+        throw new DotSyntaxError("unterminated quoted string (missing closing quote)", line);
+      }
+      const c = text.charCodeAt(i);
+      if (c === 34) {
+        out += text.slice(segment, i);
+        this.pos = i + 1;
+        return { kind: "id", text: out, quoted: true, html: false, line };
+      }
+      if (c === 92) {
+        const d = text.charCodeAt(i + 1);
+        if (d === 34) {
+          out += `${text.slice(segment, i)}"`;
+          i += 2;
+          segment = i;
+          continue;
+        }
+        if (d === 92) {
+          i += 2;
+          continue;
+        }
+        if (d === 10 || d === 13) {
+          out += text.slice(segment, i);
+          i += d === 13 && text.charCodeAt(i + 2) === 10 ? 3 : 2;
+          this.line++;
+          segment = i;
+          continue;
+        }
+        i++;
+        continue;
+      }
+      if (c === 10 || c === 13) {
+        if (c === 13 && text.charCodeAt(i + 1) === 10) {
+          i++;
+        }
+        this.line++;
+      }
+      i++;
+    }
+  }
+  /**
+   * Lex an HTML string starting at the opening angle bracket: the text up to the matching
+   * closing bracket, brackets balanced, kept verbatim including the outer pair.
+   * @param start - the offset of the opening bracket
+   * @param line - the line of the opening bracket
+   * @returns the id token holding the whole `<...>` text
+   */
+  html(start, line) {
+    const { text } = this;
+    let depth = 0;
+    for (let i = start; i < text.length; i++) {
+      const c = text.charCodeAt(i);
+      if (c === 60) {
+        depth++;
+      } else if (c === 62) {
+        depth--;
+        if (depth === 0) {
+          this.pos = i + 1;
+          return { kind: "id", text: text.slice(start, i + 1), quoted: false, html: true, line };
+        }
+      } else if (c === 10 || c === 13 && text.charCodeAt(i + 1) !== 10) {
+        this.line++;
+      }
+    }
+    throw new DotSyntaxError("unterminated HTML string (missing closing '>')", line);
+  }
+  /**
+   * Skip whitespace and comments, counting lines.
+   */
+  skipTrivia() {
+    const { text } = this;
+    for (; ; ) {
+      if (this.pos >= text.length) {
+        return;
+      }
+      const c = text.charCodeAt(this.pos);
+      if (c === 10) {
+        this.line++;
+        this.pos++;
+        this.skipPreprocessorLine();
+        continue;
+      }
+      if (c === 13) {
+        this.line++;
+        this.pos += text.charCodeAt(this.pos + 1) === 10 ? 2 : 1;
+        this.skipPreprocessorLine();
+        continue;
+      }
+      if (c === 32 || c === 9 || c === 11 || c === 12) {
+        this.pos++;
+        continue;
+      }
+      if (c === 47) {
+        const d = text.charCodeAt(this.pos + 1);
+        if (d === 47) {
+          this.skipToLineEnd();
+          continue;
+        }
+        if (d === 42) {
+          this.skipBlockComment();
+          continue;
+        }
+      }
+      if (c === 35 && this.pos === 0) {
+        this.skipToLineEnd();
+        continue;
+      }
+      return;
+    }
+  }
+  /**
+   * Discard a `#` line when one starts at the current position (the start of a line).
+   */
+  skipPreprocessorLine() {
+    if (this.text.charCodeAt(this.pos) === 35) {
+      this.skipToLineEnd();
+    }
+  }
+  /**
+   * Advance to the next line break without consuming it.
+   */
+  skipToLineEnd() {
+    const { text } = this;
+    while (this.pos < text.length) {
+      const c = text.charCodeAt(this.pos);
+      if (c === 10 || c === 13) {
+        return;
+      }
+      this.pos++;
+    }
+  }
+  /**
+   * Skip a block comment starting at the current `/*`.
+   */
+  skipBlockComment() {
+    const { text } = this;
+    const startLine = this.line;
+    let i = this.pos + 2;
+    for (; i < text.length; i++) {
+      const c = text.charCodeAt(i);
+      if (c === 42 && text.charCodeAt(i + 1) === 47) {
+        this.pos = i + 2;
+        return;
+      }
+      if (c === 10 || c === 13 && text.charCodeAt(i + 1) !== 10) {
+        this.line++;
+      }
+    }
+    throw new DotSyntaxError("unterminated block comment", startLine);
+  }
+}
+const DOT_ISSUE = Object.freeze({
+  /** A grammar violation; fatal. */
+  SYNTAX: SYNTAX_CODE,
+  /** The input holds no graph at all (empty or only comments); fatal. */
+  EMPTY_INPUT: EMPTY_INPUT_CODE,
+  /** The input holds invalid UTF-8 (fatal). */
+  INVALID_UTF8: INVALID_UTF8_CODE,
+  /** Subgraphs or braces nested deeper than the parser's limit; fatal. */
+  NESTING: "E_DOT_NESTING",
+  /** An edge operator contradicting the graph keyword (warning under "operator" / "header"). */
+  EDGE_OPERATOR: "W_DOT_EDGE_OPERATOR",
+  /** A second graph in the same input; only the first is read. */
+  MULTIPLE_GRAPHS: MULTIPLE_GRAPHS_CODE,
+  /** A badly delimited numeral (`1e3`) split into two tokens, as Graphviz does with a warning. */
+  NUMERAL_AMBIGUITY: "W_DOT_NUMERAL_AMBIGUITY",
+  /** Attributes of a subgraph that is not a cluster (rank=same and the like) cannot be represented. */
+  SUBGRAPH_ATTRIBUTES_DROPPED: "W_DOT_SUBGRAPH_ATTRIBUTES_DROPPED",
+  /** A port on a node statement has no meaning and was dropped. */
+  NODE_PORT_DROPPED: "W_DOT_NODE_PORT_DROPPED",
+  /** A plain node and a cluster share a name and were merged into one container node. */
+  CLUSTER_NODE_MERGED: "W_DOT_CLUSTER_NODE_MERGED",
+  /** A node mentioned in two unrelated clusters keeps the first. */
+  CLUSTER_CONFLICT: "W_DOT_CLUSTER_CONFLICT",
+  /** A node `pos` that is not a point; the value was dropped. */
+  BAD_POS: "W_DOT_BAD_POS",
+  /** A parallel edge merged into an earlier one under `strict`. */
+  STRICT_MERGED: "W_DOT_STRICT_MERGED",
+  /** An edge merged into an earlier one with the same endpoints and `key`. */
+  KEY_MERGED: "W_DOT_KEY_MERGED",
+  /** A role (label, id, position, ...) was already taken in the caller's sink; the column was declared without it. */
+  ROLE_TAKEN: ROLE_TAKEN_CODE,
+  /** A column of another shape exists in the caller's sink under a name the importer declares; renamed `<name>#<id>`. */
+  COLUMN_RENAMED: COLUMN_RENAMED_CODE,
+  /** A common option the format has no use for was given a non-default value. */
+  OPTION_IGNORED: OPTION_IGNORED_CODE,
+  /** Two distinct id texts merged under ids: "number". */
+  ID_MERGED: ID_MERGED_CODE,
+  /** A builder-policy option the sink does not honour. */
+  SINK_OPTION: SINK_OPTION_CODE,
+  /** The sink refused the file's direction. */
+  DIRECTION_REFUSED: DIRECTION_REFUSED_CODE,
+  /** Edges forced to the policy's direction. */
+  DIRECTION_FORCED: DIRECTION_FORCED_CODE,
+  /** A mixed file under onMixedDirection "error" (fatal). */
+  MIXED_DIRECTION: MIXED_DIRECTION_CODE,
+  /** A text column the sink could not widen to the dtype its cells imply. */
+  WIDENING_UNSUPPORTED: WIDENING_UNSUPPORTED_CODE
+});
+const USED_OPTIONS = /* @__PURE__ */ new Set([
+  "ids",
+  "addMissingNodes",
+  "duplicateEdges",
+  "selfLoops",
+  "onMixedDirection",
+  "weightFrom",
+  "weightDtype",
+  "errorLimit",
+  "signal",
+  "onProgress"
+]);
+const MAX_NESTING = 1024;
+const EXTENSIONS = Object.freeze([".dot", ".gv"]);
+const MIME_TYPES = Object.freeze(["text/vnd.graphviz"]);
+const CLUSTER_PREFIX = "cluster";
+const CLUSTER_ATTRIBUTE = "cluster";
+const STATEMENTS_PER_ABORT_CHECK = 64;
+const MAX_ANCESTOR_WALK = 4096;
+const DOT_HEADER = /^\s*(strict\s+)?(di)?graph\b/i;
+const TRUE_TEXTS = /* @__PURE__ */ new Set(["true", "yes", "1"]);
+const POINT_TEXT = /^\s*([-+]?[0-9]*\.?[0-9]+(?:[eE][-+]?[0-9]+)?)\s*,\s*([-+]?[0-9]*\.?[0-9]+(?:[eE][-+]?[0-9]+)?)(?:\s*,\s*([-+]?[0-9]*\.?[0-9]+(?:[eE][-+]?[0-9]+)?))?\s*(!?)\s*$/;
+const dotImporter = Object.freeze({
+  format: DOT_FORMAT,
+  extensions: EXTENSIONS,
+  mimeTypes: MIME_TYPES,
+  /**
+   * Confidence that the head of an input is DOT: the `[strict] graph | digraph` header after
+   * optional comments.
+   * @param head - the first bytes of the input
+   * @returns 0.95 for a header followed by `{`, 0.8 for a header alone, 0 otherwise
+   */
+  sniff(head) {
+    const text = stripLeadingComments(new TextDecoder("utf-8").decode(head));
+    const match = DOT_HEADER.exec(text);
+    if (match === null) {
+      return 0;
+    }
+    return text.includes("{") ? 0.95 : 0.8;
+  },
+  /**
+   * Read a DOT document into the sink.
+   * @param input - the text, bytes or stream
+   * @param sink - the sink to push into
+   * @param options - format-specific and common options
+   * @returns the import report; ImportError (E_IMPORT) on a syntax error or beyond the error limit
+   */
+  async import(input, sink, options) {
+    const resolved = resolveImportOptions(options, {
+      ids: "canonical",
+      defaultDirected: true,
+      weightFrom: "weight"
+    });
+    const mismatch = mismatchOption(options?.mismatchedEdgeOperator);
+    const report = new ImportReportBuilder(DOT_FORMAT, resolved.errorLimit);
+    reportUnusedOptions(options, report, USED_OPTIONS);
+    reportSinkOptions(sink, options, report);
+    const text = await readText(input, report, resolved);
+    const parser = new DotParser(text, sink, report, resolved, mismatch);
+    try {
+      parser.parse();
+    } catch (err) {
+      if (err instanceof DotSyntaxError) {
+        report.fail(SYNTAX_CODE, err.message, { line: err.line }, { line: err.line });
+      }
+      throw err;
+    }
+    throwIfAborted(resolved.signal);
+    return report.finish();
+  }
+});
+function mismatchOption(value) {
+  if (value === void 0) {
+    return "operator";
+  }
+  if (value === "operator" || value === "header" || value === "error") {
+    return value;
+  }
+  throw new GraphFormatError(
+    "E_UNSUPPORTED",
+    `option mismatchedEdgeOperator: ${JSON.stringify(value)} is not one of "operator", "header", "error"`,
+    { option: "mismatchedEdgeOperator", found: value, supported: ["operator", "header", "error"] }
+  );
+}
+function stripLeadingComments(text) {
+  let rest = text;
+  for (; ; ) {
+    const trimmed = rest.replace(/^\s+/, "");
+    if (trimmed.startsWith("//") || trimmed.startsWith("#")) {
+      const nl = trimmed.search(/[\r\n]/);
+      if (nl < 0) {
+        return "";
+      }
+      rest = trimmed.slice(nl);
+      continue;
+    }
+    if (trimmed.startsWith("/*")) {
+      const end = trimmed.indexOf("*/");
+      if (end < 0) {
+        return "";
+      }
+      rest = trimmed.slice(end + 2);
+      continue;
+    }
+    return trimmed;
+  }
+}
+function isKeyword(token, keyword) {
+  return token.kind === "id" && !token.quoted && !token.html && token.text.toLowerCase() === keyword;
+}
+function isPunct(token, text) {
+  return token.kind === "punct" && token.text === text;
+}
+function isEdgeOp(token) {
+  return token.kind === "punct" && (token.text === "->" || token.text === "--");
+}
+function describeToken(token) {
+  if (token.kind === "eof") {
+    return "end of input";
+  }
+  return JSON.stringify(token.text.length > 40 ? `${token.text.slice(0, 40)}...` : token.text);
+}
+function isClusterName(name) {
+  return name !== null && name.startsWith(CLUSTER_PREFIX);
+}
+class DotParser {
+  /**
+   * Create a parser over one document.
+   * @param text - the DOT text
+   * @param sink - the sink
+   * @param report - the report
+   * @param options - the resolved common options
+   * @param mismatch - the resolved mismatchedEdgeOperator option
+   */
+  constructor(text, sink, report, options, mismatch) {
+    this.directed = true;
+    this.strict = false;
+    this.statements = 0;
+    this.idOf = /* @__PURE__ */ new Map();
+    this.containers = /* @__PURE__ */ new Set();
+    this.parentOf = /* @__PURE__ */ new Map();
+    this.conflictWarned = /* @__PURE__ */ new Set();
+    this.strictEdges = /* @__PURE__ */ new Map();
+    this.keyedEdges = /* @__PURE__ */ new Map();
+    this.nodeLabelHandle = INVALID_INDEX;
+    this.edgeLabelHandle = INVALID_INDEX;
+    this.positionHandle = INVALID_INDEX;
+    this.clusterHandle = INVALID_INDEX;
+    this.parentHandle = INVALID_INDEX;
+    this.keyHandle = INVALID_INDEX;
+    this.sourcePortHandle = INVALID_INDEX;
+    this.targetPortHandle = INVALID_INDEX;
+    this.depth = 0;
+    this.nodeWriters = /* @__PURE__ */ new Map();
+    this.edgeWriters = /* @__PURE__ */ new Map();
+    this.lexer = new DotTokenizer(text, (numeral, line) => {
+      report.warning(
+        "validation-error",
+        DOT_ISSUE.NUMERAL_AMBIGUITY,
+        `badly delimited number ${JSON.stringify(numeral)} splits into two tokens (Graphviz warns the same)`,
+        { line, element: numeral }
+      );
+    });
+    this.sink = sink;
+    this.report = report;
+    this.options = options;
+    this.mismatch = mismatch;
+    this.ids = new IdCoercer(options.ids);
+    this.resolver = new DirectionResolver(sink, report, options.onMixedDirection);
+  }
+  /**
+   * Parse the whole document: `[strict] (graph | digraph) [ID] { stmt_list }`.
+   */
+  parse() {
+    const { lexer } = this;
+    let token = lexer.next();
+    if (token.kind === "eof") {
+      this.report.fail(EMPTY_INPUT_CODE, "the input holds no graph (empty or only comments)", {
+        line: token.line
+      });
+    }
+    if (isKeyword(token, "strict")) {
+      this.strict = true;
+      token = lexer.next();
+    }
+    if (isKeyword(token, "digraph")) {
+      this.directed = true;
+    } else if (isKeyword(token, "graph")) {
+      this.directed = false;
+    } else {
+      throw new DotSyntaxError(`expected "graph" or "digraph", found ${describeToken(token)}`, token.line);
+    }
+    const headerLine = token.line;
+    token = lexer.next();
+    let name = null;
+    if (token.kind === "id") {
+      name = token.text;
+      token = lexer.next();
+    }
+    if (!isPunct(token, "{")) {
+      throw new DotSyntaxError(`expected "{" after the graph header, found ${describeToken(token)}`, token.line);
+    }
+    this.resolver.setHeader(this.directed, { line: headerLine });
+    this.sink.setMeta({
+      name,
+      sourceFormat: DOT_FORMAT,
+      ...this.strict ? { extra: { dot: { strict: true } } } : {}
+    });
+    const root = this.newScope(null, headerLine, true, null);
+    this.statementList(root);
+    const trailing = lexer.next();
+    if (trailing.kind !== "eof") {
+      this.report.warning(
+        "unsupported",
+        MULTIPLE_GRAPHS_CODE,
+        `content after the closing brace of the graph (${describeToken(trailing)}) was not read; one graph per input`,
+        { line: trailing.line }
+      );
+    }
+  }
+  /**
+   * Create a scope.
+   * @param parent - the enclosing scope, or null for the root
+   * @param line - the line the scope opens on
+   * @param root - whether this is the root graph
+   * @param name - the subgraph name, or null
+   * @returns the scope
+   */
+  newScope(parent, line, root, name) {
+    return {
+      root,
+      name,
+      line,
+      nodeDefaults: new Map(parent?.nodeDefaults),
+      edgeDefaults: new Map(parent?.edgeDefaults),
+      members: [],
+      memberSet: /* @__PURE__ */ new Set(),
+      containers: [],
+      attributes: /* @__PURE__ */ new Map(),
+      cluster: false,
+      container: INVALID_INDEX
+    };
+  }
+  /**
+   * Parse `stmt_list }` for a scope whose `{` was consumed.
+   * @param scope - the scope
+   */
+  statementList(scope) {
+    const { lexer } = this;
+    for (; ; ) {
+      const token = lexer.peek();
+      if (isPunct(token, "}")) {
+        lexer.next();
+        return;
+      }
+      if (token.kind === "eof") {
+        throw new DotSyntaxError(
+          scope.root ? 'unexpected end of input: missing "}" closing the graph' : `unexpected end of input: missing "}" closing the subgraph opened on line ${scope.line}`,
+          token.line
+        );
+      }
+      if (isPunct(token, ";")) {
+        lexer.next();
+        continue;
+      }
+      this.statement(scope);
+      if (++this.statements % STATEMENTS_PER_ABORT_CHECK === 0) {
+        throwIfAborted(this.options.signal);
+      }
+    }
+  }
+  /**
+   * Parse one statement of a scope.
+   * @param scope - the scope
+   */
+  statement(scope) {
+    const { lexer } = this;
+    const token = lexer.peek();
+    if (token.kind === "punct") {
+      if (token.text === "{") {
+        const group = this.subgraph(scope);
+        this.maybeEdgeStatement(scope, group, token.line);
+        return;
+      }
+      throw new DotSyntaxError(`unexpected ${describeToken(token)} at the start of a statement`, token.line);
+    }
+    if (!token.quoted && !token.html) {
+      const keyword = token.text.toLowerCase();
+      if (keyword === "node" || keyword === "edge" || keyword === "graph") {
+        lexer.next();
+        this.attributeStatement(scope, keyword, token.line);
+        return;
+      }
+      if (keyword === "subgraph") {
+        const group = this.subgraph(scope);
+        this.maybeEdgeStatement(scope, group, token.line);
+        return;
+      }
+      if (keyword === "digraph" || keyword === "strict") {
+        throw new DotSyntaxError(`unexpected keyword ${describeToken(token)} inside a graph`, token.line);
+      }
+    }
+    const id = this.identifier();
+    if (isPunct(lexer.peek(), "=")) {
+      lexer.next();
+      const value = this.identifier();
+      this.scopeAttribute(scope, { name: id.text, value: value.text, line: id.line });
+      return;
+    }
+    const port = this.port();
+    if (isEdgeOp(lexer.peek())) {
+      const endpoint = this.mentionEndpoint(scope, id, port);
+      this.edgeStatement(scope, endpoint === null ? [] : [endpoint], id.line);
+      return;
+    }
+    this.nodeStatement(scope, id, port);
+  }
+  /**
+   * Read an ID, concatenating quoted strings joined by `+`.
+   * @returns the id token (the concatenation keeps the first token's line and quoted flag)
+   */
+  identifier() {
+    const { lexer } = this;
+    const token = lexer.next();
+    if (token.kind !== "id") {
+      throw new DotSyntaxError(`expected an identifier, found ${describeToken(token)}`, token.line);
+    }
+    if (!token.quoted || !isPunct(lexer.peek(), "+")) {
+      return token;
+    }
+    let { text } = token;
+    while (isPunct(lexer.peek(), "+")) {
+      const plus = lexer.next();
+      const more = lexer.next();
+      if (more.kind !== "id" || !more.quoted) {
+        throw new DotSyntaxError(
+          `expected a quoted string after "+", found ${describeToken(more)}`,
+          more.kind === "eof" ? plus.line : more.line
+        );
+      }
+      text += more.text;
+    }
+    return { kind: "id", text, quoted: true, html: false, line: token.line };
+  }
+  /**
+   * Read an optional port after a node id: `: ID [ : compass ]` or `: compass`.
+   * @returns the port text (`f0`, `f0:n`, `n`), or null when there is none
+   */
+  port() {
+    const { lexer } = this;
+    if (!isPunct(lexer.peek(), ":")) {
+      return null;
+    }
+    lexer.next();
+    let { text } = this.identifier();
+    if (isPunct(lexer.peek(), ":")) {
+      lexer.next();
+      text += `:${this.identifier().text}`;
+    }
+    return text;
+  }
+  /**
+   * Parse `[subgraph [ID]] { stmt_list }` and return its member nodes for use as an edge endpoint.
+   * @param parent - the enclosing scope
+   * @returns the endpoints (every node mentioned in the subgraph, in first-mention order)
+   */
+  subgraph(parent) {
+    const { lexer } = this;
+    let token = lexer.next();
+    let name = null;
+    if (isKeyword(token, "subgraph")) {
+      token = lexer.next();
+      if (token.kind === "id") {
+        name = token.text;
+        token = lexer.next();
+      }
+    }
+    if (!isPunct(token, "{")) {
+      throw new DotSyntaxError(`expected "{" to open a subgraph, found ${describeToken(token)}`, token.line);
+    }
+    if (++this.depth > MAX_NESTING) {
+      this.report.fail(
+        DOT_ISSUE.NESTING,
+        `subgraphs nested deeper than ${MAX_NESTING} levels (the parser recurses per level)`,
+        { line: token.line }
+      );
+    }
+    const scope = this.newScope(parent, token.line, false, name);
+    if (isClusterName(name)) {
+      scope.cluster = true;
+      this.ensureContainer(scope);
+    }
+    this.statementList(scope);
+    this.depth--;
+    this.closeScope(scope, parent);
+    return scope.members.map((index) => ({ id: this.idOf.get(index) ?? index, index, port: null }));
+  }
+  /**
+   * Finish a subgraph: apply its attributes to the container node when it is a cluster (or report
+   * them dropped), assign parents to its members, and propagate members and containers upward.
+   * @param scope - the closed scope
+   * @param parent - the enclosing scope
+   */
+  closeScope(scope, parent) {
+    const { container } = scope;
+    if (container !== INVALID_INDEX) {
+      for (const attribute of scope.attributes.values()) {
+        if (attribute.name !== CLUSTER_ATTRIBUTE) {
+          this.setNodeAttribute(container, attribute.name, attribute.value, attribute.line);
+        }
+      }
+      for (const nested of scope.containers) {
+        if (nested !== container && !this.parentOf.has(nested)) {
+          this.setParent(nested, container);
+        }
+      }
+      for (const member of scope.members) {
+        if (member === container) {
+          continue;
+        }
+        const existing = this.parentOf.get(member);
+        if (existing === void 0) {
+          this.setParent(member, container);
+        } else if (existing !== container && !this.isAncestor(container, existing)) {
+          this.clusterConflict(member, existing, container, scope.line);
+        }
+      }
+      parent.containers.push(container);
+    } else {
+      if (scope.attributes.size > 0) {
+        const names = [...scope.attributes.keys()].join(", ");
+        this.report.warning(
+          "unsupported",
+          DOT_ISSUE.SUBGRAPH_ATTRIBUTES_DROPPED,
+          `subgraph ${scope.name === null ? "(anonymous)" : JSON.stringify(scope.name)} is not a cluster; its attributes (${names}) cannot be represented and were dropped`,
+          { line: scope.line, element: scope.name }
+        );
+      }
+      for (const nested of scope.containers) {
+        parent.containers.push(nested);
+      }
+    }
+    if (!parent.root) {
+      for (const member of scope.members) {
+        if (!parent.memberSet.has(member)) {
+          parent.memberSet.add(member);
+          parent.members.push(member);
+        }
+      }
+    }
+  }
+  /**
+   * Whether `candidate` is an ancestor of `node` through the parents assigned so far.
+   * @param candidate - the possible ancestor
+   * @param node - the node whose chain is walked
+   * @returns true when candidate is reached
+   */
+  isAncestor(candidate, node) {
+    let current = node;
+    for (let steps = 0; current !== void 0 && steps < MAX_ANCESTOR_WALK; steps++) {
+      if (current === candidate) {
+        return true;
+      }
+      current = this.parentOf.get(current);
+    }
+    return false;
+  }
+  /**
+   * Record a node mentioned in two unrelated clusters (once per node).
+   * @param member - the node
+   * @param existing - its parent
+   * @param container - the cluster it was also mentioned in
+   * @param line - the line of the losing cluster
+   */
+  clusterConflict(member, existing, container, line) {
+    if (this.conflictWarned.has(member)) {
+      return;
+    }
+    this.conflictWarned.add(member);
+    const id = this.idOf.get(member) ?? member;
+    this.report.warning(
+      "coercion",
+      DOT_ISSUE.CLUSTER_CONFLICT,
+      `node ${JSON.stringify(id)} is in cluster ${JSON.stringify(this.idOf.get(existing) ?? existing)} and in cluster ${JSON.stringify(this.idOf.get(container) ?? container)}; the first is kept`,
+      { line, element: String(id) }
+    );
+  }
+  /**
+   * Assign a parent.
+   * @param node - the node index
+   * @param container - the container index
+   */
+  setParent(node, container) {
+    if (node === container) {
+      return;
+    }
+    try {
+      this.sink.setNodeValue(this.parentColumn(), node, container);
+      this.parentOf.set(node, container);
+    } catch (err) {
+      this.report.recordError(err, { element: String(this.idOf.get(node) ?? node) });
+    }
+  }
+  /**
+   * Create (or adopt) the container node of a cluster scope.
+   * @param scope - the cluster scope
+   */
+  ensureContainer(scope) {
+    if (scope.container !== INVALID_INDEX || scope.name === null) {
+      return;
+    }
+    const id = this.coerceId(scope.name, scope.line);
+    if (id === null) {
+      return;
+    }
+    let index = this.sink.indexOf(id);
+    try {
+      if (index === INVALID_INDEX) {
+        index = this.sink.addNode(id);
+        this.report.counts.nodes++;
+      } else if (!this.containers.has(index)) {
+        this.report.warning(
+          "coercion",
+          DOT_ISSUE.CLUSTER_NODE_MERGED,
+          `cluster ${JSON.stringify(scope.name)} and the node of the same name were merged into one container node`,
+          { line: scope.line, element: scope.name }
+        );
+      }
+      this.idOf.set(index, id);
+      if (!this.containers.has(index)) {
+        this.containers.add(index);
+        this.sink.setNodeValue(this.clusterColumn(), index, true);
+      }
+      scope.container = index;
+    } catch (err) {
+      this.report.recordError(err, { line: scope.line, element: scope.name });
+      if (index === INVALID_INDEX) {
+        this.report.counts.skippedNodes++;
+      }
+    }
+  }
+  /**
+   * Apply an `ID = ID` or `graph [..]` attribute: the graph table at the root, a buffered
+   * subgraph attribute otherwise (`cluster=true` turns the subgraph into a cluster).
+   * @param scope - the scope
+   * @param attribute - the attribute
+   */
+  scopeAttribute(scope, attribute) {
+    if (scope.root) {
+      this.setGraphAttribute(attribute);
+      return;
+    }
+    scope.attributes.set(attribute.name, attribute);
+    if (attribute.name === CLUSTER_ATTRIBUTE && TRUE_TEXTS.has(attribute.value.trim().toLowerCase())) {
+      scope.cluster = true;
+      this.ensureContainer(scope);
+    }
+  }
+  /**
+   * Parse `node|edge|graph attr_list` after the keyword.
+   * @param scope - the scope
+   * @param keyword - which defaults are set
+   * @param line - the keyword's line
+   */
+  attributeStatement(scope, keyword, line) {
+    if (!isPunct(this.lexer.peek(), "[")) {
+      const found = this.lexer.peek();
+      throw new DotSyntaxError(`expected "[" after "${keyword}", found ${describeToken(found)}`, found.line);
+    }
+    const attributes = this.attributeList();
+    switch (keyword) {
+      case "node":
+        for (const a of attributes) {
+          scope.nodeDefaults.set(a.name, a.value);
+        }
+        break;
+      case "edge":
+        for (const a of attributes) {
+          scope.edgeDefaults.set(a.name, a.value);
+        }
+        break;
+      case "graph":
+        for (const a of attributes) {
+          this.scopeAttribute(scope, a);
+        }
+        break;
+      default:
+        throw new DotSyntaxError(`unknown attribute statement "${keyword}"`, line);
+    }
+  }
+  /**
+   * Parse one or more `[ a_list ]` groups.
+   * @returns the attributes in order (a repeated name keeps its last value at application time)
+   */
+  attributeList() {
+    const { lexer } = this;
+    const out = [];
+    while (isPunct(lexer.peek(), "[")) {
+      lexer.next();
+      for (; ; ) {
+        const token = lexer.peek();
+        if (isPunct(token, "]")) {
+          lexer.next();
+          break;
+        }
+        if (isPunct(token, ";") || isPunct(token, ",")) {
+          lexer.next();
+          continue;
+        }
+        const name = this.identifier();
+        const eq = lexer.next();
+        if (!isPunct(eq, "=")) {
+          throw new DotSyntaxError(
+            `expected "=" after attribute name ${JSON.stringify(name.text)}, found ${describeToken(eq)}`,
+            eq.line
+          );
+        }
+        const value = this.identifier();
+        out.push({ name: name.text, value: value.text, line: name.line });
+      }
+    }
+    return out;
+  }
+  /**
+   * Parse a node statement after its id and port: an optional attribute list, then apply.
+   * @param scope - the scope
+   * @param id - the id token
+   * @param port - the port, if any (dropped with a warning)
+   */
+  nodeStatement(scope, id, port) {
+    const attributes = this.attributeList();
+    const endpoint = this.mentionEndpoint(scope, id, null);
+    if (endpoint === null) {
+      return;
+    }
+    if (port !== null) {
+      this.report.warning(
+        "unsupported",
+        DOT_ISSUE.NODE_PORT_DROPPED,
+        `port ${JSON.stringify(port)} on the node statement of ${JSON.stringify(id.text)} has no meaning and was dropped`,
+        { line: id.line, element: id.text }
+      );
+    }
+    for (const attribute of attributes) {
+      this.setNodeAttribute(endpoint.index, attribute.name, attribute.value, attribute.line);
+    }
+  }
+  /**
+   * After a subgraph statement: continue as an edge statement when an edge operator follows.
+   * @param scope - the scope
+   * @param group - the subgraph's members
+   * @param line - the statement's line
+   */
+  maybeEdgeStatement(scope, group, line) {
+    if (isEdgeOp(this.lexer.peek())) {
+      this.edgeStatement(scope, group, line);
+    }
+  }
+  /**
+   * Parse `edgeRHS [attr_list]` after the first endpoint group and push the edges.
+   * @param scope - the scope
+   * @param first - the first group (empty when its node could not be created)
+   * @param line - the statement's line
+   */
+  edgeStatement(scope, first, line) {
+    const { lexer } = this;
+    const groups = [first];
+    const kinds = [];
+    while (isEdgeOp(lexer.peek())) {
+      const op = lexer.next();
+      kinds.push(this.edgeKind(op));
+      const next = lexer.peek();
+      if (isPunct(next, "{") || isKeyword(next, "subgraph")) {
+        groups.push(this.subgraph(scope));
+      } else {
+        const id = this.identifier();
+        const port = this.port();
+        const endpoint = this.mentionEndpoint(scope, id, port);
+        groups.push(endpoint === null ? [] : [endpoint]);
+      }
+    }
+    const attributes = this.attributeList();
+    for (let k = 0; k < kinds.length; k++) {
+      for (const source of groups[k]) {
+        for (const target of groups[k + 1]) {
+          this.pushEdge(scope, source, target, kinds[k], attributes, line);
+        }
+      }
+    }
+  }
+  /**
+   * The direction of an edge from its operator, checked against the graph keyword.
+   * @param op - the operator token
+   * @returns the edge kind
+   */
+  edgeKind(op) {
+    const operatorDirected = op.text === "->";
+    if (operatorDirected === this.directed) {
+      return operatorDirected ? "directed" : "undirected";
+    }
+    const message = `edge operator "${op.text}" in a ${this.directed ? "digraph" : "graph"}`;
+    switch (this.mismatch) {
+      case "error":
+        throw new DotSyntaxError(`${message} (mismatchedEdgeOperator: "error")`, op.line);
+      case "header":
+        this.report.warnOnce(
+          "coercion",
+          DOT_ISSUE.EDGE_OPERATOR,
+          `${message}; read with the graph's direction (mismatchedEdgeOperator: "header")`,
+          { line: op.line }
+        );
+        return this.directed ? "directed" : "undirected";
+      case "operator":
+        this.report.warnOnce(
+          "coercion",
+          DOT_ISSUE.EDGE_OPERATOR,
+          `${message}; read with the operator's direction and resolved per onMixedDirection`,
+          { line: op.line }
+        );
+        return operatorDirected ? "directed" : "undirected";
+      default: {
+        const name = this.mismatch;
+        throw new GraphFormatError("E_UNSUPPORTED", `unknown mismatchedEdgeOperator ${name}`, { found: name });
+      }
+    }
+  }
+  /**
+   * Coerce an id text, recording a merge under ids: "number".
+   * @param text - the id text
+   * @param line - the line, for issues
+   * @returns the id, or null when the text was rejected (recorded, node skipped)
+   */
+  coerceId(text, line) {
+    try {
+      const id = this.ids.text(text);
+      const merge = this.ids.lastMerge;
+      if (merge !== null) {
+        this.report.warning(
+          "coercion",
+          DOT_ISSUE.ID_MERGED,
+          `id text ${JSON.stringify(merge.text)} merged with ${JSON.stringify(merge.previousText)} as ${merge.id} under ids: "number"`,
+          { line, element: text }
+        );
+      }
+      return id;
+    } catch (err) {
+      this.report.recordError(err, { line, element: text });
+      this.report.counts.skippedNodes++;
+      return null;
+    }
+  }
+  /**
+   * Mention a node: create it on first mention (applying the scope's node defaults), record it as
+   * a member of the scope, and return it as an endpoint.
+   * @param scope - the scope
+   * @param id - the id token
+   * @param port - the endpoint's port, or null
+   * @returns the endpoint, or null when the node could not be created (recorded)
+   */
+  mentionEndpoint(scope, id, port) {
+    const nodeId = this.coerceId(id.text, id.line);
+    if (nodeId === null) {
+      return null;
+    }
+    const { sink } = this;
+    let index = sink.indexOf(nodeId);
+    if (index === INVALID_INDEX) {
+      try {
+        index = sink.addNode(nodeId);
+      } catch (err) {
+        this.report.recordError(err, { line: id.line, element: id.text });
+        this.report.counts.skippedNodes++;
+        return null;
+      }
+      this.report.counts.nodes++;
+      this.idOf.set(index, nodeId);
+      for (const [name, value] of scope.nodeDefaults) {
+        this.setNodeAttribute(index, name, value, id.line);
+      }
+    } else if (!this.idOf.has(index)) {
+      this.idOf.set(index, nodeId);
+    }
+    if (!scope.root && !scope.memberSet.has(index)) {
+      scope.memberSet.add(index);
+      scope.members.push(index);
+    }
+    return { id: nodeId, index, port };
+  }
+  /**
+   * Push one edge with its effective attributes (scope defaults overridden by the statement's).
+   * @param scope - the scope
+   * @param source - the source endpoint
+   * @param target - the target endpoint
+   * @param kind - the edge's direction
+   * @param attributes - the statement's attributes
+   * @param line - the statement's line
+   */
+  pushEdge(scope, source, target, kind, attributes, line) {
+    const effective = new Map(scope.edgeDefaults);
+    for (const a of attributes) {
+      effective.set(a.name, a.value);
+    }
+    const element = `${String(source.id)} ${kind === "directed" ? "->" : "--"} ${String(target.id)}`;
+    const where = { line, element };
+    const { weightFrom } = this.options;
+    let weight;
+    const weightText = weightFrom === null ? void 0 : effective.get(weightFrom);
+    if (weightText !== void 0) {
+      try {
+        weight = parseWeightText(weightText);
+      } catch (err) {
+        this.report.recordError(err, where);
+        this.report.counts.skippedEdges++;
+        return;
+      }
+    }
+    const key = effective.get(KEY_ATTRIBUTE);
+    const dedupeKey = this.dedupeKey(source.index, target.index, kind, key);
+    if (dedupeKey !== null) {
+      const existing = (this.strict ? this.strictEdges : this.keyedEdges).get(dedupeKey);
+      if (existing !== void 0) {
+        this.mergeEdge(existing, weight, effective, where, key);
+        this.setPorts(existing, source, target, where);
+        return;
+      }
+    }
+    const { sink } = this;
+    const before = sink.edgeCount;
+    let e;
+    try {
+      e = this.resolver.addEdge(source.id, target.id, kind, weight, where);
+    } catch (err) {
+      this.report.recordError(err, where);
+      this.report.counts.skippedEdges++;
+      return;
+    }
+    this.report.counts.edges += sink.edgeCount - before;
+    if (dedupeKey !== null) {
+      (this.strict ? this.strictEdges : this.keyedEdges).set(dedupeKey, e);
+    }
+    for (const [name, value] of effective) {
+      if (name !== weightFrom) {
+        this.setEdgeAttribute(e, name, value, line, element);
+      }
+    }
+    this.setPorts(e, source, target, where);
+  }
+  /**
+   * Write the endpoints' ports of an edge, when they have any.
+   * @param e - the edge index
+   * @param source - the source endpoint
+   * @param target - the target endpoint
+   * @param where - the line and element
+   */
+  setPorts(e, source, target, where) {
+    if (source.port !== null) {
+      this.setPort(e, "source", source.port, where);
+    }
+    if (target.port !== null) {
+      this.setPort(e, "target", target.port, where);
+    }
+  }
+  /**
+   * The key under which an edge is merged with an earlier one: every (source, target) pair under
+   * `strict` (unordered for an undirected edge), else the (source, target, key) triple of an edge
+   * carrying a `key` attribute (cgraph's edge identity).
+   * @param source - the source index
+   * @param target - the target index
+   * @param kind - the edge's direction
+   * @param key - the `key` attribute, or undefined
+   * @returns the dedupe key, or null when the edge is never merged
+   */
+  dedupeKey(source, target, kind, key) {
+    const ordered = kind === "undirected" && target < source ? `${target}>${source}` : `${source}>${target}`;
+    if (this.strict) {
+      return ordered;
+    }
+    return key === void 0 ? null : `${ordered}#${key}`;
+  }
+  /**
+   * Merge a repeated edge into the earlier one: its attributes overwrite, an explicit weight too.
+   * @param e - the existing edge index
+   * @param weight - the repeated edge's weight, or undefined
+   * @param effective - the repeated edge's effective attributes
+   * @param where - the line and element
+   * @param key - the `key` attribute when the merge is by key
+   */
+  mergeEdge(e, weight, effective, where, key) {
+    const byKey = !this.strict && key !== void 0;
+    this.report.warning(
+      "merged",
+      byKey ? DOT_ISSUE.KEY_MERGED : DOT_ISSUE.STRICT_MERGED,
+      byKey ? `edge ${where.element} with key ${JSON.stringify(key)} repeats an earlier edge; attributes merged` : `parallel edge ${where.element} merged into the earlier one (strict graph)`,
+      where
+    );
+    try {
+      if (weight !== void 0) {
+        this.sink.setEdgeWeight(e, weight);
+      }
+    } catch (err) {
+      this.report.recordError(err, where);
+    }
+    for (const [name, value] of effective) {
+      if (name !== this.options.weightFrom) {
+        this.setEdgeAttribute(e, name, value, where.line, where.element);
+      }
+    }
+  }
+  /**
+   * Write one node attribute: `label` to the label column, `pos` to the position column,
+   * anything else as an inferred cell.
+   * @param index - the node index
+   * @param name - the attribute name
+   * @param value - the value text
+   * @param line - the line, for issues
+   */
+  setNodeAttribute(index, name, value, line) {
+    const element = String(this.idOf.get(index) ?? index);
+    try {
+      if (name === LABEL_ATTRIBUTE) {
+        this.sink.setNodeValue(this.nodeLabel(), index, value);
+      } else if (name === POS_ATTRIBUTE) {
+        this.setPosition(index, value, line, element);
+      } else {
+        this.textWriter("node", name).write(index, value);
+      }
+    } catch (err) {
+      this.report.recordError(err, { line, element });
+    }
+  }
+  /**
+   * Write one edge attribute: `label` to the label column, `key` to the edge id column, anything
+   * else as an inferred cell.
+   * @param e - the edge index
+   * @param name - the attribute name
+   * @param value - the value text
+   * @param line - the line, for issues
+   * @param element - the edge description, for issues
+   */
+  setEdgeAttribute(e, name, value, line, element) {
+    try {
+      if (name === LABEL_ATTRIBUTE) {
+        this.setEdgeText(this.edgeLabel(), e, value);
+      } else if (name === KEY_ATTRIBUTE) {
+        this.setEdgeText(this.keyColumn(), e, value);
+      } else {
+        this.textWriter("edge", name).write(e, value);
+      }
+    } catch (err) {
+      this.report.recordError(err, { line, element });
+    }
+  }
+  /**
+   * Write a graph attribute (the root's `ID = ID` and `graph [..]`).
+   * @param attribute - the attribute
+   */
+  setGraphAttribute(attribute) {
+    try {
+      if (attribute.name === LABEL_ATTRIBUTE) {
+        this.sink.setGraphValue(attribute.name, attribute.value, { dtype: "string", origin: DOT_ORIGIN });
+      } else {
+        this.sink.setGraphValue(attribute.name, parseTextCell(attribute.value), { origin: DOT_ORIGIN });
+      }
+    } catch (err) {
+      this.report.recordError(err, { line: attribute.line, element: attribute.name });
+    }
+  }
+  /**
+   * Write a node's `pos`: `x,y[,z][!]` into the position column, the `!` as `pin` = true.
+   * @param index - the node index
+   * @param text - the pos text
+   * @param line - the line
+   * @param element - the node id text
+   */
+  setPosition(index, text, line, element) {
+    const match = POINT_TEXT.exec(text);
+    if (match === null) {
+      this.report.warning(
+        "validation-error",
+        DOT_ISSUE.BAD_POS,
+        `pos ${JSON.stringify(text)} is not a point "x,y[,z][!]"; dropped`,
+        { line, element }
+      );
+      return;
+    }
+    const x = Number(match[1]);
+    const y = Number(match[2]);
+    const z = match[3] === void 0 ? 0 : Number(match[3]);
+    const dims = match[3] === void 0 ? 2 : 3;
+    this.sink.setNodeValue(this.positionColumn(dims), index, [x, y, z]);
+    if (match[4] === "!") {
+      this.sink.setNodeValue(PIN_ATTRIBUTE, index, true);
+    }
+  }
+  /**
+   * Write an endpoint's port into the source / target port column.
+   * @param e - the edge index
+   * @param side - which endpoint
+   * @param port - the port text
+   * @param where - the line and element
+   */
+  setPort(e, side, port, where) {
+    try {
+      this.setEdgeText(side === "source" ? this.sourcePortColumn() : this.targetPortColumn(), e, port);
+    } catch (err) {
+      this.report.recordError(err, where);
+    }
+  }
+  /**
+   * Write a text cell into one of the importer's edge text columns.
+   * @param handle - the column
+   * @param e - the edge index
+   * @param text - the text
+   */
+  setEdgeText(handle, e, text) {
+    this.sink.setEdgeValue(handle, e, text);
+  }
+  // ============================================================ lazily declared columns
+  /**
+   * The node label column (string, role label).
+   * @returns the handle
+   */
+  nodeLabel() {
+    if (this.nodeLabelHandle === INVALID_INDEX) {
+      this.nodeLabelHandle = this.declare("node", {
+        name: LABEL_ATTRIBUTE,
+        dtype: "string",
+        nullable: true,
+        role: "label",
+        origin: DOT_ORIGIN
+      });
+    }
+    return this.nodeLabelHandle;
+  }
+  /**
+   * The edge label column (string, role label).
+   * @returns the handle
+   */
+  edgeLabel() {
+    if (this.edgeLabelHandle === INVALID_INDEX) {
+      this.edgeLabelHandle = this.declare("edge", {
+        name: LABEL_ATTRIBUTE,
+        dtype: "string",
+        nullable: true,
+        role: "label",
+        origin: DOT_ORIGIN
+      });
+    }
+    return this.edgeLabelHandle;
+  }
+  /**
+   * The position column (f32 x3, role position, design section 5.2), declared on the first `pos`.
+   * @param dims - the dimensions of the first value, recorded in extra.sourceDims
+   * @returns the handle
+   */
+  positionColumn(dims) {
+    if (this.positionHandle === INVALID_INDEX) {
+      this.positionHandle = this.declare("node", {
+        name: POS_ATTRIBUTE,
+        dtype: "f32",
+        components: 3,
+        nullable: true,
+        mutable: true,
+        role: "position",
+        origin: { ...DOT_ORIGIN, type: "point" },
+        extra: { sourceDims: dims, units: "file" }
+      });
+    }
+    return this.positionHandle;
+  }
+  /**
+   * The cluster marker column (bool).
+   * @returns the handle
+   */
+  clusterColumn() {
+    if (this.clusterHandle === INVALID_INDEX) {
+      this.clusterHandle = this.declare("node", {
+        name: CLUSTER_COLUMN,
+        dtype: "bool",
+        nullable: true,
+        origin: DOT_ORIGIN
+      });
+    }
+    return this.clusterHandle;
+  }
+  /**
+   * The parent column (u32, role parent, refersTo node).
+   * @returns the handle
+   */
+  parentColumn() {
+    if (this.parentHandle === INVALID_INDEX) {
+      this.parentHandle = this.declare("node", {
+        name: PARENT_COLUMN,
+        dtype: "u32",
+        nullable: true,
+        role: "parent",
+        refersTo: "node",
+        origin: DOT_ORIGIN
+      });
+    }
+    return this.parentHandle;
+  }
+  /**
+   * The edge key column (string, role id): cgraph's edge identity within a source / target pair.
+   * @returns the handle
+   */
+  keyColumn() {
+    if (this.keyHandle === INVALID_INDEX) {
+      this.keyHandle = this.declare("edge", {
+        name: KEY_ATTRIBUTE,
+        dtype: "string",
+        nullable: true,
+        role: "id",
+        origin: { ...DOT_ORIGIN, id: KEY_ATTRIBUTE }
+      });
+    }
+    return this.keyHandle;
+  }
+  /**
+   * The source port column (string, role sourcePort).
+   * @returns the handle
+   */
+  sourcePortColumn() {
+    if (this.sourcePortHandle === INVALID_INDEX) {
+      this.sourcePortHandle = this.declare("edge", {
+        name: SOURCE_PORT_COLUMN,
+        dtype: "string",
+        nullable: true,
+        role: "sourcePort",
+        origin: DOT_ORIGIN
+      });
+    }
+    return this.sourcePortHandle;
+  }
+  /**
+   * The target port column (string, role targetPort).
+   * @returns the handle
+   */
+  targetPortColumn() {
+    if (this.targetPortHandle === INVALID_INDEX) {
+      this.targetPortHandle = this.declare("edge", {
+        name: TARGET_PORT_COLUMN,
+        dtype: "string",
+        nullable: true,
+        role: "targetPort",
+        origin: DOT_ORIGIN
+      });
+    }
+    return this.targetPortHandle;
+  }
+  /**
+   * The inferred-column writer of an attribute name in a domain (design section 5.1: the column's
+   * dtype follows the text grammar per column; a caller's column of the name receives parsed
+   * values through the sink's own inference).
+   * @param domain - node or edge
+   * @param name - the attribute name
+   * @returns the writer
+   */
+  textWriter(domain, name) {
+    const writers = domain === "node" ? this.nodeWriters : this.edgeWriters;
+    let writer = writers.get(name);
+    if (writer === void 0) {
+      writer = new TextCellWriter(name, domain, this.sink, this.report);
+      writers.set(name, writer);
+    }
+    return writer;
+  }
+  /**
+   * Declare one of the importer's columns on the sink through the shared design section 5.6
+   * rule: a caller's sink that already holds the role gets the column without it (reported), one
+   * that holds the name with another shape gets it renamed `<name>#<id>` (reported).
+   * @param domain - node or edge
+   * @param decl - the declaration
+   * @returns the handle
+   */
+  declare(domain, decl) {
+    const withId = decl.origin?.id === void 0 ? { ...decl, origin: { ...decl.origin, id: decl.name } } : decl;
+    return declareResolved(this.sink, domain, withId, this.report, { element: decl.name }).handle;
+  }
+}
+export {
+  DOT_ISSUE as D,
+  DOT_LOSS as a,
+  dotImporter as b,
+  dotExporter as d
+};
+//# sourceMappingURL=importer-DbnGYr3_.js.map