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

package/dist/graphml-loader.cjs

@@ -1,8 +1,18 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -15,45 +25,458 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// dist/graphml-loader.js
-var graphml_loader_exports = {};
-__export(graphml_loader_exports, {
-  GraphMLLoaderWithParser: () => GraphMLLoaderWithParser
+// src/graphml-loader-types.ts
+async function preload() {
+  const { GraphMLLoaderWithParser: GraphMLLoaderWithParser3 } = await Promise.resolve().then(() => (init_graphml_loader(), graphml_loader_exports));
+  return GraphMLLoaderWithParser3;
+}
+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
+    };
+  }
 });
-module.exports = __toCommonJS(graphml_loader_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: {}
-};
+// ../schema-utils/src/lib/schema/convert-arrow-schema.ts
+function convertArrowToSchema(arrowSchema) {
+  return serializeArrowSchema(arrowSchema);
+}
+function serializeArrowSchema(arrowSchema) {
+  return {
+    fields: arrowSchema.fields.map((arrowField) => serializeArrowField(arrowField)),
+    metadata: serializeArrowMetadata(arrowSchema.metadata)
+  };
+}
+function serializeArrowMetadata(arrowMetadata) {
+  return Object.fromEntries(arrowMetadata);
+}
+function serializeArrowField(field) {
+  return {
+    name: field.name,
+    type: serializeArrowType(field.type),
+    nullable: field.nullable,
+    metadata: serializeArrowMetadata(field.metadata)
+  };
+}
+function serializeArrowType(arrowType) {
+  if (isArrowViewType(arrowType, "BinaryView")) {
+    return "binary-view";
+  }
+  if (isArrowViewType(arrowType, "Utf8View")) {
+    return "utf8-view";
+  }
+  if (isOptionalArrowType(arrowType, "LargeList")) {
+    const largeListType = arrowType;
+    return {
+      type: "large-list",
+      children: [serializeArrowField(largeListType.valueField)]
+    };
+  }
+  switch (arrowType.constructor) {
+    case arrow.Null:
+      return "null";
+    case arrow.Binary:
+      return "binary";
+    case arrow.FixedSizeBinary:
+      return {
+        type: "fixed-size-binary",
+        byteWidth: arrowType.byteWidth
+      };
+    case arrow.Bool:
+      return "bool";
+    case arrow.Int:
+      const intType = arrowType;
+      return `${intType.isSigned ? "" : "u"}int${intType.bitWidth}`;
+    case arrow.Int8:
+      return "int8";
+    case arrow.Int16:
+      return "int16";
+    case arrow.Int32:
+      return "int32";
+    case arrow.Int64:
+      return "int64";
+    case arrow.Uint8:
+      return "uint8";
+    case arrow.Uint16:
+      return "uint16";
+    case arrow.Uint32:
+      return "uint32";
+    case arrow.Uint64:
+      return "uint64";
+    case arrow.Float:
+      const precision = arrowType.precision;
+      switch (precision) {
+        case arrow.Precision.HALF:
+          return "float16";
+        case arrow.Precision.SINGLE:
+          return "float32";
+        case arrow.Precision.DOUBLE:
+          return "float64";
+        default:
+          return "float16";
+      }
+    case arrow.Float16:
+      return "float16";
+    case arrow.Float32:
+      return "float32";
+    case arrow.Float64:
+      return "float64";
+    case arrow.Utf8:
+      return "utf8";
+    case arrow.Decimal:
+      const decimal = arrowType;
+      return {
+        type: "decimal",
+        bitWidth: decimal.bitWidth,
+        precision: decimal.precision,
+        scale: decimal.scale
+      };
+    case arrow.Date_:
+      const dateUnit = arrowType.unit;
+      return dateUnit === arrow.DateUnit.DAY ? "date-day" : "date-millisecond";
+    case arrow.DateDay:
+      return "date-day";
+    case arrow.DateMillisecond:
+      return "date-millisecond";
+    case arrow.Time:
+      const timeUnit = arrowType.unit;
+      switch (timeUnit) {
+        case arrow.TimeUnit.SECOND:
+          return "time-second";
+        case arrow.TimeUnit.MILLISECOND:
+          return "time-millisecond";
+        case arrow.TimeUnit.MICROSECOND:
+          return "time-microsecond";
+        case arrow.TimeUnit.NANOSECOND:
+          return "time-nanosecond";
+        default:
+          return "time-second";
+      }
+    case arrow.TimeMillisecond:
+      return "time-millisecond";
+    case arrow.TimeSecond:
+      return "time-second";
+    case arrow.TimeMicrosecond:
+      return "time-microsecond";
+    case arrow.TimeNanosecond:
+      return "time-nanosecond";
+    case arrow.Timestamp:
+      const timeStampUnit = arrowType.unit;
+      switch (timeStampUnit) {
+        case arrow.TimeUnit.SECOND:
+          return "timestamp-second";
+        case arrow.TimeUnit.MILLISECOND:
+          return "timestamp-millisecond";
+        case arrow.TimeUnit.MICROSECOND:
+          return "timestamp-microsecond";
+        case arrow.TimeUnit.NANOSECOND:
+          return "timestamp-nanosecond";
+        default:
+          return "timestamp-second";
+      }
+    case arrow.TimestampSecond:
+      return "timestamp-second";
+    case arrow.TimestampMillisecond:
+      return "timestamp-millisecond";
+    case arrow.TimestampMicrosecond:
+      return "timestamp-microsecond";
+    case arrow.TimestampNanosecond:
+      return "timestamp-nanosecond";
+    case arrow.Interval:
+      const intervalUnit = arrowType.unit;
+      switch (intervalUnit) {
+        case arrow.IntervalUnit.DAY_TIME:
+          return "interval-daytime";
+        case arrow.IntervalUnit.YEAR_MONTH:
+          return "interval-yearmonth";
+        default:
+          return "interval-daytime";
+      }
+    case arrow.IntervalDayTime:
+      return "interval-daytime";
+    case arrow.IntervalYearMonth:
+      return "interval-yearmonth";
+    case arrow.Map_:
+      const mapType = arrowType;
+      return {
+        type: "map",
+        keysSorted: mapType.keysSorted,
+        children: mapType.children.map((arrowField) => serializeArrowField(arrowField))
+      };
+    case arrow.List:
+      const listType = arrowType;
+      const listField = listType.valueField;
+      return {
+        type: "list",
+        children: [serializeArrowField(listField)]
+      };
+    case arrow.FixedSizeList:
+      const fixedSizeList = arrowType;
+      return {
+        type: "fixed-size-list",
+        listSize: fixedSizeList.listSize,
+        children: [serializeArrowField(fixedSizeList.children[0])]
+      };
+    case arrow.Struct:
+      const structType = arrowType;
+      return {
+        type: "struct",
+        children: structType.children.map((arrowField) => serializeArrowField(arrowField))
+      };
+    case arrow.SparseUnion:
+    case arrow.DenseUnion:
+      const unionType = arrowType;
+      return {
+        type: unionType instanceof arrow.DenseUnion ? "dense-union" : "sparse-union",
+        typeIds: unionType.typeIds,
+        children: unionType.children.map((arrowField) => serializeArrowField(arrowField)),
+        typeIdToChildIndex: { ...unionType.typeIdToChildIndex }
+      };
+    case arrow.Dictionary:
+      const dictionaryType = arrowType;
+      return {
+        type: "dictionary",
+        id: dictionaryType.id,
+        indices: serializeArrowDictionaryKeyType(dictionaryType.indices),
+        dictionary: serializeArrowType(dictionaryType.dictionary),
+        isOrdered: dictionaryType.isOrdered
+      };
+    default:
+      throw new Error(`arrow type not supported: ${arrowType.constructor.name}`);
+  }
+}
+function getOptionalArrowConstructor(typeName) {
+  return arrow[typeName];
+}
+function isArrowViewType(arrowType, viewTypeName) {
+  const constructor = getOptionalArrowConstructor(viewTypeName);
+  if (constructor && arrowType instanceof constructor) {
+    return true;
+  }
+  const guards = arrow.DataType;
+  const guard = viewTypeName === "BinaryView" ? guards.isBinaryView : guards.isUtf8View;
+  return Boolean(guard == null ? void 0 : guard(arrowType));
+}
+function isOptionalArrowType(arrowType, typeName) {
+  const constructor = getOptionalArrowConstructor(typeName);
+  return Boolean(constructor && arrowType instanceof constructor);
+}
+function serializeArrowDictionaryKeyType(arrowType) {
+  if (arrowType instanceof arrow.Int) {
+    const prefix = arrowType.isSigned ? "int" : "uint";
+    const keyType = `${prefix}${arrowType.bitWidth}`;
+    if (isSchemaDictionaryKeyType(keyType)) {
+      return keyType;
+    }
+  }
+  switch (arrowType.constructor) {
+    case arrow.Int8:
+      return "int8";
+    case arrow.Int16:
+      return "int16";
+    case arrow.Int32:
+      return "int32";
+    case arrow.Uint8:
+      return "uint8";
+    case arrow.Uint16:
+      return "uint16";
+    case arrow.Uint32:
+      return "uint32";
+    default:
+      throw new Error(`arrow dictionary index type not supported: ${arrowType.constructor.name}`);
+  }
+}
+function isSchemaDictionaryKeyType(keyType) {
+  return ["int8", "int16", "int32", "uint8", "uint16", "uint32"].includes(keyType);
+}
+var arrow;
+var init_convert_arrow_schema = __esm({
+  "../schema-utils/src/lib/schema/convert-arrow-schema.ts"() {
+    "use strict";
+    arrow = __toESM(require("apache-arrow"), 1);
+  }
+});
 
