@loaders.gl/graphs 5.0.0-beta.1 → 5.0.0-beta.2

package/dist/index.cjs

@@ -5,14 +5,6 @@ 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 });
@@ -35,1921 +27,26 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/graphml-loader-types.ts
-async function preload() {
-  const { GraphMLLoaderWithParser: GraphMLLoaderWithParser2 } = await Promise.resolve().then(() => (init_graphml_loader(), graphml_loader_exports));
-  return GraphMLLoaderWithParser2;
-}
-var VERSION, GraphMLLoader;
-var init_graphml_loader_types = __esm({
-  "src/graphml-loader-types.ts"() {
-    "use strict";
-    VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
-    GraphMLLoader = {
-      name: "GraphML",
-      id: "graphml",
-      module: "graphs",
-      version: VERSION,
-      extensions: ["graphml"],
-      mimeTypes: ["application/graphml+xml"],
-      text: true,
-      worker: false,
-      dataType: null,
-      batchType: null,
-      options: { graphml: { shape: "arrow-table" } },
-      preload
-    };
-  }
-});
-
-// ../core/src/schema-utils/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({
-  "../core/src/schema-utils/lib/schema/convert-arrow-schema.ts"() {
-    "use strict";
-    arrow = __toESM(require("apache-arrow"), 1);
-  }
-});
-
-// ../core/src/schema-utils/index.ts
-var init_schema_utils = __esm({
-  "../core/src/schema-utils/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_schema_utils();
-  }
-});
-
-// src/lib/parse-graphml.ts
-function parseGraphML(graphml, shape = "plain-graph-data") {
-  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,
-    shape !== "plain-graph-data"
-  );
-  const defaultDirected = parseEdgeDefault(graphElement[`${XML_ATTRIBUTE_PREFIX}edgedefault`]);
-  const declarations = { nodes: /* @__PURE__ */ new Map(), edges: /* @__PURE__ */ new Map() };
-  for (const definition of keyDefinitions.values()) {
-    if (definition.domain === "all" || definition.domain === "node")
-      declarations.nodes.set(definition.name, definition.type);
-    if (definition.domain === "all" || definition.domain === "edge")
-      declarations.edges.set(definition.name, definition.type);
-  }
-  return buildGraphTables(
-    iterateNodes(graphElement.node, keyDefinitions),
-    iterateEdges(graphElement.edge, keyDefinitions, defaultDirected),
-    shape,
-    declarations
-  );
-}
-function* iterateNodes(nodes, definitions) {
-  for (const node of normalizeArray(nodes)) {
-    const record = parseNode(node, definitions);
-    if (record) yield record;
-  }
-}
-function* iterateEdges(edges, definitions, directed) {
-  let index = 0;
-  for (const edge of normalizeArray(edges)) {
-    const record = parseEdge(edge, index++, definitions, directed);
-    if (record) yield record;
-  }
-}
-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 (typeof graph === "string" && !graph.trim()) {
-    return {};
-  }
-  if (!graph) {
-    return null;
-  }
-  if (Array.isArray(graph)) {
-    const firstGraph = graph.find(
-      (entry) => isObject(entry) || typeof entry === "string" && !entry.trim()
-    );
-    return isObject(firstGraph) ? firstGraph : typeof firstGraph === "string" ? {} : null;
-  }
-  return isObject(graph) ? graph : null;
-}
-function collectKeyDefinitions(graphmlRoot, graphElement, lossless) {
-  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, lossless) : void 0;
-        keys.set(id, { id, domain, name, type, defaultValue, lossless });
-      }
-    }
-  }
-  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 = (definition == null ? void 0 : definition.type) === "boolean" && extractTextContent(entry) === void 0 ? false : castDataValue(entry, (definition == null ? void 0 : definition.type) ?? "string", definition == null ? void 0 : definition.lossless);
-  if (value !== void 0) {
-    attributes[attributeName] = value;
-  }
-}
-function castDataValue(value, type, lossless = false) {
-  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 === "long" && lossless) {
-    return /^[+-]?\d+$/.test(text.trim()) ? BigInt(text.trim()) : 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];
-    const nonAttributeEntries = Object.entries(value).filter(
-      ([key]) => !key.startsWith(XML_ATTRIBUTE_PREFIX) && key !== XML_TEXT_KEY
-    );
-    if (nonAttributeEntries.length === 0) {
-      return typeof text === "string" ? text : void 0;
-    }
-    if (typeof text === "string" && text.trim()) {
-      nonAttributeEntries.push([XML_TEXT_KEY, text]);
-    }
-    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(normalized);
-}
-var import_fast_xml_parser, XML_ATTRIBUTE_PREFIX, XML_TEXT_KEY, graphmlParser;
-var init_parse_graphml = __esm({
-  "src/lib/parse-graphml.ts"() {
-    "use strict";
-    import_fast_xml_parser = require("fast-xml-parser");
-    init_build_graph_tables();
-    XML_ATTRIBUTE_PREFIX = "@_";
-    XML_TEXT_KEY = "#text";
-    graphmlParser = new import_fast_xml_parser.XMLParser({
-      ignoreAttributes: false,
-      attributeNamePrefix: XML_ATTRIBUTE_PREFIX,
-      textNodeName: XML_TEXT_KEY,
-      trimValues: false,
-      parseAttributeValue: false,
-      parseTagValue: false,
-      removeNSPrefix: true
-    });
-  }
-});
-
-// src/graphml-loader.ts
-var graphml_loader_exports = {};
-__export(graphml_loader_exports, {
-  GraphMLLoaderWithParser: () => GraphMLLoaderWithParser
-});
-var GraphMLLoaderWithParser;
-var init_graphml_loader = __esm({
-  "src/graphml-loader.ts"() {
-    "use strict";
-    init_graphml_loader_types();
-    init_parse_graphml();
-    GraphMLLoaderWithParser = {
-      ...GraphMLLoader,
-      parse: async (data, options) => {
-        var _a;
-        return parseGraphML(data, ((_a = options == null ? void 0 : options.graphml) == null ? void 0 : _a.shape) ?? "arrow-table");
-      },
-      parseSync: (data, options) => {
-        var _a;
-        return parseGraphML(data, ((_a = options == null ? void 0 : options.graphml) == null ? void 0 : _a.shape) ?? "arrow-table");
-      },
-      parseTextSync: (data, options) => {
-        var _a;
-        return parseGraphML(data, ((_a = options == null ? void 0 : options.graphml) == null ? void 0 : _a.shape) ?? "arrow-table");
-      }
-    };
-  }
-});
-
-// src/dot-loader-types.ts
-async function preload3() {
-  const { DOTLoaderWithParser: DOTLoaderWithParser2 } = await Promise.resolve().then(() => (init_dot_loader(), dot_loader_exports));
-  return DOTLoaderWithParser2;
-}
-var VERSION3, DOTLoader;
-var init_dot_loader_types = __esm({
-  "src/dot-loader-types.ts"() {
-    "use strict";
-    VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
-    DOTLoader = {
-      name: "DOT",
-      id: "dot",
-      module: "graphs",
-      version: VERSION3,
-      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: preload3
-    };
-  }
-});
-
-// src/lib/parse-dot.ts
-function parseDOT(input, shape = "plain-graph-data") {
-  const parsed = parseDOTDocument(input);
-  return {
-    ...buildGraphTables(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)) } : {}
-      }
-    };
-  }
-}
-function* iterateEdges2(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 parser2 = new DOTParser(tokenize(input));
-  return parser2.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(["{", "}", "[", "]", "=", ";", ",", '"', "<", "#"]);
-  }
-});
-
-// src/dot-loader.ts
-var dot_loader_exports = {};
-__export(dot_loader_exports, {
-  DOTLoaderWithParser: () => DOTLoaderWithParser
-});
-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");
-      }
-    };
-  }
-});
-
-// src/gexf-loader-types.ts
-async function preload5() {
-  const { GEXFLoaderWithParser: GEXFLoaderWithParser2 } = await Promise.resolve().then(() => (init_gexf_loader(), gexf_loader_exports));
-  return GEXFLoaderWithParser2;
-}
-var VERSION5, GEXFLoader;
-var init_gexf_loader_types = __esm({
-  "src/gexf-loader-types.ts"() {
-    "use strict";
-    VERSION5 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
-    GEXFLoader = {
-      name: "GEXF",
-      id: "gexf",
-      module: "graphs",
-      version: VERSION5,
-      extensions: ["gexf"],
-      mimeTypes: ["application/gexf+xml"],
-      text: true,
-      worker: false,
-      dataType: null,
-      batchType: null,
-      options: { gexf: { shape: "arrow-table" } },
-      preload: preload5
-    };
-  }
-});
-
-// src/lib/parse-gexf.ts
-function parseGEXF(input, shape = "arrow-table") {
-  const text = typeof input === "string" ? input : new TextDecoder().decode(input);
-  const validation = import_fast_xml_parser2.XMLValidator.validate(text);
-  if (validation !== true) throw new Error(`Invalid GEXF XML: ${validation.err.msg}`);
-  if (/<!DOCTYPE\s/i.test(text)) throw new Error("GEXF document types are unsupported.");
-  const document = normalizeNamespaces(parser.parse(text), {});
-  const root = getElement(document.gexf, "gexf");
-  const version = root["@_version"];
-  if (version && !["1.2", "1.2draft", "1.3"].includes(version)) {
-    throw new Error(`Unsupported GEXF version: ${version}`);
-  }
-  const graph = getElement(root.graph, "graph");
-  const directed = parseDirection(graph["@_defaultedgetype"] ?? "undirected");
-  const definitions = {
-    nodes: /* @__PURE__ */ new Map(),
-    edges: /* @__PURE__ */ new Map()
-  };
-  for (const attributes of getElements(graph.attributes)) {
-    const domain = attributes["@_class"];
-    if (domain !== "node" && domain !== "edge")
-      throw new Error("GEXF attributes require a node or edge class.");
-    const scoped = domain === "node" ? definitions.nodes : definitions.edges;
-    const names = new Set(Array.from(scoped.values(), (definition) => definition.name));
-    for (const attribute of getElements(attributes.attribute)) {
-      const identifier = requireAttribute(attribute, "id");
-      const name = requireAttribute(attribute, "title");
-      if (name === "gexf" || names.has(name) || scoped.has(identifier)) {
-        throw new Error(`Duplicate or reserved GEXF attribute: ${name}`);
-      }
-      names.add(name);
-      const type = parseAttributeType(requireAttribute(attribute, "type"));
-      scoped.set(identifier, {
-        name,
-        type,
-        defaultValue: attribute.default === void 0 ? void 0 : castValue(readTextContent(attribute.default), type)
-      });
-    }
-  }
-  const nodeElements = getElements(getContainer(graph.nodes).node);
-  const edgeElements = getElements(getContainer(graph.edges).edge);
-  const nodeIdentifiers = /* @__PURE__ */ new Set();
-  for (const node of nodeElements) {
-    const identifier = requireAttribute(node, "id");
-    if (nodeIdentifiers.has(identifier)) throw new Error(`Duplicate GEXF node ID: ${identifier}`);
-    nodeIdentifiers.add(identifier);
-  }
-  const edgeIdentifiers = new Set(
-    edgeElements.map((edge) => edge["@_id"]).filter((identifier) => typeof identifier === "string")
-  );
-  const seenEdges = /* @__PURE__ */ new Set();
-  function* iterateNodes3() {
-    for (const node of nodeElements) yield parseRecord(node, definitions.nodes);
-  }
-  function* iterateEdges3() {
-    for (const [index, edge] of edgeElements.entries()) {
-      const sourceId = requireAttribute(edge, "source");
-      const targetId = requireAttribute(edge, "target");
-      if (!nodeIdentifiers.has(sourceId) || !nodeIdentifiers.has(targetId)) {
-        throw new Error("GEXF edge references an undeclared node.");
-      }
-      let identifier = edge["@_id"] === void 0 ? void 0 : requireAttribute(edge, "id");
-      if (identifier === void 0) {
-        identifier = `edge-${index}`;
-        while (edgeIdentifiers.has(identifier)) identifier = `_${identifier}`;
-        edgeIdentifiers.add(identifier);
-      }
-      if (seenEdges.has(identifier)) throw new Error(`Duplicate GEXF edge ID: ${identifier}`);
-      seenEdges.add(identifier);
-      yield {
-        ...parseRecord(edge, definitions.edges, identifier),
-        sourceId,
-        targetId,
-        directed: edge["@_type"] === void 0 ? directed : parseDirection(edge["@_type"])
-      };
-    }
-  }
-  const metadataAttributes = /* @__PURE__ */ Object.create(null);
-  const meta = getContainer(root.meta);
-  for (const name of ["creator", "description", "keywords"]) {
-    if (meta[name] !== void 0) metadataAttributes[name] = readTextContent(meta[name]);
-  }
-  if (typeof meta["@_lastmodifieddate"] === "string")
-    metadataAttributes.lastmodifieddate = meta["@_lastmodifieddate"];
-  const declarations = {
-    nodes: new Map(
-      Array.from(definitions.nodes.values(), (definition) => [definition.name, definition.type])
-    ),
-    edges: new Map(
-      Array.from(definitions.edges.values(), (definition) => [definition.name, definition.type])
-    )
-  };
-  return {
-    ...buildGraphTables(iterateNodes3(), iterateEdges3(), shape, declarations),
-    metadata: { version, directed, attributes: metadataAttributes }
-  };
-}
-function normalizeNamespaces(element, inherited) {
-  const namespaces = Object.assign(/* @__PURE__ */ Object.create(null), inherited);
-  for (const [name, value] of Object.entries(element)) {
-    if (name === "@_xmlns") namespaces[""] = String(value);
-    else if (name.startsWith("@_xmlns:")) namespaces[name.slice(8)] = String(value);
-  }
-  const normalized = /* @__PURE__ */ Object.create(null);
-  for (const [name, value] of Object.entries(element)) {
-    if (name.startsWith("@_") || name === "#text" || name.startsWith("?")) {
-      normalized[name] = value;
-      continue;
-    }
-    const separator = name.indexOf(":");
-    const prefix = separator < 0 ? "" : name.slice(0, separator);
-    const localName = name.slice(separator + 1);
-    const children = Array.isArray(value) ? value : [value];
-    for (const child of children) {
-      const object = typeof child === "object" && child !== null ? child : {};
-      const namespace = object[prefix ? `@_xmlns:${prefix}` : "@_xmlns"] ?? namespaces[prefix];
-      const match = typeof namespace === "string" ? GEXF_NAMESPACE.exec(namespace) : null;
-      const key = match ? `${match[1] ? "viz:" : ""}${localName}` : namespace || prefix ? `foreign:${name}` : localName;
-      const childValue = typeof child === "object" && child !== null ? match || !namespace && !prefix ? normalizeNamespaces(object, namespaces) : object : child;
-      if (normalized[key] === void 0) normalized[key] = childValue;
-      else
-        normalized[key] = [
-          ...Array.isArray(normalized[key]) ? normalized[key] : [normalized[key]],
-          childValue
-        ];
-    }
-  }
-  assertStaticElement(normalized);
-  return normalized;
-}
-function assertStaticElement(element) {
-  if (element["@_mode"] !== void 0 && element["@_mode"] !== "static" || TEMPORAL_ATTRIBUTES.some((name) => element[`@_${name}`] !== void 0) || element.spells !== void 0) {
-    throw new Error("Dynamic GEXF graphs and temporal values are unsupported.");
-  }
-  if (element["@_pid"] !== void 0 || element.parents !== void 0 || element["@_id"] !== void 0 && (element.nodes !== void 0 || element.edges !== void 0)) {
-    throw new Error("Hierarchical GEXF graphs are unsupported.");
-  }
-}
-function getElement(value, name) {
-  if (value === "") return {};
-  if (value && typeof value === "object" && !Array.isArray(value)) return value;
-  throw new Error(`GEXF requires one <${name}> element.`);
-}
-function readTextContent(value) {
-  if (typeof value === "string") return value;
-  const text = getElement(value, "text")["#text"];
-  return typeof text === "string" ? text : "";
-}
-function getContainer(value) {
-  return value === void 0 ? {} : getElement(value, "container");
-}
-function getElements(value) {
-  if (value === void 0) return [];
-  return (Array.isArray(value) ? value : [value]).map((entry) => getElement(entry, "record"));
-}
-function requireAttribute(element, name) {
-  const value = element[`@_${name}`];
-  if (typeof value !== "string" || value === "")
-    throw new Error(`GEXF requires a ${name} attribute.`);
-  return value;
-}
-function parseDirection(value) {
-  if (value !== "directed" && value !== "undirected")
-    throw new Error(`Unsupported GEXF edge type: ${String(value)}`);
-  return value === "directed";
-}
-function parseAttributeType(value) {
-  if (value.startsWith("list") && !value.slice(4).startsWith("list")) {
-    return { list: parseAttributeType(value.slice(4)) };
-  }
-  if (value === "integer" || value === "byte" || value === "short") return "int";
-  if (value === "boolean" || value === "long" || value === "float" || value === "double")
-    return value;
-  if (["string", "anyURI", "date", "char", "bigdecimal", "biginteger"].includes(value))
-    return "string";
-  throw new Error(`Unsupported GEXF attribute type: ${value}`);
-}
-function castValue(text, type) {
-  if (typeof type === "object") {
-    return parseListValues(text).map((value) => castValue(value, type.list));
-  }
-  if (type === "string") return text;
-  const trimmed = text.trim();
-  if (type === "boolean") {
-    if (trimmed === "true" || trimmed === "1") return true;
-    if (trimmed === "false" || trimmed === "0") return false;
-    return text;
-  }
-  if (type === "int" || type === "long") {
-    if (!/^[+-]?\d+$/.test(trimmed)) return text;
-    return type === "long" ? BigInt(trimmed) : Number.isSafeInteger(Number(trimmed)) ? Number(trimmed) : text;
-  }
-  if (trimmed === "INF") return Infinity;
-  if (trimmed === "-INF") return -Infinity;
-  if (trimmed === "NaN") return NaN;
-  if (!/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/.test(trimmed)) return text;
-  const number = Number(trimmed);
-  const represented = type === "float" ? Math.fround(number) : number;
-  const nonzero = /[1-9]/.test(trimmed.split(/[eE]/)[0]);
-  return Number.isFinite(represented) && (represented !== 0 || !nonzero) ? number : text;
-}
-function parseListValues(text) {
-  const trimmed = text.trim();
-  const bracketed = trimmed.startsWith("[");
-  if (bracketed !== trimmed.endsWith("]")) throw new Error("Invalid GEXF list brackets.");
-  const contents = bracketed ? trimmed.slice(1, -1) : trimmed;
-  if (!contents.trim()) return [];
-  const values = [];
-  let value = "";
-  let quote = "";
-  let quoted = false;
-  let closed = false;
-  for (let index = 0; index < contents.length; index++) {
-    const character = contents[index];
-    if (quote) {
-      if (character === "\\" && (contents[index + 1] === quote || contents[index + 1] === "\\")) {
-        value += contents[++index];
-      } else if (character === quote) {
-        quote = "";
-        closed = true;
-      } else value += character;
-    } else if (character === "," || !bracketed && (character === "|" || character === ";")) {
-      values.push(quoted ? value : value.trim());
-      value = "";
-      quoted = false;
-      closed = false;
-    } else if (closed) {
-      if (character.trim()) throw new Error("Invalid GEXF list text after a quote.");
-    } else if ((character === "'" || character === '"') && !value.trim()) {
-      quote = character;
-      quoted = true;
-      value = "";
-    } else value += character;
-  }
-  if (quote) throw new Error("Unterminated GEXF list quote.");
-  values.push(quoted ? value : value.trim());
-  return values;
-}
-function parseRecord(element, definitions, identifier) {
-  const attributes = /* @__PURE__ */ Object.create(null);
-  for (const definition of definitions.values()) {
-    if (definition.defaultValue !== void 0)
-      attributes[definition.name] = Array.isArray(definition.defaultValue) ? [...definition.defaultValue] : definition.defaultValue;
-  }
-  for (const attvalue of getElements(getContainer(element.attvalues).attvalue)) {
-    const key = requireAttribute(attvalue, "for");
-    const definition = definitions.get(key);
-    if (!definition) throw new Error(`Undeclared GEXF attribute: ${key}`);
-    attributes[definition.name] = castValue(requireValue(attvalue), definition.type);
-  }
-  const native = /* @__PURE__ */ Object.create(null);
-  if (element["@_weight"] !== void 0)
-    native.weight = castValue(String(element["@_weight"]), "double");
-  if (element["@_kind"] !== void 0) native.kind = element["@_kind"];
-  const visualization = /* @__PURE__ */ Object.create(null);
-  for (const name of ["color", "position", "size", "shape", "thickness"]) {
-    const value = element[`viz:${name}`];
-    if (value === void 0) continue;
-    const properties = /* @__PURE__ */ Object.create(null);
-    for (const [key, property] of Object.entries(getElement(value, `viz:${name}`))) {
-      if (key.startsWith("@_") && !key.startsWith("@_xmlns")) {
-        const propertyName = key.slice(2);
-        properties[propertyName] = ["r", "g", "b", "a", "x", "y", "z"].includes(propertyName) || propertyName === "value" && (name === "size" || name === "thickness") ? castValue(String(property), "double") : property;
-      }
-    }
-    visualization[name] = properties;
-  }
-  if (Object.keys(visualization).length) native.viz = visualization;
-  if (Object.keys(native).length) attributes.gexf = native;
-  return {
-    id: identifier ?? requireAttribute(element, "id"),
-    label: element["@_label"],
-    attributes
-  };
-}
-function requireValue(element) {
-  const value = element["@_value"];
-  if (typeof value !== "string") throw new Error("GEXF attvalue requires a value attribute.");
-  return value;
-}
-var import_fast_xml_parser2, parser, GEXF_NAMESPACE, TEMPORAL_ATTRIBUTES;
-var init_parse_gexf = __esm({
-  "src/lib/parse-gexf.ts"() {
-    "use strict";
-    import_fast_xml_parser2 = require("fast-xml-parser");
-    init_build_graph_tables();
-    parser = new import_fast_xml_parser2.XMLParser({
-      ignoreAttributes: false,
-      parseAttributeValue: false,
-      parseTagValue: false,
-      trimValues: false
-    });
-    GEXF_NAMESPACE = /^https?:\/\/(?:www\.)?gexf.net\/1\.(?:2(?:draft)?|3)(\/viz)?$/;
-    TEMPORAL_ATTRIBUTES = [
-      "start",
-      "end",
-      "startopen",
-      "endopen",
-      "timestamp",
-      "timestamps",
-      "intervals"
-    ];
-  }
-});
-
-// src/gexf-loader.ts
-var gexf_loader_exports = {};
-__export(gexf_loader_exports, {
-  GEXFLoaderWithParser: () => GEXFLoaderWithParser
-});
-var GEXFLoaderWithParser;
-var init_gexf_loader = __esm({
-  "src/gexf-loader.ts"() {
-    "use strict";
-    init_gexf_loader_types();
-    init_parse_gexf();
-    GEXFLoaderWithParser = {
-      ...GEXFLoader,
-      parse: async (data, options) => {
-        var _a;
-        return parseGEXF(data, ((_a = options == null ? void 0 : options.gexf) == null ? void 0 : _a.shape) ?? "arrow-table");
-      },
-      parseSync: (data, options) => {
-        var _a;
-        return parseGEXF(data, ((_a = options == null ? void 0 : options.gexf) == null ? void 0 : _a.shape) ?? "arrow-table");
-      },
-      parseTextSync: (data, options) => {
-        var _a;
-        return parseGEXF(data, ((_a = options == null ? void 0 : options.gexf) == null ? void 0 : _a.shape) ?? "arrow-table");
-      }
-    };
-  }
-});
-
 // dist/index.js
 var index_exports = {};
 __export(index_exports, {
-  DOTLoader: () => DOTLoader2,
-  GEXFLoader: () => GEXFLoader2,
-  GraphMLLoader: () => GraphMLLoader2
+  DOTLoader: () => DOTLoader,
+  GEXFLoader: () => GEXFLoader,
+  GraphMLLoader: () => GraphMLLoader
 });
 module.exports = __toCommonJS(index_exports);
 
 // dist/graphml-loader-types.js
