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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@loaders.gl/graphs",
-  "version": "5.0.0-alpha.9",
-  "description": "Graph format parsers for DOT, GraphML, and related formats",
+  "version": "5.0.0-beta.2",
+  "description": "Graph loaders for Graphviz DOT, GraphML, and GEXF",
   "license": "MIT",
   "type": "module",
   "repository": {
@@ -12,8 +12,10 @@
     "graph",
     "dot",
     "graphml",
+    "gexf",
     "parser",
-    "loader"
+    "loader",
+    "loaders.gl"
   ],
   "types": "dist/index.d.ts",
   "main": "dist/index.cjs",
@@ -33,26 +35,34 @@
       "types": "./dist/dot-loader.d.ts",
       "import": "./dist/dot-loader.js",
       "require": "./dist/dot-loader.cjs"
+    },
+    "./gexf-loader": {
+      "types": "./dist/gexf-loader.d.ts",
+      "import": "./dist/gexf-loader.js",
+      "require": "./dist/gexf-loader.cjs"
     }
   },
   "sideEffects": false,
   "files": [
     "src",
     "dist",
-    "README.md"
+    "README.md",
+    "LICENSE",
+    "THIRD-PARTY-NOTICES.md"
   ],
   "scripts": {
-    "pre-build": "echo \"Nothing to build in @loaders.gl/graphs\""
+    "pre-build": "npm run build-metadata",
+    "build-metadata": "node ../../scripts/build-graphs-metadata.mjs"
   },
   "peerDependencies": {
     "@loaders.gl/core": "~5.0.0-alpha.0"
   },
-  "gitHead": "f1a6da2c65e4ea06b59c61d1884819b6be577fe3",
+  "gitHead": "d259e5bc74caf8d75e808314b7fef2fa1bd70ff7",
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
-    "@loaders.gl/loader-utils": "5.0.0-alpha.9",
-    "fast-xml-parser": "^5.5.3"
+    "@loaders.gl/documents": "5.0.0-beta.2",
+    "apache-arrow": ">= 17.0.0"
   }
 }

package/src/dot-loader-types.ts

@@ -2,8 +2,18 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {Loader} from '@loaders.gl/loader-utils';
-import type {DOTGraphData} from './dot-types';
+import type {Loader} from '@loaders.gl/core/loader-utils';
+import type {DOTOutput} from './dot-types';
+import type {GraphShape} from './graph-types';
+
+/** Options for selecting the DOT graph output representation. */
+export type DOTLoaderOptions = {
+  /** Format-specific graph options. */
+  dot?: {
+    /** Representation of each named table; defaults to Arrow. */
+    shape?: GraphShape;
+  };
+};
 
 // @ts-ignore __VERSION__ is injected by the build.
 const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
@@ -24,8 +34,8 @@ export const DOTLoader = {
   mimeTypes: ['text/vnd.graphviz', 'text/x-graphviz', 'application/vnd.graphviz'],
   text: true,
   worker: false,
-  dataType: null as unknown as DOTGraphData,
+  dataType: null as unknown as DOTOutput,
   batchType: null as never,
-  options: {},
+  options: {dot: {shape: 'arrow-table'}},
   preload
-} as const satisfies Loader<DOTGraphData, never>;
+} as const satisfies Loader<DOTOutput, never, DOTLoaderOptions>;

package/src/dot-loader.ts

@@ -2,13 +2,16 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {DOTLoader} from './dot-loader-types';
+import {DOTLoader, type DOTLoaderOptions} from './dot-loader-types';
 import {parseDOT} from './lib/parse-dot';
 
 /** Parser-bearing loader for synchronous and asynchronous DOT parsing. */
 export const DOTLoaderWithParser = {
   ...DOTLoader,
-  parse: async (data: ArrayBuffer) => parseDOT(new TextDecoder().decode(data)),
-  parseSync: (data: ArrayBuffer) => parseDOT(new TextDecoder().decode(data)),
-  parseTextSync: parseDOT
+  parse: async (data: ArrayBuffer, options?: DOTLoaderOptions) =>
+    parseDOT(new TextDecoder().decode(data), options?.dot?.shape ?? 'arrow-table'),
+  parseSync: (data: ArrayBuffer, options?: DOTLoaderOptions) =>
+    parseDOT(new TextDecoder().decode(data), options?.dot?.shape ?? 'arrow-table'),
+  parseTextSync: (data: string, options?: DOTLoaderOptions) =>
+    parseDOT(data, options?.dot?.shape ?? 'arrow-table')
 };