-// 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
+// ../schema-utils/src/index.ts
+var init_src = __esm({
+  "../schema-utils/src/index.ts"() {
+    "use strict";
+    init_convert_arrow_schema();
+  }
 });
-function parseGraphML(graphml) {
+
+// src/lib/build-graph-tables.ts
+function buildGraphTables(nodes, edges, shape, declarations) {
+  if (shape === "plain-graph-data") {
+    return { shape, nodes: Array.from(nodes), edges: Array.from(edges) };
+  }
+  if (shape !== "arrow-table" && shape !== "object-row-table") {
+    throw new Error(`Unsupported graph shape: ${shape}`);
+  }
+  const nodeTable = buildGraphTable(nodes, false, shape, declarations == null ? void 0 : declarations.nodes);
+  const edgeTable = buildGraphTable(edges, true, shape, declarations == null ? void 0 : declarations.edges);
+  return {
+    shape: "tables",
+    tables: [
+      { name: "nodes", table: nodeTable },
+      { name: "edges", table: edgeTable }
+    ]
+  };
+}
+function buildGraphTable(records, isEdge, shape, declarations) {
+  const columnNames = isEdge ? ["id", "sourceId", "targetId", "directed", "label", "attributes"] : ["id", "label", "attributes"];
+  const columns = new Map(columnNames.map((name) => [name, []]));
+  for (const record of records) {
+    for (const name of columnNames) {
+      const value = record[name];
+      columns.get(name).push(
+        name === "id" || name === "sourceId" || name === "targetId" ? String(value) : value ?? null
+      );
+    }
+  }
+  if (shape === "object-row-table") {
+    return {
+      shape,
+      data: columns.get("id").map(
+        (_, index) => Object.fromEntries(columnNames.map((name) => [name, columns.get(name)[index]]))
+      )
+    };
+  }
+  const vectors = /* @__PURE__ */ Object.create(null);
+  for (const [name, values] of columns) {
+    const type = name === "attributes" ? inferAttributeType(values, declarations) : name === "directed" ? new import_apache_arrow.Bool() : new import_apache_arrow.Utf8();
+    vectors[name] = (0, import_apache_arrow.vectorFromArray)(
+      values.map((value) => normalizeValue(value, type)),
+      type
+    );
+  }
+  const data = new import_apache_arrow.Table(vectors);
+  return { shape, schema: convertArrowToSchema(data.schema), data };
+}
+function inferAttributeType(values, declarations) {
+  const names = new Set(declarations == null ? void 0 : declarations.keys());
+  for (const value of values) {
+    if (value && typeof value === "object") {
+      for (const name of Object.keys(value)) {
+        names.add(name);
+      }
+    }
+  }
+  return new import_apache_arrow.Struct(
+    Array.from(names, (name) => {
+      const fieldValues = values.map(
+        (value) => (value == null ? void 0 : value[name]) ?? null
+      );
+      return new import_apache_arrow.Field(name, inferValueType(fieldValues, declarations == null ? void 0 : declarations.get(name)), true);
+    })
+  );
+}
+function inferValueType(values, declaration) {
+  const present = values.filter((value) => value !== null && value !== void 0);
+  if (declaration && typeof declaration === "object") {
+    if (!present.every((value) => Array.isArray(value))) return new import_apache_arrow.Utf8();
+    return new import_apache_arrow.List(
+      new import_apache_arrow.Field(
+        "item",
+        inferValueType(
+          present.flatMap((value) => value),
+          declaration.list
+        ),
+        true
+      )
+    );
+  }
+  if (declaration) {
+    const declaredTypes = {
+      boolean: new import_apache_arrow.Bool(),
+      int: new import_apache_arrow.Int32(),
+      long: new import_apache_arrow.Int64(),
+      float: new import_apache_arrow.Float32(),
+      double: new import_apache_arrow.Float64(),
+      string: new import_apache_arrow.Utf8()
+    };
+    const valid = present.every((value) => {
+      switch (declaration) {
+        case "boolean":
+          return typeof value === "boolean";
+        case "int":
+          return typeof value === "number" && Number.isInteger(value) && value >= -2147483648 && value <= 2147483647;
+        case "long":
+          return typeof value === "bigint" && value >= -(2n ** 63n) && value < 2n ** 63n;
+        case "float":
+        case "double":
+          return typeof value === "number";
+        case "string":
+          return typeof value === "string";
+      }
+    });
+    return valid ? declaredTypes[declaration] : new import_apache_arrow.Utf8();
+  }
+  if (present.length && present.every((value) => typeof value === "boolean")) return new import_apache_arrow.Bool();
+  if (present.length && present.every((value) => typeof value === "number")) return new import_apache_arrow.Float64();
+  if (present.length && present.every((value) => Array.isArray(value))) {
+    return new import_apache_arrow.List(
+      new import_apache_arrow.Field("item", inferValueType(present.flatMap((value) => value)), true)
+    );
+  }
+  if (present.length && present.every((value) => typeof value === "object" && !Array.isArray(value))) {
+    return inferAttributeType(present);
+  }
+  return new import_apache_arrow.Utf8();
+}
+function normalizeValue(value, type) {
+  if (value === null || value === void 0) return null;
+  if (type instanceof import_apache_arrow.Struct) {
+    return Object.fromEntries(
+      type.children.map((field) => [
+        field.name,
+        normalizeValue(value[field.name], field.type)
+      ])
+    );
+  }
+  if (type instanceof import_apache_arrow.List)
+    return value.map((item) => normalizeValue(item, type.valueType));
+  if (type instanceof import_apache_arrow.Utf8 && typeof value !== "string") {
+    return typeof value === "object" ? JSON.stringify(value) : String(value);
+  }
+  return value;
+}
+var import_apache_arrow;
+var init_build_graph_tables = __esm({
+  "src/lib/build-graph-tables.ts"() {
+    "use strict";
+    import_apache_arrow = require("apache-arrow");
+    init_src();
+  }
+});
+
+// src/lib/parse-graphml.ts
+function parseGraphML(graphml, shape = "plain-graph-data") {
   const xmlText = decodeGraphML(graphml);
   const document = graphmlParser.parse(xmlText);
   const graphmlRoot = getGraphMLRoot(document);
@@ -64,17 +487,38 @@ function parseGraphML(graphml) {
   if (!graphElement) {
     throw new Error("GraphML document does not contain a <graph> element.");
   }
-  const keyDefinitions = collectKeyDefinitions(graphmlRoot, graphElement);
+  const keyDefinitions = collectKeyDefinitions(
+    graphmlRoot,
+    graphElement,
+    shape !== "plain-graph-data"
+  );
   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
-  };
+  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") {
@@ -97,16 +541,21 @@ function getGraphMLRoot(document) {
 }
 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));