-var VERSION2 = true ? "5.0.0-beta.1" : "latest";
-async function preload2() {
-  const { GraphMLLoaderWithParser: GraphMLLoaderWithParser2 } = await Promise.resolve().then(() => (init_graphml_loader(), graphml_loader_exports));
-  return GraphMLLoaderWithParser2;
+var VERSION = true ? "5.0.0-beta.2" : "latest";
+async function preload() {
+  const { GraphMLLoaderWithParser } = await import("@loaders.gl/graphs/graphml-loader");
+  return GraphMLLoaderWithParser;
 }
-var GraphMLLoader2 = {
+var GraphMLLoader = {
   name: "GraphML",
   id: "graphml",
   module: "graphs",
-  version: VERSION2,
+  version: VERSION,
   extensions: ["graphml"],
   mimeTypes: ["application/graphml+xml"],
   text: true,
@@ -1957,20 +54,20 @@ var GraphMLLoader2 = {
   dataType: null,
   batchType: null,
   options: { graphml: { shape: "arrow-table" } },
-  preload: preload2
+  preload
 };
 
 // dist/dot-loader-types.js
-var VERSION4 = true ? "5.0.0-beta.1" : "latest";
-async function preload4() {
-  const { DOTLoaderWithParser: DOTLoaderWithParser2 } = await Promise.resolve().then(() => (init_dot_loader(), dot_loader_exports));
-  return DOTLoaderWithParser2;
+var VERSION2 = true ? "5.0.0-beta.2" : "latest";
+async function preload2() {
+  const { DOTLoaderWithParser } = await import("@loaders.gl/graphs/dot-loader");
+  return DOTLoaderWithParser;
 }
-var DOTLoader2 = {
+var DOTLoader = {
   name: "DOT",
   id: "dot",
   module: "graphs",
-  version: VERSION4,
+  version: VERSION2,
   extensions: ["dot", "gv"],
   mimeTypes: ["text/vnd.graphviz", "text/x-graphviz", "application/vnd.graphviz"],
   text: true,
@@ -1978,20 +75,20 @@ var DOTLoader2 = {
   dataType: null,
   batchType: null,
   options: { dot: { shape: "arrow-table" } },
-  preload: preload4
+  preload: preload2
 };
 
 // dist/gexf-loader-types.js
-var VERSION6 = true ? "5.0.0-beta.1" : "latest";
-async function preload6() {
-  const { GEXFLoaderWithParser: GEXFLoaderWithParser2 } = await Promise.resolve().then(() => (init_gexf_loader(), gexf_loader_exports));
-  return GEXFLoaderWithParser2;
+var VERSION3 = true ? "5.0.0-beta.2" : "latest";
+async function preload3() {
+  const { GEXFLoaderWithParser } = await import("@loaders.gl/graphs/gexf-loader");
+  return GEXFLoaderWithParser;
 }
-var GEXFLoader2 = {
+var GEXFLoader = {
   name: "GEXF",
   id: "gexf",
   module: "graphs",
-  version: VERSION6,
+  version: VERSION3,
   extensions: ["gexf"],
   mimeTypes: ["application/gexf+xml"],
   text: true,
@@ -1999,6 +96,12 @@ var GEXFLoader2 = {
   dataType: null,
   batchType: null,
   options: { gexf: { shape: "arrow-table" } },
-  preload: preload6
+  preload: preload3
 };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DOTLoader,
+  GEXFLoader,
+  GraphMLLoader
+});
 //# sourceMappingURL=index.cjs.map