package/src/dot-types.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {GraphData} from './graph-types';
+import type {GraphData, GraphOutput} from './graph-types';
 
 /** Application attributes parsed from DOT. */
 type DOTAttributeMap = Record<string, unknown>;
@@ -36,3 +36,9 @@ export type DOTGraphData = GraphData & {
   /** DOT graph identity, direction, strictness, attributes, and subgraphs. */
   metadata: DOTMetadata;
 };
+
+/** DOT tables or compatibility records with graph metadata. */
+export type DOTOutput = GraphOutput & {
+  /** Graph identity, defaults, and subgraph descriptors. */
+  metadata: DOTMetadata;
+};

package/src/gexf-loader-types.ts

@@ -0,0 +1,41 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {Loader} from '@loaders.gl/core/loader-utils';
+import type {GraphShape} from './graph-types';
+import type {GEXFOutput} from './gexf-types';
+
+/** Options for selecting the GEXF graph output representation. */
+export type GEXFLoaderOptions = {
+  /** GEXF-specific graph options. */
+  gexf?: {
+    /** Representation of each named table; defaults to Arrow. */
+    shape?: GraphShape;
+  };
+};
+
+// @ts-ignore __VERSION__ is injected by the build.
+const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
+
+/** Preloads the GEXF parser implementation. */
+async function preload() {
+  const {GEXFLoaderWithParser} = await import('@loaders.gl/graphs/gexf-loader');
+  return GEXFLoaderWithParser;
+}
+
+/** Metadata-only loader for static GEXF 1.2 and 1.3 documents. */
+export const GEXFLoader = {
+  name: 'GEXF',
+  id: 'gexf',
+  module: 'graphs',
+  version: VERSION,
+  extensions: ['gexf'],
+  mimeTypes: ['application/gexf+xml'],
+  text: true,
+  worker: false,
+  dataType: null as unknown as GEXFOutput,
+  batchType: null as never,
+  options: {gexf: {shape: 'arrow-table'}},
+  preload
+} as const satisfies Loader<GEXFOutput, never, GEXFLoaderOptions>;

package/src/gexf-loader.ts

@@ -0,0 +1,17 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {GEXFLoader, type GEXFLoaderOptions} from './gexf-loader-types';
+import {parseGEXF} from './lib/parse-gexf';
+
+/** Parser-bearing loader for synchronous and asynchronous GEXF parsing. */
+export const GEXFLoaderWithParser = {
+  ...GEXFLoader,
+  parse: async (data: ArrayBuffer, options?: GEXFLoaderOptions) =>
+    parseGEXF(data, options?.gexf?.shape ?? 'arrow-table'),
+  parseSync: (data: ArrayBuffer, options?: GEXFLoaderOptions) =>
+    parseGEXF(data, options?.gexf?.shape ?? 'arrow-table'),
+  parseTextSync: (data: string, options?: GEXFLoaderOptions) =>
+    parseGEXF(data, options?.gexf?.shape ?? 'arrow-table')
+};

package/src/gexf-types.ts

@@ -0,0 +1,21 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {GraphOutput} from './graph-types';
+
+/** Static GEXF document metadata, retained in every output shape. */
+export type GEXFMetadata = {
+  /** Document format version, when supplied. */
+  version?: string;
+  /** Default direction used by edges without a type override. */
+  directed: boolean;
+  /** Document author, description, keywords, and modification date. */
+  attributes: Record<string, string>;
+};
+
+/** Standard graph tables or plain records with GEXF document metadata. */
+export type GEXFOutput = GraphOutput & {
+  /** Document metadata and graph-wide direction. */
+  metadata: GEXFMetadata;
+};

package/src/graph-types.ts