-    return isObject(firstGraph) ? firstGraph : null;
+    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) {
+function collectKeyDefinitions(graphmlRoot, graphElement, lossless) {
   const keys = /* @__PURE__ */ new Map();
   for (const candidate of [
     ...normalizeArray(graphmlRoot.key),
@@ -119,8 +568,8 @@ function collectKeyDefinitions(graphmlRoot, graphElement) {
         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 });
+        const defaultValue = defaultNode !== null ? castDataValue(defaultNode, type, lossless) : void 0;
+        keys.set(id, { id, domain, name, type, defaultValue, lossless });
       }
     }
   }
@@ -198,12 +647,12 @@ function assignAttributeFromDataEntry(entry, keyDefinitions, attributes) {
   }
   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");
+  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) {
+function castDataValue(value, type, lossless = false) {
   if (value === null || typeof value === "undefined") {
     return void 0;
   }
@@ -214,6 +663,9 @@ function castDataValue(value, type) {
   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;
@@ -236,12 +688,14 @@ function extractTextContent(value) {
   }
   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));
+    const nonAttributeEntries = Object.entries(value).filter(
+      ([key]) => !key.startsWith(XML_ATTRIBUTE_PREFIX) && key !== XML_TEXT_KEY
+    );
     if (nonAttributeEntries.length === 0) {
-      return void 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));
   }
