@graphty/graph-io 0.3.42 → 0.3.44

package/dist/gml.js

@@ -1,3034 +1,11 @@
-import { ak as SYNTAX_CODE, b as plural, a as checkCapabilities, L as LOSS, p as pairFolding, $ as agree, c as capabilities, r as resolveExportOptions, ac as DictHeuristic, aG as formatInteger, bv as formatGmlReal, aE as sanitizeIds, bD as countMixedEdges, e as explicitWeights, bU as DICT_SAMPLE_ROWS, R as ROLE_TAKEN_CODE$1, aj as WIDENED_CODE$1, P as PRECISION_CODE$1, n as DUPLICATE_NODE_CODE$1, s as MISSING_ENDPOINT_CODE$1, t as MISSING_ID_CODE$1, l as MULTIPLE_GRAPHS_CODE, N as NO_GRAPH_CODE$1, al as resolveImportOptions, a8 as ImportReportBuilder, an as reportUnusedOptions, bB as readText, am as throwIfAborted, ao as reportSinkOptions, ap as graphChosen, ar as IdCoercer, aq as DirectionResolver, a0 as uniqueColumnName, C as COLUMN_RENAMED_CODE, as as weightFromValue, bV as reportWeightPrecision, aK as parseWeightText, a1 as declareResolved, M as MIXED_DIRECTION_CODE, D as DIRECTION_FORCED_CODE, d as DIRECTION_REFUSED_CODE, S as SINK_OPTION_CODE, O as OPTION_IGNORED_CODE, I as ID_MERGED_CODE, ae as AMBIGUOUS_GRAPH_NAME_CODE, af as GRAPH_NOT_FOUND_CODE, w as UNKNOWN_ENCODING_CODE, x as ENCODING_FALLBACK_CODE, y as INVALID_ENCODING_CODE, z as INVALID_UTF8_CODE, F as ELEMENT_ISSUE, G as INPUT_ISSUE } from "./chunks/export-rKLeGQMo.js";
-import { GraphFormatError, INVALID_INDEX } from "@graphty/graph-format";
-import { k as decodeGmlString, m as quoteGmlString } from "./chunks/escape-B62ZGM_a.js";
-import { j as joinText, e as encodeChunks } from "./chunks/writer-DxjgHwSe.js";
-import { i as importChosenGraph } from "./chunks/choose-DvpbdRuz.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_]\w*$/;
-const STRICT_KEY_TEXT = /^[A-Za-z]\w*$/;
-const INT_TEXT = /^[+-]?\d+$/;
-const REAL_TEXT = /^[+-]?(?:(?:\d+\.\d*|\.\d+)(?:[eE][+-]?\d+)?|\d+[eE][+-]?\d+)$/;
-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.onUnknownEntity = null;
-    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) {
-    let text = this.textOf(i);
-    if (text.includes("\r")) {
-      text = text.replaceAll(/\r\n?/g, "\n");
-    }
-    if (!text.includes("&")) {
-      return text;
-    }
-    const report = this.onUnknownEntity;
-    return decodeGmlString(
-      text,
-      report === null ? void 0 : (entity) => {
-        report(entity, this.line[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;
-  let spanningLine = 0;
-  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 === 65279) {
-      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);
-      if (close < 0) {
-        const hint = spanningLine === 0 ? "" : `; the string opened at line ${spanningLine} spans lines, so a quote may be missing there`;
-        throw new GmlSyntaxError(SYNTAX_STRING_CODE, `unclosed string opened at line ${line}${hint}`, line);
-      }
-      tokens.push(TOKEN_STRING, i + 1, close, line);
-      const opened = line;
-      for (let k = i + 1; k < close; k++) {
-        const d = text.codePointAt(k);
-        if (d === 10 || d === 13 && text.codePointAt(k + 1) !== 10) {
-          line++;
-        }
-      }
-      if (line !== opened && spanningLine === 0) {
-        spanningLine = opened;
-      }
-      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 hex = (c) => (c.codePointAt(0) ?? 0).toString(16).toUpperCase().padStart(4, "0");
-  const head = token.length > 20 ? `${token.slice(0, 20)}...` : token;
-  const shown = head.replaceAll(/[^\x20-\x7e]/gu, (c) => String.raw`\u` + hex(c));
-  const odd = /[^\x21-\x7e]/u.exec(token);
-  const note2 = odd === null ? "" : ` (it holds U+${hex(odd[0])}, which GML allows only inside a string)`;
-  throw new GmlSyntaxError(SYNTAX_TOKEN_CODE, `cannot tokenize "${shown}" at line ${line}${note2}`, 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${plural(stack.length)} 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 Number.NaN;
-    }
-    return lower.startsWith("-") ? -Infinity : Infinity;
-  }
-  return Number(text);
-}
-function isGmlKey(text) {
-  return STRICT_KEY_TEXT.test(text);
-}
-function mangleGmlKey(text) {
-  const body = text.replaceAll(/\W/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) {
-      storeString(frame, key, tokens.stringOf(v));
-    } 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 storeString(frame, key, text) {
-  if (text === LIST_START_MARKER) {
-    frame.record[key] = [];
-    frame.listKeys ??= /* @__PURE__ */ new Set();
-    frame.listKeys.add(key);
-    return;
-  }
-  storeValue(frame, key, text === EMPTY_LIST_TEXT || text === EMPTY_TUPLE_TEXT ? [] : text);
-}
-function storeValue(frame, key, value) {
-  const { record } = frame;
-  if (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",
-  "spellsOpen"
-]);
-const NODE_RESERVED = /* @__PURE__ */ new Set(["id"]);
-const EDGE_RESERVED = /* @__PURE__ */ new Set(["source", "target", "directed"]);
-const GRAPH_RESERVED = /* @__PURE__ */ new Set(["node", "edge", "directed", "multigraph"]);
-const TOP_RESERVED = /* @__PURE__ */ new Set(["graph"]);
-const NUMBER_TEXT = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/;
-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, name } = meta;
-  if (origin?.format !== "gml" || origin.id === null) {
-    return name;
-  }
-  return name === origin.id || name.startsWith(`${origin.id}#`) ? origin.id : 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 labelRoleColumn(columns, label, used) {
-  if (label !== "node" && label !== "edge") {
-    return void 0;
-  }
-  const column = columns.find((c) => c.meta.role === "label");
-  if (column !== void 0) {
-    used.add("label");
-  }
-  return column;
-}
-function selectColumns(table, reserved, label, plan, notes, filter = () => true) {
-  const used = new Set(reserved);
-  const out = [];
-  const columns = [...table].filter((c) => isWritten(c) && filter(c));
-  const labelRole = labelRoleColumn(columns, label, used);
-  for (const column of columns) {
-    const preferred = column === labelRole ? "label" : preferredKey(column.meta);
-    let key = preferred;
-    const valid = isGmlKey(preferred);
-    const taken = column !== labelRole && 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}; the save fails 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 countOnce(seen, flag, stats, counter) {
-  if (!seen[flag]) {
-    seen[flag] = true;
-    stats[counter]++;
-  }
-}
-function inspectJson(value, stats, inArray, seen) {
-  if (value === null) {
-    countOnce(seen, "nulls", stats, "nulls");
-    return;
-  }
-  switch (typeof value) {
-    case "number":
-      countOnce(seen, "numbers", stats, "numbers");
-      return;
-    case "boolean":
-      countOnce(seen, "booleans", stats, "booleans");
-      return;
-    case "string":
-      return;
-  }
-  if (Array.isArray(value)) {
-    if (inArray) {
-      countOnce(seen, "nested", 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 rowCount(count) {
-  return `${count} row${plural(count)}`;
-}
-function pushCounted(notes, count, code, text, column) {
-  if (count > 0) {
-    notes.push(note(code, text, column, count));
-  }
-}
-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}"`;
-    const counted = (count, code, text) => {
-      pushCounted(notes, count, code, text, name);
-    };
-    counted(
-      stats.numbers,
-      RECORD_NUMBER_TYPE_CODE,
-      `${where} holds numbers in ${rowCount(stats.numbers)}; GML records cannot keep the int / real distinction`
-    );
-    counted(
-      stats.booleans,
-      RECORD_BOOLEAN_CODE,
-      `${where} holds booleans in ${rowCount(stats.booleans)}; written as 1 / 0`
-    );
-    counted(
-      stats.nulls,
-      RECORD_NULL_CODE,
-      `${where} holds nulls in ${rowCount(stats.nulls)}; GML has no null, the key is omitted`
-    );
-    counted(
-      stats.arrays,
-      JSON_ARRAY_CODE,
-      `${where} holds arrays as values in ${rowCount(stats.arrays)}; written as repeated keys, they re-import as a list`
-    );
-    counted(
-      stats.nestedArrays,
-      NESTED_ARRAY_CODE,
-      `${where} holds arrays nested in arrays in ${rowCount(stats.nestedArrays)}; GML cannot write them and the save fails`
-    );
-    const keys = `${stats.invalidKeys} record key${plural(stats.invalidKeys)} ${agree(stats.invalidKeys, "is", "are")} not GML keys`;
-    counted(
-      stats.invalidKeys,
-      plan.mangle ? KEY_MANGLED_CODE : INVALID_KEY_CODE,
-      plan.mangle ? `${where}: ${keys} and are rewritten` : `${where}: ${keys}; the save fails unless sanitizeKeys is "mangle"`
-    );
-  }
-}
-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${plural(overridden)} ${agree(overridden, "has", "have")} x / y / z keys the position column replaces`,
-        "graphics",
-        overridden
-      )
-    );
-  }
-  if (conflicts > 0) {
-    notes.push(
-      note(
-        GRAPHICS_CONFLICT_CODE,
-        `${conflicts} node graphics value${plural(conflicts)} ${agree(conflicts, "is", "are")} not records and cannot hold the position; the save fails`,
-        "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 edge weights 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${plural(folding.mutualCount)} ${agree(folding.mutualCount, "is", "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 numberText(value, meta) {
-  switch (meta.dtype) {
-    case "i32":
-    case "u32":
-    case "u8":
-      return formatInteger(value);
-    case "f32":
-      return formatGmlReal(value, "f32");
-    default:
-      if (meta.origin?.type === "int" && Number.isInteger(value)) {
-        return formatInteger(value);
-      }
-      return formatGmlReal(value, "f64");
-  }
-}
-function jsonScalarText(value) {
-  switch (typeof value) {
-    case "number":
-      return Number.isInteger(value) ? formatInteger(value) : formatGmlReal(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 formatGmlReal(item, "f32");
-        case "json":
-          return jsonScalarText(item);
-        default:
-          return meta.origin?.type === "int" && Number.isInteger(item) ? formatInteger(item) : formatGmlReal(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${plural(mixed)} in a directed graph, and GML holds one direction per file, so the save fails unless onMixedDirection is "directed" or "undirected"`,
-      {
-        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) : formatGmlReal(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?.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?.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) : formatGmlReal(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?.isSet(i) === true;
-  const graphicsValue = 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",
-  options: Object.freeze(["sanitizeKeys", "weightKey"]),
-  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 = MULTIPLE_GRAPHS_CODE;
-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 STRING_ID_CODE = "W_GML_STRING_ID";
-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 QUOTED_INT = /^\s*[+-]?\d+\s*$/;
-const UNKNOWN_ENTITY_CODE = "W_GML_UNKNOWN_ENTITY";
-const GRAPHICS_CODE = "W_GML_GRAPHICS";
-const NESTED_ELEMENT_CODE = "W_GML_NESTED_ELEMENT";
-const GROUPS_CODE = "W_GML_GROUPS";
-const WIDENED_CODE = WIDENED_CODE$1;
-const PRECISION_CODE = PRECISION_CODE$1;
-const COLUMN_RENAMED_CODE_GML = COLUMN_RENAMED_CODE;
-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",
-  "long",
-  "errorLimit",
-  "signal",
-  "onProgress"
-]);
-const GRAPH_SEQ = -1;
-const TOP_SEQ = -2;
-function isLabel(domain, key) {
-  return roleOf(domain, key) === "label";
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-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
-   * @param which - which `graph [ ... ]` block to read (0: the first)
-   */
-  constructor(sink, report, options, format, which = 0) {
-    this.which = which;
-    this.tokens = null;
-    this.graphCount = 0;
-    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.skippedIds = /* @__PURE__ */ new Set();
-    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.keepPositionSource = format?.keepPositionSource ?? false;
-    this.dictionaries = format?.dictionaries ?? true;
-    this.coercer = new IdCoercer(options.ids);
-  }
-  /**
-   * Run the import over the tokens of a text.
-   * @param tokens - the whole text, tokenized (tokenize())
-   */
-  run(tokens) {
-    this.tokens = tokens;
-    tokens.onUnknownEntity = (entity, line) => {
-      this.report.warnOnce(
-        "parse-error",
-        UNKNOWN_ENTITY_CODE,
-        `character entity ${entity} cannot be decoded; it is kept as written`,
-        { line, element: entity },
-        `${UNKNOWN_ENTITY_CODE}:${entity}`
-      );
-    };
-    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();
-    let scalarGraph = -1;
-    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 && scalarGraph < 0) {
-        scalarGraph = v;
-      }
-      this.scanTopPair(key, record, v);
-    }
-    if (this.graphOpen < 0) {
-      this.failNoGraph(t, scalarGraph);
-    }
-  }
-  /**
-   * Handle one top-level pair other than a scalar `graph`.
-   * @param key - the key
-   * @param record - whether the value is a `[ ... ]` block
-   * @param v - the value token
-   */
-  scanTopPair(key, record, v) {
-    if (key === "graph" && record) {
-      if (this.graphCount++ === this.which) {
-        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);
-    }
-  }
-  /**
-   * Fail because the input holds no graph block.
-   * @param t - the tokens
-   * @param scalarGraph - the token of a scalar `graph` key, or -1
-   */
-  failNoGraph(t, scalarGraph) {
-    if (scalarGraph >= 0) {
-      this.report.fail(
-        NO_GRAPH_CODE,
-        `the graph key at line ${t.line[scalarGraph]} holds ${describeValue(t, scalarGraph)}, not a [ ... ] block; the input contains no graph block`,
-        { line: t.line[scalarGraph] }
-      );
-    }
-    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;
-    for (let p = open + 1; p < close; p = t.nextPair(p)) {
-      const key = t.textOf(p);
-      const v = p + 1;
-      if (this.skipsKey(domain, key, v)) {
-        continue;
-      }
-      this.observe(schema, domain, key, v, seq);
-    }
-  }
-  /**
-   * Whether a key of a node or edge block is structural (id, endpoints, weight, original id), not
-   * a column; notes the original id and the weight's kinds on the way.
-   * @param domain - node or edge
-   * @param key - the key
-   * @param v - the value token
-   * @returns true when the key is not a column
-   */
-  skipsKey(domain, key, v) {
-    const { weightFrom, restoreMangledIds } = this.options;
-    if (domain === "node") {
-      if (key === ORIGINAL_ID_KEY && restoreMangledIds) {
-        this.hasOriginalId = true;
-        return true;
-      }
-      return key === "id";
-    }
-    if (key === "source" || key === "target" || key === "directed") {
-      return true;
-    }
-    if (key === weightFrom) {
-      this.weightKinds |= kindBit(this.requireTokens(), v);
-      return true;
-    }
-    return false;
-  }
-  /**
-   * 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();
-    this.noteStructure(domain, key, v);
-    let entry = schema.get(key);
-    const graphics = domain === "node" && key === "graphics" && this.positions;
-    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;
-      entry.rest ||= graphics;
-    } else {
-      entry.lastSeq = seq;
-    }
-    if (graphics && t.kind[v] !== TOKEN_OPEN) {
-      entry.rest = true;
-    }
-    switch (t.kind[v]) {
-      case TOKEN_STRING: {
-        const raw = t.textOf(v);
-        if (raw === LIST_START_MARKER || !isLabel(domain, key) && (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;
-        const text = t.textOf(v);
-        if (/\d/.test(text) && !Number.isFinite(Number(text))) {
-          this.report.warnOnce(
-            "precision",
-            PRECISION_CODE,
-            `${domain} key "${key}" holds the real ${text}, beyond the f64 range; it is stored as ${numberOfText(text) > 0 ? "" : "-"}Infinity`,
-            { line: t.line[v], element: key },
-            `${PRECISION_CODE}:overflow:${domain}:${key}`
-          );
-        }
-      }
-    }
-  }
-  /**
-   * Warn about keys of a node or edge whose meaning GML readers give but this import does not:
-   * a nested graph / node / edge record, and yEd's group hierarchy.
-   * @param domain - the table
-   * @param key - the key
-   * @param v - the value token
-   */
-  noteStructure(domain, key, v) {
-    const t = this.requireTokens();
-    if (domain === "graph") {
-      return;
-    }
-    if ((key === "graph" || key === "node" || key === "edge") && t.kind[v] === TOKEN_OPEN) {
-      this.report.warnOnce(
-        "unsupported",
-        NESTED_ELEMENT_CODE,
-        `a nested ${key} record inside a ${domain} is kept as the json column "${key}"; it is not read as structure`,
-        { line: t.line[v], element: key },
-        `${NESTED_ELEMENT_CODE}:${domain}:${key}`
-      );
-    } else if (domain === "node" && (key === "isGroup" || key === "gid")) {
-      this.report.warnOnce(
-        "unsupported",
-        GROUPS_CODE,
-        "yEd group keys (isGroup, gid) are kept as plain node columns; the group hierarchy is not read as containment",
-        { line: t.line[v], element: key }
-      );
-    }
-  }
-  /**
-   * 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 || this.keepPositionSource : 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));
-    }
-  }
-  /**
-   * Warn about a key that mixes numbers and strings, or holds integers beyond 2^53.
-   * @param domain - the table
-   * @param entry - the schema entry
-   * @param asText - whether the integers are kept as text
-   */
-  warnKinds(domain, entry, asText) {
-    if ((entry.kinds & KIND_STRING) !== 0 && (entry.kinds & (KIND_INT | KIND_REAL)) !== 0 && (entry.kinds & KIND_RECORD) === 0) {
-      this.report.warnOnce(
-        "coercion",
-        WIDENED_CODE,
-        `${domain} key "${entry.key}" mixes numbers and strings; the column is string and the numbers are kept as written`,
-        { element: entry.key },
-        `${WIDENED_CODE}:${domain}:${entry.key}`
-      );
-    }
-    if (entry.unsafe && !asText) {
-      this.report.warnOnce(
-        "precision",
-        PRECISION_CODE,
-        `${domain} key "${entry.key}" holds integers beyond 2^53; they are stored as the nearest f64 (pass long: "string" to keep every digit as text)`,
-        { element: entry.key },
-        `${PRECISION_CODE}:${domain}:${entry.key}`
-      );
-    }
-  }
-  /**
-   * The plan of a node `graphics` record: the plan plus its position and rest columns.
-   * @param plan - the record's plan
-   * @param entry - the schema entry
-   * @returns the plan with its position (and rest) plans
-   */
-  graphicsPlan(plan, entry) {
-    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",
-      list: false,
-      role: "position"
-    };
-    const rest = entry.rest ? { ...plan, dtype: "json", itemDtype: null, kind: "record", list: false } : null;
-    return { ...plan, position, rest };
-  }
-  /**
-   * 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 asText = entry.unsafe && this.options.long === "string" && kindOf(entry) === "int";
-    const kind = asText ? "string" : 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";
-    }
-    this.warnKinds(domain, entry, asText);
-    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" && this.positions && (entry.kinds & KIND_RECORD) !== 0) {
-      return this.graphicsPlan(plan, entry);
-    }
-    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);
-    if (name !== key) {
-      this.report.warning(
-        "coercion",
-        COLUMN_RENAMED_CODE_GML,
-        `the top-level key "${key}" and a key of the graph block share the graph column name; the top-level value is stored as "${name}"`,
-        { element: key }
-      );
-    }
-    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,
-      // The header as written, so a reader can say which words set the direction and tell
-      // `directed 0` from a file that relies on the specification's default.
-      extra: this.directedToken >= 0 ? { gml: { directed: textOf(this.directedToken) } } : 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();
-    const quoted = t.kind[v] === TOKEN_STRING && QUOTED_INT.test(t.stringOf(v));
-    if (quoted) {
-      this.report.warning(
-        "validation-error",
-        FLAG_VALUE_CODE,
-        `flag "${name}" is written as the string ${describeValue(t, v)}; read as an integer`,
-        { line: t.line[v], element: name }
-      );
-    } else if (t.kind[v] !== TOKEN_INT) {
-      this.report.error(
-        "validation-error",
-        FLAG_TYPE_CODE,
-        `flag "${name}" must be the integer 0 or 1, found ${describeValue(t, v)}`,
-        { line: t.line[v], element: name }
-      );
-      return null;
-    }
-    const n = Number(quoted ? t.stringOf(v) : t.textOf(v));
-    if (n !== 0 && n !== 1) {
-      this.report.warning(
-        "validation-error",
-        FLAG_VALUE_CODE,
-        `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;
-    let fileId;
-    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" });
-      }
-      fileId = this.coerceFileId(idTok, this.fileIdOf(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 = fileId;
-        }
-      }
-      index = sink.addNode(sinkId);
-      if (this.idMap !== null) {
-        const before = this.idMap.get(fileId);
-        if (before !== void 0 && before !== sinkId) {
-          report.warning(
-            "merged",
-            DUPLICATE_NODE_CODE,
-            `file id ${JSON.stringify(fileId)} is declared twice (nodes ${JSON.stringify(before)} and ${JSON.stringify(sinkId)}); edges to it resolve to the later`,
-            { line, element: String(fileId) }
-          );
-        }
-        this.idMap.set(fileId, sinkId);
-      }
-    } catch (err) {
-      this.recordNodeError(err, line);
-      report.counts.skippedNodes++;
-      if (fileId !== void 0) {
-        this.skippedIds.add(fileId);
-      }
-      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 {
-      const graphics = [];
-      let graphicsPlan = null;
-      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 && plan.position !== null) {
-          graphicsPlan = plan;
-          graphics.push(p + 1);
-        } else if (plan !== void 0) {
-          this.writeNode(plan, index, p + 1);
-        }
-      }
-      if (graphicsPlan !== null) {
-        this.writeGraphics(graphicsPlan, index, graphics, {
-          line: t.line[graphics[0]],
-          element: String(sinkId)
-        });
-      }
-      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;
-      let directedTok = -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 === "directed") {
-          directedTok = this.structuralToken(directedTok, p, "directed");
-        } 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;
-      const directed = this.readFlag(directedTok, "directed") ?? this.headerDirected;
-      edge = this.requireResolver().addEdge(source, target, directed ? "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 === "directed" || 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 value of an id / source / target token: an integer (the GML spec's type) as a number, a
-   * string (NetworkX and Gephi write them) as its text with one warning per file.
-   * @param v - the value token
-   * @param key - the key name, for the error
-   * @returns the number or the string
-   */
-  fileIdOf(v, key) {
-    const t = this.requireTokens();
-    if (t.kind[v] === TOKEN_STRING) {
-      this.report.warnOnce(
-        "validation-error",
-        STRING_ID_CODE,
-        `${key} is the string "${t.textOf(v)}"; GML ids are integers, string ids are kept under the ids rule`,
-        { line: t.line[v], element: t.stringOf(v) }
-      );
-      return t.stringOf(v);
-    }
-    if (t.kind[v] !== TOKEN_INT) {
-      throw new GraphFormatError(
-        "E_INVALID_ID",
-        `${key} must be an integer or a string, 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 id / source / target value under the `ids` rule: a string by its text, an integer
-   * through coerceInteger().
-   * @param v - the value token
-   * @param id - its value (fileIdOf())
-   * @returns the id
-   */
-  coerceFileId(v, id) {
-    return typeof id === "string" ? this.coercer.text(id) : this.coerceInteger(v, id);
-  }
-  /**
-   * 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 id = this.coerceFileId(v, this.fileIdOf(v, key));
-    const mapped = this.idMap?.get(id);
-    if (mapped !== void 0) {
-      return mapped;
-    }
-    if (this.skippedIds.has(id)) {
-      throw new GraphFormatError(
-        "E_UNKNOWN_NODE",
-        `${key} ${JSON.stringify(id)} names a node block that was skipped after an error`,
-        { reason: "skipped node", id }
-      );
-    }
-    return id;
-  }
-  /**
-   * 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), this.report);
-      case TOKEN_OPEN:
-        throw new GraphFormatError("E_INVALID_WEIGHT", "edge weight is a record", { value: "[...]" });
-      default: {
-        const text = t.textOf(v);
-        const weight = weightFromValue(numberOfText(text));
-        if (weight !== void 0) {
-          reportWeightPrecision(text, weight, this.report);
-        }
-        return weight;
-      }
-    }
-  }
-  /**
-   * 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.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;
-    }
-    const value = this.scalarOf(plan, v);
-    this.sink.setGraphValue(plan.name, value, graphDecl(plan));
-    if (seq === GRAPH_SEQ && plan.key === "name" && typeof value === "string") {
-      this.sink.setMeta({ name: value });
-    }
-  }
-  /**
-   * Write a node's graphics values: the position column from the x / y / z of the first record,
-   * everything else (the remaining keys, a value that is not a record, a repeated record) to the
-   * json column, with a warning when the value cannot give a position as written.
-   * @param plan - the graphics plan
-   * @param index - the node index
-   * @param vs - the value tokens of the node's graphics keys, in order
-   * @param where - the line and the node, for issues
-   */
-  writeGraphics(plan, index, vs, where) {
-    const t = this.requireTokens();
-    const { sink } = this;
-    const values = vs.map((v) => t.kind[v] === TOKEN_OPEN ? parseRecord(t, v) : this.scalarOf(plan, v));
-    const first = values[0];
-    const positionPlan = plan.position;
-    let rest = first;
-    if (isRecord(first) && positionPlan !== null) {
-      const left = this.writePosition(positionPlan, index, this.keepPositionSource ? { ...first } : first, where);
-      rest = this.keepPositionSource ? first : left;
-    } else if (!isRecord(first)) {
-      this.graphicsWarning("scalar", `node ${where.element}'s graphics is not a record`, where);
-    }
-    if (values.length > 1) {
-      this.graphicsWarning(
-        "repeated",
-        `node ${where.element} has ${values.length} graphics records; the position comes from the first`,
-        where
-      );
-      rest = values;
-    }
-    if (rest !== void 0 && plan.rest !== null) {
-      sink.setNodeValue(this.handleOf(plan.rest, "node"), index, rest);
-    }
-  }
-  /**
-   * Write a node's position from the x / y / z of its graphics record, taking them out of it.
-   * @param positionPlan - the position column's plan
-   * @param index - the node index
-   * @param record - the graphics record
-   * @param where - the line and the node, for issues
-   * @returns what is left of the record for the json column, or undefined when nothing is
-   */
-  writePosition(positionPlan, index, record, where) {
-    const { x, y, z } = record;
-    let rest = record;
-    if (typeof x === "number" && typeof y === "number") {
-      const depth = typeof z === "number" ? z : 0;
-      this.sink.setNodeValue(this.handleOf(positionPlan, "node"), index, [x, y, depth]);
-      delete record.x;
-      delete record.y;
-      if (typeof z === "number") {
-        delete record.z;
-      }
-      rest = Object.keys(record).length > 0 ? record : void 0;
-    }
-    if ("x" in record || "y" in record || "z" in record) {
-      this.graphicsWarning(
-        "coordinate",
-        `node ${where.element}'s graphics x / y / z is not one number each`,
-        where
-      );
-    }
-    return rest;
-  }
-  /**
-   * Warn once per kind of graphics problem.
-   * @param kind - the problem
-   * @param what - the message start, naming the node
-   * @param where - the line and the node
-   */
-  graphicsWarning(kind, what, where) {
-    this.report.warnOnce(
-      "validation-error",
-      GRAPHICS_CODE,
-      `${what}; the value is kept in the graphics json column (warned once for every such node)`,
-      where,
-      `${GRAPHICS_CODE}:${kind}`
-    );
-  }
-  /**
-   * 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_]\w*\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",
-  options: Object.freeze(["dictionaries", "keepPositionSource", "positions"]),
-  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) {
-    if (graphChosen(options)) {
-      return importChosenGraph(gmlImporter, 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 tokens = tokenize(await readText(input, report, resolved), report);
-    throwIfAborted(resolved.signal);
-    const gml = new GmlImport(sink, report, resolved, options);
-    gml.run(tokens);
-    if (gml.graphCount > 1) {
-      report.warning(
-        "unsupported",
-        SECOND_GRAPH_CODE,
-        `the input holds ${gml.graphCount - 1} more graph block${plural(gml.graphCount - 1)} after the first; the first is read (graphIndex or graphName chooses another; importAllGraphs() reads every one)`
-      );
-    }
-    throwIfAborted(resolved.signal);
-    return report.finish();
-  },
-  /**
-   * Read every `graph [ ... ]` block of a GML text, each into its own sink; the top-level keys
-   * (Creator, Version, ...) apply to each.
-   * @param input - the text, bytes or stream
-   * @param sinkFor - the sink of the graph with this index, called before its first push
-   * @param options - format-specific and common options
-   * @returns one report per graph block
-   */
-  async importAll(input, sinkFor, options) {
-    const resolved = resolveImportOptions(options, FORMAT_DEFAULTS);
-    const first = new ImportReportBuilder("gml", resolved.errorLimit);
-    reportUnusedOptions(options, first, USED_OPTIONS);
-    const tokens = tokenize(await readText(input, first, resolved), first);
-    const reports = [];
-    let count = 1;
-    for (let i = 0; i < count; i++) {
-      throwIfAborted(resolved.signal);
-      const report = i === 0 ? first : new ImportReportBuilder("gml", resolved.errorLimit);
-      const sink = sinkFor(i);
-      reportSinkOptions(sink, options, report);
-      const gml = new GmlImport(sink, report, resolved, options, i);
-      gml.run(tokens);
-      count = gml.graphCount;
-      reports.push(report.finish());
-    }
-    throwIfAborted(resolved.signal);
-    return reports;
-  }
-});
-function tokenize(text, report) {
-  try {
-    return tokenizeGml(text);
-  } catch (err) {
-    if (err instanceof GmlSyntaxError) {
-      report.fail(err.code, err.message, { line: err.line });
-    }
-    throw err;
-  }
-}
-const GML_ISSUE = Object.freeze({
-  ...INPUT_ISSUE,
-  ...ELEMENT_ISSUE,
-  /**
-   * The text breaks GML's syntax: a word that is not a key or a value, an unclosed string or `[`, a stray `]`, or a
-   * key without a value. The import stops.
-   */
-  SYNTAX: SYNTAX_CODE,
-  /** The input is not valid UTF-8. The import stops. */
-  INVALID_UTF8: INVALID_UTF8_CODE,
-  /**
-   * Some bytes are not valid in the encoding that was chosen (by a byte order mark, the file's declaration or the
-   * `encoding` option). The import stops.
-   */
-  INVALID_ENCODING: INVALID_ENCODING_CODE,
-  /** Bytes that are not UTF-8 and declare no encoding were read as windows-1252. */
-  ENCODING_FALLBACK: ENCODING_FALLBACK_CODE,
-  /** A declared encoding the platform cannot decode was ignored. */
-  UNKNOWN_ENCODING: UNKNOWN_ENCODING_CODE,
-  /** There is no `graph [` block. The import stops. */
-  NO_GRAPH: NO_GRAPH_CODE,
-  /** The file holds more than one `graph` block and only the first was read. It is not added when `graphIndex` or `graphName` chose the graph. */
-  MULTIPLE_GRAPHS: SECOND_GRAPH_CODE,
-  /** `graphIndex` or `graphName` names no graph of the file; the message lists the graphs it holds. The import stops. */
-  GRAPH_NOT_FOUND: GRAPH_NOT_FOUND_CODE,
-  /** `graphName` matches more than one graph; pass `graphIndex`. The import stops. */
-  AMBIGUOUS_GRAPH_NAME: AMBIGUOUS_GRAPH_NAME_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 neither an integer nor a string. */
-  ID_TYPE: ID_TYPE_CODE,
-  /**
-   * Node ids, sources or targets are text, where GML expects integers. They are read under the `ids` option.
-   * Reported once per file.
-   */
-  STRING_ID: STRING_ID_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,
-  /** A named entity no table decodes, or a numeric reference beyond U+10FFFF; kept as written. */
-  UNKNOWN_ENTITY: UNKNOWN_ENTITY_CODE,
-  /** An integer beyond 2^53 was stored as the nearest 64-bit float; pass `long: "string"` to keep every digit. */
-  PRECISION: PRECISION_CODE,
-  /** A node's graphics value that cannot give a position as written; kept in the graphics json column. */
-  GRAPHICS: GRAPHICS_CODE,
-  /** A graph, node or edge record nested in a node or edge; kept as json, not read as structure. */
-  NESTED_ELEMENT: NESTED_ELEMENT_CODE,
-  /** YEd's isGroup / gid keys, kept as plain columns; the hierarchy is not read as containment. */
-  GROUPS: GROUPS_CODE,
-  /**
-   * An attribute's type was widened because a later value did not fit: an integer above 2^31 in an integer column,
-   * or two declared types for one attribute.
-   */
-  WIDENED: WIDENED_CODE,
-  /**
-   * An attribute was renamed `<name>#<suffix>` because another attribute already has its name, for example
-   * two attributes declared with the same name.
-   */
-  COLUMN_RENAMED: COLUMN_RENAMED_CODE,
-  /**
-   * You read into a graph builder that already has an id, label or position attribute, so this file's one is kept as
-   * a plain attribute.
-   */
-  ROLE_TAKEN: ROLE_TAKEN_CODE,
-  /** Two different id texts became the same number because `ids` is "number", so their nodes were merged. */
-  ID_MERGED: ID_MERGED_CODE,
-  /** You set an option this format does not use; it had no effect. The message names the option. */
-  OPTION_IGNORED: OPTION_IGNORED_CODE,
-  /**
-   * You read into your own graph builder, which was created with a different `addMissingNodes`, `duplicateEdges`,
-   * `selfLoops` or `weightDtype` than the option you passed; the builder's setting applies.
-   */
-  SINK_OPTION: SINK_OPTION_CODE,
-  /**
-   * You read into a graph builder whose direction is already set, or which already holds edges, so the file is read
-   * with the builder's direction instead of its own.
-   */
-  DIRECTION_REFUSED: DIRECTION_REFUSED_CODE,
-  /** Edges of the other direction were read with the direction `onMixedDirection` chose. */
-  DIRECTION_FORCED: DIRECTION_FORCED_CODE,
-  /**
-   * The graph has both directed and undirected edges and `onMixedDirection` is "error". An import stops; a save to a
-   * format that holds one direction per file fails with E_DIRECTED. Pass "directed" or "undirected" to read or write
-   * it anyway.
-   */
-  MIXED_DIRECTION: MIXED_DIRECTION_CODE,
-  /**
-   * Under `nodeIdFrom: "label"` or `"index"` the file's integer ids are not kept. It is listed in `report.lossy`, not
-   * in `report.issues`.
-   */
-  ID_DROPPED: ID_DROPPED_CODE
-});
-const GML_LOSS = Object.freeze({
-  /** A json column holds numbers; GML records cannot keep int versus real. */
-  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 attribute holds an array inside an array, which GML cannot write; the save fails. */
-  NESTED_ARRAY: NESTED_ARRAY_CODE,
-  /** A json row that is an array, written as repeated keys. */
-  JSON_ARRAY: JSON_ARRAY_CODE,
-  /**
-   * An attribute name GML cannot use as a key (keys are letters and digits, starting with a letter). The save fails
-   * unless `sanitizeKeys` is "mangle".
-   */
-  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
-});
+import "./chunks/format-GDmO6m6Q.js";
+import { G, b, c, d, a, g } from "./chunks/index-B9fdNpTA.js";
 export {
-  GML_ISSUE,
-  GML_LOSS,
-  gmlExporter,
-  gmlImporter
+  G as GML_ISSUE,
+  b as GML_LOSS,
+  c as GML_STYLE_BLOCK_KEY,
+  d as GML_STYLE_CAPABILITIES,
+  a as gmlExporter,
+  g as gmlImporter
 };
 //# sourceMappingURL=gml.js.map