@@ -2,6 +2,8 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
+import type {ArrowTable, ObjectRowTable, Tables} from '@loaders.gl/core/schema';
+
 /** A graph node with its original identifier and application attributes. */
 export type GraphNode = {
   /** Original node identifier. */
@@ -31,3 +33,36 @@ export type GraphData = {
   /** Edges in document order. */
   edges: GraphEdge[];
 };
+
+/** Standard table representations supported by graph loaders. */
+export type GraphShape = 'arrow-table' | 'object-row-table' | 'plain-graph-data';
+
+/** Named node and edge tables in document order. */
+export type GraphTables<TableType = ArrowTable> = Tables<TableType> & {
+  /** Node table followed by edge table. */
+  tables: [{name: 'nodes'; table: TableType}, {name: 'edges'; table: TableType}];
+};
+
+/** Graph loader output, with Arrow tables as the default representation. */
+export type GraphOutput = GraphTables | GraphTables<ObjectRowTable> | GraphData;
+
+/** Scalar and list types declared by graph format attributes. */
+export type GraphAttributeType =
+  | 'boolean'
+  | 'int'
+  | 'long'
+  | 'float'
+  | 'double'
+  | 'string'
+  | {
+      /** Declared element type for a GEXF list attribute. */
+      list: GraphAttributeType;
+    };
+
+/** Declared application attribute schemas for each graph table. */
+export type GraphAttributeSchemas = {
+  /** Declared node attributes, including keys with no values. */
+  nodes: Map<string, GraphAttributeType>;
+  /** Declared edge attributes, including keys with no values. */
+  edges: Map<string, GraphAttributeType>;
+};

package/src/graphml-loader-types.ts

@@ -2,8 +2,17 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {Loader} from '@loaders.gl/loader-utils';
-import type {GraphData} from './graph-types';
+import type {Loader} from '@loaders.gl/core/loader-utils';
+import type {GraphOutput, GraphShape} from './graph-types';
+
+/** Options for selecting the GraphML graph output representation. */
+export type GraphMLLoaderOptions = {
+  /** Format-specific graph options. */
+  graphml?: {
+    /** Representation of each named table; defaults to Arrow. */
+    shape?: GraphShape;
+  };
+};
 
 // @ts-ignore __VERSION__ is injected by the build.
 const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
@@ -24,8 +33,8 @@ export const GraphMLLoader = {
   mimeTypes: ['application/graphml+xml'],
   text: true,
   worker: false,
-  dataType: null as unknown as GraphData,
+  dataType: null as unknown as GraphOutput,
   batchType: null as never,
-  options: {},
+  options: {graphml: {shape: 'arrow-table'}},
   preload
-} as const satisfies Loader<GraphData, never>;
+} as const satisfies Loader<GraphOutput, never, GraphMLLoaderOptions>;

package/src/graphml-loader.ts

@@ -2,13 +2,16 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {GraphMLLoader} from './graphml-loader-types';
+import {GraphMLLoader, type GraphMLLoaderOptions} from './graphml-loader-types';
 import {parseGraphML} from './lib/parse-graphml';
 
 /** Parser-bearing loader for synchronous and asynchronous GraphML parsing. */
 export const GraphMLLoaderWithParser = {
   ...GraphMLLoader,
-  parse: async (data: ArrayBuffer) => parseGraphML(data),
-  parseSync: parseGraphML,
-  parseTextSync: parseGraphML
+  parse: async (data: ArrayBuffer, options?: GraphMLLoaderOptions) =>
+    parseGraphML(data, options?.graphml?.shape ?? 'arrow-table'),
+  parseSync: (data: ArrayBuffer, options?: GraphMLLoaderOptions) =>
+    parseGraphML(data, options?.graphml?.shape ?? 'arrow-table'),
+  parseTextSync: (data: string, options?: GraphMLLoaderOptions) =>
+    parseGraphML(data, options?.graphml?.shape ?? 'arrow-table')
 };

package/src/index.ts

@@ -6,3 +6,12 @@ export {GraphMLLoader} from './graphml-loader-types';
 export type {GraphData, GraphNode, GraphEdge} from './graph-types';
 export {DOTLoader} from './dot-loader-types';
 export type {DOTGraphData, DOTMetadata, DOTSubgraph} from './dot-types';
+
+export type {GraphShape, GraphTables, GraphOutput} from './graph-types';
+export type {DOTOutput} from './dot-types';
+export type {DOTLoaderOptions} from './dot-loader-types';
+export type {GraphMLLoaderOptions} from './graphml-loader-types';
+
+export {GEXFLoader} from './gexf-loader-types';
+export type {GEXFLoaderOptions} from './gexf-loader-types';
+export type {GEXFMetadata, GEXFOutput} from './gexf-types';

package/src/lib/build-graph-tables.ts

