@loaders.gl/graphs 5.0.0-alpha.9 → 5.0.0-beta.1

package/src/lib/parse-gexf.ts

@@ -0,0 +1,388 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {XMLParser, XMLValidator} from 'fast-xml-parser';
+import type {GraphNode, GraphEdge, GraphShape, GraphAttributeType} from '../graph-types';
+import type {GEXFOutput} from '../gexf-types';
+import {buildGraphTables} from './build-graph-tables';
+
+/** XML element and attribute representation. */
+type XMLElement = Record<string, unknown>;
+
+/** A scoped application attribute declaration. */
+type AttributeDefinition = {
+  /** Application attribute title. */
+  name: string;
+  /** Arrow-compatible scalar or list type. */
+  type: GraphAttributeType;
+  /** Default value, when supplied. */
+  defaultValue?: unknown;
+};
+
+const parser = new XMLParser({
+  ignoreAttributes: false,
+  parseAttributeValue: false,
+  parseTagValue: false,
+  trimValues: false
+});
+const GEXF_NAMESPACE = /^https?:\/\/(?:www\.)?gexf.net\/1\.(?:2(?:draft)?|3)(\/viz)?$/;
+const TEMPORAL_ATTRIBUTES = [
+  'start',
+  'end',
+  'startopen',
+  'endopen',
+  'timestamp',
+  'timestamps',
+  'intervals'
+];
+
+/** Parses a static GEXF document directly into the selected graph representation. */
+export function parseGEXF(
+  input: string | ArrayBuffer | Uint8Array,
+  shape: GraphShape = 'arrow-table'
+): GEXFOutput {
+  const text = typeof input === 'string' ? input : new TextDecoder().decode(input);
+  const validation = XMLValidator.validate(text);
+  if (validation !== true) throw new Error(`Invalid GEXF XML: ${validation.err.msg}`);
+  // External and custom entity declarations are outside the supported format subset.
+  if (/<!DOCTYPE\s/i.test(text)) throw new Error('GEXF document types are unsupported.');
+  const document = normalizeNamespaces(parser.parse(text) as XMLElement, {});
+  const root = getElement(document.gexf, 'gexf');
+  const version = root['@_version'] as string | undefined;
+  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: new Map<string, AttributeDefinition>(),
+    edges: new Map<string, AttributeDefinition>()
+  };
+  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 === undefined
+            ? undefined
+            : castValue(readTextContent(attribute.default), type)
+      });
+    }
+  }
+  const nodeElements = getElements(getContainer(graph.nodes).node);
+  const edgeElements = getElements(getContainer(graph.edges).edge);
+  const nodeIdentifiers = new Set<string>();
+  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): identifier is string => typeof identifier === 'string')
+  );
+  const seenEdges = new Set<string>();
+  /** Emits node records directly to the table builder. */
+  function* iterateNodes(): Iterable<GraphNode> {
+    for (const node of nodeElements) yield parseRecord(node, definitions.nodes);
+  }
+  /** Emits edge records without materializing a plain graph. */
+  function* iterateEdges(): Iterable<GraphEdge> {
+    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'] === undefined ? undefined : requireAttribute(edge, 'id');
+      if (identifier === undefined) {
+        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'] === undefined ? directed : parseDirection(edge['@_type'])
+      };
+    }
+  }
+  const metadataAttributes: Record<string, string> = Object.create(null);
+  const meta = getContainer(root.meta);
+  for (const name of ['creator', 'description', 'keywords']) {
+    if (meta[name] !== undefined) 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(iterateNodes(), iterateEdges(), shape, declarations),
+    metadata: {version, directed, attributes: metadataAttributes}
+  };
+}
+
+/** Resolves inherited namespace bindings without treating foreign elements as GEXF. */
+function normalizeNamespaces(element: XMLElement, inherited: Record<string, string>): XMLElement {
+  const namespaces: Record<string, string> = Object.assign(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: XMLElement = 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);
+    // Namespace declarations on this child also scope the child's own name.
+    const children = Array.isArray(value) ? value : [value];
+    for (const child of children) {
+      const object = typeof child === 'object' && child !== null ? (child as XMLElement) : {};
+      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] === undefined) normalized[key] = childValue;
+      else
+        normalized[key] = [
+          ...(Array.isArray(normalized[key]) ? (normalized[key] as unknown[]) : [normalized[key]]),
+          childValue
+        ];
+    }
+  }
+  assertStaticElement(normalized);
+  return normalized;
+}
+
+/** Rejects temporal and hierarchical constructs that flat static tables cannot represent. */
+function assertStaticElement(element: XMLElement): void {
+  if (
+    (element['@_mode'] !== undefined && element['@_mode'] !== 'static') ||
+    TEMPORAL_ATTRIBUTES.some(name => element[`@_${name}`] !== undefined) ||
+    element.spells !== undefined
+  ) {
+    throw new Error('Dynamic GEXF graphs and temporal values are unsupported.');
+  }
+  if (
+    element['@_pid'] !== undefined ||
+    element.parents !== undefined ||
+    (element['@_id'] !== undefined && (element.nodes !== undefined || element.edges !== undefined))
+  ) {
+    throw new Error('Hierarchical GEXF graphs are unsupported.');
+  }
+}
+
+/** Reads a singleton element, including an empty element. */
+function getElement(value: unknown, name: string): XMLElement {
+  if (value === '') return {};
+  if (value && typeof value === 'object' && !Array.isArray(value)) return value as XMLElement;
+  throw new Error(`GEXF requires one <${name}> element.`);
+}
+
+/** Reads scalar text from elements that also declare local namespace bindings. */
+function readTextContent(value: unknown): string {
+  if (typeof value === 'string') return value;
+  const text = getElement(value, 'text')['#text'];
+  return typeof text === 'string' ? text : '';
+}
+
+/** Reads an optional container while rejecting repeated containers. */
+function getContainer(value: unknown): XMLElement {
+  return value === undefined ? {} : getElement(value, 'container');
+}
+
+/** Reads repeated or singleton element records. */
+function getElements(value: unknown): XMLElement[] {
+  if (value === undefined) return [];
+  return (Array.isArray(value) ? value : [value]).map(entry => getElement(entry, 'record'));
+}
+
+/** Reads a required XML attribute without changing identifier or label whitespace. */
+function requireAttribute(element: XMLElement, name: string): string {
+  const value = element[`@_${name}`];
+  if (typeof value !== 'string' || value === '')
+    throw new Error(`GEXF requires a ${name} attribute.`);
+  return value;
+}
+
+/** Reads a direction while rejecting bidirectional mutual edges. */
+function parseDirection(value: unknown): boolean {
+  if (value !== 'directed' && value !== 'undirected')
+    throw new Error(`Unsupported GEXF edge type: ${String(value)}`);
+  return value === 'directed';
+}
+
+/** Maps supported GEXF scalar and list types to graph column declarations. */
+function parseAttributeType(value: string): GraphAttributeType {
+  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}`);
+}
+
+/** Casts exact declared values; invalid scalar text survives Arrow promotion to Utf8. */
+function castValue(text: string, type: GraphAttributeType): unknown {
+  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;
+}
+
+/** Reads bracketed and legacy lists, preserving quoted delimiters and string whitespace. */
+function parseListValues(text: string): string[] {
+  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: string[] = [];
+  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;
+}
+
+/** Converts application attributes and native GEXF properties to a collision-free record. */
+function parseRecord(
+  element: XMLElement,
+  definitions: Map<string, AttributeDefinition>,
+  identifier?: string
+): GraphNode {
+  const attributes: Record<string, unknown> = Object.create(null);
+  for (const definition of definitions.values()) {
+    if (definition.defaultValue !== undefined)
+      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: Record<string, unknown> = Object.create(null);
+  if (element['@_weight'] !== undefined)
+    native.weight = castValue(String(element['@_weight']), 'double');
+  if (element['@_kind'] !== undefined) native.kind = element['@_kind'];
+  const visualization: Record<string, unknown> = Object.create(null);
+  for (const name of ['color', 'position', 'size', 'shape', 'thickness']) {
+    const value = element[`viz:${name}`];
+    if (value === undefined) continue;
+    const properties: Record<string, unknown> = 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'] as string | undefined,
+    attributes
+  };
+}
+
+/** Reads an attribute value, allowing the empty string. */
+function requireValue(element: XMLElement): string {
+  const value = element['@_value'];
+  if (typeof value !== 'string') throw new Error('GEXF attvalue requires a value attribute.');
+  return value;
+}

package/src/lib/parse-graphml.ts

@@ -4,7 +4,16 @@
 
 import {XMLParser} from 'fast-xml-parser';
 
-import type {GraphData, GraphEdge, GraphNode} from '../graph-types';
+import type {
+  GraphData,
+  GraphEdge,
+  GraphNode,
+  GraphOutput,
+  GraphShape,
+  GraphAttributeSchemas,
+  GraphAttributeType
+} from '../graph-types';
+import {buildGraphTables} from './build-graph-tables';
 
 const XML_ATTRIBUTE_PREFIX = '@_';
 const XML_TEXT_KEY = '#text';
@@ -12,9 +21,6 @@ const XML_TEXT_KEY = '#text';
 /** Supported key scopes. */
 type GraphMLDomain = 'all' | 'node' | 'edge' | 'graph';
 
-/** Supported scalar attribute types. */
-type GraphMLAttributeType = 'boolean' | 'int' | 'long' | 'float' | 'double' | 'string';
-
 /** A declared GraphML key and its default. */
 type GraphMLKeyDefinition = {
   /** Key identifier. */
@@ -24,9 +30,11 @@ type GraphMLKeyDefinition = {
   /** Elements to which defaults apply. */
   domain: GraphMLDomain;
   /** Declared scalar type. */
-  type: GraphMLAttributeType;
+  type: GraphAttributeType;
   /** Typed default value. */
   defaultValue?: unknown;
+  /** Whether long values retain exact integer precision. */
+  lossless: boolean;
 };
 
 /** XML element representation emitted by fast-xml-parser. */
@@ -39,7 +47,7 @@ const graphmlParser = new XMLParser({
   ignoreAttributes: false,
   attributeNamePrefix: XML_ATTRIBUTE_PREFIX,
   textNodeName: XML_TEXT_KEY,
-  trimValues: true,
+  trimValues: false,
   parseAttributeValue: false,
   parseTagValue: false,
   removeNSPrefix: true
@@ -49,7 +57,12 @@ const graphmlParser = new XMLParser({
 export type GraphMLInput = string | ArrayBuffer | Uint8Array;
 
 /** Parses the first GraphML graph into framework-independent node and edge records. */
-export function parseGraphML(graphml: GraphMLInput): GraphData {
+export function parseGraphML(graphml: GraphMLInput): GraphData;
+export function parseGraphML(graphml: GraphMLInput, shape: GraphShape): GraphOutput;
+export function parseGraphML(
+  graphml: GraphMLInput,
+  shape: GraphShape = 'plain-graph-data'
+): GraphOutput {
   const xmlText = decodeGraphML(graphml);
   const document = graphmlParser.parse(xmlText) as GraphMLObject;
   const graphmlRoot = getGraphMLRoot(document);
@@ -62,22 +75,50 @@ export function parseGraphML(graphml: GraphMLInput): GraphData {
     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 declarations: GraphAttributeSchemas = {nodes: new Map(), edges: 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
   );
+}
 
-  const filteredNodes = nodes.filter((node): node is GraphNode => Boolean(node));
-  const filteredEdges = edges.filter((edge): edge is GraphEdge => Boolean(edge));
+/** Emits valid nodes directly to the selected output builder. */
+function* iterateNodes(
+  nodes: unknown,
+  definitions: Map<string, GraphMLKeyDefinition>
+): Iterable<GraphNode> {
+  for (const node of normalizeArray(nodes)) {
+    const record = parseNode(node, definitions);
+    if (record) yield record;
+  }
+}
 
-  return {
-    shape: 'plain-graph-data',
-    nodes: filteredNodes,
-    edges: filteredEdges
-  } satisfies GraphData;
+/** Emits valid edges while preserving generated IDs and document order. */
+function* iterateEdges(
+  edges: unknown,
+  definitions: Map<string, GraphMLKeyDefinition>,
+  directed: boolean
+): Iterable<GraphEdge> {
+  let index = 0;
+  for (const edge of normalizeArray(edges)) {
+    const record = parseEdge(edge, index++, definitions, directed);
+    if (record) yield record;
+  }
 }
 
 /** Decodes text or UTF-8 binary input. */
@@ -110,13 +151,18 @@ function getGraphMLRoot(document: GraphMLObject): GraphMLObject | null {
 /** Selects the first graph element. */
 function getGraphElement(graphmlRoot: GraphMLObject): GraphMLObject | null {
   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;
@@ -125,7 +171,8 @@ function getGraphElement(graphmlRoot: GraphMLObject): GraphMLObject | null {
 /** Collects scoped keys and typed defaults. */
 function collectKeyDefinitions(
   graphmlRoot: GraphMLObject,
-  graphElement: GraphMLObject
+  graphElement: GraphMLObject,
+  lossless: boolean
 ): Map<string, GraphMLKeyDefinition> {
   const keys = new Map<string, GraphMLKeyDefinition>();
 
@@ -140,9 +187,10 @@ function collectKeyDefinitions(
         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) : undefined;
+        const defaultValue =
+          defaultNode !== null ? castDataValue(defaultNode, type, lossless) : undefined;
 
-        keys.set(id, {id, domain, name, type, defaultValue});
+        keys.set(id, {id, domain, name, type, defaultValue, lossless});
       }
     }
   }
@@ -260,14 +308,17 @@ function assignAttributeFromDataEntry(
 
   const definition = keyDefinitions.get(keyId);
   const attributeName = definition?.name ?? keyId;
-  const value = castDataValue(entry, definition?.type ?? 'string');
+  const value =
+    definition?.type === 'boolean' && extractTextContent(entry) === undefined
+      ? false
+      : castDataValue(entry, definition?.type ?? 'string', definition?.lossless);
   if (value !== undefined) {
     attributes[attributeName] = value;
   }
 }
 
 /** Converts GraphML scalar types while preserving unparseable numeric text. */
-function castDataValue(value: unknown, type: GraphMLAttributeType): unknown {
+function castDataValue(value: unknown, type: GraphAttributeType, lossless = false): unknown {
   if (value === null || typeof value === 'undefined') {
     return undefined;
   }
@@ -280,6 +331,9 @@ function castDataValue(value: unknown, type: GraphMLAttributeType): unknown {
   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;
@@ -307,15 +361,14 @@ function extractTextContent(value: unknown): string | undefined {
 
   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)
+      ([key]) => !key.startsWith(XML_ATTRIBUTE_PREFIX) && key !== XML_TEXT_KEY
     );
     if (nonAttributeEntries.length === 0) {
-      return undefined;
+      return typeof text === 'string' ? text : undefined;
+    }
+    if (typeof text === 'string' && text.trim()) {
+      nonAttributeEntries.push([XML_TEXT_KEY, text]);
     }
     return JSON.stringify(Object.fromEntries(nonAttributeEntries));
   }
@@ -350,7 +403,7 @@ function normalizeDomain(value: unknown): GraphMLDomain {
 }
 
 /** Normalizes supported GraphML scalar types. */
-function normalizeType(value: unknown): GraphMLAttributeType {
+function normalizeType(value: unknown): GraphAttributeType {
   if (typeof value !== 'string') {
     return 'string';
   }
@@ -368,7 +421,6 @@ function normalizeType(value: unknown): GraphMLAttributeType {
   return 'string';
 }
 
-/** Converts an edge element with its effective direction. */
 /** Reads the graph-wide default edge direction. */
 function parseEdgeDefault(value: unknown): boolean {
   if (typeof value !== 'string') {
@@ -410,5 +462,5 @@ function parseBoolean(value: string): boolean {
   if (normalized === 'false' || normalized === '0' || normalized === 'no' || normalized === 'n') {
     return false;
   }
-  return Boolean(value);
+  return Boolean(normalized);
 }