@loaders.gl/graphs 4.5.3 → 5.0.0-alpha.10

package/dist/dot-loader.cjs

@@ -1,8 +1,18 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -13,51 +23,1372 @@ var __copyProps = (to, from, except, desc) => {
       if (!__hasOwnProp.call(to, key) && key !== except)
         __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/dot-loader-types.ts
+async function preload() {
+  const { DOTLoaderWithParser: DOTLoaderWithParser3 } = await Promise.resolve().then(() => (init_dot_loader(), dot_loader_exports));
+  return DOTLoaderWithParser3;
+}
+var VERSION, DOTLoader;
+var init_dot_loader_types = __esm({
+  "src/dot-loader-types.ts"() {
+    "use strict";
+    VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+    DOTLoader = {
+      name: "DOT",
+      id: "dot",
+      module: "graphs",
+      version: VERSION,
+      extensions: ["dot", "gv"],
+      mimeTypes: ["text/vnd.graphviz", "text/x-graphviz", "application/vnd.graphviz"],
+      text: true,
+      worker: false,
+      dataType: null,
+      batchType: null,
+      options: { dot: { shape: "arrow-table" } },
+      preload
+    };
+  }
+});
+
+// ../schema-utils/src/lib/schema/convert-arrow-schema.ts
+function convertArrowToSchema(arrowSchema) {
+  return serializeArrowSchema(arrowSchema);
+}
+function serializeArrowSchema(arrowSchema) {
+  return {
+    fields: arrowSchema.fields.map((arrowField) => serializeArrowField(arrowField)),
+    metadata: serializeArrowMetadata(arrowSchema.metadata)
+  };
+}
+function serializeArrowMetadata(arrowMetadata) {
+  return Object.fromEntries(arrowMetadata);
+}
+function serializeArrowField(field) {
+  return {
+    name: field.name,
+    type: serializeArrowType(field.type),
+    nullable: field.nullable,
+    metadata: serializeArrowMetadata(field.metadata)
+  };
+}
+function serializeArrowType(arrowType) {
+  if (isArrowViewType(arrowType, "BinaryView")) {
+    return "binary-view";
+  }
+  if (isArrowViewType(arrowType, "Utf8View")) {
+    return "utf8-view";
+  }
+  if (isOptionalArrowType(arrowType, "LargeList")) {
+    const largeListType = arrowType;
+    return {
+      type: "large-list",
+      children: [serializeArrowField(largeListType.valueField)]
+    };
+  }
+  switch (arrowType.constructor) {
+    case arrow.Null:
+      return "null";
+    case arrow.Binary:
+      return "binary";
+    case arrow.FixedSizeBinary:
+      return {
+        type: "fixed-size-binary",
+        byteWidth: arrowType.byteWidth
+      };
+    case arrow.Bool:
+      return "bool";
+    case arrow.Int:
+      const intType = arrowType;
+      return `${intType.isSigned ? "" : "u"}int${intType.bitWidth}`;
+    case arrow.Int8:
+      return "int8";
+    case arrow.Int16:
+      return "int16";
+    case arrow.Int32:
+      return "int32";
+    case arrow.Int64:
+      return "int64";
+    case arrow.Uint8:
+      return "uint8";
+    case arrow.Uint16:
+      return "uint16";
+    case arrow.Uint32:
+      return "uint32";
+    case arrow.Uint64:
+      return "uint64";
+    case arrow.Float:
+      const precision = arrowType.precision;
+      switch (precision) {
+        case arrow.Precision.HALF:
+          return "float16";
+        case arrow.Precision.SINGLE:
+          return "float32";
+        case arrow.Precision.DOUBLE:
+          return "float64";
+        default:
+          return "float16";
+      }
+    case arrow.Float16:
+      return "float16";
+    case arrow.Float32:
+      return "float32";
+    case arrow.Float64:
+      return "float64";
+    case arrow.Utf8:
+      return "utf8";
+    case arrow.Decimal:
+      const decimal = arrowType;
+      return {
+        type: "decimal",
+        bitWidth: decimal.bitWidth,
+        precision: decimal.precision,
+        scale: decimal.scale
+      };
+    case arrow.Date_:
+      const dateUnit = arrowType.unit;
+      return dateUnit === arrow.DateUnit.DAY ? "date-day" : "date-millisecond";
+    case arrow.DateDay:
+      return "date-day";
+    case arrow.DateMillisecond:
+      return "date-millisecond";
+    case arrow.Time:
+      const timeUnit = arrowType.unit;
+      switch (timeUnit) {
+        case arrow.TimeUnit.SECOND:
+          return "time-second";
+        case arrow.TimeUnit.MILLISECOND:
+          return "time-millisecond";
+        case arrow.TimeUnit.MICROSECOND:
+          return "time-microsecond";
+        case arrow.TimeUnit.NANOSECOND:
+          return "time-nanosecond";
+        default:
+          return "time-second";
+      }
+    case arrow.TimeMillisecond:
+      return "time-millisecond";
+    case arrow.TimeSecond:
+      return "time-second";
+    case arrow.TimeMicrosecond:
+      return "time-microsecond";
+    case arrow.TimeNanosecond:
+      return "time-nanosecond";
+    case arrow.Timestamp:
+      const timeStampUnit = arrowType.unit;
+      switch (timeStampUnit) {
+        case arrow.TimeUnit.SECOND:
+          return "timestamp-second";
+        case arrow.TimeUnit.MILLISECOND:
+          return "timestamp-millisecond";
+        case arrow.TimeUnit.MICROSECOND:
+          return "timestamp-microsecond";
+        case arrow.TimeUnit.NANOSECOND:
+          return "timestamp-nanosecond";
+        default:
+          return "timestamp-second";
+      }
+    case arrow.TimestampSecond:
+      return "timestamp-second";
+    case arrow.TimestampMillisecond:
+      return "timestamp-millisecond";
+    case arrow.TimestampMicrosecond:
+      return "timestamp-microsecond";
+    case arrow.TimestampNanosecond:
+      return "timestamp-nanosecond";
+    case arrow.Interval:
+      const intervalUnit = arrowType.unit;
+      switch (intervalUnit) {
+        case arrow.IntervalUnit.DAY_TIME:
+          return "interval-daytime";
+        case arrow.IntervalUnit.YEAR_MONTH:
+          return "interval-yearmonth";
+        default:
+          return "interval-daytime";
+      }
+    case arrow.IntervalDayTime:
+      return "interval-daytime";
+    case arrow.IntervalYearMonth:
+      return "interval-yearmonth";
+    case arrow.Map_:
+      const mapType = arrowType;
+      return {
+        type: "map",
+        keysSorted: mapType.keysSorted,
+        children: mapType.children.map((arrowField) => serializeArrowField(arrowField))
+      };
+    case arrow.List:
+      const listType = arrowType;
+      const listField = listType.valueField;
+      return {
+        type: "list",
+        children: [serializeArrowField(listField)]
+      };
+    case arrow.FixedSizeList:
+      const fixedSizeList = arrowType;
+      return {
+        type: "fixed-size-list",
+        listSize: fixedSizeList.listSize,
+        children: [serializeArrowField(fixedSizeList.children[0])]
+      };
+    case arrow.Struct:
+      const structType = arrowType;
+      return {
+        type: "struct",
+        children: structType.children.map((arrowField) => serializeArrowField(arrowField))
+      };
+    case arrow.SparseUnion:
+    case arrow.DenseUnion:
+      const unionType = arrowType;
+      return {
+        type: unionType instanceof arrow.DenseUnion ? "dense-union" : "sparse-union",
+        typeIds: unionType.typeIds,
+        children: unionType.children.map((arrowField) => serializeArrowField(arrowField)),
+        typeIdToChildIndex: { ...unionType.typeIdToChildIndex }
+      };
+    case arrow.Dictionary:
+      const dictionaryType = arrowType;
+      return {
+        type: "dictionary",
+        id: dictionaryType.id,
+        indices: serializeArrowDictionaryKeyType(dictionaryType.indices),
+        dictionary: serializeArrowType(dictionaryType.dictionary),
+        isOrdered: dictionaryType.isOrdered
+      };
+    default:
+      throw new Error(`arrow type not supported: ${arrowType.constructor.name}`);
+  }
+}
+function getOptionalArrowConstructor(typeName) {
+  return arrow[typeName];
+}
+function isArrowViewType(arrowType, viewTypeName) {
+  const constructor = getOptionalArrowConstructor(viewTypeName);
+  if (constructor && arrowType instanceof constructor) {
+    return true;
+  }
+  const guards = arrow.DataType;
+  const guard = viewTypeName === "BinaryView" ? guards.isBinaryView : guards.isUtf8View;
+  return Boolean(guard == null ? void 0 : guard(arrowType));
+}
+function isOptionalArrowType(arrowType, typeName) {
+  const constructor = getOptionalArrowConstructor(typeName);
+  return Boolean(constructor && arrowType instanceof constructor);
+}
+function serializeArrowDictionaryKeyType(arrowType) {
+  if (arrowType instanceof arrow.Int) {
+    const prefix = arrowType.isSigned ? "int" : "uint";
+    const keyType = `${prefix}${arrowType.bitWidth}`;
+    if (isSchemaDictionaryKeyType(keyType)) {
+      return keyType;
+    }
+  }
+  switch (arrowType.constructor) {
+    case arrow.Int8:
+      return "int8";
+    case arrow.Int16:
+      return "int16";
+    case arrow.Int32:
+      return "int32";
+    case arrow.Uint8:
+      return "uint8";
+    case arrow.Uint16:
+      return "uint16";
+    case arrow.Uint32:
+      return "uint32";
+    default:
+      throw new Error(`arrow dictionary index type not supported: ${arrowType.constructor.name}`);
+  }
+}
+function isSchemaDictionaryKeyType(keyType) {
+  return ["int8", "int16", "int32", "uint8", "uint16", "uint32"].includes(keyType);
+}
+var arrow;
+var init_convert_arrow_schema = __esm({
+  "../schema-utils/src/lib/schema/convert-arrow-schema.ts"() {
+    "use strict";
+    arrow = __toESM(require("apache-arrow"), 1);
+  }
+});
+
+// ../schema-utils/src/index.ts
+var init_src = __esm({
+  "../schema-utils/src/index.ts"() {
+    "use strict";
+    init_convert_arrow_schema();
+  }
+});
+
+// src/lib/build-graph-tables.ts
+function buildGraphTables(nodes, edges, shape, declarations) {
+  if (shape === "plain-graph-data") {
+    return { shape, nodes: Array.from(nodes), edges: Array.from(edges) };
+  }
+  if (shape !== "arrow-table" && shape !== "object-row-table") {
+    throw new Error(`Unsupported graph shape: ${shape}`);
+  }
+  const nodeTable = buildGraphTable(nodes, false, shape, declarations == null ? void 0 : declarations.nodes);
+  const edgeTable = buildGraphTable(edges, true, shape, declarations == null ? void 0 : declarations.edges);
+  return {
+    shape: "tables",
+    tables: [
+      { name: "nodes", table: nodeTable },
+      { name: "edges", table: edgeTable }
+    ]
+  };
+}
+function buildGraphTable(records, isEdge, shape, declarations) {
+  const columnNames = isEdge ? ["id", "sourceId", "targetId", "directed", "label", "attributes"] : ["id", "label", "attributes"];
+  const columns = new Map(columnNames.map((name) => [name, []]));
+  for (const record of records) {
+    for (const name of columnNames) {
+      const value = record[name];
+      columns.get(name).push(
+        name === "id" || name === "sourceId" || name === "targetId" ? String(value) : value ?? null
+      );
+    }
+  }
+  if (shape === "object-row-table") {
+    return {
+      shape,
+      data: columns.get("id").map(
+        (_, index) => Object.fromEntries(columnNames.map((name) => [name, columns.get(name)[index]]))
+      )
+    };
+  }
+  const vectors = /* @__PURE__ */ Object.create(null);
+  for (const [name, values] of columns) {
+    const type = name === "attributes" ? inferAttributeType(values, declarations) : name === "directed" ? new import_apache_arrow.Bool() : new import_apache_arrow.Utf8();
+    vectors[name] = (0, import_apache_arrow.vectorFromArray)(
+      values.map((value) => normalizeValue(value, type)),
+      type
+    );
+  }
+  const data = new import_apache_arrow.Table(vectors);
+  return { shape, schema: convertArrowToSchema(data.schema), data };
+}
+function inferAttributeType(values, declarations) {
+  const names = new Set(declarations == null ? void 0 : declarations.keys());
+  for (const value of values) {
+    if (value && typeof value === "object") {
+      for (const name of Object.keys(value)) {
+        names.add(name);
+      }
+    }
+  }
+  return new import_apache_arrow.Struct(
+    Array.from(names, (name) => {
+      const fieldValues = values.map(
+        (value) => (value == null ? void 0 : value[name]) ?? null
+      );
+      return new import_apache_arrow.Field(name, inferValueType(fieldValues, declarations == null ? void 0 : declarations.get(name)), true);
+    })
+  );
+}
+function inferValueType(values, declaration) {
+  const present = values.filter((value) => value !== null && value !== void 0);
+  if (declaration && typeof declaration === "object") {
+    if (!present.every((value) => Array.isArray(value))) return new import_apache_arrow.Utf8();
+    return new import_apache_arrow.List(
+      new import_apache_arrow.Field(
+        "item",
+        inferValueType(
+          present.flatMap((value) => value),
+          declaration.list
+        ),
+        true
+      )
+    );
+  }
+  if (declaration) {
+    const declaredTypes = {
+      boolean: new import_apache_arrow.Bool(),
+      int: new import_apache_arrow.Int32(),
+      long: new import_apache_arrow.Int64(),
+      float: new import_apache_arrow.Float32(),
+      double: new import_apache_arrow.Float64(),
+      string: new import_apache_arrow.Utf8()
+    };
+    const valid = present.every((value) => {
+      switch (declaration) {
+        case "boolean":
+          return typeof value === "boolean";
+        case "int":
+          return typeof value === "number" && Number.isInteger(value) && value >= -2147483648 && value <= 2147483647;
+        case "long":
+          return typeof value === "bigint" && value >= -(2n ** 63n) && value < 2n ** 63n;
+        case "float":
+        case "double":
+          return typeof value === "number";
+        case "string":
+          return typeof value === "string";
+      }
+    });
+    return valid ? declaredTypes[declaration] : new import_apache_arrow.Utf8();
+  }
+  if (present.length && present.every((value) => typeof value === "boolean")) return new import_apache_arrow.Bool();
+  if (present.length && present.every((value) => typeof value === "number")) return new import_apache_arrow.Float64();
+  if (present.length && present.every((value) => Array.isArray(value))) {
+    return new import_apache_arrow.List(
+      new import_apache_arrow.Field("item", inferValueType(present.flatMap((value) => value)), true)
+    );
+  }
+  if (present.length && present.every((value) => typeof value === "object" && !Array.isArray(value))) {
+    return inferAttributeType(present);
+  }
+  return new import_apache_arrow.Utf8();
+}
+function normalizeValue(value, type) {
+  if (value === null || value === void 0) return null;
+  if (type instanceof import_apache_arrow.Struct) {
+    return Object.fromEntries(
+      type.children.map((field) => [
+        field.name,
+        normalizeValue(value[field.name], field.type)
+      ])
+    );
+  }
+  if (type instanceof import_apache_arrow.List)
+    return value.map((item) => normalizeValue(item, type.valueType));
+  if (type instanceof import_apache_arrow.Utf8 && typeof value !== "string") {
+    return typeof value === "object" ? JSON.stringify(value) : String(value);
+  }
+  return value;
+}
+var import_apache_arrow;
+var init_build_graph_tables = __esm({
+  "src/lib/build-graph-tables.ts"() {
+    "use strict";
+    import_apache_arrow = require("apache-arrow");
+    init_src();
+  }
+});
+
+// src/lib/parse-dot.ts
+function parseDOT(input, shape = "plain-graph-data") {
+  const parsed = parseDOTDocument(input);
+  return {
+    ...buildGraphTables(iterateNodes(parsed), iterateEdges(parsed), shape),
+    metadata: {
+      id: parsed.id,
+      directed: parsed.directed,
+      strict: parsed.strict,
+      attributes: { ...parsed.graphAttributes },
+      subgraphs: Array.from(parsed.subgraphs.values(), (subgraph) => ({
+        ...subgraph,
+        attributes: { ...subgraph.attributes }
+      }))
+    }
+  };
+}
+function* iterateNodes(parsed) {
+  for (const node of parsed.nodes.values()) {
+    yield {
+      id: node.id,
+      ...typeof node.attributes.label === "string" ? { label: node.attributes.label } : {},
+      attributes: {
+        ...node.attributes,
+        ...node.subgraphs.size ? { subgraphs: Array.from(node.subgraphs, (id) => describeSubgraph(id, parsed.subgraphs)) } : {}
+      }
+    };
+  }
+}
+function* iterateEdges(parsed) {
+  for (const edge of parsed.edges) {
+    yield {
+      id: edge.id,
+      sourceId: edge.sourceId,
+      targetId: edge.targetId,
+      directed: edge.directed,
+      ...typeof edge.attributes.label === "string" ? { label: edge.attributes.label } : {},
+      attributes: {
+        ...edge.attributes,
+        ...edge.subgraphs.length ? { subgraphs: edge.subgraphs.map((id) => describeSubgraph(id, parsed.subgraphs)) } : {}
+      }
+    };
+  }
+}
+function describeSubgraph(id, descriptors) {
+  const subgraph = descriptors.get(id);
+  return {
+    id,
+    attributes: { ...subgraph.attributes },
+    parentId: subgraph.parentId
+  };
+}
+function parseDOTDocument(input) {
+  const parser = new DOTParser(tokenize(input));
+  return parser.parse();
+}
+function tokenize(input) {
+  const tokens = [];
+  let index = 0;
+  while (index < input.length) {
+    const { token, nextIndex } = readNextToken(input, index);
+    if (nextIndex <= index) {
+      throw new Error(`Tokenizer did not advance at position ${index}.`);
+    }
+    if (token) {
+      tokens.push(token);
+    }
+    index = nextIndex;
+  }
+  return tokens;
+}
+function readNextToken(input, index) {
+  if (index >= input.length) {
+    return { token: null, nextIndex: input.length };
+  }
+  const character = input[index];
+  if (isWhitespace(character)) {
+    return { token: null, nextIndex: index + 1 };
+  }
+  const commentEnd = skipComment(input, index);
+  if (commentEnd !== null) {
+    return { token: null, nextIndex: commentEnd };
+  }
+  const arrowToken = readArrowToken(input, index);
+  if (arrowToken) {
+    return arrowToken;
+  }
+  const punctuation = readPunctuationToken(character);
+  if (punctuation) {
+    return { token: punctuation, nextIndex: index + 1 };
+  }
+  if (character === '"') {
+    const { value, nextIndex } = readQuotedString(input, index + 1);
+    return { token: { type: "string", value }, nextIndex };
+  }
+  if (character === "<") {
+    const { value, nextIndex } = readHtmlString(input, index + 1);
+    return { token: { type: "html", value }, nextIndex };
+  }
+  const identifier = readIdentifier(input, index);
+  if (identifier.value) {
+    return {
+      token: { type: "identifier", value: identifier.value },
+      nextIndex: identifier.nextIndex
+    };
+  }
+  throw new Error(`Unexpected token at position ${index}.`);
+}
+function skipComment(input, index) {
+  const character = input[index];
+  if (character === "/") {
+    const next = input[index + 1];
+    if (next === "/") {
+      return skipLineComment(input, index + 2);
+    }
+    if (next === "*") {
+      return skipBlockComment(input, index + 2);
+    }
+    return null;
+  }
+  if (character === "#") {
+    return skipLineComment(input, index + 1);
+  }
+  return null;
+}
+function skipLineComment(input, startIndex) {
+  let cursor = startIndex;
+  while (cursor < input.length && !isLineBreak(input[cursor])) {
+    cursor++;
+  }
+  return cursor;
+}
+function skipBlockComment(input, startIndex) {
+  let cursor = startIndex;
+  while (cursor < input.length) {
+    if (input[cursor] === "*" && input[cursor + 1] === "/") {
+      return cursor + 2;
+    }
+    cursor++;
+  }
+  throw new Error("Unterminated block comment in DOT source.");
+}
+function readArrowToken(input, index) {
+  const next = input[index + 1];
+  if (input[index] === "-" && next === "-") {
+    return { token: { type: "arrow", value: "--" }, nextIndex: index + 2 };
+  }
+  if (input[index] === "-" && next === ">") {
+    return { token: { type: "arrow", value: "->" }, nextIndex: index + 2 };
+  }
+  return null;
+}
+function readPunctuationToken(character) {
+  switch (character) {
+    case "{":
+      return { type: "lbrace", value: character };
+    case "}":
+      return { type: "rbrace", value: character };
+    case "[":
+      return { type: "lbrack", value: character };
+    case "]":
+      return { type: "rbrack", value: character };
+    case "=":
+      return { type: "equals", value: character };
+    case ",":
+      return { type: "comma", value: character };
+    case ";":
+      return { type: "semicolon", value: character };
+    default:
+      return null;
+  }
+}
+function readQuotedString(input, startIndex) {
+  let value = "";
+  let index = startIndex;
+  while (index < input.length) {
+    const character = input[index];
+    if (character === '"') {
+      return { value, nextIndex: index + 1 };
+    }
+    if (character === "\\") {
+      const escape = readEscapedCharacter(input, index + 1);
+      value += escape.value;
+      index = escape.nextIndex;
+    } else {
+      value += character;
+      index++;
+    }
+  }
+  throw new Error("Unterminated string literal in DOT source.");
+}
+function readEscapedCharacter(input, startIndex) {
+  const next = input[startIndex];
+  switch (next) {
+    case "\n":
+      return { value: "", nextIndex: startIndex + 1 };
+    case "\r":
+      return { value: "", nextIndex: startIndex + (input[startIndex + 1] === "\n" ? 2 : 1) };
+    case "n":
+    case "l":
+    case "L":
+      return { value: "\n", nextIndex: startIndex + 1 };
+    case "t":
+      return { value: "	", nextIndex: startIndex + 1 };
+    case "r":
+      return { value: "\r", nextIndex: startIndex + 1 };
+    case '"':
+      return { value: '"', nextIndex: startIndex + 1 };
+    case "\\":
+      return { value: "\\", nextIndex: startIndex + 1 };
+    default: {
+      if (typeof next === "undefined") {
+        throw new Error("Unterminated escape sequence in DOT source.");
+      }
+      return { value: `\\${next}`, nextIndex: startIndex + 1 };
+    }
+  }
+}
+function readHtmlString(input, startIndex) {
+  let value = "<";
+  let depth = 1;
+  let index = startIndex;
+  while (index < input.length) {
+    const character = input[index];
+    value += character;
+    if (character === "<") {
+      depth++;
+    } else if (character === ">") {
+      depth--;
+      if (depth === 0) {
+        return { value, nextIndex: index + 1 };
+      }
+    }
+    index++;
+  }
+  throw new Error("Unterminated HTML-like string literal in DOT source.");
+}
+function readIdentifier(input, startIndex) {
+  let index = startIndex;
+  let value = "";
+  while (index < input.length && !isIdentifierTerminator(input, index)) {
+    value += input[index];
+    index++;
+  }
+  if (value.includes(":")) {
+    throw new Error("DOT node ports are not supported; quote identifiers containing colons.");
+  }
+  return { value, nextIndex: index };
+}
+function isIdentifierTerminator(input, index) {
+  const character = input[index];
+  if (isWhitespace(character) || IDENTIFIER_TERMINATORS.has(character)) {
+    return true;
+  }
+  if (isArrowOperatorStart(input, index)) {
+    return true;
+  }
+  if (isCommentStart(input, index)) {
+    return true;
+  }
+  return false;
+}
+function isArrowOperatorStart(input, index) {
+  if (input[index] !== "-") {
+    return false;
+  }
+  const next = input[index + 1];
+  return next === "-" || next === ">";
+}
+function isCommentStart(input, index) {
+  if (input[index] !== "/") {
+    return false;
+  }
+  const next = input[index + 1];
+  return next === "/" || next === "*";
+}
+function isWhitespace(character) {
+  return character === " " || character === "\n" || character === "\r" || character === "	" || character === "\f";
+}
+function isLineBreak(character) {
+  return character === "\n" || character === "\r";
+}
+function isKeyword(token, keyword) {
+  return token.type === "identifier" && token.value.toLowerCase() === keyword.toLowerCase();
+}
+function isGraphType(token) {
+  return isKeyword(token, "graph") || isKeyword(token, "digraph");
+}
+function isIdentifierLike(token) {
+  return token.type === "identifier" || token.type === "string" || token.type === "html";
+}
+function parseIdentifierValue(token) {
+  return token.value;
+}
+function parseAttributeValue(token) {
+  if (token.type === "string" || token.type === "html") {
+    return token.value;
+  }
+  if (token.type === "identifier") {
+    const numeric = Number(token.value);
+    if (!Number.isNaN(numeric)) {
+      return numeric;
+    }
+    return token.value;
+  }
+  throw new Error("Invalid attribute value in DOT input.");
+}
+function deriveEdgeId(attributes, sourceId, targetId, counter) {
+  const candidate = attributes.id ?? attributes.Id ?? attributes.ID;
+  if (typeof candidate === "string" || typeof candidate === "number") {
+    return String(candidate);
+  }
+  return `${String(sourceId)}-${String(targetId)}-${counter}`;
+}
+function deriveDirectedFlag(attributes, defaultDirected) {
+  const candidate = attributes.directed;
+  if (typeof candidate === "boolean") {
+    return candidate;
+  }
+  const directionAttribute = attributes.dir;
+  if (typeof directionAttribute === "string") {
+    const normalized = directionAttribute.toLowerCase();
+    if (normalized === "none") {
+      return false;
+    }
+    return true;
+  }
+  return defaultDirected;
+}
+var DOTParser, IDENTIFIER_TERMINATORS;
+var init_parse_dot = __esm({
+  "src/lib/parse-dot.ts"() {
+    "use strict";
+    init_build_graph_tables();
+    DOTParser = class {
+      /** Tokens for DOT parsing. */
+      tokens;
+      /** Position for DOT parsing. */
+      position = 0;
+      /** Accumulated graph records and attributes. */
+      result = {
+        directed: false,
+        strict: false,
+        graphAttributes: /* @__PURE__ */ Object.create(null),
+        nodes: /* @__PURE__ */ new Map(),
+        edges: [],
+        subgraphs: /* @__PURE__ */ new Map()
+      };
+      /** Scopes for DOT parsing. */
+      scopes = [
+        {
+          nodeDefaults: /* @__PURE__ */ Object.create(null),
+          edgeDefaults: /* @__PURE__ */ Object.create(null),
+          graphAttributes: /* @__PURE__ */ Object.create(null)
+        }
+      ];
+      /** Subgraph counter for DOT parsing. */
+      subgraphCounter = 0;
+      /** Edge counter for DOT parsing. */
+      edgeCounter = 0;
+      /** Edge lookup used to coalesce parallel edges in strict graphs. */
+      strictEdges = /* @__PURE__ */ new Map();
+      /** Persistent attributes and defaults for reopened named subgraphs. */
+      subgraphScopes = /* @__PURE__ */ new Map();
+      /** Explicit names reserved so anonymous subgraph IDs cannot collide with them. */
+      namedSubgraphIds = /* @__PURE__ */ new Set();
+      /** Initializes the token stream. */
+      constructor(tokens) {
+        this.tokens = tokens;
+        for (let index = 0; index < tokens.length - 1; index++) {
+          if (isKeyword(tokens[index], "subgraph") && isIdentifierLike(tokens[index + 1])) {
+            this.namedSubgraphIds.add(tokens[index + 1].value);
+          }
+        }
+      }
+      /** Parses one complete DOT document. */
+      parse() {
+        this.parseGraph();
+        this.consumeOptionalSemicolon();
+        if (this.peek()) {
+          throw new Error("Unexpected content after DOT graph.");
+        }
+        return this.result;
+      }
+      /** Reads graph identity, declaration, and statements. */
+      parseGraph() {
+        const strictToken = this.peek();
+        if (strictToken && isKeyword(strictToken, "strict")) {
+          this.consume();
+          this.result.strict = true;
+        }
+        const typeToken = this.peek();
+        if (!typeToken || !isGraphType(typeToken)) {
+          throw new Error("DOT graph must start with graph or digraph keyword.");
+        }
+        this.consume();
+        this.result.directed = isKeyword(typeToken, "digraph");
+        const idToken = this.peek();
+        if (idToken && isIdentifierLike(idToken)) {
+          this.result.id = parseIdentifierValue(this.consume());
+        }
+        this.expect("lbrace");
+        while (!this.match("rbrace")) {
+          if (!this.parseStatement()) {
+            throw new Error("Expected closing brace in DOT graph.");
+          }
+        }
+        this.result.graphAttributes = { ...this.scopes[0].graphAttributes };
+      }
+      /** Dispatches a graph statement. */
+      parseStatement() {
+        if (this.consumeSemicolonIfPresent()) {
+          return true;
+        }
+        const token = this.peek();
+        if (!token) {
+          return false;
+        }
+        if (this.tryParseSubgraphStatement(token)) {
+          return true;
+        }
+        if (this.tryParseKeywordStatement(token)) {
+          return true;
+        }
+        if (this.tryParseAssignmentStatement(token)) {
+          return true;
+        }
+        if (isIdentifierLike(token)) {
+          this.parseNodeOrEdgeStatement();
+          this.consumeOptionalSemicolon();
+          return true;
+        }
+        throw new Error(`Unexpected token: ${token.value}`);
+      }
+      /** Consumes an empty statement. */
+      consumeSemicolonIfPresent() {
+        const next = this.peek();
+        if ((next == null ? void 0 : next.type) === "semicolon") {
+          this.consume();
+          return true;
+        }
+        return false;
+      }
+      /** Reads a standalone subgraph statement. */
+      tryParseSubgraphStatement(token) {
+        if (token.type !== "lbrace" && !isKeyword(token, "subgraph")) {
+          return false;
+        }
+        this.parseSubgraph();
+        return true;
+      }
+      /** Applies graph, node, or edge defaults. */
+      tryParseKeywordStatement(token) {
+        if (!(isKeyword(token, "graph") || isKeyword(token, "node") || isKeyword(token, "edge"))) {
+          return false;
+        }
+        this.consume();
+        const explicitAttributes = this.parseAttributeList();
+        if (isKeyword(token, "graph")) {
+          Object.assign(this.currentScope().graphAttributes, explicitAttributes);
+        } else if (isKeyword(token, "node")) {
+          Object.assign(this.currentScope().nodeDefaults, explicitAttributes);
+        } else {
+          Object.assign(this.currentScope().edgeDefaults, explicitAttributes);
+        }
+        this.consumeOptionalSemicolon();
+        return true;
+      }
+      /** Reads a graph attribute assignment. */
+      tryParseAssignmentStatement(token) {
+        if (!isIdentifierLike(token)) {
+          return false;
+        }
+        const next = this.peek(1);
+        if ((next == null ? void 0 : next.type) !== "equals") {
+          return false;
+        }
+        const key = parseIdentifierValue(this.consume());
+        this.consume();
+        const valueToken = this.consume();
+        const value = parseAttributeValue(valueToken);
+        this.currentScope().graphAttributes[key] = value;
+        this.consumeOptionalSemicolon();
+        return true;
+      }
+      /** Reads a node statement or chained edges. */
+      parseNodeOrEdgeStatement() {
+        const first = parseIdentifierValue(this.consume());
+        const references = [first];
+        const operators = [];
+        let operatorToken = this.match("arrow");
+        while (operatorToken) {
+          operators.push(operatorToken.value);
+          const referenceToken = this.consume();
+          if (!isIdentifierLike(referenceToken)) {
+            throw new Error("Expected node identifier in edge statement.");
+          }
+          references.push(parseIdentifierValue(referenceToken));
+          operatorToken = this.match("arrow");
+        }
+        if (operators.length === 0) {
+          const explicitAttributes2 = this.parseAttributeList();
+          this.addNode(first, explicitAttributes2);
+          return;
+        }
+        const explicitAttributes = this.parseAttributeList();
+        this.addEdgeChain(references, operators, explicitAttributes);
+      }
+      /** Merges explicit attributes into a node. */
+      addNode(id, explicitAttributes) {
+        const membership = this.getCurrentSubgraphChain();
+        const node = this.ensureNode(id, membership);
+        node.attributes = { ...node.attributes, ...explicitAttributes };
+      }
+      /** Expands an edge chain into node and edge records. */
+      addEdgeChain(nodes, operators, explicitAttributes) {
+        const membership = this.getCurrentSubgraphChain();
+        const defaults = this.currentScope().edgeDefaults;
+        const attributes = { ...defaults, ...explicitAttributes };
+        for (let index = 0; index < nodes.length - 1; index++) {
+          const sourceId = nodes[index];
+          const targetId = nodes[index + 1];
+          const operator = operators[index];
+          const directed = operator === "->";
+          if (directed !== this.result.directed) {
+            throw new Error("DOT edge operator must match graph or digraph declaration.");
+          }
+          const edgeId = deriveEdgeId(attributes, sourceId, targetId, ++this.edgeCounter);
+          const edgeAttributes = { ...attributes };
+          this.ensureNode(sourceId, membership);
+          this.ensureNode(targetId, membership);
+          const strictKey = JSON.stringify(
+            directed ? [sourceId, targetId] : [sourceId, targetId].sort()
+          );
+          const existingEdge = this.result.strict ? this.strictEdges.get(strictKey) : void 0;
+          if (existingEdge) {
+            existingEdge.attributes = { ...existingEdge.attributes, ...explicitAttributes };
+            const explicitId = explicitAttributes.id ?? explicitAttributes.Id ?? explicitAttributes.ID;
+            if (typeof explicitId === "string" || typeof explicitId === "number") {
+              existingEdge.id = String(explicitId);
+            }
+            existingEdge.directed = deriveDirectedFlag(existingEdge.attributes, directed);
+            existingEdge.subgraphs = Array.from(/* @__PURE__ */ new Set([...existingEdge.subgraphs, ...membership]));
+            continue;
+          }
+          const directedOverride = deriveDirectedFlag(edgeAttributes, directed);
+          const edge = {
+            id: edgeId,
+            sourceId,
+            targetId,
+            directed: directedOverride,
+            attributes: edgeAttributes,
+            subgraphs: membership
+          };
+          this.result.edges.push(edge);
+          if (this.result.strict) {
+            this.strictEdges.set(strictKey, edge);
+          }
+        }
+      }
+      /** Reads a nested scope with inherited defaults. */
+      parseSubgraph() {
+        let idToken = this.peek();
+        let subgraphId;
+        if (idToken && isKeyword(idToken, "subgraph")) {
+          this.consume();
+          idToken = this.peek();
+        }
+        if (idToken && isIdentifierLike(idToken)) {
+          subgraphId = parseIdentifierValue(this.consume());
+        } else {
+          do {
+            subgraphId = `subgraph_${++this.subgraphCounter}`;
+          } while (this.namedSubgraphIds.has(subgraphId));
+        }
+        this.expect("lbrace");
+        const parentId = this.findCurrentSubgraphId();
+        let context = this.subgraphScopes.get(subgraphId);
+        if (!context) {
+          context = {
+            id: subgraphId,
+            nodeDefaults: Object.assign(/* @__PURE__ */ Object.create(null), this.currentScope().nodeDefaults),
+            edgeDefaults: Object.assign(/* @__PURE__ */ Object.create(null), this.currentScope().edgeDefaults),
+            graphAttributes: /* @__PURE__ */ Object.create(null)
+          };
+          this.subgraphScopes.set(subgraphId, context);
+          this.result.subgraphs.set(subgraphId, {
+            id: subgraphId,
+            attributes: context.graphAttributes,
+            parentId
+          });
+        }
+        this.scopes.push(context);
+        let shouldContinue = true;
+        while (shouldContinue) {
+          if (this.match("rbrace")) {
+            break;
+          }
+          shouldContinue = this.parseStatement();
+          if (!shouldContinue) {
+            throw new Error("Expected closing brace in DOT subgraph.");
+          }
+        }
+        this.scopes.pop();
+      }
+      /** Reads repeated attribute lists. */
+      parseAttributeList() {
+        var _a, _b;
+        const attributes = /* @__PURE__ */ Object.create(null);
+        while (this.match("lbrack")) {
+          while (!this.match("rbrack")) {
+            const keyToken = this.consume();
+            if (!isIdentifierLike(keyToken)) {
+              throw new Error("Expected attribute name.");
+            }
+            const key = parseIdentifierValue(keyToken);
+            let value = true;
+            if (this.match("equals")) {
+              const valueToken = this.consume();
+              value = parseAttributeValue(valueToken);
+            }
+            attributes[key] = value;
+            if (((_a = this.peek()) == null ? void 0 : _a.type) === "comma" || ((_b = this.peek()) == null ? void 0 : _b.type) === "semicolon") {
+              this.consume();
+            }
+          }
+        }
+        return attributes;
+      }
+      /** Creates an implicit node and records its subgraph memberships. */
+      ensureNode(id, membership) {
+        let node = this.result.nodes.get(id);
+        if (!node) {
+          const defaults = this.currentScope().nodeDefaults;
+          node = { id, attributes: { ...defaults }, subgraphs: /* @__PURE__ */ new Set() };
+          this.result.nodes.set(id, node);
+        }
+        membership.forEach((subgraphId) => node.subgraphs.add(subgraphId));
+        return node;
+      }
+      /** Lists enclosing subgraphs. */
+      getCurrentSubgraphChain() {
+        const chain = [];
+        for (const scope of this.scopes) {
+          if (scope.id) {
+            chain.push(scope.id);
+          }
+        }
+        return chain;
+      }
+      /** Finds the nearest enclosing named or generated subgraph. */
+      findCurrentSubgraphId() {
+        for (let index = this.scopes.length - 1; index >= 0; index--) {
+          const scope = this.scopes[index];
+          if (scope.id) {
+            return scope.id;
+          }
+        }
+        return void 0;
+      }
+      /** Returns the active attribute scope. */
+      currentScope() {
+        return this.scopes[this.scopes.length - 1];
+      }
+      /** Consumes an optional statement terminator. */
+      consumeOptionalSemicolon() {
+        const next = this.peek();
+        if ((next == null ? void 0 : next.type) === "semicolon") {
+          this.consume();
+        }
+      }
+      /** Requires the next token to have the requested type. */
+      expect(type) {
+        const token = this.consume();
+        if (!token || token.type !== type) {
+          throw new Error(`Expected token ${type}.`);
+        }
+        return token;
+      }
+      /** Consumes the next token or reports truncated input. */
+      consume() {
+        const token = this.tokens[this.position];
+        if (!token) {
+          throw new Error("Unexpected end of DOT input.");
+        }
+        this.position++;
+        return token;
+      }
+      /** Consumes a token when its type matches. */
+      match(type) {
+        const token = this.peek();
+        if (token && token.type === type) {
+          this.position++;
+          return token;
+        }
+        return null;
+      }
+      /** Inspects a token without consuming it. */
+      peek(offset = 0) {
+        return this.tokens[this.position + offset] ?? null;
+      }
+    };
+    IDENTIFIER_TERMINATORS = /* @__PURE__ */ new Set(["{", "}", "[", "]", "=", ";", ",", '"', "<", "#"]);
+  }
+});
 
-// dist/dot-loader.js
+// src/dot-loader.ts
 var dot_loader_exports = {};
 __export(dot_loader_exports, {
   DOTLoaderWithParser: () => DOTLoaderWithParser
 });
-module.exports = __toCommonJS(dot_loader_exports);
+var DOTLoaderWithParser;
+var init_dot_loader = __esm({
+  "src/dot-loader.ts"() {
+    "use strict";
+    init_dot_loader_types();
+    init_parse_dot();
+    DOTLoaderWithParser = {
+      ...DOTLoader,
+      parse: async (data, options) => {
+        var _a;
+        return parseDOT(new TextDecoder().decode(data), ((_a = options == null ? void 0 : options.dot) == null ? void 0 : _a.shape) ?? "arrow-table");
+      },
+      parseSync: (data, options) => {
+        var _a;
+        return parseDOT(new TextDecoder().decode(data), ((_a = options == null ? void 0 : options.dot) == null ? void 0 : _a.shape) ?? "arrow-table");
+      },
+      parseTextSync: (data, options) => {
+        var _a;
+        return parseDOT(data, ((_a = options == null ? void 0 : options.dot) == null ? void 0 : _a.shape) ?? "arrow-table");
+      }
+    };
+  }
+});
+
+// dist/dot-loader.js
+var dot_loader_exports2 = {};
+__export(dot_loader_exports2, {
+  DOTLoaderWithParser: () => DOTLoaderWithParser2
+});
+module.exports = __toCommonJS(dot_loader_exports2);
 
 // dist/dot-loader-types.js
-var VERSION = true ? "4.5.3" : "latest";
-var DOTLoader = {
+var VERSION2 = true ? "5.0.0-alpha.10" : "latest";
+async function preload2() {
+  const { DOTLoaderWithParser: DOTLoaderWithParser3 } = await Promise.resolve().then(() => (init_dot_loader(), dot_loader_exports));
+  return DOTLoaderWithParser3;
+}
+var DOTLoader2 = {
   name: "DOT",
   id: "dot",
   module: "graphs",
-  version: VERSION,
+  version: VERSION2,
   extensions: ["dot", "gv"],
   mimeTypes: ["text/vnd.graphviz", "text/x-graphviz", "application/vnd.graphviz"],
   text: true,
   worker: false,
   dataType: null,
   batchType: null,
-  options: {}
+  options: { dot: { shape: "arrow-table" } },
+  preload: preload2
 };
 
-// dist/lib/parse-dot.js
-function parseDOT(input) {
-  const parsed = parseDOTDocument(input);
-  const subgraphs = Array.from(parsed.subgraphs.values(), (subgraph) => ({
-    ...subgraph,
-    attributes: { ...subgraph.attributes }
+// dist/lib/build-graph-tables.js
+var import_apache_arrow2 = require("apache-arrow");
+init_src();
+function buildGraphTables2(nodes, edges, shape, declarations) {
+  if (shape === "plain-graph-data") {
+    return { shape, nodes: Array.from(nodes), edges: Array.from(edges) };
+  }
+  if (shape !== "arrow-table" && shape !== "object-row-table") {
+    throw new Error(`Unsupported graph shape: ${shape}`);
+  }
+  const nodeTable = buildGraphTable2(nodes, false, shape, declarations == null ? void 0 : declarations.nodes);
+  const edgeTable = buildGraphTable2(edges, true, shape, declarations == null ? void 0 : declarations.edges);
+  return {
+    shape: "tables",
+    tables: [
+      { name: "nodes", table: nodeTable },
+      { name: "edges", table: edgeTable }
+    ]
+  };
+}
+function buildGraphTable2(records, isEdge, shape, declarations) {
+  const columnNames = isEdge ? ["id", "sourceId", "targetId", "directed", "label", "attributes"] : ["id", "label", "attributes"];
+  const columns = new Map(columnNames.map((name) => [name, []]));
+  for (const record of records) {
+    for (const name of columnNames) {
+      const value = record[name];
+      columns.get(name).push(name === "id" || name === "sourceId" || name === "targetId" ? String(value) : value ?? null);
+    }
+  }
+  if (shape === "object-row-table") {
+    return {
+      shape,
+      data: columns.get("id").map((_, index) => Object.fromEntries(columnNames.map((name) => [name, columns.get(name)[index]])))
+    };
+  }
+  const vectors = /* @__PURE__ */ Object.create(null);
+  for (const [name, values] of columns) {
+    const type = name === "attributes" ? inferAttributeType2(values, declarations) : name === "directed" ? new import_apache_arrow2.Bool() : new import_apache_arrow2.Utf8();
+    vectors[name] = (0, import_apache_arrow2.vectorFromArray)(values.map((value) => normalizeValue2(value, type)), type);
+  }
+  const data = new import_apache_arrow2.Table(vectors);
+  return { shape, schema: convertArrowToSchema(data.schema), data };
+}
+function inferAttributeType2(values, declarations) {
+  const names = new Set(declarations == null ? void 0 : declarations.keys());
+  for (const value of values) {
+    if (value && typeof value === "object") {
+      for (const name of Object.keys(value)) {
+        names.add(name);
+      }
+    }
+  }
+  return new import_apache_arrow2.Struct(Array.from(names, (name) => {
+    const fieldValues = values.map((value) => (value == null ? void 0 : value[name]) ?? null);
+    return new import_apache_arrow2.Field(name, inferValueType2(fieldValues, declarations == null ? void 0 : declarations.get(name)), true);
   }));
+}
+function inferValueType2(values, declaration) {
+  const present = values.filter((value) => value !== null && value !== void 0);
+  if (declaration && typeof declaration === "object") {
+    if (!present.every((value) => Array.isArray(value)))
+      return new import_apache_arrow2.Utf8();
+    return new import_apache_arrow2.List(new import_apache_arrow2.Field("item", inferValueType2(present.flatMap((value) => value), declaration.list), true));
+  }
+  if (declaration) {
+    const declaredTypes = {
+      boolean: new import_apache_arrow2.Bool(),
+      int: new import_apache_arrow2.Int32(),
+      long: new import_apache_arrow2.Int64(),
+      float: new import_apache_arrow2.Float32(),
+      double: new import_apache_arrow2.Float64(),
+      string: new import_apache_arrow2.Utf8()
+    };
+    const valid = present.every((value) => {
+      switch (declaration) {
+        case "boolean":
+          return typeof value === "boolean";
+        case "int":
+          return typeof value === "number" && Number.isInteger(value) && value >= -2147483648 && value <= 2147483647;
+        case "long":
+          return typeof value === "bigint" && value >= -(2n ** 63n) && value < 2n ** 63n;
+        case "float":
+        case "double":
+          return typeof value === "number";
+        case "string":
+          return typeof value === "string";
+      }
+    });
+    return valid ? declaredTypes[declaration] : new import_apache_arrow2.Utf8();
+  }
+  if (present.length && present.every((value) => typeof value === "boolean"))
+    return new import_apache_arrow2.Bool();
+  if (present.length && present.every((value) => typeof value === "number"))
+    return new import_apache_arrow2.Float64();
+  if (present.length && present.every((value) => Array.isArray(value))) {
+    return new import_apache_arrow2.List(new import_apache_arrow2.Field("item", inferValueType2(present.flatMap((value) => value)), true));
+  }
+  if (present.length && present.every((value) => typeof value === "object" && !Array.isArray(value))) {
+    return inferAttributeType2(present);
+  }
+  return new import_apache_arrow2.Utf8();
+}
+function normalizeValue2(value, type) {
+  if (value === null || value === void 0)
+    return null;
+  if (type instanceof import_apache_arrow2.Struct) {
+    return Object.fromEntries(type.children.map((field) => [
+      field.name,
+      normalizeValue2(value[field.name], field.type)
+    ]));
+  }
+  if (type instanceof import_apache_arrow2.List)
+    return value.map((item) => normalizeValue2(item, type.valueType));
+  if (type instanceof import_apache_arrow2.Utf8 && typeof value !== "string") {
+    return typeof value === "object" ? JSON.stringify(value) : String(value);
+  }
+  return value;
+}
+
+// dist/lib/parse-dot.js
+function parseDOT2(input, shape = "plain-graph-data") {
+  const parsed = parseDOTDocument2(input);
   return {
-    shape: "plain-graph-data",
-    nodes: Array.from(parsed.nodes.values(), (node) => ({
+    ...buildGraphTables2(iterateNodes2(parsed), iterateEdges2(parsed), shape),
+    metadata: {
+      id: parsed.id,
+      directed: parsed.directed,
+      strict: parsed.strict,
+      attributes: { ...parsed.graphAttributes },
+      subgraphs: Array.from(parsed.subgraphs.values(), (subgraph) => ({
+        ...subgraph,
+        attributes: { ...subgraph.attributes }
+      }))
+    }
+  };
+}
+function* iterateNodes2(parsed) {
+  for (const node of parsed.nodes.values()) {
+    yield {
       id: node.id,
       ...typeof node.attributes.label === "string" ? { label: node.attributes.label } : {},
       attributes: {
         ...node.attributes,
-        ...node.subgraphs.size ? { subgraphs: Array.from(node.subgraphs, (id) => describeSubgraph(id, parsed.subgraphs)) } : {}
+        ...node.subgraphs.size ? { subgraphs: Array.from(node.subgraphs, (id) => describeSubgraph2(id, parsed.subgraphs)) } : {}
       }
-    })),
-    edges: parsed.edges.map((edge) => ({
+    };
+  }
+}
+function* iterateEdges2(parsed) {
+  for (const edge of parsed.edges) {
+    yield {
       id: edge.id,
       sourceId: edge.sourceId,
       targetId: edge.targetId,
@@ -65,19 +1396,12 @@ function parseDOT(input) {
       ...typeof edge.attributes.label === "string" ? { label: edge.attributes.label } : {},
       attributes: {
         ...edge.attributes,
-        ...edge.subgraphs.length ? { subgraphs: edge.subgraphs.map((id) => describeSubgraph(id, parsed.subgraphs)) } : {}
+        ...edge.subgraphs.length ? { subgraphs: edge.subgraphs.map((id) => describeSubgraph2(id, parsed.subgraphs)) } : {}
       }
-    })),
-    metadata: {
-      id: parsed.id,
-      directed: parsed.directed,
-      strict: parsed.strict,
-      attributes: { ...parsed.graphAttributes },
-      subgraphs
-    }
-  };
+    };
+  }
 }
-function describeSubgraph(id, descriptors) {
+function describeSubgraph2(id, descriptors) {
   const subgraph = descriptors.get(id);
   return {
     id,
@@ -85,7 +1409,7 @@ function describeSubgraph(id, descriptors) {
     parentId: subgraph.parentId
   };
 }
-var DOTParser = class {
+var DOTParser2 = class {
   /** Tokens for DOT parsing. */
   tokens;
   /** Position for DOT parsing. */
@@ -121,7 +1445,7 @@ var DOTParser = class {
   constructor(tokens) {
     this.tokens = tokens;
     for (let index = 0; index < tokens.length - 1; index++) {
-      if (isKeyword(tokens[index], "subgraph") && isIdentifierLike(tokens[index + 1])) {
+      if (isKeyword2(tokens[index], "subgraph") && isIdentifierLike2(tokens[index + 1])) {
         this.namedSubgraphIds.add(tokens[index + 1].value);
       }
     }
@@ -138,19 +1462,19 @@ var DOTParser = class {
   /** Reads graph identity, declaration, and statements. */
   parseGraph() {
     const strictToken = this.peek();
-    if (strictToken && isKeyword(strictToken, "strict")) {
+    if (strictToken && isKeyword2(strictToken, "strict")) {
       this.consume();
       this.result.strict = true;
     }
     const typeToken = this.peek();
-    if (!typeToken || !isGraphType(typeToken)) {
+    if (!typeToken || !isGraphType2(typeToken)) {
       throw new Error("DOT graph must start with graph or digraph keyword.");
     }
     this.consume();
-    this.result.directed = isKeyword(typeToken, "digraph");
+    this.result.directed = isKeyword2(typeToken, "digraph");
     const idToken = this.peek();
-    if (idToken && isIdentifierLike(idToken)) {
-      this.result.id = parseIdentifierValue(this.consume());
+    if (idToken && isIdentifierLike2(idToken)) {
+      this.result.id = parseIdentifierValue2(this.consume());
     }
     this.expect("lbrace");
     while (!this.match("rbrace")) {
@@ -178,7 +1502,7 @@ var DOTParser = class {
     if (this.tryParseAssignmentStatement(token)) {
       return true;
     }
-    if (isIdentifierLike(token)) {
+    if (isIdentifierLike2(token)) {
       this.parseNodeOrEdgeStatement();
       this.consumeOptionalSemicolon();
       return true;
@@ -196,7 +1520,7 @@ var DOTParser = class {
   }
   /** Reads a standalone subgraph statement. */
   tryParseSubgraphStatement(token) {
-    if (token.type !== "lbrace" && !isKeyword(token, "subgraph")) {
+    if (token.type !== "lbrace" && !isKeyword2(token, "subgraph")) {
       return false;
     }
     this.parseSubgraph();
@@ -204,14 +1528,14 @@ var DOTParser = class {
   }
   /** Applies graph, node, or edge defaults. */
   tryParseKeywordStatement(token) {
-    if (!(isKeyword(token, "graph") || isKeyword(token, "node") || isKeyword(token, "edge"))) {
+    if (!(isKeyword2(token, "graph") || isKeyword2(token, "node") || isKeyword2(token, "edge"))) {
       return false;
     }
     this.consume();
     const explicitAttributes = this.parseAttributeList();
-    if (isKeyword(token, "graph")) {
+    if (isKeyword2(token, "graph")) {
       Object.assign(this.currentScope().graphAttributes, explicitAttributes);
-    } else if (isKeyword(token, "node")) {
+    } else if (isKeyword2(token, "node")) {
       Object.assign(this.currentScope().nodeDefaults, explicitAttributes);
     } else {
       Object.assign(this.currentScope().edgeDefaults, explicitAttributes);
@@ -221,34 +1545,34 @@ var DOTParser = class {
   }
   /** Reads a graph attribute assignment. */
   tryParseAssignmentStatement(token) {
-    if (!isIdentifierLike(token)) {
+    if (!isIdentifierLike2(token)) {
       return false;
     }
     const next = this.peek(1);
     if ((next == null ? void 0 : next.type) !== "equals") {
       return false;
     }
-    const key = parseIdentifierValue(this.consume());
+    const key = parseIdentifierValue2(this.consume());
     this.consume();
     const valueToken = this.consume();
-    const value = parseAttributeValue(valueToken);
+    const value = parseAttributeValue2(valueToken);
     this.currentScope().graphAttributes[key] = value;
     this.consumeOptionalSemicolon();
     return true;
   }
   /** Reads a node statement or chained edges. */
   parseNodeOrEdgeStatement() {
-    const first = parseIdentifierValue(this.consume());
+    const first = parseIdentifierValue2(this.consume());
     const references = [first];
     const operators = [];
     let operatorToken = this.match("arrow");
     while (operatorToken) {
       operators.push(operatorToken.value);
       const referenceToken = this.consume();
-      if (!isIdentifierLike(referenceToken)) {
+      if (!isIdentifierLike2(referenceToken)) {
         throw new Error("Expected node identifier in edge statement.");
       }
-      references.push(parseIdentifierValue(referenceToken));
+      references.push(parseIdentifierValue2(referenceToken));
       operatorToken = this.match("arrow");
     }
     if (operators.length === 0) {
@@ -278,7 +1602,7 @@ var DOTParser = class {
       if (directed !== this.result.directed) {
         throw new Error("DOT edge operator must match graph or digraph declaration.");
       }
-      const edgeId = deriveEdgeId(attributes, sourceId, targetId, ++this.edgeCounter);
+      const edgeId = deriveEdgeId2(attributes, sourceId, targetId, ++this.edgeCounter);
       const edgeAttributes = { ...attributes };
       this.ensureNode(sourceId, membership);
       this.ensureNode(targetId, membership);
@@ -286,11 +1610,15 @@ var DOTParser = class {
       const existingEdge = this.result.strict ? this.strictEdges.get(strictKey) : void 0;
       if (existingEdge) {
         existingEdge.attributes = { ...existingEdge.attributes, ...explicitAttributes };
-        existingEdge.directed = deriveDirectedFlag(existingEdge.attributes, directed);
+        const explicitId = explicitAttributes.id ?? explicitAttributes.Id ?? explicitAttributes.ID;
+        if (typeof explicitId === "string" || typeof explicitId === "number") {
+          existingEdge.id = String(explicitId);
+        }
+        existingEdge.directed = deriveDirectedFlag2(existingEdge.attributes, directed);
         existingEdge.subgraphs = Array.from(/* @__PURE__ */ new Set([...existingEdge.subgraphs, ...membership]));
         continue;
       }
-      const directedOverride = deriveDirectedFlag(edgeAttributes, directed);
+      const directedOverride = deriveDirectedFlag2(edgeAttributes, directed);
       const edge = {
         id: edgeId,
         sourceId,
@@ -309,12 +1637,12 @@ var DOTParser = class {
   parseSubgraph() {
     let idToken = this.peek();
     let subgraphId;
-    if (idToken && isKeyword(idToken, "subgraph")) {
+    if (idToken && isKeyword2(idToken, "subgraph")) {
       this.consume();
       idToken = this.peek();
     }
-    if (idToken && isIdentifierLike(idToken)) {
-      subgraphId = parseIdentifierValue(this.consume());
+    if (idToken && isIdentifierLike2(idToken)) {
+      subgraphId = parseIdentifierValue2(this.consume());
     } else {
       do {
         subgraphId = `subgraph_${++this.subgraphCounter}`;
@@ -357,14 +1685,14 @@ var DOTParser = class {
     while (this.match("lbrack")) {
       while (!this.match("rbrack")) {
         const keyToken = this.consume();
-        if (!isIdentifierLike(keyToken)) {
+        if (!isIdentifierLike2(keyToken)) {
           throw new Error("Expected attribute name.");
         }
-        const key = parseIdentifierValue(keyToken);
+        const key = parseIdentifierValue2(keyToken);
         let value = true;
         if (this.match("equals")) {
           const valueToken = this.consume();
-          value = parseAttributeValue(valueToken);
+          value = parseAttributeValue2(valueToken);
         }
         attributes[key] = value;
         if (((_a = this.peek()) == null ? void 0 : _a.type) === "comma" || ((_b = this.peek()) == null ? void 0 : _b.type) === "semicolon") {
@@ -447,16 +1775,16 @@ var DOTParser = class {
     return this.tokens[this.position + offset] ?? null;
   }
 };
-function parseDOTDocument(input) {
-  const parser = new DOTParser(tokenize(input));
+function parseDOTDocument2(input) {
+  const parser = new DOTParser2(tokenize2(input));
   return parser.parse();
 }
-var IDENTIFIER_TERMINATORS = /* @__PURE__ */ new Set(["{", "}", "[", "]", "=", ";", ",", '"', "<", "#"]);
-function tokenize(input) {
+var IDENTIFIER_TERMINATORS2 = /* @__PURE__ */ new Set(["{", "}", "[", "]", "=", ";", ",", '"', "<", "#"]);
+function tokenize2(input) {
   const tokens = [];
   let index = 0;
   while (index < input.length) {
-    const { token, nextIndex } = readNextToken(input, index);
+    const { token, nextIndex } = readNextToken2(input, index);
     if (nextIndex <= index) {
       throw new Error(`Tokenizer did not advance at position ${index}.`);
     }
@@ -467,35 +1795,35 @@ function tokenize(input) {
   }
   return tokens;
 }
-function readNextToken(input, index) {
+function readNextToken2(input, index) {
   if (index >= input.length) {
     return { token: null, nextIndex: input.length };
   }
   const character = input[index];
-  if (isWhitespace(character)) {
+  if (isWhitespace2(character)) {
     return { token: null, nextIndex: index + 1 };
   }
-  const commentEnd = skipComment(input, index);
+  const commentEnd = skipComment2(input, index);
   if (commentEnd !== null) {
     return { token: null, nextIndex: commentEnd };
   }
-  const arrowToken = readArrowToken(input, index);
+  const arrowToken = readArrowToken2(input, index);
   if (arrowToken) {
     return arrowToken;
   }
-  const punctuation = readPunctuationToken(character);
+  const punctuation = readPunctuationToken2(character);
   if (punctuation) {
     return { token: punctuation, nextIndex: index + 1 };
   }
   if (character === '"') {
-    const { value, nextIndex } = readQuotedString(input, index + 1);
+    const { value, nextIndex } = readQuotedString2(input, index + 1);
     return { token: { type: "string", value }, nextIndex };
   }
   if (character === "<") {
-    const { value, nextIndex } = readHtmlString(input, index + 1);
+    const { value, nextIndex } = readHtmlString2(input, index + 1);
     return { token: { type: "html", value }, nextIndex };
   }
-  const identifier = readIdentifier(input, index);
+  const identifier = readIdentifier2(input, index);
   if (identifier.value) {
     return {
       token: { type: "identifier", value: identifier.value },
@@ -504,31 +1832,31 @@ function readNextToken(input, index) {
   }
   throw new Error(`Unexpected token at position ${index}.`);
 }
-function skipComment(input, index) {
+function skipComment2(input, index) {
   const character = input[index];
   if (character === "/") {
     const next = input[index + 1];
     if (next === "/") {
-      return skipLineComment(input, index + 2);
+      return skipLineComment2(input, index + 2);
     }
     if (next === "*") {
-      return skipBlockComment(input, index + 2);
+      return skipBlockComment2(input, index + 2);
     }
     return null;
   }
   if (character === "#") {
-    return skipLineComment(input, index + 1);
+    return skipLineComment2(input, index + 1);
   }
   return null;
 }
-function skipLineComment(input, startIndex) {
+function skipLineComment2(input, startIndex) {
   let cursor = startIndex;
-  while (cursor < input.length && !isLineBreak(input[cursor])) {
+  while (cursor < input.length && !isLineBreak2(input[cursor])) {
     cursor++;
   }
   return cursor;
 }
-function skipBlockComment(input, startIndex) {
+function skipBlockComment2(input, startIndex) {
   let cursor = startIndex;
   while (cursor < input.length) {
     if (input[cursor] === "*" && input[cursor + 1] === "/") {
@@ -538,7 +1866,7 @@ function skipBlockComment(input, startIndex) {
   }
   throw new Error("Unterminated block comment in DOT source.");
 }
-function readArrowToken(input, index) {
+function readArrowToken2(input, index) {
   const next = input[index + 1];
   if (input[index] === "-" && next === "-") {
     return { token: { type: "arrow", value: "--" }, nextIndex: index + 2 };
@@ -548,7 +1876,7 @@ function readArrowToken(input, index) {
   }
   return null;
 }
-function readPunctuationToken(character) {
+function readPunctuationToken2(character) {
   switch (character) {
     case "{":
       return { type: "lbrace", value: character };
@@ -568,7 +1896,7 @@ function readPunctuationToken(character) {
       return null;
   }
 }
-function readQuotedString(input, startIndex) {
+function readQuotedString2(input, startIndex) {
   let value = "";
   let index = startIndex;
   while (index < input.length) {
@@ -577,7 +1905,7 @@ function readQuotedString(input, startIndex) {
       return { value, nextIndex: index + 1 };
     }
     if (character === "\\") {
-      const escape = readEscapedCharacter(input, index + 1);
+      const escape = readEscapedCharacter2(input, index + 1);
       value += escape.value;
       index = escape.nextIndex;
     } else {
@@ -587,9 +1915,13 @@ function readQuotedString(input, startIndex) {
   }
   throw new Error("Unterminated string literal in DOT source.");
 }
-function readEscapedCharacter(input, startIndex) {
+function readEscapedCharacter2(input, startIndex) {
   const next = input[startIndex];
   switch (next) {
+    case "\n":
+      return { value: "", nextIndex: startIndex + 1 };
+    case "\r":
+      return { value: "", nextIndex: startIndex + (input[startIndex + 1] === "\n" ? 2 : 1) };
     case "n":
     case "l":
     case "L":
@@ -606,11 +1938,11 @@ function readEscapedCharacter(input, startIndex) {
       if (typeof next === "undefined") {
         throw new Error("Unterminated escape sequence in DOT source.");
       }
-      return { value: next, nextIndex: startIndex + 1 };
+      return { value: `\\${next}`, nextIndex: startIndex + 1 };
     }
   }
 }
-function readHtmlString(input, startIndex) {
+function readHtmlString2(input, startIndex) {
   let value = "<";
   let depth = 1;
   let index = startIndex;
@@ -629,10 +1961,10 @@ function readHtmlString(input, startIndex) {
   }
   throw new Error("Unterminated HTML-like string literal in DOT source.");
 }
-function readIdentifier(input, startIndex) {
+function readIdentifier2(input, startIndex) {
   let index = startIndex;
   let value = "";
-  while (index < input.length && !isIdentifierTerminator(input, index)) {
+  while (index < input.length && !isIdentifierTerminator2(input, index)) {
     value += input[index];
     index++;
   }
@@ -641,52 +1973,52 @@ function readIdentifier(input, startIndex) {
   }
   return { value, nextIndex: index };
 }
-function isIdentifierTerminator(input, index) {
+function isIdentifierTerminator2(input, index) {
   const character = input[index];
-  if (isWhitespace(character) || IDENTIFIER_TERMINATORS.has(character)) {
+  if (isWhitespace2(character) || IDENTIFIER_TERMINATORS2.has(character)) {
     return true;
   }
-  if (isArrowOperatorStart(input, index)) {
+  if (isArrowOperatorStart2(input, index)) {
     return true;
   }
-  if (isCommentStart(input, index)) {
+  if (isCommentStart2(input, index)) {
     return true;
   }
   return false;
 }
-function isArrowOperatorStart(input, index) {
+function isArrowOperatorStart2(input, index) {
   if (input[index] !== "-") {
     return false;
   }
   const next = input[index + 1];
   return next === "-" || next === ">";
 }
-function isCommentStart(input, index) {
+function isCommentStart2(input, index) {
   if (input[index] !== "/") {
     return false;
   }
   const next = input[index + 1];
   return next === "/" || next === "*";
 }
-function isWhitespace(character) {
+function isWhitespace2(character) {
   return character === " " || character === "\n" || character === "\r" || character === "	" || character === "\f";
 }
-function isLineBreak(character) {
+function isLineBreak2(character) {
   return character === "\n" || character === "\r";
 }
-function isKeyword(token, keyword) {
+function isKeyword2(token, keyword) {
   return token.type === "identifier" && token.value.toLowerCase() === keyword.toLowerCase();
 }
-function isGraphType(token) {
-  return isKeyword(token, "graph") || isKeyword(token, "digraph");
+function isGraphType2(token) {
+  return isKeyword2(token, "graph") || isKeyword2(token, "digraph");
 }
-function isIdentifierLike(token) {
+function isIdentifierLike2(token) {
   return token.type === "identifier" || token.type === "string" || token.type === "html";
 }
-function parseIdentifierValue(token) {
+function parseIdentifierValue2(token) {
   return token.value;
 }
-function parseAttributeValue(token) {
+function parseAttributeValue2(token) {
   if (token.type === "string" || token.type === "html") {
     return token.value;
   }
@@ -699,14 +2031,14 @@ function parseAttributeValue(token) {
   }
   throw new Error("Invalid attribute value in DOT input.");
 }
-function deriveEdgeId(attributes, sourceId, targetId, counter) {
+function deriveEdgeId2(attributes, sourceId, targetId, counter) {
   const candidate = attributes.id ?? attributes.Id ?? attributes.ID;
   if (typeof candidate === "string" || typeof candidate === "number") {
     return String(candidate);
   }
   return `${String(sourceId)}-${String(targetId)}-${counter}`;
 }
-function deriveDirectedFlag(attributes, defaultDirected) {
+function deriveDirectedFlag2(attributes, defaultDirected) {
   const candidate = attributes.directed;
   if (typeof candidate === "boolean") {
     return candidate;
@@ -723,10 +2055,19 @@ function deriveDirectedFlag(attributes, defaultDirected) {
 }
 
 // dist/dot-loader.js
-var DOTLoaderWithParser = {
-  ...DOTLoader,
-  parse: async (data) => parseDOT(new TextDecoder().decode(data)),
-  parseSync: (data) => parseDOT(new TextDecoder().decode(data)),
-  parseTextSync: parseDOT
+var DOTLoaderWithParser2 = {
+  ...DOTLoader2,
+  parse: async (data, options) => {
+    var _a;
+    return parseDOT2(new TextDecoder().decode(data), ((_a = options == null ? void 0 : options.dot) == null ? void 0 : _a.shape) ?? "arrow-table");
+  },
+  parseSync: (data, options) => {
+    var _a;
+    return parseDOT2(new TextDecoder().decode(data), ((_a = options == null ? void 0 : options.dot) == null ? void 0 : _a.shape) ?? "arrow-table");
+  },
+  parseTextSync: (data, options) => {
+    var _a;
+    return parseDOT2(data, ((_a = options == null ? void 0 : options.dot) == null ? void 0 : _a.shape) ?? "arrow-table");
+  }
 };
 //# sourceMappingURL=dot-loader.cjs.map