@@ -0,0 +1,208 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {
+  Bool,
+  Float32,
+  Float64,
+  Int32,
+  Int64,
+  Utf8,
+  Struct,
+  List,
+  Field,
+  Table,
+  vectorFromArray
+} from 'apache-arrow';
+import type {DataType, Vector} from 'apache-arrow';
+import {convertArrowToSchema} from '@loaders.gl/core/schema-utils';
+import type {ArrowTable, ObjectRowTable} from '@loaders.gl/core/schema';
+import type {
+  GraphNode,
+  GraphEdge,
+  GraphOutput,
+  GraphShape,
+  GraphAttributeSchemas,
+  GraphAttributeType
+} from '../graph-types';
+
+/** Constructs named tables without materializing an intermediate plain graph. */
+export function buildGraphTables(
+  nodes: Iterable<GraphNode>,
+  edges: Iterable<GraphEdge>,
+  shape: GraphShape,
+  declarations?: GraphAttributeSchemas
+): GraphOutput {
+  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?.nodes);
+  const edgeTable = buildGraphTable(edges, true, shape, declarations?.edges);
+  // Both tables always have the same representation.
+  return {
+    shape: 'tables',
+    tables: [
+      {name: 'nodes', table: nodeTable},
+      {name: 'edges', table: edgeTable}
+    ]
+  } as GraphOutput;
+}
+
+/** Builds structural columns and a collision-free application attribute struct. */
+function buildGraphTable(
+  records: Iterable<GraphNode | GraphEdge>,
+  isEdge: boolean,
+  shape: 'arrow-table' | 'object-row-table',
+  declarations?: Map<string, GraphAttributeType>
+): ArrowTable | ObjectRowTable {
+  const columnNames = isEdge
+    ? ['id', 'sourceId', 'targetId', 'directed', 'label', 'attributes']
+    : ['id', 'label', 'attributes'];
+  const columns = new Map<string, unknown[]>(columnNames.map(name => [name, []]));
+  for (const record of records) {
+    for (const name of columnNames) {
+      const value = (record as unknown as Record<string, unknown>)[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: Record<string, Vector> = Object.create(null);
+  for (const [name, values] of columns) {
+    const type =
+      name === 'attributes'
+        ? inferAttributeType(values, declarations)
+        : name === 'directed'
+          ? new Bool()
+          : new Utf8();
+    vectors[name] = vectorFromArray(
+      values.map(value => normalizeValue(value, type)),
+      type
+    );
+  }
+  const data = new Table(vectors);
+  return {shape, schema: convertArrowToSchema(data.schema), data};
+}
+
+/** Infers a struct using the union of declared and observed application keys. */
+function inferAttributeType(
+  values: unknown[],
+  declarations?: Map<string, GraphAttributeType>
+): Struct {
+  const names = new Set(declarations?.keys());
+  for (const value of values) {
+    if (value && typeof value === 'object') {
+      for (const name of Object.keys(value)) {
+        names.add(name);
+      }
+    }
+  }
+  return new Struct(
+    Array.from(names, name => {
+      const fieldValues = values.map(
+        value => (value as Record<string, unknown> | null)?.[name] ?? null
+      );
+      return new Field(name, inferValueType(fieldValues, declarations?.get(name)), true);
+    })
+  );
+}
+
+/** Preserves declared scalar types where valid and infers nested DOT attributes. */
+function inferValueType(values: unknown[], declaration?: GraphAttributeType): DataType {
+  const present = values.filter(value => value !== null && value !== undefined);
+  if (declaration && typeof declaration === 'object') {
+    if (!present.every(value => Array.isArray(value))) return new Utf8();
+    return new List(
+      new Field(
+        'item',
+        inferValueType(
+          present.flatMap(value => value as unknown[]),
+          declaration.list
+        ),
+        true
+      )
+    );
+  }
+  if (declaration) {
+    const declaredTypes = {
+      boolean: new Bool(),
+      int: new Int32(),
+      long: new Int64(),
+      float: new Float32(),
+      double: new Float64(),
+      string: new 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 Utf8();
+  }
+  if (present.length && present.every(value => typeof value === 'boolean')) return new Bool();
+  if (present.length && present.every(value => typeof value === 'number')) return new Float64();
+  if (present.length && present.every(value => Array.isArray(value))) {
+    return new List(
+      new Field('item', inferValueType(present.flatMap(value => value as unknown[])), true)
+    );
+  }
+  if (
+    present.length &&
+    present.every(value => typeof value === 'object' && !Array.isArray(value))
+  ) {
+    return inferAttributeType(present);
+  }
+  return new Utf8();
+}
+
+/** Normalizes missing fields and mixed values for the selected Arrow type. */
+function normalizeValue(value: unknown, type: DataType): unknown {
+  if (value === null || value === undefined) return null;
+  if (type instanceof Struct) {
+    return Object.fromEntries(
+      type.children.map(field => [
+        field.name,
+        normalizeValue((value as Record<string, unknown>)[field.name], field.type)
+      ])
+    );
+  }
+  if (type instanceof List)
+    return (value as unknown[]).map(item => normalizeValue(item, type.valueType));
+  if (type instanceof Utf8 && typeof value !== 'string') {
+    return typeof value === 'object' ? JSON.stringify(value) : String(value);
+  }
+  return value;
+}

package/src/lib/parse-dot.ts

@@ -2,7 +2,9 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {DOTGraphData} from '../dot-types';
+import type {DOTGraphData, DOTOutput} from '../dot-types';
+import type {GraphShape, GraphNode, GraphEdge} from '../graph-types';
+import {buildGraphTables} from './build-graph-tables';
 
 /** Internal DOT parsing representation. */
 type DOTAttributeMap = Record<string, unknown>;
@@ -62,15 +64,29 @@ type DOTParseResult = {
 };
 
 /** Parses DOT source into plain graph records without a visualization dependency. */
-export function parseDOT(input: string): DOTGraphData {
+export function parseDOT(input: string): DOTGraphData;
+export function parseDOT(input: string, shape: GraphShape): DOTOutput;
+export function parseDOT(input: string, shape: GraphShape = 'plain-graph-data'): DOTOutput {
   const parsed = parseDOTDocument(input);
-  const subgraphs = Array.from(parsed.subgraphs.values(), subgraph => ({
-    ...subgraph,
-    attributes: {...subgraph.attributes}
-  }));
   return {
-    shape: 'plain-graph-data',
-    nodes: Array.from(parsed.nodes.values(), node => ({
+    ...buildGraphTables(iterateNodes(parsed), iterateEdges(parsed), shape),
+    metadata: {
+      id: parsed.id,
+      directed: parsed.directed,
+      strict: parsed.strict,
+      attributes: {...parsed.graphAttributes},
+      subgraphs: Array.from(parsed.subgraphs.values(), subgraph => ({
+        ...subgraph,
+        attributes: {...subgraph.attributes}
+      }))
+    }
+  };
+}
+
+/** Emits finalized nodes without creating an intermediate record array. */
+function* iterateNodes(parsed: DOTParseResult): Iterable<GraphNode> {
+  for (const node of parsed.nodes.values()) {
+    yield {
       id: node.id,
       ...(typeof node.attributes.label === 'string' ? {label: node.attributes.label} : {}),
       attributes: {
@@ -79,8 +95,14 @@ export function parseDOT(input: string): DOTGraphData {
           ? {subgraphs: Array.from(node.subgraphs, id => describeSubgraph(id, parsed.subgraphs))}
           : {})
       }
-    })),
-    edges: parsed.edges.map(edge => ({
+    };
+  }
+}
+
+/** Emits coalesced edges in document order. */
+function* iterateEdges(parsed: DOTParseResult): Iterable<GraphEdge> {
+  for (const edge of parsed.edges) {
+    yield {
       id: edge.id,
       sourceId: edge.sourceId,
       targetId: edge.targetId,
@@ -92,15 +114,8 @@ export function parseDOT(input: string): DOTGraphData {
           ? {subgraphs: edge.subgraphs.map(id => describeSubgraph(id, parsed.subgraphs))}
           : {})
       }
-    })),
-    metadata: {
-      id: parsed.id,
-      directed: parsed.directed,
-      strict: parsed.strict,
-      attributes: {...parsed.graphAttributes},
-      subgraphs
-    }
-  };
+    };
+  }
 }
 
 /** Copies a subgraph descriptor into node or edge attributes. */
@@ -393,6 +408,10 @@ class DOTParser {
       const existingEdge = this.result.strict ? this.strictEdges.get(strictKey) : undefined;
       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(new Set([...existingEdge.subgraphs, ...membership]));
         continue;
@@ -742,13 +761,17 @@ function readQuotedString(input: string, startIndex: number): {value: string; ne
   throw new Error('Unterminated string literal in DOT source.');
 }
 
-/** Decodes one quoted-string escape. */
+/** Decodes one quoted-string escape or removes a physical line continuation. */
 function readEscapedCharacter(
   input: string,
   startIndex: number
 ): {value: string; nextIndex: number} {
   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':
@@ -765,7 +788,7 @@ function readEscapedCharacter(
       if (typeof next === 'undefined') {
         throw new Error('Unterminated escape sequence in DOT source.');
       }
-      return {value: next, nextIndex: startIndex + 1};
+      return {value: `\\${next}`, nextIndex: startIndex + 1};
     }
   }
 }