@loaders.gl/graphs 4.5.3

package/dist/index.cjs

@@ -0,0 +1,1022 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      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);
+
+// dist/index.js
+var dist_exports = {};
+__export(dist_exports, {
+  DOTLoader: () => DOTLoaderWithParser,
+  GraphMLLoader: () => GraphMLLoaderWithParser
+});
+module.exports = __toCommonJS(dist_exports);
+
+// dist/graphml-loader-types.js
+var VERSION = true ? "4.5.3" : "latest";
+var GraphMLLoader = {
+  name: "GraphML",
+  id: "graphml",
+  module: "graphs",
+  version: VERSION,
+  extensions: ["graphml"],
+  mimeTypes: ["application/graphml+xml"],
+  text: true,
+  worker: false,
+  dataType: null,
+  batchType: null,
+  options: {}
+};
+
+// dist/lib/parse-graphml.js
+var import_fast_xml_parser = require("fast-xml-parser");
+var XML_ATTRIBUTE_PREFIX = "@_";
+var XML_TEXT_KEY = "#text";
+var graphmlParser = new import_fast_xml_parser.XMLParser({
+  ignoreAttributes: false,
+  attributeNamePrefix: XML_ATTRIBUTE_PREFIX,
+  textNodeName: XML_TEXT_KEY,
+  trimValues: true,
+  parseAttributeValue: false,
+  parseTagValue: false,
+  removeNSPrefix: true
+});
+function parseGraphML(graphml) {
+  const xmlText = decodeGraphML(graphml);
+  const document = graphmlParser.parse(xmlText);
+  const graphmlRoot = getGraphMLRoot(document);
+  if (!graphmlRoot) {
+    throw new Error("GraphML document does not contain a <graphml> element.");
+  }
+  const graphElement = getGraphElement(graphmlRoot);
+  if (!graphElement) {
+    throw new Error("GraphML document does not contain a <graph> element.");
+  }
+  const keyDefinitions = collectKeyDefinitions(graphmlRoot, graphElement);
+  const defaultDirected = parseEdgeDefault(graphElement[`${XML_ATTRIBUTE_PREFIX}edgedefault`]);
+  const nodes = normalizeArray(graphElement.node).map((node) => parseNode(node, keyDefinitions));
+  const edges = normalizeArray(graphElement.edge).map((edge, index) => parseEdge(edge, index, keyDefinitions, defaultDirected));
+  const filteredNodes = nodes.filter((node) => Boolean(node));
+  const filteredEdges = edges.filter((edge) => Boolean(edge));
+  return {
+    shape: "plain-graph-data",
+    nodes: filteredNodes,
+    edges: filteredEdges
+  };
+}
+function decodeGraphML(graphml) {
+  if (typeof graphml === "string") {
+    return graphml;
+  }
+  if (graphml instanceof Uint8Array) {
+    return new TextDecoder().decode(graphml);
+  }
+  if (graphml instanceof ArrayBuffer) {
+    return new TextDecoder().decode(new Uint8Array(graphml));
+  }
+  throw new Error("Unsupported GraphML input. Expected a string, ArrayBuffer, or Uint8Array.");
+}
+function getGraphMLRoot(document) {
+  const root = document.graphml;
+  if (isObject(root)) {
+    return root;
+  }
+  return null;
+}
+function getGraphElement(graphmlRoot) {
+  const graph = graphmlRoot.graph;
+  if (!graph) {
+    return null;
+  }
+  if (Array.isArray(graph)) {
+    const firstGraph = graph.find((entry) => isObject(entry));
+    return isObject(firstGraph) ? firstGraph : null;
+  }
+  return isObject(graph) ? graph : null;
+}
+function collectKeyDefinitions(graphmlRoot, graphElement) {
+  const keys = /* @__PURE__ */ new Map();
+  for (const candidate of [
+    ...normalizeArray(graphmlRoot.key),
+    ...normalizeArray(graphElement.key)
+  ]) {
+    if (isObject(candidate)) {
+      const id = String(candidate[`${XML_ATTRIBUTE_PREFIX}id`] ?? "").trim();
+      if (id) {
+        const domain = normalizeDomain(candidate[`${XML_ATTRIBUTE_PREFIX}for`]);
+        const name = String(candidate[`${XML_ATTRIBUTE_PREFIX}attr.name`] ?? id).trim();
+        const type = normalizeType(candidate[`${XML_ATTRIBUTE_PREFIX}attr.type`]);
+        const defaultNode = candidate.default ?? null;
+        const defaultValue = defaultNode !== null ? castDataValue(defaultNode, type) : void 0;
+        keys.set(id, { id, domain, name, type, defaultValue });
+      }
+    }
+  }
+  return keys;
+}
+function parseNode(node, keyDefinitions) {
+  if (!isObject(node)) {
+    return null;
+  }
+  const id = node[`${XML_ATTRIBUTE_PREFIX}id`];
+  if (typeof id !== "string") {
+    return null;
+  }
+  const attributes = buildAttributeBag("node", node.data, keyDefinitions);
+  const graphNode = {
+    id,
+    attributes: Object.keys(attributes).length > 0 ? attributes : void 0
+  };
+  const label = attributes.label;
+  if (typeof label === "string") {
+    graphNode.label = label;
+  }
+  return graphNode;
+}
+function parseEdge(edge, index, keyDefinitions, defaultDirected) {
+  if (!isObject(edge)) {
+    return null;
+  }
+  const sourceId = edge[`${XML_ATTRIBUTE_PREFIX}source`];
+  const targetId = edge[`${XML_ATTRIBUTE_PREFIX}target`];
+  if (typeof sourceId !== "string") {
+    return null;
+  }
+  if (typeof targetId !== "string") {
+    return null;
+  }
+  const rawId = edge[`${XML_ATTRIBUTE_PREFIX}id`];
+  const id = typeof rawId === "string" ? rawId : `edge-${index}`;
+  const directed = parseDirected(edge[`${XML_ATTRIBUTE_PREFIX}directed`], defaultDirected);
+  const attributes = buildAttributeBag("edge", edge.data, keyDefinitions);
+  const graphEdge = {
+    id,
+    sourceId,
+    targetId,
+    directed,
+    attributes: Object.keys(attributes).length > 0 ? attributes : void 0
+  };
+  const label = attributes.label;
+  if (typeof label === "string") {
+    graphEdge.label = label;
+  }
+  return graphEdge;
+}
+function buildAttributeBag(domain, data, keyDefinitions) {
+  const attributes = /* @__PURE__ */ Object.create(null);
+  for (const key of keyDefinitions.values()) {
+    if (key.domain === "all" || key.domain === domain) {
+      if (key.defaultValue !== void 0) {
+        attributes[key.name] = key.defaultValue;
+      }
+    }
+  }
+  for (const entry of normalizeArray(data)) {
+    assignAttributeFromDataEntry(entry, keyDefinitions, attributes);
+  }
+  return attributes;
+}
+function assignAttributeFromDataEntry(entry, keyDefinitions, attributes) {
+  if (!isObject(entry)) {
+    return;
+  }
+  const keyId = entry[`${XML_ATTRIBUTE_PREFIX}key`];
+  if (typeof keyId !== "string") {
+    return;
+  }
+  const definition = keyDefinitions.get(keyId);
+  const attributeName = (definition == null ? void 0 : definition.name) ?? keyId;
+  const value = castDataValue(entry, (definition == null ? void 0 : definition.type) ?? "string");
+  if (value !== void 0) {
+    attributes[attributeName] = value;
+  }
+}
+function castDataValue(value, type) {
+  if (value === null || typeof value === "undefined") {
+    return void 0;
+  }
+  const text = extractTextContent(value);
+  if (text === void 0) {
+    return void 0;
+  }
+  if (type === "boolean") {
+    return parseBoolean(text);
+  }
+  if (type === "int" || type === "long") {
+    const parsed = Number.parseInt(text, 10);
+    return Number.isNaN(parsed) ? text : parsed;
+  }
+  if (type === "float" || type === "double") {
+    const parsed = Number.parseFloat(text);
+    return Number.isNaN(parsed) ? text : parsed;
+  }
+  return text;
+}
+function extractTextContent(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (Array.isArray(value)) {
+    return extractTextContent(value[0]);
+  }
+  if (isObject(value)) {
+    const text = value[XML_TEXT_KEY];
+    if (typeof text === "string") {
+      return text;
+    }
+    const nonAttributeEntries = Object.entries(value).filter(([key]) => !key.startsWith(XML_ATTRIBUTE_PREFIX));
+    if (nonAttributeEntries.length === 0) {
+      return void 0;
+    }
+    return JSON.stringify(Object.fromEntries(nonAttributeEntries));
+  }
+  return void 0;
+}
+function normalizeArray(value) {
+  if (!value) {
+    return [];
+  }
+  return Array.isArray(value) ? value : [value];
+}
+function isObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeDomain(value) {
+  if (typeof value !== "string") {
+    return "all";
+  }
+  const lower = value.toLowerCase();
+  if (lower === "node" || lower === "edge" || lower === "graph" || lower === "all") {
+    return lower;
+  }
+  return "all";
+}
+function normalizeType(value) {
+  if (typeof value !== "string") {
+    return "string";
+  }
+  const lower = value.toLowerCase();
+  if (lower === "boolean" || lower === "int" || lower === "long" || lower === "float" || lower === "double") {
+    return lower;
+  }
+  return "string";
+}
+function parseEdgeDefault(value) {
+  if (typeof value !== "string") {
+    return false;
+  }
+  return value.toLowerCase() !== "undirected";
+}
+function parseDirected(value, defaultDirected) {
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "true" || normalized === "1" || normalized === "yes" || normalized === "directed") {
+      return true;
+    }
+    if (normalized === "false" || normalized === "0" || normalized === "no" || normalized === "undirected") {
+      return false;
+    }
+  }
+  return defaultDirected;
+}
+function parseBoolean(value) {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "true" || normalized === "1" || normalized === "yes" || normalized === "y") {
+    return true;
+  }
+  if (normalized === "false" || normalized === "0" || normalized === "no" || normalized === "n") {
+    return false;
+  }
+  return Boolean(value);
+}
+
+// dist/graphml-loader.js
+var GraphMLLoaderWithParser = {
+  ...GraphMLLoader,
+  parse: async (data) => parseGraphML(data),
+  parseSync: parseGraphML,
+  parseTextSync: parseGraphML
+};
+
+// dist/dot-loader-types.js
+var VERSION2 = true ? "4.5.3" : "latest";
+var DOTLoader = {
+  name: "DOT",
+  id: "dot",
+  module: "graphs",
+  version: VERSION2,
+  extensions: ["dot", "gv"],
+  mimeTypes: ["text/vnd.graphviz", "text/x-graphviz", "application/vnd.graphviz"],
+  text: true,
+  worker: false,
+  dataType: null,
+  batchType: null,
+  options: {}
+};
+
+// dist/lib/parse-dot.js
+function parseDOT(input) {
+  const parsed = parseDOTDocument(input);
+  const subgraphs = Array.from(parsed.subgraphs.values(), (subgraph) => ({
+    ...subgraph,
+    attributes: { ...subgraph.attributes }
+  }));
+  return {
+    shape: "plain-graph-data",
+    nodes: Array.from(parsed.nodes.values(), (node) => ({
+      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)) } : {}
+      }
+    })),
+    edges: parsed.edges.map((edge) => ({
+      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)) } : {}
+      }
+    })),
+    metadata: {
+      id: parsed.id,
+      directed: parsed.directed,
+      strict: parsed.strict,
+      attributes: { ...parsed.graphAttributes },
+      subgraphs
+    }
+  };
+}
+function describeSubgraph(id, descriptors) {
+  const subgraph = descriptors.get(id);
+  return {
+    id,
+    attributes: { ...subgraph.attributes },
+    parentId: subgraph.parentId
+  };
+}
+var 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 };
+        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;
+  }
+};
+function parseDOTDocument(input) {
+  const parser = new DOTParser(tokenize(input));
+  return parser.parse();
+}
+var IDENTIFIER_TERMINATORS = /* @__PURE__ */ new Set(["{", "}", "[", "]", "=", ";", ",", '"', "<", "#"]);
+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":
+    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;
+}
+
+// dist/dot-loader.js
+var DOTLoaderWithParser = {
+  ...DOTLoader,
+  parse: async (data) => parseDOT(new TextDecoder().decode(data)),
+  parseSync: (data) => parseDOT(new TextDecoder().decode(data)),
+  parseTextSync: parseDOT
+};
+//# sourceMappingURL=index.cjs.map