@graphty/graph-io 0.0.0 → 0.2.0

package/dist/gml.js

@@ -0,0 +1,2647 @@
+import { Z as SYNTAX_CODE, au as joinText, ah as encodeChunks, aa as checkCapabilities, L as LOSS, aw as pairFolding, a9 as capabilities, aB as resolveExportOptions, aX as DictHeuristic, an as formatInteger, aD as sanitizeIds, aG as countMixedEdges, ai as explicitWeights, aY as DICT_SAMPLE_ROWS, am as formatGmlReal, V as ROLE_TAKEN_CODE$1, R as PRECISION_CODE$1, k as DUPLICATE_NODE_CODE$1, M as MISSING_ENDPOINT_CODE$1, w as MISSING_ID_CODE$1, G as NO_GRAPH_CODE$1, aC as resolveImportOptions, I as ImportReportBuilder, az as reportSinkOptions, aA as reportUnusedOptions, ay as readText, a as throwIfAborted, s as IdCoercer, l as DirectionResolver, aI as uniqueColumnName, aH as weightFromValue, ax as parseWeightText, af as declareResolved, x as MIXED_DIRECTION_CODE, g as DIRECTION_FORCED_CODE, h as DIRECTION_REFUSED_CODE, W as SINK_OPTION_CODE, J as OPTION_IGNORED_CODE, n as ID_MERGED_CODE, C as COLUMN_RENAMED_CODE, r as INVALID_UTF8_CODE } from "./chunks/writer-DxSKC7TL.js";
+import { GraphFormatError, INVALID_INDEX } from "@graphty/graph-format";
+import { g as decodeGmlString, j as quoteGmlString } from "./chunks/escape-DyI8JofU.js";
+const TOKEN_WORD = 0;
+const TOKEN_INT = 1;
+const TOKEN_REAL = 2;
+const TOKEN_STRING = 3;
+const TOKEN_OPEN = 4;
+const TOKEN_CLOSE = 5;
+const LIST_START_MARKER = "_networkx_list_start";
+const EMPTY_LIST_TEXT = "[]";
+const EMPTY_TUPLE_TEXT = "()";
+const ORIGINAL_ID_KEY = "graphty_originalId";
+const SYNTAX_STRUCTURE_CODE = SYNTAX_CODE;
+const SYNTAX_TOKEN_CODE = SYNTAX_CODE;
+const SYNTAX_STRING_CODE = SYNTAX_CODE;
+const SYNTAX_BRACKET_CODE = SYNTAX_CODE;
+const KEY_TEXT = /^[A-Za-z_][0-9A-Za-z_]*$/;
+const STRICT_KEY_TEXT = /^[A-Za-z][0-9A-Za-z_]*$/;
+const INT_TEXT = /^[+-]?[0-9]+$/;
+const REAL_TEXT = /^[+-]?(?:(?:[0-9]+\.[0-9]*|\.[0-9]+)(?:[eE][+-]?[0-9]+)?|[0-9]+[eE][+-]?[0-9]+)$/;
+const NON_FINITE_TEXT = /^[+-]?(?:inf|infinity|nan)$/i;
+const NON_FINITE_WORD = /^(?:inf|infinity|nan)$/i;
+class GmlSyntaxError extends Error {
+  /**
+   * Create a syntax error.
+   * @param code - the issue code
+   * @param message - a plain-ASCII message
+   * @param line - the 1-based line
+   */
+  constructor(code, message, line) {
+    super(message);
+    this.name = "GmlSyntaxError";
+    this.code = code;
+    this.line = line;
+  }
+}
+class GmlTokens {
+  /**
+   * Create an empty token list over a text.
+   * @param text - the source text
+   * @param capacity - the initial capacity
+   */
+  constructor(text, capacity = 1024) {
+    this.count = 0;
+    this.text = text;
+    this.kind = new Uint8Array(capacity);
+    this.start = new Uint32Array(capacity);
+    this.end = new Uint32Array(capacity);
+    this.line = new Uint32Array(capacity);
+    this.match = new Uint32Array(0);
+  }
+  /**
+   * Append a token.
+   * @param kind - the kind
+   * @param start - the start offset
+   * @param end - the end offset
+   * @param line - the 1-based line
+   */
+  push(kind, start, end, line) {
+    if (this.count === this.kind.length) {
+      this.grow();
+    }
+    const i = this.count++;
+    this.kind[i] = kind;
+    this.start[i] = start;
+    this.end[i] = end;
+    this.line[i] = line;
+  }
+  /**
+   * The raw text of a token (a string's body without the quotes, entities undecoded).
+   * @param i - the token index
+   * @returns the text
+   */
+  textOf(i) {
+    return this.text.slice(this.start[i], this.end[i]);
+  }
+  /**
+   * The decoded value of a string token.
+   * @param i - the token index
+   * @returns the body with character references decoded
+   */
+  stringOf(i) {
+    return decodeGmlString(this.textOf(i));
+  }
+  /**
+   * Whether a token is a `[` or `]`.
+   * @param i - the token index
+   * @returns true for a bracket
+   */
+  isBracket(i) {
+    return this.kind[i] >= TOKEN_OPEN;
+  }
+  /**
+   * The index of the pair following the pair whose key is at `key`.
+   * @param key - the index of a key token
+   * @returns the index after the pair's value (after the matching `]` for a record)
+   */
+  nextPair(key) {
+    const value = key + 1;
+    return this.kind[value] === TOKEN_OPEN ? this.match[value] + 1 : value + 1;
+  }
+  /** Double every array. */
+  grow() {
+    const capacity = this.kind.length * 2;
+    const kind = new Uint8Array(capacity);
+    kind.set(this.kind);
+    this.kind = kind;
+    const start = new Uint32Array(capacity);
+    start.set(this.start);
+    this.start = start;
+    const end = new Uint32Array(capacity);
+    end.set(this.end);
+    this.end = end;
+    const line = new Uint32Array(capacity);
+    line.set(this.line);
+    this.line = line;
+  }
+}
+function tokenizeGml(text) {
+  const tokens = new GmlTokens(text, Math.max(1024, text.length >>> 3));
+  const n = text.length;
+  let i = 0;
+  let line = 1;
+  while (i < n) {
+    const c = text.charCodeAt(i);
+    if (c === 10) {
+      line++;
+      i++;
+    } else if (c === 13) {
+      line++;
+      i++;
+      if (i < n && text.charCodeAt(i) === 10) {
+        i++;
+      }
+    } else if (c === 32 || c === 9 || c === 11 || c === 12) {
+      i++;
+    } else if (c === 35) {
+      i = endOfLine(text, i);
+    } else if (c === 91) {
+      tokens.push(TOKEN_OPEN, i, i + 1, line);
+      i++;
+    } else if (c === 93) {
+      tokens.push(TOKEN_CLOSE, i, i + 1, line);
+      i++;
+    } else if (c === 34) {
+      const close = text.indexOf('"', i + 1);
+      const eol = endOfLine(text, i + 1);
+      if (close < 0 || close > eol) {
+        throw new GmlSyntaxError(SYNTAX_STRING_CODE, `unclosed string at line ${line}`, line);
+      }
+      tokens.push(TOKEN_STRING, i + 1, close, line);
+      i = close + 1;
+    } else {
+      let j = i + 1;
+      while (j < n && !isDelimiter(text.charCodeAt(j))) {
+        j++;
+      }
+      tokens.push(classifyBare(text, i, j, line), i, j, line);
+      i = j;
+    }
+  }
+  validateStructure(tokens);
+  return tokens;
+}
+function endOfLine(text, from) {
+  const n = text.length;
+  for (let i = from; i < n; i++) {
+    const c = text.charCodeAt(i);
+    if (c === 10 || c === 13) {
+      return i;
+    }
+  }
+  return n;
+}
+function isDelimiter(c) {
+  return c === 32 || c === 9 || c === 10 || c === 13 || c === 11 || c === 12 || c === 91 || c === 93 || c === 34 || c === 35;
+}
+function classifyBare(text, start, end, line) {
+  const token = text.slice(start, end);
+  if (KEY_TEXT.test(token)) {
+    return TOKEN_WORD;
+  }
+  if (INT_TEXT.test(token)) {
+    return TOKEN_INT;
+  }
+  if (REAL_TEXT.test(token) || NON_FINITE_TEXT.test(token)) {
+    return TOKEN_REAL;
+  }
+  const shown = token.length > 20 ? `${token.slice(0, 20)}...` : token;
+  throw new GmlSyntaxError(SYNTAX_TOKEN_CODE, `cannot tokenize "${shown}" at line ${line}`, line);
+}
+function validateStructure(tokens) {
+  const { count, kind } = tokens;
+  const match = new Uint32Array(count);
+  const stack = [];
+  let i = 0;
+  while (i < count) {
+    const k = kind[i];
+    if (k === TOKEN_CLOSE) {
+      const open = stack.pop();
+      if (open === void 0) {
+        throw new GmlSyntaxError(
+          SYNTAX_STRUCTURE_CODE,
+          `unexpected "]" at line ${tokens.line[i]}: no open "["`,
+          tokens.line[i]
+        );
+      }
+      match[open] = i;
+      i++;
+      continue;
+    }
+    if (k !== TOKEN_WORD) {
+      throw new GmlSyntaxError(
+        SYNTAX_STRUCTURE_CODE,
+        `expected a key at line ${tokens.line[i]}, found ${describeToken(tokens, i)}`,
+        tokens.line[i]
+      );
+    }
+    const value = i + 1;
+    if (value >= count) {
+      throw new GmlSyntaxError(
+        SYNTAX_STRUCTURE_CODE,
+        `key "${tokens.textOf(i)}" at line ${tokens.line[i]} has no value`,
+        tokens.line[i]
+      );
+    }
+    const vk = kind[value];
+    if (vk === TOKEN_OPEN) {
+      stack.push(value);
+    } else if (vk === TOKEN_CLOSE || vk === TOKEN_WORD && !NON_FINITE_WORD.test(tokens.textOf(value))) {
+      throw new GmlSyntaxError(
+        SYNTAX_STRUCTURE_CODE,
+        `expected a value for key "${tokens.textOf(i)}" at line ${tokens.line[i]}, found ${describeToken(tokens, value)}`,
+        tokens.line[value]
+      );
+    }
+    i = value + 1;
+  }
+  if (stack.length > 0) {
+    const open = stack[stack.length - 1];
+    throw new GmlSyntaxError(
+      SYNTAX_BRACKET_CODE,
+      `unexpected end of input: ${stack.length} bracket(s) still open, the last opened at line ${tokens.line[open]}`,
+      tokens.line[open]
+    );
+  }
+  tokens.match = match;
+}
+function describeToken(tokens, i) {
+  switch (tokens.kind[i]) {
+    case TOKEN_OPEN:
+      return '"["';
+    case TOKEN_CLOSE:
+      return '"]"';
+    case TOKEN_STRING:
+      return `the string "${tokens.textOf(i)}"`;
+    default:
+      return `"${tokens.textOf(i)}"`;
+  }
+}
+function numberOfText(text) {
+  if (NON_FINITE_TEXT.test(text)) {
+    const lower = text.toLowerCase();
+    if (lower.endsWith("nan")) {
+      return NaN;
+    }
+    return lower.startsWith("-") ? -Infinity : Infinity;
+  }
+  return Number(text);
+}
+function isGmlKey(text) {
+  return STRICT_KEY_TEXT.test(text);
+}
+function mangleGmlKey(text) {
+  const body = text.replace(/[^0-9A-Za-z_]/g, "_");
+  return /^[A-Za-z]/.test(body) ? body : `x${body}`;
+}
+function parseRecord(tokens, open) {
+  const root = /* @__PURE__ */ Object.create(null);
+  const stack = [
+    { record: root, listKeys: null, close: tokens.match[open], next: open + 1, key: null }
+  ];
+  while (stack.length > 0) {
+    const frame = stack[stack.length - 1];
+    if (frame.next >= frame.close) {
+      stack.pop();
+      if (frame.key !== null) {
+        storeValue(stack[stack.length - 1], frame.key, frame.record);
+      }
+      continue;
+    }
+    const p = frame.next;
+    frame.next = tokens.nextPair(p);
+    const key = tokens.textOf(p);
+    const v = p + 1;
+    if (tokens.kind[v] === TOKEN_STRING) {
+      const text = tokens.stringOf(v);
+      if (text === LIST_START_MARKER) {
+        frame.record[key] = [];
+        frame.listKeys ??= /* @__PURE__ */ new Set();
+        frame.listKeys.add(key);
+        continue;
+      }
+      storeValue(frame, key, text === EMPTY_LIST_TEXT || text === EMPTY_TUPLE_TEXT ? [] : text);
+    } else if (tokens.kind[v] === TOKEN_OPEN) {
+      stack.push({
+        record: /* @__PURE__ */ Object.create(null),
+        listKeys: null,
+        close: tokens.match[v],
+        next: v + 1,
+        key
+      });
+    } else {
+      storeValue(frame, key, numberOfText(tokens.textOf(v)));
+    }
+  }
+  return root;
+}
+function storeValue(frame, key, value) {
+  const { record } = frame;
+  if (frame.listKeys !== null && frame.listKeys.has(key)) {
+    record[key].push(value);
+  } else if (key in record) {
+    record[key] = [record[key], value];
+    frame.listKeys ??= /* @__PURE__ */ new Set();
+    frame.listKeys.add(key);
+  } else {
+    record[key] = value;
+  }
+}
+function scalarOrRecord(tokens, v) {
+  return tokens.kind[v] === TOKEN_OPEN ? parseRecord(tokens, v) : numberOfText(tokens.textOf(v));
+}
+const RECORD_NUMBER_TYPE_CODE = "W_GML_RECORD_NUMBER_TYPE";
+const RECORD_BOOLEAN_CODE = "W_GML_RECORD_BOOLEAN";
+const RECORD_NULL_CODE = "W_GML_RECORD_NULL";
+const NESTED_ARRAY_CODE = "E_GML_NESTED_ARRAY";
+const JSON_ARRAY_CODE = "W_GML_JSON_ARRAY";
+const INVALID_KEY_CODE = "E_GML_INVALID_KEY";
+const RESERVED_KEY_CODE = "E_GML_RESERVED_KEY";
+const KEY_MANGLED_CODE = "W_GML_KEY_MANGLED";
+const POSITION_COMPONENTS_CODE = "W_GML_POSITION_COMPONENTS";
+const GRAPHICS_OVERRIDDEN_CODE = "W_GML_GRAPHICS_OVERRIDDEN";
+const GRAPHICS_CONFLICT_CODE = "E_GML_GRAPHICS_CONFLICT";
+const DEFAULT_WEIGHT_KEY = "value";
+const KEPT_ROLES = /* @__PURE__ */ new Set(["label", "id", "key"]);
+const ROLE_NAMES = Object.freeze({
+  label: "label",
+  id: "id",
+  key: "key"
+});
+const GML_CAPABILITIES = capabilities({
+  mixedDirection: false,
+  multiEdges: true,
+  selfLoops: true,
+  edgeIds: "optional",
+  idCharset: "integer",
+  dtypes: ["i32", "f64", "string", "dict", "json"],
+  components: false,
+  lists: true,
+  json: true,
+  defaults: false,
+  options: false,
+  hierarchy: false,
+  temporal: "none",
+  graphAttributes: true,
+  positions: true,
+  viz: false
+});
+const SKIPPED_ROLES = /* @__PURE__ */ new Set([
+  "directed",
+  "pair",
+  "mutual",
+  "weight",
+  "timeText",
+  "originalId",
+  "position",
+  "color",
+  "size",
+  "shape",
+  "thickness",
+  "parent",
+  "parents",
+  "start",
+  "end",
+  "timestamp",
+  "timestamps",
+  "spells",
+  "open"
+]);
+const NODE_RESERVED = /* @__PURE__ */ new Set(["id"]);
+const EDGE_RESERVED = /* @__PURE__ */ new Set(["source", "target"]);
+const GRAPH_RESERVED = /* @__PURE__ */ new Set(["node", "edge", "directed", "multigraph"]);
+const TOP_RESERVED = /* @__PURE__ */ new Set(["graph"]);
+const NUMBER_TEXT = /^[+-]?(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)(?:[eE][+-]?[0-9]+)?$/;
+function planOf(snapshot, options) {
+  const common = resolveExportOptions(options);
+  const mode = options?.sanitizeKeys ?? "error";
+  if (mode !== "error" && mode !== "mangle") {
+    throw new GraphFormatError(
+      "E_UNSUPPORTED",
+      `option sanitizeKeys: ${JSON.stringify(mode)} is not "error" or "mangle"`,
+      {
+        option: "sanitizeKeys",
+        found: mode
+      }
+    );
+  }
+  let weightKey = options?.weightKey;
+  if (weightKey === void 0) {
+    const origin = snapshot.meta.weightOrigin;
+    weightKey = origin !== null && origin.format === "gml" && origin.id !== null ? origin.id : DEFAULT_WEIGHT_KEY;
+  } else if (typeof weightKey !== "string" || !isGmlKey(weightKey)) {
+    throw new GraphFormatError("E_UNSUPPORTED", `option weightKey: ${JSON.stringify(weightKey)} is not a GML key`, {
+      option: "weightKey",
+      found: weightKey
+    });
+  }
+  return { common, weightKey, mangle: mode === "mangle" };
+}
+function isWritten(column) {
+  const { role } = column.meta;
+  return role === null || !SKIPPED_ROLES.has(role);
+}
+function preferredKey(meta) {
+  const { origin } = meta;
+  return origin !== null && origin.format === "gml" && origin.id !== null ? origin.id : meta.name;
+}
+function hasWeights(snapshot) {
+  return snapshot.flags.weighted;
+}
+function isTopLevel(column) {
+  return column.meta.extra.gmlTopLevel === true;
+}
+function versionText(text) {
+  return NUMBER_TEXT.test(text) ? text : quoteGmlString(text);
+}
+function selectColumns(table, reserved, label, plan, notes, filter = () => true) {
+  const used = new Set(reserved);
+  const out = [];
+  for (const column of table) {
+    if (!isWritten(column) || !filter(column)) {
+      continue;
+    }
+    const preferred = preferredKey(column.meta);
+    let key = preferred;
+    const valid = isGmlKey(preferred);
+    const taken = used.has(preferred);
+    if (!valid || taken) {
+      const code = valid ? RESERVED_KEY_CODE : INVALID_KEY_CODE;
+      let why = "is not a GML key";
+      if (valid) {
+        why = reserved.has(preferred) ? "collides with a structural GML key" : "repeats another column's key";
+      }
+      if (!plan.mangle) {
+        if (notes === null) {
+          throw new GraphFormatError(
+            "E_UNSUPPORTED",
+            `${label} column "${column.meta.name}" ${why}; pass sanitizeKeys: "mangle" to rewrite it`,
+            {
+              reason: "gml key",
+              column: column.meta.name,
+              key: preferred
+            }
+          );
+        }
+        notes.push(
+          note(
+            code,
+            `${label} column "${column.meta.name}" ${why}; export() will throw unless sanitizeKeys is "mangle"`,
+            column.meta.name
+          )
+        );
+        continue;
+      }
+      key = uniqueKey(valid ? preferred : mangleGmlKey(preferred), used);
+      notes?.push(
+        note(
+          KEY_MANGLED_CODE,
+          `${label} column "${column.meta.name}" is written as "${key}"`,
+          column.meta.name
+        )
+      );
+    }
+    used.add(key);
+    out.push({ column, key });
+  }
+  return out;
+}
+function uniqueKey(base, used) {
+  let candidate = base;
+  for (let k = 2; used.has(candidate); k++) {
+    candidate = `${base}_${k}`;
+  }
+  return candidate;
+}
+function note(code, message, column = null, count = null) {
+  return Object.freeze({ code, message, column, count });
+}
+function inspectJson(value, stats, inArray, seen) {
+  if (value === null) {
+    if (!seen.nulls) {
+      seen.nulls = true;
+      stats.nulls++;
+    }
+    return;
+  }
+  switch (typeof value) {
+    case "number":
+      if (!seen.numbers) {
+        seen.numbers = true;
+        stats.numbers++;
+      }
+      return;
+    case "boolean":
+      if (!seen.booleans) {
+        seen.booleans = true;
+        stats.booleans++;
+      }
+      return;
+    case "string":
+      return;
+  }
+  if (Array.isArray(value)) {
+    if (inArray && !seen.nested) {
+      seen.nested = true;
+      stats.nestedArrays++;
+    }
+    for (const item of value) {
+      inspectJson(item, stats, true, seen);
+    }
+    return;
+  }
+  const record = value;
+  for (const key of Object.keys(record)) {
+    if (!isGmlKey(key)) {
+      stats.invalidKeys++;
+    }
+    inspectJson(record[key], stats, false, seen);
+  }
+}
+function jsonNotes(columns, label, plan, notes) {
+  for (const { column } of columns) {
+    const stats = jsonStatsOf(column);
+    if (stats === null) {
+      continue;
+    }
+    const { name } = column.meta;
+    const where = `${label} column "${name}"`;
+    if (stats.numbers > 0) {
+      notes.push(
+        note(
+          RECORD_NUMBER_TYPE_CODE,
+          `${where} holds numbers in ${stats.numbers} row(s); GML records cannot keep the int / real distinction`,
+          name,
+          stats.numbers
+        )
+      );
+    }
+    if (stats.booleans > 0) {
+      notes.push(
+        note(
+          RECORD_BOOLEAN_CODE,
+          `${where} holds booleans in ${stats.booleans} row(s); written as 1 / 0`,
+          name,
+          stats.booleans
+        )
+      );
+    }
+    if (stats.nulls > 0) {
+      notes.push(
+        note(
+          RECORD_NULL_CODE,
+          `${where} holds nulls in ${stats.nulls} row(s); GML has no null, the key is omitted`,
+          name,
+          stats.nulls
+        )
+      );
+    }
+    if (stats.arrays > 0) {
+      notes.push(
+        note(
+          JSON_ARRAY_CODE,
+          `${where} holds arrays as values in ${stats.arrays} row(s); written as repeated keys, they re-import as a list`,
+          name,
+          stats.arrays
+        )
+      );
+    }
+    if (stats.nestedArrays > 0) {
+      notes.push(
+        note(
+          NESTED_ARRAY_CODE,
+          `${where} holds arrays nested in arrays in ${stats.nestedArrays} row(s); GML cannot write them and export() will throw`,
+          name,
+          stats.nestedArrays
+        )
+      );
+    }
+    if (stats.invalidKeys > 0) {
+      notes.push(
+        plan.mangle ? note(
+          KEY_MANGLED_CODE,
+          `${where}: ${stats.invalidKeys} record key(s) are not GML keys and are rewritten`,
+          name,
+          stats.invalidKeys
+        ) : note(
+          INVALID_KEY_CODE,
+          `${where}: ${stats.invalidKeys} record key(s) are not GML keys; export() will throw unless sanitizeKeys is "mangle"`,
+          name,
+          stats.invalidKeys
+        )
+      );
+    }
+  }
+}
+function jsonStatsOf(column) {
+  const stats = { numbers: 0, booleans: 0, nulls: 0, nestedArrays: 0, arrays: 0, invalidKeys: 0 };
+  if (column.dtype === "json") {
+    for (let r = 0; r < column.length; r++) {
+      if (!column.isSet(r)) {
+        continue;
+      }
+      const value = column.values[r];
+      const seen = { numbers: false, booleans: false, nulls: false, nested: false };
+      if (Array.isArray(value)) {
+        stats.arrays++;
+        for (const item of value) {
+          inspectJson(item, stats, true, seen);
+        }
+      } else {
+        inspectJson(value, stats, false, seen);
+      }
+    }
+    return stats;
+  }
+  if (column.dtype === "list" && column.meta.itemDtype === "json") {
+    for (let r = 0; r < column.length; r++) {
+      if (!column.isSet(r)) {
+        continue;
+      }
+      const seen = { numbers: false, booleans: false, nulls: false, nested: false };
+      for (const item of column.sliceOf(r)) {
+        inspectJson(item, stats, true, seen);
+      }
+    }
+    return stats;
+  }
+  return null;
+}
+function positionColumn(snapshot) {
+  const column = snapshot.nodes.byRole("position");
+  if (column === null) {
+    return null;
+  }
+  switch (column.dtype) {
+    case "f32":
+    case "f64":
+    case "i32":
+    case "u32":
+    case "u8":
+      return column;
+    default:
+      return null;
+  }
+}
+function graphicsColumn(snapshot) {
+  return snapshot.nodes.typed("graphics", "json");
+}
+function graphicsNotes(snapshot, notes) {
+  const position = positionColumn(snapshot);
+  if (position === null) {
+    return;
+  }
+  if (position.meta.components > 3) {
+    notes.push(
+      note(
+        POSITION_COMPONENTS_CODE,
+        `node column "${position.meta.name}" has ${position.meta.components} components; only x, y and z are written`,
+        position.meta.name,
+        position.length - position.nullCount
+      )
+    );
+  }
+  const graphics = graphicsColumn(snapshot);
+  if (graphics === null) {
+    return;
+  }
+  let overridden = 0;
+  let conflicts = 0;
+  for (let r = 0; r < snapshot.nodeCount; r++) {
+    if (!position.isSet(r) || !graphics.isSet(r)) {
+      continue;
+    }
+    const value = graphics.values[r];
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+      conflicts++;
+    } else if ("x" in value || "y" in value || "z" in value) {
+      overridden++;
+    }
+  }
+  if (overridden > 0) {
+    notes.push(
+      note(
+        GRAPHICS_OVERRIDDEN_CODE,
+        `${overridden} node graphics record(s) have x / y / z keys the position column replaces`,
+        "graphics",
+        overridden
+      )
+    );
+  }
+  if (conflicts > 0) {
+    notes.push(
+      note(
+        GRAPHICS_CONFLICT_CODE,
+        `${conflicts} node graphics value(s) are not records and cannot hold the position; export() will throw`,
+        "graphics",
+        conflicts
+      )
+    );
+  }
+}
+function reimportNotes(columns, domain, notes) {
+  for (const { column, key } of columns) {
+    const { meta } = column;
+    const set = column.length - column.nullCount;
+    if (set === 0) {
+      notes.push(
+        note(
+          LOSS.EMPTY_COLUMN,
+          `${domain} column "${meta.name}" has no set cell and is not written: GML writes cells, never declarations`,
+          meta.name,
+          0
+        )
+      );
+      continue;
+    }
+    if (meta.role === null && (key === "label" || domain === "edge" && (key === "id" || key === "key"))) {
+      notes.push(
+        note(
+          LOSS.ROLE_ASSUMED,
+          `${domain} column "${meta.name}" is written under "${key}" and reads back with the ${key === "label" ? "label" : key} role`,
+          meta.name,
+          set
+        )
+      );
+      continue;
+    }
+    if (column.dtype === "list" || !(column.dtype === "string" || column.dtype === "dict")) {
+      continue;
+    }
+    const heuristic = new DictHeuristic(DICT_SAMPLE_ROWS);
+    for (let r = 0; r < column.length && !heuristic.decided; r++) {
+      if (column.isSet(r)) {
+        heuristic.observe(column.value(r));
+      }
+    }
+    const readsAsDict = heuristic.decide() === "dict";
+    if (column.dtype === "string" && readsAsDict) {
+      notes.push(
+        note(
+          LOSS.STORAGE_CLASS,
+          `${domain} column "${meta.name}" reads back as dict (low cardinality)`,
+          meta.name,
+          null
+        )
+      );
+    } else if (column.dtype === "dict" && !readsAsDict) {
+      notes.push(
+        note(
+          LOSS.STORAGE_CLASS,
+          `${domain} column "${meta.name}" reads back as string (cardinality too high for a dict)`,
+          meta.name,
+          null
+        )
+      );
+    }
+  }
+}
+function positionNameNote(snapshot, nodeColumns, notes) {
+  const position = positionColumn(snapshot);
+  if (position === null) {
+    return;
+  }
+  const { name } = position.meta;
+  const plainPosition = nodeColumns.some((c) => c.key === "position");
+  const reimportName = plainPosition ? "position#graphics" : "position";
+  if (name !== reimportName) {
+    notes.push(
+      note(
+        LOSS.COLUMN_NAME_CHANGED,
+        `node column "${name}" (position) is written as the graphics x / y / z keys and reads back as "${reimportName}"`,
+        name,
+        position.length - position.nullCount
+      )
+    );
+  }
+}
+function check(snapshot, options) {
+  const plan = planOf(snapshot, options);
+  const notes = checkCapabilities(snapshot, GML_CAPABILITIES, plan.common, {
+    positionDtype: "f64",
+    roles: KEPT_ROLES,
+    roleNames: ROLE_NAMES
+  });
+  const nodeReserved = new Set(NODE_RESERVED);
+  if (plan.common.sanitizeIds === "mangle" && countMangled(snapshot) > 0 || snapshot.nodes.byRole("originalId") !== null) {
+    nodeReserved.add(ORIGINAL_ID_KEY);
+  }
+  const edgeIds = snapshot.edges.byRole("id");
+  const edgeReserved = edgeReservedKeys(snapshot, plan, edgeIds);
+  const topReserved = topReservedKeys(snapshot);
+  const nodeColumns = selectColumns(snapshot.nodes, nodeReserved, "node", plan, notes);
+  const edgeColumns = selectColumns(snapshot.edges, edgeReserved, "edge", plan, notes, (c) => c !== edgeIds);
+  const graphColumns = selectColumns(snapshot.graph, GRAPH_RESERVED, "graph", plan, notes, (c) => !isTopLevel(c));
+  const topColumns = selectColumns(snapshot.graph, topReserved, "top-level", plan, notes, isTopLevel);
+  jsonNotes(nodeColumns, "node", plan, notes);
+  jsonNotes(edgeColumns, "edge", plan, notes);
+  jsonNotes(graphColumns, "graph", plan, notes);
+  jsonNotes(topColumns, "top-level", plan, notes);
+  graphicsNotes(snapshot, notes);
+  positionNameNote(snapshot, nodeColumns, notes);
+  reimportNotes(nodeColumns, "node", notes);
+  reimportNotes(edgeColumns, "edge", notes);
+  if (!hasWeights(snapshot)) {
+    const clash = edgeColumns.find((c) => c.key === plan.weightKey);
+    if (clash !== void 0) {
+      notes.push(
+        note(
+          LOSS.WEIGHT_KEY_CLASH,
+          `edge column "${clash.column.meta.name}" is written under "${plan.weightKey}", the key the importer reads THE weight from; it reads back as the weight, not as a column`,
+          clash.column.meta.name,
+          clash.column.length - clash.column.nullCount
+        )
+      );
+    }
+  }
+  const folding = pairFolding(snapshot);
+  if (folding.mutualCount > 0) {
+    notes.push(
+      note(
+        LOSS.MUTUAL_EXPANDED,
+        `${folding.mutualCount} mutual pair(s) are written as two directed edges; the mutual mark is lost`,
+        null,
+        folding.mutualCount
+      )
+    );
+  }
+  return Object.freeze(notes);
+}
+function edgeReservedKeys(snapshot, plan, edgeIds) {
+  const reserved = new Set(EDGE_RESERVED);
+  if (hasWeights(snapshot)) {
+    reserved.add(plan.weightKey);
+  }
+  if (edgeIds !== null) {
+    reserved.add("id");
+  }
+  return reserved;
+}
+function topReservedKeys(snapshot) {
+  const reserved = new Set(TOP_RESERVED);
+  if (snapshot.meta.creator !== null) {
+    reserved.add("Creator");
+  }
+  if (snapshot.meta.sourceFormat === "gml" && snapshot.meta.sourceVersion !== null) {
+    reserved.add("Version");
+  }
+  return reserved;
+}
+function countMangled(snapshot) {
+  let count = 0;
+  for (let i = 0; i < snapshot.nodeCount; i++) {
+    const id = snapshot.ids.idOf(i);
+    if (typeof id !== "number" || !Number.isSafeInteger(id)) {
+      count++;
+    }
+  }
+  return count;
+}
+function gmlRealText(value, dtype = "f64") {
+  return formatGmlReal(value, dtype);
+}
+function numberText(value, meta) {
+  switch (meta.dtype) {
+    case "i32":
+    case "u32":
+    case "u8":
+      return formatInteger(value);
+    case "f32":
+      return gmlRealText(value, "f32");
+    default:
+      if (meta.origin?.type === "int" && Number.isInteger(value)) {
+        return formatInteger(value);
+      }
+      return gmlRealText(value, "f64");
+  }
+}
+function jsonScalarText(value) {
+  switch (typeof value) {
+    case "number":
+      return Number.isInteger(value) ? formatInteger(value) : gmlRealText(value, "f64");
+    case "boolean":
+      return value ? "1" : "0";
+    default:
+      return quoteGmlString(value);
+  }
+}
+function itemText(item, itemDtype, meta) {
+  switch (typeof item) {
+    case "number":
+      switch (itemDtype) {
+        case "i32":
+        case "u32":
+        case "u8":
+          return formatInteger(item);
+        case "f32":
+          return gmlRealText(item, "f32");
+        case "json":
+          return jsonScalarText(item);
+        default:
+          return meta.origin?.type === "int" && Number.isInteger(item) ? formatInteger(item) : gmlRealText(item, "f64");
+      }
+    case "boolean":
+      return item ? "1" : "0";
+    case "string":
+      return quoteGmlString(item);
+    default:
+      throw new GraphFormatError(
+        "E_COLUMN_TYPE",
+        `column "${meta.name}": a ${typeof item} list item cannot be written as GML`,
+        {
+          column: meta.name,
+          found: typeof item
+        }
+      );
+  }
+}
+class GmlWriter {
+  /**
+   * Create a writer.
+   * @param mangle - whether record keys are rewritten rather than refused
+   */
+  constructor(mangle) {
+    this.lines = [];
+    this.mangle = mangle;
+  }
+  /**
+   * Take the lines written so far as one string.
+   * @returns the text; the writer is empty afterwards
+   */
+  take() {
+    const text = this.lines.join("");
+    this.lines.length = 0;
+    return text;
+  }
+  /**
+   * Write one `key value` line.
+   * @param indent - the indentation
+   * @param key - the key
+   * @param value - the value text
+   */
+  line(indent, key, value) {
+    this.lines.push(`${indent}${key} ${value}
+`);
+  }
+  /**
+   * Write a raw line.
+   * @param text - the line without its terminator
+   */
+  raw(text) {
+    this.lines.push(`${text}
+`);
+  }
+  /**
+   * Write one column cell of a row.
+   * @param indent - the indentation
+   * @param key - the key
+   * @param column - the column
+   * @param row - the row
+   */
+  cell(indent, key, column, row) {
+    const { meta, dtype } = column;
+    switch (dtype) {
+      case "f32":
+      case "f64":
+      case "i32":
+      case "u32":
+      case "u8": {
+        const { components } = meta;
+        if (components === 1) {
+          this.line(indent, key, numberText(column.data[row], meta));
+        } else {
+          for (let k = 0; k < components; k++) {
+            this.line(indent, key, numberText(column.data[row * components + k], meta));
+          }
+        }
+        return;
+      }
+      case "bool":
+        this.line(indent, key, column.value(row) === true ? "1" : "0");
+        return;
+      case "dict":
+      case "string":
+        this.line(indent, key, quoteGmlString(column.value(row) ?? ""));
+        return;
+      case "list":
+        this.list(indent, key, column.sliceOf(row), meta.itemDtype ?? "string", meta);
+        return;
+      case "json":
+        this.json(indent, key, column.values[row], meta.name);
+        return;
+      default: {
+        const name = dtype;
+        throw new GraphFormatError("E_COLUMN_TYPE", `unknown dtype ${name}`, { dtype: name });
+      }
+    }
+  }
+  /**
+   * Write a list as repeated keys with the NetworkX conventions.
+   * @param indent - the indentation
+   * @param key - the key
+   * @param items - the items
+   * @param itemDtype - the item dtype
+   * @param meta - the column metadata
+   */
+  list(indent, key, items, itemDtype, meta) {
+    if (items.length === 0) {
+      this.line(indent, key, quoteGmlString(EMPTY_LIST_TEXT));
+      return;
+    }
+    if (items.length === 1) {
+      this.line(indent, key, quoteGmlString(LIST_START_MARKER));
+    }
+    for (const item of items) {
+      if (itemDtype === "json" && typeof item === "object") {
+        this.json(indent, key, item, meta.name, true);
+      } else {
+        this.line(indent, key, itemText(item, itemDtype, meta));
+      }
+    }
+  }
+  /**
+   * Write a JSON value: a record for an object, repeated keys for an array, a scalar otherwise;
+   * null writes nothing.
+   * @param indent - the indentation
+   * @param key - the key
+   * @param value - the value
+   * @param column - the column name, for errors
+   * @param inArray - whether the value is an array item (an array here has no GML spelling)
+   */
+  json(indent, key, value, column, inArray = false) {
+    if (value === null || value === void 0) {
+      return;
+    }
+    if (Array.isArray(value)) {
+      if (inArray) {
+        throw new GraphFormatError(
+          "E_UNSUPPORTED",
+          `column "${column}": an array nested in an array cannot be written as GML`,
+          {
+            reason: "nested array",
+            column
+          }
+        );
+      }
+      if (value.length === 0) {
+        this.line(indent, key, quoteGmlString(EMPTY_LIST_TEXT));
+        return;
+      }
+      if (value.length === 1) {
+        this.line(indent, key, quoteGmlString(LIST_START_MARKER));
+      }
+      for (const item of value) {
+        this.json(indent, key, item, column, true);
+      }
+      return;
+    }
+    if (typeof value === "object") {
+      this.record(indent, key, value, column);
+      return;
+    }
+    if (typeof value === "number" || typeof value === "string" || typeof value === "boolean") {
+      this.line(indent, key, jsonScalarText(value));
+      return;
+    }
+    throw new GraphFormatError("E_COLUMN_TYPE", `column "${column}": a ${typeof value} cannot be written as GML`, {
+      column,
+      found: typeof value
+    });
+  }
+  /**
+   * Write a record `key [ ... ]`.
+   * @param indent - the indentation
+   * @param key - the key
+   * @param record - the object
+   * @param column - the column name, for errors
+   * @param extra - lines to write first (the position of a graphics record), or null
+   */
+  record(indent, key, record, column, extra = null) {
+    this.raw(`${indent}${key} [`);
+    const inner = `${indent}  `;
+    const used = /* @__PURE__ */ new Set();
+    if (extra !== null) {
+      for (const [k, v] of extra) {
+        this.line(inner, k, v);
+        used.add(k);
+      }
+    }
+    for (const name of Object.keys(record)) {
+      if (used.has(name) && extra !== null && (name === "x" || name === "y" || name === "z")) {
+        continue;
+      }
+      const written = this.recordKey(name, used, column);
+      used.add(written);
+      this.json(inner, written, record[name], column);
+    }
+    this.raw(`${indent}]`);
+  }
+  /**
+   * The key a record field is written under.
+   * @param name - the field name
+   * @param used - the keys already written in the record
+   * @param column - the column name, for errors
+   * @returns a valid, unused key; E_UNSUPPORTED for an invalid key unless mangling
+   */
+  recordKey(name, used, column) {
+    if (isGmlKey(name) && !used.has(name)) {
+      return name;
+    }
+    if (!this.mangle) {
+      throw new GraphFormatError(
+        "E_UNSUPPORTED",
+        `column "${column}": record key "${name}" ${isGmlKey(name) ? "repeats a key" : "is not a GML key"}; pass sanitizeKeys: "mangle" to rewrite it`,
+        {
+          reason: "gml key",
+          column,
+          key: name
+        }
+      );
+    }
+    return uniqueKey(isGmlKey(name) ? name : mangleGmlKey(name), used);
+  }
+}
+function contextOf(snapshot, options) {
+  const plan = planOf(snapshot, options);
+  const ids = sanitizeIds(snapshot, "integer", plan.common.sanitizeIds);
+  const mixed = countMixedEdges(snapshot);
+  if (mixed > 0 && plan.common.onMixedDirection === "error") {
+    throw new GraphFormatError(
+      "E_DIRECTED",
+      `${mixed} undirected edge(s) in a directed graph; GML has no mixed direction (onMixedDirection: "error")`,
+      {
+        reason: "mixed direction",
+        count: mixed
+      }
+    );
+  }
+  const foldPairs = mixed > 0;
+  const writeDirected = snapshot.directed && plan.common.onMixedDirection !== "undirected";
+  const originalIds = snapshot.nodes.byRole("originalId");
+  const nodeReserved = new Set(NODE_RESERVED);
+  if (ids.changed > 0 || originalIds !== null) {
+    nodeReserved.add(ORIGINAL_ID_KEY);
+  }
+  const edgeIds = snapshot.edges.byRole("id");
+  const edgeReserved = edgeReservedKeys(snapshot, plan, edgeIds);
+  const topReserved = topReservedKeys(snapshot);
+  return {
+    snapshot,
+    plan,
+    ids,
+    writeDirected,
+    foldPairs,
+    nodeColumns: selectColumns(
+      snapshot.nodes,
+      nodeReserved,
+      "node",
+      plan,
+      null,
+      (c) => !(c.meta.name === "graphics" && c.dtype === "json")
+    ),
+    edgeColumns: selectColumns(snapshot.edges, edgeReserved, "edge", plan, null, (c) => c !== edgeIds),
+    graphColumns: selectColumns(snapshot.graph, GRAPH_RESERVED, "graph", plan, null, (c) => !isTopLevel(c)),
+    topColumns: selectColumns(snapshot.graph, topReserved, "top-level", plan, null, isTopLevel),
+    position: positionColumn(snapshot),
+    graphics: graphicsColumn(snapshot),
+    originalIds,
+    edgeIds,
+    weights: explicitWeights(snapshot),
+    folding: pairFolding(snapshot)
+  };
+}
+function originalIdText(id) {
+  if (typeof id === "string") {
+    return quoteGmlString(id);
+  }
+  return Number.isSafeInteger(id) ? formatInteger(id) : gmlRealText(id, "f64");
+}
+function* gmlParts(context) {
+  const { snapshot, plan, ids } = context;
+  const w = new GmlWriter(plan.mangle);
+  const { meta } = snapshot;
+  if (meta.creator !== null) {
+    w.line("", "Creator", quoteGmlString(meta.creator));
+  }
+  if (meta.sourceFormat === "gml" && meta.sourceVersion !== null) {
+    w.line("", "Version", versionText(meta.sourceVersion));
+  }
+  for (const { column, key } of context.topColumns) {
+    if (column.isSet(0)) {
+      w.cell("", key, column, 0);
+    }
+  }
+  w.raw("graph [");
+  w.line("  ", "directed", context.writeDirected ? "1" : "0");
+  const multigraph = meta.declaredMultigraph ?? (snapshot.flags.multigraph ? true : null);
+  if (multigraph !== null) {
+    w.line("  ", "multigraph", multigraph ? "1" : "0");
+  }
+  for (const { column, key } of context.graphColumns) {
+    if (column.isSet(0)) {
+      w.cell("  ", key, column, 0);
+    }
+  }
+  yield w.take();
+  for (let i = 0; i < snapshot.nodeCount; i++) {
+    w.raw("  node [");
+    w.line("    ", "id", formatInteger(ids.idAt(i)));
+    if (ids.isChanged(i)) {
+      w.line("    ", ORIGINAL_ID_KEY, originalIdText(ids.originalAt(i)));
+    } else if (context.originalIds !== null && context.originalIds.isSet(i)) {
+      const original = context.originalIds.value(i);
+      if (typeof original === "string" || typeof original === "number") {
+        w.line("    ", ORIGINAL_ID_KEY, originalIdText(original));
+      }
+    }
+    for (const { column, key } of context.nodeColumns) {
+      if (column.isSet(i)) {
+        w.cell("    ", key, column, i);
+      }
+    }
+    writeGraphics(w, context, i);
+    w.raw("  ]");
+    yield w.take();
+  }
+  const el = snapshot.edgeList();
+  const origin = meta.weightOrigin;
+  const integerWeights = origin !== null && origin.type === "int";
+  for (let e = 0; e < snapshot.edgeCount; e++) {
+    if (context.foldPairs && context.folding.folded(e)) {
+      continue;
+    }
+    w.raw("  edge [");
+    w.line("    ", "source", formatInteger(ids.idAt(el.src[e])));
+    w.line("    ", "target", formatInteger(ids.idAt(el.dst[e])));
+    if (context.edgeIds !== null && context.edgeIds.isSet(e)) {
+      w.cell("    ", "id", context.edgeIds, e);
+    }
+    if (context.weights.isExplicit(e)) {
+      const weight = context.weights.value(e);
+      const text = integerWeights && Number.isInteger(weight) ? formatInteger(weight) : gmlRealText(weight, context.weights.dtype);
+      w.line("    ", plan.weightKey, text);
+    }
+    for (const { column, key } of context.edgeColumns) {
+      if (column.isSet(e)) {
+        w.cell("    ", key, column, e);
+      }
+    }
+    w.raw("  ]");
+    yield w.take();
+  }
+  w.raw("]");
+  yield w.take();
+}
+function writeGraphics(w, context, i) {
+  const { position, graphics } = context;
+  const hasPosition = position !== null && position.isSet(i);
+  const graphicsValue = graphics !== null && graphics.isSet(i) ? graphics.values[i] : void 0;
+  if (!hasPosition) {
+    if (graphics !== null && graphicsValue !== void 0) {
+      w.cell("    ", "graphics", graphics, i);
+    }
+    return;
+  }
+  const numeric = position;
+  const { components } = numeric.meta;
+  const lanes = Math.min(components, 3);
+  const extra = [];
+  const names = ["x", "y", "z"];
+  for (let k = 0; k < lanes; k++) {
+    extra.push([names[k], numberText(numeric.data[i * components + k], numeric.meta)]);
+  }
+  let record = {};
+  if (graphicsValue !== void 0) {
+    if (typeof graphicsValue !== "object" || graphicsValue === null || Array.isArray(graphicsValue)) {
+      throw new GraphFormatError(
+        "E_UNSUPPORTED",
+        `node ${i}: the graphics value is not a record and cannot hold the position`,
+        {
+          reason: "graphics conflict",
+          node: i
+        }
+      );
+    }
+    record = graphicsValue;
+  }
+  w.record("    ", "graphics", record, "graphics", extra);
+}
+const gmlExporter = Object.freeze({
+  format: "gml",
+  capabilities: GML_CAPABILITIES,
+  check,
+  /**
+   * Write the snapshot as UTF-8 chunks; the context is resolved on the first pull, so the
+   * errors check() announced surface from the iteration.
+   * @param snapshot - the snapshot
+   * @param options - the options
+   * @returns the chunks
+   */
+  export(snapshot, options) {
+    return encodeChunks(lazyParts(snapshot, options));
+  },
+  /**
+   * Write the snapshot as one string.
+   * @param snapshot - the snapshot
+   * @param options - the options
+   * @returns the document
+   */
+  exportToString(snapshot, options) {
+    return joinText(lazyParts(snapshot, options));
+  }
+});
+function* lazyParts(snapshot, options) {
+  yield* gmlParts(contextOf(snapshot, options));
+}
+const NO_GRAPH_CODE = NO_GRAPH_CODE$1;
+const SECOND_GRAPH_CODE = "E_GML_SECOND_GRAPH";
+const MISSING_ID_CODE = MISSING_ID_CODE$1;
+const MISSING_LABEL_CODE = "E_GML_MISSING_LABEL";
+const MISSING_ENDPOINT_CODE = MISSING_ENDPOINT_CODE$1;
+const ID_TYPE_CODE = "E_GML_ID_TYPE";
+const DUPLICATE_NODE_CODE = DUPLICATE_NODE_CODE$1;
+const REPEATED_KEY_CODE = "E_GML_REPEATED_KEY";
+const ELEMENT_TYPE_CODE = "E_GML_ELEMENT_TYPE";
+const FLAG_TYPE_CODE = "E_GML_FLAG_TYPE";
+const FLAG_VALUE_CODE = "W_GML_FLAG_VALUE";
+const PRECISION_CODE = PRECISION_CODE$1;
+const ROLE_TAKEN_CODE = ROLE_TAKEN_CODE$1;
+const ID_DROPPED_CODE = "W_GML_ID_DROPPED";
+const FORMAT_DEFAULTS = { ids: "canonical", defaultDirected: false, weightFrom: "value" };
+const KIND_INT = 1;
+const KIND_REAL = 2;
+const KIND_STRING = 4;
+const KIND_RECORD = 8;
+const I32_MIN = -2147483648;
+const I32_MAX = 2147483647;
+const ABORT_CHECK_INTERVAL = 64;
+const USED_OPTIONS = /* @__PURE__ */ new Set([
+  "ids",
+  "nodeIdFrom",
+  "addMissingNodes",
+  "duplicateEdges",
+  "selfLoops",
+  "onMixedDirection",
+  "defaultDirected",
+  "weightFrom",
+  "weightDtype",
+  "restoreMangledIds",
+  "errorLimit",
+  "signal",
+  "onProgress"
+]);
+const GRAPH_SEQ = -1;
+const TOP_SEQ = -2;
+function roleOf(domain, key) {
+  if (key === "label" && domain !== "graph") {
+    return "label";
+  }
+  if (domain === "edge") {
+    if (key === "id") {
+      return "id";
+    }
+    if (key === "key") {
+      return "key";
+    }
+  }
+  return null;
+}
+class GmlImport {
+  /**
+   * Create one import.
+   * @param sink - the sink
+   * @param report - the report
+   * @param options - the resolved common options
+   * @param format - the format-specific options
+   */
+  constructor(sink, report, options, format) {
+    this.tokens = null;
+    this.resolver = null;
+    this.nodeSchema = /* @__PURE__ */ new Map();
+    this.edgeSchema = /* @__PURE__ */ new Map();
+    this.graphSchema = /* @__PURE__ */ new Map();
+    this.topSchema = /* @__PURE__ */ new Map();
+    this.nodePlans = /* @__PURE__ */ new Map();
+    this.edgePlans = /* @__PURE__ */ new Map();
+    this.graphPlans = /* @__PURE__ */ new Map();
+    this.topPlans = /* @__PURE__ */ new Map();
+    this.graphNames = /* @__PURE__ */ new Set();
+    this.graphOpen = -1;
+    this.directedToken = -1;
+    this.multigraphToken = -1;
+    this.creatorToken = -1;
+    this.versionToken = -1;
+    this.nodeCount = 0;
+    this.edgeCount = 0;
+    this.weightKinds = 0;
+    this.hasOriginalId = false;
+    this.headerDirected = false;
+    this.seq = 0;
+    this.nodeOrdinal = 0;
+    this.elementsSinceCheck = 0;
+    this.idMap = null;
+    this.declared = new Uint32Array(64);
+    this.touched = [];
+    this.graphTouched = [];
+    this.seqNow = 0;
+    this.sink = sink;
+    this.report = report;
+    this.options = options;
+    this.positions = format?.positions ?? true;
+    this.dictionaries = format?.dictionaries ?? true;
+    this.coercer = new IdCoercer(options.ids);
+  }
+  /**
+   * Run the import over a text.
+   * @param text - the whole GML text
+   */
+  run(text) {
+    const { report } = this;
+    try {
+      this.tokens = tokenizeGml(text);
+    } catch (err) {
+      if (err instanceof GmlSyntaxError) {
+        report.fail(err.code, err.message, { line: err.line });
+      }
+      throw err;
+    }
+    this.scan();
+    this.push();
+  }
+  // ============================================================ pass 1: the schema
+  /**
+   * Walk the top level: find the graph block, the metadata keys and the top-level attributes,
+   * and derive every table's schema.
+   */
+  scan() {
+    const t = this.requireTokens();
+    for (let p = 0; p < t.count; p = t.nextPair(p)) {
+      const key = t.textOf(p);
+      const v = p + 1;
+      const record = t.kind[v] === TOKEN_OPEN;
+      if (key === "graph" && record) {
+        if (this.graphOpen >= 0) {
+          this.report.fail(SECOND_GRAPH_CODE, "the input contains more than one graph", {
+            line: t.line[p]
+          });
+        }
+        this.graphOpen = v;
+        this.scanGraph(v);
+      } else if (key === "Creator" && !record && this.creatorToken < 0) {
+        this.creatorToken = v;
+      } else if (key === "Version" && !record && this.versionToken < 0) {
+        this.versionToken = v;
+      } else {
+        this.observe(this.topSchema, "graph", key, v, TOP_SEQ);
+      }
+    }
+    if (this.graphOpen < 0) {
+      this.report.fail(NO_GRAPH_CODE, "the input contains no graph [ ... ] block", { line: null });
+    }
+  }
+  /**
+   * Walk the graph block for the schema.
+   * @param open - the index of the block's `[`
+   */
+  scanGraph(open) {
+    const t = this.requireTokens();
+    const close = t.match[open];
+    for (let p = open + 1; p < close; p = t.nextPair(p)) {
+      const key = t.textOf(p);
+      const v = p + 1;
+      switch (key) {
+        case "node":
+          if (t.kind[v] === TOKEN_OPEN) {
+            this.nodeCount++;
+            this.scanElement("node", v);
+          }
+          break;
+        case "edge":
+          if (t.kind[v] === TOKEN_OPEN) {
+            this.edgeCount++;
+            this.scanElement("edge", v);
+          }
+          break;
+        case "directed":
+          if (this.directedToken < 0) {
+            this.directedToken = v;
+          }
+          break;
+        case "multigraph":
+          if (this.multigraphToken < 0) {
+            this.multigraphToken = v;
+          }
+          break;
+        default:
+          this.observe(this.graphSchema, "graph", key, v, GRAPH_SEQ);
+      }
+    }
+  }
+  /**
+   * Walk one node or edge block for the schema.
+   * @param domain - node or edge
+   * @param open - the block's `[`
+   */
+  scanElement(domain, open) {
+    const t = this.requireTokens();
+    const close = t.match[open];
+    const seq = this.seq++;
+    const schema = domain === "node" ? this.nodeSchema : this.edgeSchema;
+    const { weightFrom, restoreMangledIds } = this.options;
+    for (let p = open + 1; p < close; p = t.nextPair(p)) {
+      const key = t.textOf(p);
+      const v = p + 1;
+      if (domain === "node") {
+        if (key === "id") {
+          continue;
+        }
+        if (key === ORIGINAL_ID_KEY && restoreMangledIds) {
+          this.hasOriginalId = true;
+          continue;
+        }
+      } else {
+        if (key === "source" || key === "target") {
+          continue;
+        }
+        if (key === weightFrom) {
+          this.weightKinds |= kindBit(t, v);
+          continue;
+        }
+      }
+      this.observe(schema, domain, key, v, seq);
+    }
+  }
+  /**
+   * Record one value of one key in a table's schema.
+   * @param schema - the table's schema
+   * @param domain - the table
+   * @param key - the key
+   * @param v - the value token
+   * @param seq - the element sequence number
+   */
+  observe(schema, domain, key, v, seq) {
+    const t = this.requireTokens();
+    let entry = schema.get(key);
+    if (entry === void 0) {
+      entry = {
+        key,
+        kinds: 0,
+        list: false,
+        lastSeq: seq,
+        wide: false,
+        unsafe: false,
+        dict: this.dictionaries && roleOf(domain, key) === null ? new DictHeuristic() : null,
+        position: false,
+        rest: false
+      };
+      schema.set(key, entry);
+    } else if (entry.lastSeq === seq) {
+      entry.list = true;
+    } else {
+      entry.lastSeq = seq;
+    }
+    switch (t.kind[v]) {
+      case TOKEN_STRING: {
+        const raw = t.textOf(v);
+        if (raw === LIST_START_MARKER || raw === EMPTY_LIST_TEXT || raw === EMPTY_TUPLE_TEXT) {
+          entry.list = true;
+          return;
+        }
+        entry.kinds |= KIND_STRING;
+        if (entry.dict !== null && !entry.dict.decided) {
+          entry.dict.observe(raw);
+        }
+        return;
+      }
+      case TOKEN_INT: {
+        entry.kinds |= KIND_INT;
+        const n = Number(t.textOf(v));
+        if (n < I32_MIN || n > I32_MAX) {
+          entry.wide = true;
+          if (!Number.isSafeInteger(n)) {
+            entry.unsafe = true;
+          }
+        }
+        return;
+      }
+      case TOKEN_OPEN:
+        entry.kinds |= KIND_RECORD;
+        if (domain === "node" && key === "graphics" && this.positions) {
+          this.inspectGraphics(entry, v);
+        }
+        return;
+      default:
+        entry.kinds |= KIND_REAL;
+    }
+  }
+  /**
+   * Note whether a node's graphics record carries a position (numeric x and y) and whether
+   * anything besides the position remains.
+   * @param entry - the graphics schema entry
+   * @param open - the record's `[`
+   */
+  inspectGraphics(entry, open) {
+    const t = this.requireTokens();
+    const close = t.match[open];
+    let x = false;
+    let y = false;
+    let other = false;
+    for (let p = open + 1; p < close; p = t.nextPair(p)) {
+      const key = t.textOf(p);
+      const numeric = t.kind[p + 1] === TOKEN_INT || t.kind[p + 1] === TOKEN_REAL;
+      if (key === "x" && numeric && !x) {
+        x = true;
+      } else if (key === "y" && numeric && !y) {
+        y = true;
+      } else if (!(key === "z" && numeric)) {
+        other = true;
+      }
+    }
+    const positioned = x && y;
+    entry.position ||= positioned;
+    entry.rest ||= positioned ? other : true;
+  }
+  // ============================================================ pass 2: the push
+  /** Declare what the schema needs, set the header and push every element. */
+  push() {
+    const { sink, report, options } = this;
+    const t = this.requireTokens();
+    sink.reserve(this.nodeCount, this.edgeCount);
+    this.buildPlans();
+    this.setMetadata();
+    this.headerDirected = this.readFlag(this.directedToken, "directed") ?? options.defaultDirected;
+    const resolver = new DirectionResolver(sink, report, options.onMixedDirection);
+    resolver.setHeader(this.headerDirected, {
+      line: this.directedToken >= 0 ? t.line[this.directedToken] : t.line[this.graphOpen]
+    });
+    this.resolver = resolver;
+    if (options.nodeIdFrom !== "id" || this.hasOriginalId) {
+      this.idMap = /* @__PURE__ */ new Map();
+    }
+    if (options.nodeIdFrom !== "id") {
+      report.loss(
+        ID_DROPPED_CODE,
+        `node ids taken from the ${options.nodeIdFrom}; the integer id keys are not kept as a column`,
+        null,
+        this.nodeCount
+      );
+    }
+    this.pushTopLevel();
+    this.pushNodes();
+    this.pushEdges();
+  }
+  /** Turn every schema entry into a column plan. */
+  buildPlans() {
+    for (const [key, entry] of this.nodeSchema) {
+      this.nodePlans.set(key, this.planOf("node", entry));
+    }
+    for (const [key, entry] of this.edgeSchema) {
+      this.edgePlans.set(key, this.planOf("edge", entry));
+    }
+    for (const [key, entry] of this.graphSchema) {
+      this.graphPlans.set(key, this.planOf("graph", entry));
+    }
+    for (const [key, entry] of this.topSchema) {
+      this.topPlans.set(key, this.planOf("graph", entry, true));
+    }
+  }
+  /**
+   * The plan of one schema entry.
+   * @param domain - the table
+   * @param entry - the schema entry
+   * @param top - whether the key is a top-level one (graph table)
+   * @returns the plan
+   */
+  planOf(domain, entry, top = false) {
+    const kind = kindOf(entry);
+    let scalar = dtypeOfKind(kind, entry);
+    if (scalar === "string" && !entry.list && entry.dict !== null && entry.kinds === KIND_STRING && entry.dict.decide() === "dict") {
+      scalar = "dict";
+    }
+    if (entry.unsafe) {
+      this.report.warnOnce(
+        "precision",
+        PRECISION_CODE,
+        `${domain} key "${entry.key}" holds integers beyond 2^53; they are stored as the nearest f64`,
+        { element: entry.key },
+        `${PRECISION_CODE}:${domain}:${entry.key}`
+      );
+    }
+    const name = domain === "graph" ? this.uniqueGraphName(entry.key) : entry.key;
+    let itemDtype = null;
+    if (entry.list) {
+      itemDtype = scalar === "dict" ? "string" : scalar;
+    }
+    const plan = {
+      key: entry.key,
+      name,
+      dtype: entry.list ? "list" : scalar,
+      itemDtype,
+      kind,
+      list: entry.list,
+      role: roleOf(domain, entry.key),
+      top,
+      position: null,
+      rest: null,
+      handle: INVALID_INDEX,
+      declared: false,
+      items: null,
+      seq: Number.NEGATIVE_INFINITY
+    };
+    if (domain === "node" && entry.key === "graphics" && entry.position && entry.kinds === KIND_RECORD && !entry.list) {
+      const taken = (candidate) => this.nodeSchema.has(candidate) || this.sink.nodeColumn(candidate) !== INVALID_INDEX;
+      const position = {
+        ...plan,
+        name: uniqueColumnName("position", "graphics", taken),
+        dtype: "f64",
+        itemDtype: null,
+        kind: "real",
+        role: "position"
+      };
+      const rest = entry.rest ? { ...plan } : null;
+      return { ...plan, position, rest };
+    }
+    return plan;
+  }
+  /**
+   * A graph column name not yet used by this import (top-level and in-graph keys share the table).
+   * @param key - the key
+   * @returns the name
+   */
+  uniqueGraphName(key) {
+    const name = uniqueColumnName(key, key, (candidate) => this.graphNames.has(candidate));
+    this.graphNames.add(name);
+    return name;
+  }
+  /** Set the graph metadata: source format, creator, version, multigraph flag, weight origin. */
+  setMetadata() {
+    const t = this.requireTokens();
+    const { sink, options } = this;
+    const textOf = (v) => t.kind[v] === TOKEN_STRING ? t.stringOf(v) : t.textOf(v);
+    const multigraph = this.readFlag(this.multigraphToken, "multigraph");
+    sink.setMeta({
+      sourceFormat: "gml",
+      creator: this.creatorToken >= 0 ? textOf(this.creatorToken) : void 0,
+      sourceVersion: this.versionToken >= 0 ? textOf(this.versionToken) : void 0,
+      declaredMultigraph: multigraph ?? void 0,
+      weightOrigin: this.weightKinds !== 0 && options.weightFrom !== null ? {
+        format: "gml",
+        id: options.weightFrom,
+        title: null,
+        type: this.weightKinds === KIND_INT ? "int" : "real",
+        namespace: null
+      } : void 0
+    });
+  }
+  /**
+   * Read a `directed` / `multigraph` flag token.
+   * @param v - the value token, or -1 when absent
+   * @param name - the flag name, for issues
+   * @returns the flag, or null when absent or not an integer
+   */
+  readFlag(v, name) {
+    if (v < 0) {
+      return null;
+    }
+    const t = this.requireTokens();
+    if (t.kind[v] !== TOKEN_INT) {
+      this.report.error(
+        "validation-error",
+        FLAG_TYPE_CODE,
+        `graph flag "${name}" must be the integer 0 or 1, found ${describeValue(t, v)}`,
+        { line: t.line[v], element: name }
+      );
+      return null;
+    }
+    const n = Number(t.textOf(v));
+    if (n !== 0 && n !== 1) {
+      this.report.warning(
+        "validation-error",
+        FLAG_VALUE_CODE,
+        `graph flag "${name}" is ${n}; read as ${n !== 0 ? "1" : "0"}`,
+        { line: t.line[v], element: name }
+      );
+    }
+    return n !== 0;
+  }
+  /** Push the top-level attributes (every top-level key but graph, Creator and Version). */
+  pushTopLevel() {
+    const t = this.requireTokens();
+    for (let p = 0; p < t.count; p = t.nextPair(p)) {
+      const v = p + 1;
+      if (v === this.graphOpen || v === this.creatorToken || v === this.versionToken) {
+        continue;
+      }
+      const plan = this.topPlans.get(t.textOf(p));
+      if (plan !== void 0) {
+        this.writeGraph(plan, v, TOP_SEQ);
+      }
+    }
+    this.flushGraphLists();
+  }
+  /** Push every node block and the graph block's own attributes, in file order. */
+  pushNodes() {
+    const t = this.requireTokens();
+    const close = t.match[this.graphOpen];
+    for (let p = this.graphOpen + 1; p < close; p = t.nextPair(p)) {
+      const key = t.textOf(p);
+      const v = p + 1;
+      switch (key) {
+        case "node":
+          if (t.kind[v] === TOKEN_OPEN) {
+            this.importNode(v);
+          } else {
+            this.badElement("node", p);
+            this.report.counts.skippedNodes++;
+          }
+          break;
+        case "edge":
+          break;
+        case "directed":
+        case "multigraph":
+          if (v !== this.directedToken && v !== this.multigraphToken) {
+            this.report.warning(
+              "validation-error",
+              FLAG_VALUE_CODE,
+              `graph flag "${key}" repeated; the first value stands`,
+              { line: t.line[p], element: key }
+            );
+          }
+          break;
+        default: {
+          const plan = this.graphPlans.get(key);
+          if (plan !== void 0) {
+            this.writeGraph(plan, v, GRAPH_SEQ);
+          }
+        }
+      }
+    }
+    this.flushGraphLists();
+  }
+  /** Push every edge block, in file order. */
+  pushEdges() {
+    const t = this.requireTokens();
+    const close = t.match[this.graphOpen];
+    let ordinal = 0;
+    for (let p = this.graphOpen + 1; p < close; p = t.nextPair(p)) {
+      if (t.textOf(p) !== "edge") {
+        continue;
+      }
+      const v = p + 1;
+      if (t.kind[v] === TOKEN_OPEN) {
+        this.importEdge(v, ordinal);
+      } else {
+        this.badElement("edge", p);
+        this.report.counts.skippedEdges++;
+      }
+      ordinal++;
+    }
+  }
+  /**
+   * Record a `node` / `edge` key whose value is not a block.
+   * @param what - node or edge
+   * @param p - the key token
+   */
+  badElement(what, p) {
+    const t = this.requireTokens();
+    this.report.error(
+      "validation-error",
+      ELEMENT_TYPE_CODE,
+      `${what} must be a [ ... ] block, found ${describeValue(t, p + 1)}`,
+      { line: t.line[p], element: what }
+    );
+  }
+  /**
+   * Push one node block.
+   * @param open - the block's `[`
+   */
+  importNode(open) {
+    const t = this.requireTokens();
+    const { sink, report, options } = this;
+    const close = t.match[open];
+    const line = t.line[open];
+    const ordinal = this.nodeOrdinal++;
+    this.checkAbort();
+    let index;
+    let sinkId;
+    try {
+      let idTok = -1;
+      let labelTok = -1;
+      let originalTok = -1;
+      for (let p = open + 1; p < close; p = t.nextPair(p)) {
+        const key = t.textOf(p);
+        if (key === "id") {
+          idTok = this.structuralToken(idTok, p, "id");
+        } else if (key === "label") {
+          labelTok = labelTok < 0 ? p + 1 : labelTok;
+        } else if (key === ORIGINAL_ID_KEY && options.restoreMangledIds) {
+          originalTok = originalTok < 0 ? p + 1 : originalTok;
+        }
+      }
+      if (idTok < 0) {
+        throw new GraphFormatError("E_INVALID_ID", "node has no id", { reason: "missing id" });
+      }
+      const fileId = this.integerOf(idTok, "id");
+      if (originalTok >= 0) {
+        sinkId = this.restoredId(originalTok);
+      } else {
+        switch (options.nodeIdFrom) {
+          case "label":
+            if (labelTok < 0) {
+              throw new GraphFormatError("E_INVALID_ID", "node has no label", {
+                reason: "missing label"
+              });
+            }
+            sinkId = this.coerceValueToken(labelTok);
+            break;
+          case "index":
+            sinkId = ordinal;
+            break;
+          default:
+            sinkId = this.coerceInteger(idTok, fileId);
+        }
+      }
+      if (this.idMap !== null) {
+        this.idMap.set(fileId, sinkId);
+      }
+      index = sink.addNode(sinkId);
+    } catch (err) {
+      this.recordNodeError(err, line);
+      report.counts.skippedNodes++;
+      return;
+    }
+    if (this.isDeclared(index)) {
+      report.warning(
+        "merged",
+        DUPLICATE_NODE_CODE,
+        `node ${JSON.stringify(sinkId)} is declared twice; later keys overwrite`,
+        { line, element: String(sinkId) }
+      );
+    } else {
+      this.markDeclared(index);
+      report.counts.nodes++;
+    }
+    this.beginElement(this.seq++);
+    try {
+      for (let p = open + 1; p < close; p = t.nextPair(p)) {
+        const key = t.textOf(p);
+        if (key === "id" || key === ORIGINAL_ID_KEY && options.restoreMangledIds) {
+          continue;
+        }
+        const plan = this.nodePlans.get(key);
+        if (plan !== void 0) {
+          this.writeNode(plan, index, p + 1);
+        }
+      }
+      this.flushLists("node", index);
+    } catch (err) {
+      this.touched.length = 0;
+      report.recordError(err, { line, element: String(sinkId) });
+    }
+  }
+  /**
+   * Push one edge block.
+   * @param open - the block's `[`
+   * @param ordinal - the edge's ordinal among edge blocks, for messages
+   */
+  importEdge(open, ordinal) {
+    const t = this.requireTokens();
+    const { sink, report, options } = this;
+    const close = t.match[open];
+    const line = t.line[open];
+    const element = `edge #${ordinal}`;
+    this.checkAbort();
+    let edge;
+    try {
+      let sourceTok = -1;
+      let targetTok = -1;
+      let weightTok = -1;
+      for (let p = open + 1; p < close; p = t.nextPair(p)) {
+        const key = t.textOf(p);
+        if (key === "source") {
+          sourceTok = this.structuralToken(sourceTok, p, "source");
+        } else if (key === "target") {
+          targetTok = this.structuralToken(targetTok, p, "target");
+        } else if (key === options.weightFrom) {
+          weightTok = p + 1;
+        }
+      }
+      if (sourceTok < 0 || targetTok < 0) {
+        throw new GraphFormatError("E_UNKNOWN_NODE", `edge has no ${sourceTok < 0 ? "source" : "target"}`, {
+          reason: "missing endpoint"
+        });
+      }
+      const source = this.endpoint(sourceTok, "source");
+      const target = this.endpoint(targetTok, "target");
+      const weight = weightTok >= 0 ? this.weightOf(weightTok) : void 0;
+      const before = sink.edgeCount;
+      const sourceNew = sink.indexOf(source) === INVALID_INDEX;
+      const targetNew = source !== target && sink.indexOf(target) === INVALID_INDEX;
+      edge = this.requireResolver().addEdge(
+        source,
+        target,
+        this.headerDirected ? "directed" : "undirected",
+        weight,
+        { line, element }
+      );
+      report.counts.edges += sink.edgeCount - before;
+      report.counts.nodes += (sourceNew ? 1 : 0) + (targetNew ? 1 : 0);
+    } catch (err) {
+      this.recordEdgeError(err, line, element);
+      report.counts.skippedEdges++;
+      return;
+    }
+    this.beginElement(this.seq++);
+    try {
+      for (let p = open + 1; p < close; p = t.nextPair(p)) {
+        const key = t.textOf(p);
+        if (key === "source" || key === "target" || key === options.weightFrom) {
+          continue;
+        }
+        const plan = this.edgePlans.get(key);
+        if (plan !== void 0) {
+          this.writeEdge(plan, edge, p + 1);
+        }
+      }
+      this.flushLists("edge", edge);
+    } catch (err) {
+      this.touched.length = 0;
+      report.recordError(err, { line, element });
+    }
+  }
+  // ============================================================ ids and weights
+  /**
+   * Note a structural key token, refusing a repeat.
+   * @param previous - the token seen before, or -1
+   * @param p - the key token
+   * @param key - the key name
+   * @returns the value token
+   */
+  structuralToken(previous, p, key) {
+    if (previous >= 0) {
+      throw new GraphFormatError("E_INVALID_ID", `key "${key}" appears twice in one block`, {
+        reason: "duplicate key",
+        key
+      });
+    }
+    return p + 1;
+  }
+  /**
+   * The integer value of an id / source / target token (the GML grammar's integer ids; a string
+   * id is refused, as the malformed corpus pins, although NetworkX would accept it).
+   * @param v - the value token
+   * @param key - the key name, for the error
+   * @returns the number
+   */
+  integerOf(v, key) {
+    const t = this.requireTokens();
+    if (t.kind[v] !== TOKEN_INT) {
+      throw new GraphFormatError("E_INVALID_ID", `${key} must be an integer, found ${describeValue(t, v)}`, {
+        reason: "not an integer",
+        key,
+        value: t.kind[v] === TOKEN_OPEN ? "[...]" : t.textOf(v)
+      });
+    }
+    return Number(t.textOf(v));
+  }
+  /**
+   * Coerce an integer id token under the `ids` rule: a safe integer passes as a typed number
+   * (so `01` is 1 and `-0` is 0), a larger one goes through the text rule (a string under
+   * "canonical"), and "string" keeps the text as written.
+   * @param v - the value token
+   * @param n - its numeric value
+   * @returns the id
+   */
+  coerceInteger(v, n) {
+    if (Number.isSafeInteger(n) && this.coercer.mode !== "string") {
+      return this.coercer.value(n);
+    }
+    return this.coercer.text(this.requireTokens().textOf(v));
+  }
+  /**
+   * Coerce a label token under the `ids` rule: a string by its text, a number as a typed value.
+   * @param v - the value token
+   * @returns the id
+   */
+  coerceValueToken(v) {
+    const t = this.requireTokens();
+    switch (t.kind[v]) {
+      case TOKEN_STRING:
+        return this.coercer.text(t.stringOf(v));
+      case TOKEN_INT:
+        return this.coerceInteger(v, Number(t.textOf(v)));
+      case TOKEN_OPEN:
+        throw new GraphFormatError("E_INVALID_ID", "label must be a string or a number, found a record", {
+          reason: "record label"
+        });
+      default:
+        return this.coercer.value(numberOfText(t.textOf(v)));
+    }
+  }
+  /**
+   * The id a `graphty_originalId` key restores: typed, never coerced (the exporter wrote it exactly).
+   * @param v - the value token
+   * @returns the original id
+   */
+  restoredId(v) {
+    const t = this.requireTokens();
+    switch (t.kind[v]) {
+      case TOKEN_STRING:
+        return t.stringOf(v);
+      case TOKEN_OPEN:
+        throw new GraphFormatError("E_INVALID_ID", `${ORIGINAL_ID_KEY} must be a string or a number`, {
+          reason: "record original id"
+        });
+      default:
+        return numberOfText(t.textOf(v));
+    }
+  }
+  /**
+   * Resolve a source / target token to a sink id.
+   * @param v - the value token
+   * @param key - source or target
+   * @returns the id
+   */
+  endpoint(v, key) {
+    const n = this.integerOf(v, key);
+    if (this.idMap !== null) {
+      const mapped = this.idMap.get(n);
+      if (mapped !== void 0) {
+        return mapped;
+      }
+    }
+    return this.coerceInteger(v, n);
+  }
+  /**
+   * The weight of an edge from its weight token.
+   * @param v - the value token
+   * @returns the weight; E_INVALID_WEIGHT for a record or non-numeric text
+   */
+  weightOf(v) {
+    const t = this.requireTokens();
+    switch (t.kind[v]) {
+      case TOKEN_STRING:
+        return parseWeightText(t.stringOf(v));
+      case TOKEN_OPEN:
+        throw new GraphFormatError("E_INVALID_WEIGHT", "edge weight is a record", { value: "[...]" });
+      default:
+        return weightFromValue(numberOfText(t.textOf(v)));
+    }
+  }
+  /**
+   * Record a node-level error under the GML code it implies.
+   * @param err - the thrown value
+   * @param line - the block's line
+   */
+  recordNodeError(err, line) {
+    const { report } = this;
+    if (err instanceof GraphFormatError && err.code === "E_INVALID_ID") {
+      const { reason } = err.details;
+      switch (reason) {
+        case "missing id":
+          report.error("missing-value", MISSING_ID_CODE, err.message, { line, element: "node" });
+          return;
+        case "missing label":
+          report.error("missing-value", MISSING_LABEL_CODE, err.message, { line, element: "node" });
+          return;
+        case "duplicate key":
+          report.error("validation-error", REPEATED_KEY_CODE, err.message, { line, element: "node" });
+          return;
+        case "not an integer":
+          report.error("validation-error", ID_TYPE_CODE, err.message, { line, element: "node" });
+          return;
+      }
+    }
+    report.recordError(err, { line, element: "node" });
+  }
+  /**
+   * Record an edge-level error under the GML code it implies.
+   * @param err - the thrown value
+   * @param line - the block's line
+   * @param element - the edge description
+   */
+  recordEdgeError(err, line, element) {
+    const { report } = this;
+    if (err instanceof GraphFormatError) {
+      const { reason } = err.details;
+      if (err.code === "E_UNKNOWN_NODE" && reason === "missing endpoint") {
+        report.error("missing-value", MISSING_ENDPOINT_CODE, err.message, { line, element });
+        return;
+      }
+      if (err.code === "E_INVALID_ID" && reason === "duplicate key") {
+        report.error("validation-error", REPEATED_KEY_CODE, err.message, { line, element });
+        return;
+      }
+      if (err.code === "E_INVALID_ID" && reason === "not an integer") {
+        report.error("validation-error", ID_TYPE_CODE, err.message, { line, element });
+        return;
+      }
+    }
+    report.recordError(err, { line, element });
+  }
+  // ============================================================ values
+  /**
+   * Write one node value.
+   * @param plan - the key's plan
+   * @param index - the node index
+   * @param v - the value token
+   */
+  writeNode(plan, index, v) {
+    if (plan.position !== null) {
+      this.writeGraphics(plan, index, v);
+      return;
+    }
+    if (plan.list) {
+      this.collectItem(plan, v, this.seqNow, this.touched);
+      return;
+    }
+    this.sink.setNodeValue(this.handleOf(plan, "node"), index, this.scalarOf(plan, v));
+  }
+  /**
+   * Write one edge value.
+   * @param plan - the key's plan
+   * @param edge - the edge index
+   * @param v - the value token
+   */
+  writeEdge(plan, edge, v) {
+    if (plan.list) {
+      this.collectItem(plan, v, this.seqNow, this.touched);
+      return;
+    }
+    this.sink.setEdgeValue(this.handleOf(plan, "edge"), edge, this.scalarOf(plan, v));
+  }
+  /**
+   * Write one graph value.
+   * @param plan - the key's plan
+   * @param v - the value token
+   * @param seq - TOP_SEQ or GRAPH_SEQ
+   */
+  writeGraph(plan, v, seq) {
+    if (plan.list) {
+      this.collectItem(plan, v, seq, this.graphTouched);
+      return;
+    }
+    this.sink.setGraphValue(plan.name, this.scalarOf(plan, v), graphDecl(plan));
+  }
+  /**
+   * Write a node's graphics record: the position column from x / y / z, the remaining keys to
+   * the json column.
+   * @param plan - the graphics plan
+   * @param index - the node index
+   * @param v - the value token (a record)
+   */
+  writeGraphics(plan, index, v) {
+    const t = this.requireTokens();
+    const { sink } = this;
+    const record = parseRecord(t, v);
+    const { x, y, z } = record;
+    const positionPlan = plan.position;
+    if (positionPlan !== null && typeof x === "number" && typeof y === "number") {
+      sink.setNodeValue(this.handleOf(positionPlan, "node"), index, [x, y, typeof z === "number" ? z : 0]);
+      delete record.x;
+      delete record.y;
+      if (typeof z === "number") {
+        delete record.z;
+      }
+      if (plan.rest !== null && Object.keys(record).length > 0) {
+        sink.setNodeValue(this.handleOf(plan.rest, "node"), index, record);
+      }
+      return;
+    }
+    if (plan.rest !== null) {
+      sink.setNodeValue(this.handleOf(plan.rest, "node"), index, record);
+    }
+  }
+  /**
+   * Collect one list item.
+   * @param plan - the list plan
+   * @param v - the value token
+   * @param seq - the sequence number of the element the item belongs to
+   * @param touched - the plans touched by that element
+   */
+  collectItem(plan, v, seq, touched) {
+    const t = this.requireTokens();
+    if (plan.seq !== seq) {
+      plan.seq = seq;
+      plan.items = [];
+      touched.push(plan);
+    }
+    if (t.kind[v] === TOKEN_STRING) {
+      const raw = t.textOf(v);
+      if (raw === LIST_START_MARKER || raw === EMPTY_LIST_TEXT || raw === EMPTY_TUPLE_TEXT) {
+        return;
+      }
+    }
+    plan.items.push(this.scalarOf(plan, v));
+  }
+  /**
+   * Start a node or edge: later list items belong to it.
+   * @param seq - the element's sequence number
+   */
+  beginElement(seq) {
+    this.seqNow = seq;
+    this.touched.length = 0;
+  }
+  /**
+   * Write the lists collected for the current node or edge.
+   * @param domain - node or edge
+   * @param row - the row
+   */
+  flushLists(domain, row) {
+    const { sink, touched } = this;
+    for (const plan of touched) {
+      const handle = this.handleOf(plan, domain);
+      if (domain === "node") {
+        sink.setNodeValue(handle, row, plan.items);
+      } else {
+        sink.setEdgeValue(handle, row, plan.items);
+      }
+      plan.items = null;
+    }
+    touched.length = 0;
+  }
+  /** Write the lists collected for the graph table. */
+  flushGraphLists() {
+    const { sink, graphTouched } = this;
+    for (const plan of graphTouched) {
+      sink.setGraphValue(plan.name, plan.items, graphDecl(plan));
+      plan.items = null;
+    }
+    graphTouched.length = 0;
+  }
+  /**
+   * The JS value of a scalar value token (or list item) under a plan's storage class.
+   * @param plan - the plan
+   * @param v - the value token
+   * @returns the value to push
+   */
+  scalarOf(plan, v) {
+    const t = this.requireTokens();
+    const kind = t.kind[v];
+    switch (plan.kind) {
+      case "int":
+        return Number(t.textOf(v));
+      case "real":
+        return numberOfText(t.textOf(v));
+      case "string":
+        return kind === TOKEN_STRING ? t.stringOf(v) : t.textOf(v);
+      default:
+        return kind === TOKEN_STRING ? t.stringOf(v) : scalarOrRecord(t, v);
+    }
+  }
+  /**
+   * The handle of a plan's column, declaring it on first use. A declaration the sink refuses
+   * because a column of the name exists with another declaration falls back to that column
+   * (reported once); a taken role is dropped (reported once).
+   * @param plan - the plan
+   * @param domain - node or edge
+   * @returns the handle
+   */
+  handleOf(plan, domain) {
+    if (plan.declared) {
+      return plan.handle;
+    }
+    plan.declared = true;
+    const { sink, report } = this;
+    const decl = {
+      name: plan.name,
+      dtype: plan.dtype,
+      nullable: true,
+      origin: { format: "gml", id: plan.key, title: null, type: originTypeOf(plan), namespace: null }
+    };
+    if (plan.list) {
+      decl.itemDtype = plan.itemDtype ?? "string";
+    }
+    if (plan.role === "position") {
+      decl.components = 3;
+    }
+    if (plan.role !== null) {
+      decl.role = plan.role;
+    }
+    const resolved = declareResolved(sink, domain, decl, report, { element: plan.name });
+    plan.handle = resolved.handle;
+    if (resolved.renamed) {
+      plan.name = resolved.decl.name;
+    }
+    return plan.handle;
+  }
+  // ============================================================ bookkeeping
+  /**
+   * Whether a node index was declared by a node block of this import.
+   * @param index - the node index
+   * @returns true when declared
+   */
+  isDeclared(index) {
+    const word = index >>> 5;
+    return word < this.declared.length && (this.declared[word] >>> (index & 31) & 1) === 1;
+  }
+  /**
+   * Mark a node index as declared.
+   * @param index - the node index
+   */
+  markDeclared(index) {
+    const word = index >>> 5;
+    if (word >= this.declared.length) {
+      const grown = new Uint32Array(Math.max(word + 1, this.declared.length * 2));
+      grown.set(this.declared);
+      this.declared = grown;
+    }
+    this.declared[word] |= 1 << (index & 31);
+  }
+  /** Check the abort signal every ABORT_CHECK_INTERVAL elements. */
+  checkAbort() {
+    if (++this.elementsSinceCheck >= ABORT_CHECK_INTERVAL) {
+      this.elementsSinceCheck = 0;
+      throwIfAborted(this.options.signal);
+    }
+  }
+  /**
+   * The tokens, which exist after run() lexed the text.
+   * @returns the tokens
+   */
+  requireTokens() {
+    if (this.tokens === null) {
+      throw new GraphFormatError("E_UNSUPPORTED", "the GML text was not lexed", { reason: "no tokens" });
+    }
+    return this.tokens;
+  }
+  /**
+   * The direction resolver, which exists once the header was set.
+   * @returns the resolver
+   */
+  requireResolver() {
+    if (this.resolver === null) {
+      throw new GraphFormatError("E_DIRECTED", "the header was not set", { reason: "no resolver" });
+    }
+    return this.resolver;
+  }
+}
+function kindBit(t, v) {
+  switch (t.kind[v]) {
+    case TOKEN_INT:
+      return KIND_INT;
+    case TOKEN_STRING:
+      return KIND_STRING;
+    case TOKEN_OPEN:
+      return KIND_RECORD;
+    default:
+      return KIND_REAL;
+  }
+}
+function kindOf(entry) {
+  if ((entry.kinds & KIND_RECORD) !== 0) {
+    return "record";
+  }
+  if ((entry.kinds & KIND_STRING) !== 0) {
+    return "string";
+  }
+  if ((entry.kinds & KIND_REAL) !== 0) {
+    return "real";
+  }
+  return "int";
+}
+function dtypeOfKind(kind, entry) {
+  switch (kind) {
+    case "int":
+      return entry.wide ? "f64" : "i32";
+    case "real":
+      return "f64";
+    case "string":
+      return "string";
+    default:
+      return "json";
+  }
+}
+function originTypeOf(plan) {
+  return plan.kind;
+}
+function graphDecl(plan) {
+  const decl = {
+    name: plan.name,
+    dtype: plan.dtype,
+    nullable: true,
+    origin: { format: "gml", id: plan.key, title: null, type: originTypeOf(plan), namespace: null }
+  };
+  if (plan.list) {
+    decl.itemDtype = plan.itemDtype ?? "string";
+  }
+  if (plan.top) {
+    decl.extra = { gmlTopLevel: true };
+  }
+  return decl;
+}
+function describeValue(t, v) {
+  switch (t.kind[v]) {
+    case TOKEN_OPEN:
+      return "a record";
+    case TOKEN_STRING:
+      return `the string "${t.textOf(v)}"`;
+    case TOKEN_REAL:
+      return `the real ${t.textOf(v)}`;
+    case TOKEN_WORD:
+      return `the word ${t.textOf(v)}`;
+    default:
+      return t.textOf(v);
+  }
+}
+const SNIFF_GRAPH_START = /^(?:\s|#[^\n]*\n)*graph\s*\[/;
+const SNIFF_GRAPH_ANYWHERE = /(?:^|\s)graph\s*\[/;
+const SNIFF_KEY_START = /^(?:\s|#[^\n]*\n)*[A-Za-z_][0-9A-Za-z_]*\s+(?:"|[+-]?[0-9.]|\[)/;
+function sniffGml(head) {
+  let text = new TextDecoder("utf-8", { fatal: false }).decode(head);
+  if (text.charCodeAt(0) === 65279) {
+    text = text.slice(1);
+  }
+  if (SNIFF_GRAPH_START.test(text)) {
+    return 0.95;
+  }
+  if (SNIFF_KEY_START.test(text)) {
+    return SNIFF_GRAPH_ANYWHERE.test(text) ? 0.85 : 0.4;
+  }
+  return 0;
+}
+const gmlImporter = Object.freeze({
+  format: "gml",
+  extensions: Object.freeze([".gml"]),
+  mimeTypes: Object.freeze(["text/x-gml", "text/plain"]),
+  sniff: sniffGml,
+  /**
+   * Read a GML text into a sink.
+   * @param input - the text, bytes or stream
+   * @param sink - the sink
+   * @param options - format-specific and common options
+   * @returns the report
+   */
+  async import(input, sink, options) {
+    const resolved = resolveImportOptions(options, FORMAT_DEFAULTS);
+    const report = new ImportReportBuilder("gml", resolved.errorLimit);
+    reportSinkOptions(sink, options, report);
+    reportUnusedOptions(options, report, USED_OPTIONS);
+    const text = await readText(input, report, resolved);
+    throwIfAborted(resolved.signal);
+    new GmlImport(sink, report, resolved, options).run(text);
+    throwIfAborted(resolved.signal);
+    return report.finish();
+  }
+});
+const GML_ISSUE = Object.freeze({
+  /** A grammar violation: an untokenisable bare token, an unclosed string or `[`, a stray `]`, a key without a value (fatal). */
+  SYNTAX: SYNTAX_CODE,
+  /** The input holds invalid UTF-8 (fatal). */
+  INVALID_UTF8: INVALID_UTF8_CODE,
+  /** No `graph [` block (fatal). */
+  NO_GRAPH: NO_GRAPH_CODE,
+  /** More than one `graph` block (fatal). */
+  SECOND_GRAPH: SECOND_GRAPH_CODE,
+  /** A node without an `id`. */
+  MISSING_ID: MISSING_ID_CODE,
+  /** A node without a `label` under nodeIdFrom "label". */
+  MISSING_LABEL: MISSING_LABEL_CODE,
+  /** An edge without `source` or `target`. */
+  MISSING_ENDPOINT: MISSING_ENDPOINT_CODE,
+  /** A node id, source or target that is not an integer. */
+  ID_TYPE: ID_TYPE_CODE,
+  /** A node id declared twice (later keys overwrite). */
+  DUPLICATE_NODE: DUPLICATE_NODE_CODE,
+  /** A structural key repeated in one element. */
+  REPEATED_KEY: REPEATED_KEY_CODE,
+  /** A `node` / `edge` key whose value is not a record. */
+  ELEMENT_TYPE: ELEMENT_TYPE_CODE,
+  /** A `directed` / `multigraph` flag that is not an integer. */
+  FLAG_TYPE: FLAG_TYPE_CODE,
+  /** A `directed` / `multigraph` flag outside 0 / 1, or repeated. */
+  FLAG_VALUE: FLAG_VALUE_CODE,
+  /** An integer beyond 2^53 rounded to f64. */
+  PRECISION: PRECISION_CODE,
+  /** A column renamed `<name>#<key>` because the sink held the name with another shape. */
+  COLUMN_RENAMED: COLUMN_RENAMED_CODE,
+  /** A column declared without its role because the sink already holds it. */
+  ROLE_TAKEN: ROLE_TAKEN_CODE,
+  /** Two id texts merged into one number under ids "number". */
+  ID_MERGED: ID_MERGED_CODE,
+  /** A common option the importer has no use for was given. */
+  OPTION_IGNORED: OPTION_IGNORED_CODE,
+  /** A builder-policy option the sink does not honour. */
+  SINK_OPTION: SINK_OPTION_CODE,
+  /** The sink refused the file's direction. */
+  DIRECTION_REFUSED: DIRECTION_REFUSED_CODE,
+  /** Edges forced to the policy's direction. */
+  DIRECTION_FORCED: DIRECTION_FORCED_CODE,
+  /** A mixed file under onMixedDirection "error" (fatal). */
+  MIXED_DIRECTION: MIXED_DIRECTION_CODE,
+  /** Under nodeIdFrom "label" / "index" the integer ids are not kept (a loss note). */
+  ID_DROPPED: ID_DROPPED_CODE
+});
+const GML_LOSS = Object.freeze({
+  /** A json column holds numbers; GML records cannot keep int versus real (design section 8.5). */
+  RECORD_NUMBER_TYPE: RECORD_NUMBER_TYPE_CODE,
+  /** A json column holds booleans, written 1 / 0. */
+  RECORD_BOOLEAN: RECORD_BOOLEAN_CODE,
+  /** A json column holds nulls, omitted. */
+  RECORD_NULL: RECORD_NULL_CODE,
+  /** An array inside an array; export() throws. */
+  NESTED_ARRAY: NESTED_ARRAY_CODE,
+  /** A json row that is an array, written as repeated keys. */
+  JSON_ARRAY: JSON_ARRAY_CODE,
+  /** A column name or record key outside the GML key grammar. */
+  INVALID_KEY: INVALID_KEY_CODE,
+  /** A column named like a structural key. */
+  RESERVED_KEY: RESERVED_KEY_CODE,
+  /** A key rewritten under sanitizeKeys "mangle". */
+  KEY_MANGLED: KEY_MANGLED_CODE,
+  /** A position column with more than three components. */
+  POSITION_COMPONENTS: POSITION_COMPONENTS_CODE,
+  /** A graphics record whose x / y / z the position column overrides. */
+  GRAPHICS_OVERRIDDEN: GRAPHICS_OVERRIDDEN_CODE,
+  /** A graphics record that cannot hold the position. */
+  GRAPHICS_CONFLICT: GRAPHICS_CONFLICT_CODE
+});
+export {
+  GML_ISSUE,
+  GML_LOSS,
+  gmlExporter,
+  gmlImporter
+};
+//# sourceMappingURL=gml.js.map