@@ -302,14 +756,505 @@ function parseBoolean(value) {
   if (normalized === "false" || normalized === "0" || normalized === "no" || normalized === "n") {
     return false;
   }
-  return Boolean(value);
+  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");
+      }
+    };
+  }
+});
 
 // dist/graphml-loader.js
-var GraphMLLoaderWithParser = {
-  ...GraphMLLoader,
-  parse: async (data) => parseGraphML(data),
-  parseSync: parseGraphML,
-  parseTextSync: parseGraphML
+var graphml_loader_exports2 = {};
+__export(graphml_loader_exports2, {
+  GraphMLLoaderWithParser: () => GraphMLLoaderWithParser2
+});
+module.exports = __toCommonJS(graphml_loader_exports2);
+
+// dist/graphml-loader-types.js
+var VERSION2 = true ? "5.0.0-alpha.10" : "latest";
+async function preload2() {
+  const { GraphMLLoaderWithParser: GraphMLLoaderWithParser3 } = await Promise.resolve().then(() => (init_graphml_loader(), graphml_loader_exports));
+  return GraphMLLoaderWithParser3;
+}
+var GraphMLLoader2 = {
+  name: "GraphML",
+  id: "graphml",
+  module: "graphs",
+  version: VERSION2,
+  extensions: ["graphml"],
+  mimeTypes: ["application/graphml+xml"],
+  text: true,
+  worker: false,
+  dataType: null,
+  batchType: null,
+  options: { graphml: { shape: "arrow-table" } },
+  preload: preload2
+};
+
+// dist/lib/parse-graphml.js
+var import_fast_xml_parser2 = require("fast-xml-parser");
+
+// dist/lib/build-graph-tables.js
+var import_apache_arrow2 = require("apache-arrow");
+init_src();
+function buildGraphTables2(nodes, edges, shape, declarations) {
+  if (shape === "plain-graph-data") {
+    return { shape, nodes: Array.from(nodes), edges: Array.from(edges) };
+  }
+  if (shape !== "arrow-table" && shape !== "object-row-table") {
+    throw new Error(`Unsupported graph shape: ${shape}`);
+  }
+  const nodeTable = buildGraphTable2(nodes, false, shape, declarations == null ? void 0 : declarations.nodes);
+  const edgeTable = buildGraphTable2(edges, true, shape, declarations == null ? void 0 : declarations.edges);
+  return {
+    shape: "tables",
+    tables: [
+      { name: "nodes", table: nodeTable },
+      { name: "edges", table: edgeTable }
+    ]
+  };
+}
+function buildGraphTable2(records, isEdge, shape, declarations) {
+  const columnNames = isEdge ? ["id", "sourceId", "targetId", "directed", "label", "attributes"] : ["id", "label", "attributes"];
+  const columns = new Map(columnNames.map((name) => [name, []]));
+  for (const record of records) {
+    for (const name of columnNames) {
+      const value = record[name];
+      columns.get(name).push(name === "id" || name === "sourceId" || name === "targetId" ? String(value) : value ?? null);
+    }
+  }
+  if (shape === "object-row-table") {
+    return {
+      shape,
+      data: columns.get("id").map((_, index) => Object.fromEntries(columnNames.map((name) => [name, columns.get(name)[index]])))
+    };
+  }
+  const vectors = /* @__PURE__ */ Object.create(null);
+  for (const [name, values] of columns) {
+    const type = name === "attributes" ? inferAttributeType2(values, declarations) : name === "directed" ? new import_apache_arrow2.Bool() : new import_apache_arrow2.Utf8();
+    vectors[name] = (0, import_apache_arrow2.vectorFromArray)(values.map((value) => normalizeValue2(value, type)), type);
+  }
+  const data = new import_apache_arrow2.Table(vectors);
+  return { shape, schema: convertArrowToSchema(data.schema), data };
+}
+function inferAttributeType2(values, declarations) {
+  const names = new Set(declarations == null ? void 0 : declarations.keys());
+  for (const value of values) {
+    if (value && typeof value === "object") {
+      for (const name of Object.keys(value)) {
+        names.add(name);
+      }
+    }
+  }
+  return new import_apache_arrow2.Struct(Array.from(names, (name) => {
+    const fieldValues = values.map((value) => (value == null ? void 0 : value[name]) ?? null);
+    return new import_apache_arrow2.Field(name, inferValueType2(fieldValues, declarations == null ? void 0 : declarations.get(name)), true);
+  }));
+}
+function inferValueType2(values, declaration) {
+  const present = values.filter((value) => value !== null && value !== void 0);
+  if (declaration && typeof declaration === "object") {
+    if (!present.every((value) => Array.isArray(value)))
+      return new import_apache_arrow2.Utf8();
+    return new import_apache_arrow2.List(new import_apache_arrow2.Field("item", inferValueType2(present.flatMap((value) => value), declaration.list), true));
+  }
+  if (declaration) {
+    const declaredTypes = {
+      boolean: new import_apache_arrow2.Bool(),
+      int: new import_apache_arrow2.Int32(),
+      long: new import_apache_arrow2.Int64(),
+      float: new import_apache_arrow2.Float32(),
+      double: new import_apache_arrow2.Float64(),
+      string: new import_apache_arrow2.Utf8()
+    };
+    const valid = present.every((value) => {
+      switch (declaration) {
+        case "boolean":
+          return typeof value === "boolean";
+        case "int":
+          return typeof value === "number" && Number.isInteger(value) && value >= -2147483648 && value <= 2147483647;
+        case "long":
+          return typeof value === "bigint" && value >= -(2n ** 63n) && value < 2n ** 63n;
+        case "float":
+        case "double":
+          return typeof value === "number";
+        case "string":
+          return typeof value === "string";
+      }
+    });
+    return valid ? declaredTypes[declaration] : new import_apache_arrow2.Utf8();
+  }
+  if (present.length && present.every((value) => typeof value === "boolean"))
+    return new import_apache_arrow2.Bool();
+  if (present.length && present.every((value) => typeof value === "number"))
+    return new import_apache_arrow2.Float64();
+  if (present.length && present.every((value) => Array.isArray(value))) {
+    return new import_apache_arrow2.List(new import_apache_arrow2.Field("item", inferValueType2(present.flatMap((value) => value)), true));
+  }
+  if (present.length && present.every((value) => typeof value === "object" && !Array.isArray(value))) {
+    return inferAttributeType2(present);
+  }
+  return new import_apache_arrow2.Utf8();
+}
+function normalizeValue2(value, type) {
+  if (value === null || value === void 0)
+    return null;
+  if (type instanceof import_apache_arrow2.Struct) {
+    return Object.fromEntries(type.children.map((field) => [
+      field.name,
+      normalizeValue2(value[field.name], field.type)
+    ]));
+  }
+  if (type instanceof import_apache_arrow2.List)
+    return value.map((item) => normalizeValue2(item, type.valueType));
+  if (type instanceof import_apache_arrow2.Utf8 && typeof value !== "string") {
+    return typeof value === "object" ? JSON.stringify(value) : String(value);
+  }
+  return value;
+}
+
+// dist/lib/parse-graphml.js
+var XML_ATTRIBUTE_PREFIX2 = "@_";
+var XML_TEXT_KEY2 = "#text";
+var graphmlParser2 = new import_fast_xml_parser2.XMLParser({
+  ignoreAttributes: false,
+  attributeNamePrefix: XML_ATTRIBUTE_PREFIX2,
+  textNodeName: XML_TEXT_KEY2,
+  trimValues: false,
+  parseAttributeValue: false,
+  parseTagValue: false,
+  removeNSPrefix: true
+});
+function parseGraphML2(graphml, shape = "plain-graph-data") {
+  const xmlText = decodeGraphML2(graphml);
+  const document = graphmlParser2.parse(xmlText);
+  const graphmlRoot = getGraphMLRoot2(document);
+  if (!graphmlRoot) {
+    throw new Error("GraphML document does not contain a <graphml> element.");
+  }
+  const graphElement = getGraphElement2(graphmlRoot);
+  if (!graphElement) {
+    throw new Error("GraphML document does not contain a <graph> element.");
+  }
+  const keyDefinitions = collectKeyDefinitions2(graphmlRoot, graphElement, shape !== "plain-graph-data");
+  const defaultDirected = parseEdgeDefault2(graphElement[`${XML_ATTRIBUTE_PREFIX2}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 buildGraphTables2(iterateNodes2(graphElement.node, keyDefinitions), iterateEdges2(graphElement.edge, keyDefinitions, defaultDirected), shape, declarations);
+}
+function* iterateNodes2(nodes, definitions) {
+  for (const node of normalizeArray2(nodes)) {
+    const record = parseNode2(node, definitions);
+    if (record)
+      yield record;
+  }
+}
+function* iterateEdges2(edges, definitions, directed) {
+  let index = 0;
+  for (const edge of normalizeArray2(edges)) {
+    const record = parseEdge2(edge, index++, definitions, directed);
+    if (record)
+      yield record;
+  }
+}
+function decodeGraphML2(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 getGraphMLRoot2(document) {
+  const root = document.graphml;
+  if (isObject2(root)) {
+    return root;
+  }
+  return null;
+}
+function getGraphElement2(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) => isObject2(entry) || typeof entry === "string" && !entry.trim());
+    return isObject2(firstGraph) ? firstGraph : typeof firstGraph === "string" ? {} : null;
+  }
+  return isObject2(graph) ? graph : null;
+}
+function collectKeyDefinitions2(graphmlRoot, graphElement, lossless) {
+  const keys = /* @__PURE__ */ new Map();
+  for (const candidate of [
+    ...normalizeArray2(graphmlRoot.key),
+    ...normalizeArray2(graphElement.key)
+  ]) {
+    if (isObject2(candidate)) {
+      const id = String(candidate[`${XML_ATTRIBUTE_PREFIX2}id`] ?? "").trim();
+      if (id) {
+        const domain = normalizeDomain2(candidate[`${XML_ATTRIBUTE_PREFIX2}for`]);
+        const name = String(candidate[`${XML_ATTRIBUTE_PREFIX2}attr.name`] ?? id).trim();
+        const type = normalizeType2(candidate[`${XML_ATTRIBUTE_PREFIX2}attr.type`]);
+        const defaultNode = candidate.default ?? null;
+        const defaultValue = defaultNode !== null ? castDataValue2(defaultNode, type, lossless) : void 0;
+        keys.set(id, { id, domain, name, type, defaultValue, lossless });
+      }
+    }
+  }
+  return keys;
+}
+function parseNode2(node, keyDefinitions) {
+  if (!isObject2(node)) {
+    return null;
+  }
+  const id = node[`${XML_ATTRIBUTE_PREFIX2}id`];
+  if (typeof id !== "string") {
+    return null;
+  }
+  const attributes = buildAttributeBag2("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 parseEdge2(edge, index, keyDefinitions, defaultDirected) {
+  if (!isObject2(edge)) {
+    return null;
+  }
+  const sourceId = edge[`${XML_ATTRIBUTE_PREFIX2}source`];
+  const targetId = edge[`${XML_ATTRIBUTE_PREFIX2}target`];
+  if (typeof sourceId !== "string") {
+    return null;
+  }
+  if (typeof targetId !== "string") {
+    return null;
+  }
+  const rawId = edge[`${XML_ATTRIBUTE_PREFIX2}id`];
+  const id = typeof rawId === "string" ? rawId : `edge-${index}`;
+  const directed = parseDirected2(edge[`${XML_ATTRIBUTE_PREFIX2}directed`], defaultDirected);
+  const attributes = buildAttributeBag2("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 buildAttributeBag2(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 normalizeArray2(data)) {
+    assignAttributeFromDataEntry2(entry, keyDefinitions, attributes);
+  }
+  return attributes;
+}
+function assignAttributeFromDataEntry2(entry, keyDefinitions, attributes) {
+  if (!isObject2(entry)) {
+    return;
+  }
+  const keyId = entry[`${XML_ATTRIBUTE_PREFIX2}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" && extractTextContent2(entry) === void 0 ? false : castDataValue2(entry, (definition == null ? void 0 : definition.type) ?? "string", definition == null ? void 0 : definition.lossless);
+  if (value !== void 0) {
+    attributes[attributeName] = value;
+  }
+}
+function castDataValue2(value, type, lossless = false) {
+  if (value === null || typeof value === "undefined") {
+    return void 0;
+  }
+  const text = extractTextContent2(value);
+  if (text === void 0) {
+    return void 0;
+  }
+  if (type === "boolean") {
+    return parseBoolean2(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 extractTextContent2(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (Array.isArray(value)) {
+    return extractTextContent2(value[0]);
+  }
+  if (isObject2(value)) {
+    const text = value[XML_TEXT_KEY2];
+    const nonAttributeEntries = Object.entries(value).filter(([key]) => !key.startsWith(XML_ATTRIBUTE_PREFIX2) && key !== XML_TEXT_KEY2);
+    if (nonAttributeEntries.length === 0) {
+      return typeof text === "string" ? text : void 0;
+    }
+    if (typeof text === "string" && text.trim()) {
+      nonAttributeEntries.push([XML_TEXT_KEY2, text]);
+    }
+    return JSON.stringify(Object.fromEntries(nonAttributeEntries));
+  }
+  return void 0;
+}
+function normalizeArray2(value) {
+  if (!value) {
+    return [];
+  }
+  return Array.isArray(value) ? value : [value];
+}
+function isObject2(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeDomain2(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 normalizeType2(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 parseEdgeDefault2(value) {
+  if (typeof value !== "string") {
+    return false;
+  }
+  return value.toLowerCase() !== "undirected";
+}
+function parseDirected2(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 parseBoolean2(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);
+}
+
+// dist/graphml-loader.js
+var GraphMLLoaderWithParser2 = {
+  ...GraphMLLoader2,
+  parse: async (data, options) => {
+    var _a;
+    return parseGraphML2(data, ((_a = options == null ? void 0 : options.graphml) == null ? void 0 : _a.shape) ?? "arrow-table");
+  },
+  parseSync: (data, options) => {
+    var _a;
+    return parseGraphML2(data, ((_a = options == null ? void 0 : options.graphml) == null ? void 0 : _a.shape) ?? "arrow-table");
+  },
+  parseTextSync: (data, options) => {
+    var _a;
+    return parseGraphML2(data, ((_a = options == null ? void 0 : options.graphml) == null ? void 0 : _a.shape) ?? "arrow-table");
+  }
 };
 //# sourceMappingURL=graphml-loader.cjs.map