@graphty/graph-io 0.3.42 → 0.3.44

package/dist/chunks/index-B9fdNpTA.js

@@ -0,0 +1,4310 @@
+import { p as plural, V as agree, a8 as SYNTAX_CODE, ad as formatInteger, aP as formatGmlReal, R as ROLE_TAKEN_CODE$1, a7 as WIDENED_CODE$1, P as PRECISION_CODE$1, j as DUPLICATE_NODE_CODE$1, m as MISSING_ENDPOINT_CODE$1, n as MISSING_ID_CODE$1, h as MULTIPLE_GRAPHS_CODE, N as NO_GRAPH_CODE$1, Z as ImportReportBuilder, C as COLUMN_RENAMED_CODE, M as MIXED_DIRECTION_CODE, D as DIRECTION_FORCED_CODE, a as DIRECTION_REFUSED_CODE, S as SINK_OPTION_CODE, O as OPTION_IGNORED_CODE, I as ID_MERGED_CODE, a2 as AMBIGUOUS_GRAPH_NAME_CODE, a3 as GRAPH_NOT_FOUND_CODE, r as UNKNOWN_ENCODING_CODE, s as ENCODING_FALLBACK_CODE, t as INVALID_ENCODING_CODE, u as INVALID_UTF8_CODE, x as ELEMENT_ISSUE, y as INPUT_ISSUE } from "./format-GDmO6m6Q.js";
+import { GraphFormatError, INVALID_INDEX } from "@graphty/graph-format";
+import { c as capabilities, a as checkCapabilities, L as LOSS, p as pairFolding, G as sanitizeIds, ai as countMixedEdges, e as explicitWeights, r as resolveExportOptions, D as DictHeuristic, ag as DICT_SAMPLE_ROWS, g as resolveImportOptions, i as reportUnusedOptions, ab as readText, h as throwIfAborted, j as reportSinkOptions, k as graphChosen, I as IdCoercer, l as DirectionResolver, u as uniqueColumnName, w as weightFromValue, al as reportWeightPrecision, s as parseWeightText, d as declareResolved } from "./export-D7IGzTG4.js";
+import { o as decodeGmlString, p as quoteGmlString } from "./escape-B1rMftd9.js";
+import { j as joinText, e as encodeChunks } from "./writer-DxjgHwSe.js";
+import { d as yedValue, f as yedColor, h as yedSpelled, j as bendsToPoints, Y as YED_SHAPES, k as YED_LINES, v as valueColumns, m as canonBends, n as flowchartShape, F as FONT_STYLES, o as YED_ARROWS } from "./styles-yed-DAfcIkf7.js";
+import { k as styleFingerprint, a as STYLE_ISSUE, R as styleTag, x as writeStyleBlock, y as styleBlockLosses, r as resolveStyles, S as STYLE_BLOCK_NAME, O as canonicalFor, U as degreeValues, Q as dataCell, m as plainCell, j as StyleNotes, p as parseStyleBlock, l as blockStyles, h as canonText, b as canonNumber, f as canonEnum, n as noteAt, M as MAX_STYLE_VALUE_LENGTH, c as canonColor, o as colorOpacity, s as scalarText } from "./block-JQiwViEt.js";
+import { C as CYTOSCAPE_LEXICON } from "./lexicon-B-knUi-l.js";
+import { S as StyleApproximations } from "./approximations-3Q4TsdTh.js";
+import { r as gephiRules } from "./styles-Brt9JMfs.js";
+import { i as importChosenGraph } from "./choose-BemygfH8.js";
+import { t as toolOf } from "./units-XMZFIFe1.js";
+import { m as median } from "./convert-BcQ8_jMo.js";
+const STYLE_ROLES = /* @__PURE__ */ new Set(["color", "size", "shape", "thickness", "hidden"]);
+const TARGETS = ["node", "edge"];
+function prepareStyleExport(snapshot, exporter, given, plain) {
+  const fp = styleFingerprint(snapshot);
+  const want = given.fingerprint;
+  if (fp.nodes !== want.nodes || fp.edges !== want.edges || fp.ids !== want.ids) {
+    return {
+      snapshot,
+      input: null,
+      notes: [],
+      refusal: Object.freeze({
+        code: STYLE_ISSUE.MISMATCH,
+        message: `the styles were read from or built for a different graph (${String(want.nodes)} nodes and ${String(want.edges)} edges, this graph has ${String(fp.nodes)} and ${String(fp.edges)}, or other node ids); nothing is written`,
+        column: null,
+        count: null
+      })
+    };
+  }
+  const caps = exporter.styles?.capabilities ?? null;
+  let plan = writePlan(snapshot, exporter, given);
+  if (keepsStyleBlock(exporter)) {
+    let checked;
+    try {
+      checked = exporter.check(plan.snapshot, plan.input === null ? plain : { ...plain, styles: plan.input });
+    } catch {
+      checked = [];
+    }
+    const carried = withLostInputsCarried(given, snapshot, checked);
+    if (carried !== given) {
+      plan = writePlan(snapshot, exporter, carried);
+    }
+  }
+  return {
+    snapshot: plan.snapshot,
+    input: plan.input,
+    notes: lossNotes(plan.extracted, exporter, caps, plan.picture, snapshot),
+    refusal: null
+  };
+}
+function writePlan(snapshot, exporter, extracted) {
+  const caps = exporter.styles?.capabilities ?? null;
+  const pictures = /* @__PURE__ */ new Map();
+  const picture = (target, property) => {
+    const key = `${target}\0${property}`;
+    let values = pictures.get(key);
+    if (values === void 0) {
+      values = resolveStyles(extracted, target, property, snapshot);
+      pictures.set(key, values);
+    }
+    return values;
+  };
+  const tags = { node: /* @__PURE__ */ new Map(), edge: /* @__PURE__ */ new Map() };
+  for (const target of TARGETS) {
+    for (const [key, col] of extracted.columns[target]) {
+      tags[target].set(styleTag(target, key), col);
+    }
+  }
+  const block = writeStyleBlock(extracted, { snapshot });
+  return {
+    snapshot: styledSnapshot(snapshot, caps, tags, block, extracted.styles.rules),
+    input: exporter.styles === void 0 ? null : { picture, block, tags, rules: extracted },
+    extracted,
+    picture
+  };
+}
+const VALUES_KEPT = /NODE_TABLE|NAME_CHANGED|ROLE_ASSUMED|STORAGE_CLASS|NUMBER_TYPE|INTEGRAL|WIDENED/;
+function withLostInputsCarried(extracted, snapshot, notes) {
+  const lost = /* @__PURE__ */ new Set();
+  let direction = false;
+  for (const note2 of notes) {
+    if (!VALUES_KEPT.test(note2.code)) {
+      for (const name of note2.columns ?? (note2.column === null ? [] : [note2.column])) {
+        lost.add(name);
+      }
+    }
+    direction ||= /DIRECTION/.test(note2.code);
+  }
+  const carrier = new LostInputs(snapshot, lost, direction, extracted.columns);
+  const rules = extracted.styles.rules.map((rule) => carrier.carry(rule));
+  const changed = rules.some((rule, i) => rule !== extracted.styles.rules[i]);
+  return changed ? { ...extracted, styles: { ...extracted.styles, rules }, columns: carrier.columns } : extracted;
+}
+class LostInputs {
+  /**
+   * A carrier for one export.
+   * @param snapshot - the graph
+   * @param lost - the data columns the export drops or changes
+   * @param direction - whether the file loses the edges' direction (and so the in and out degrees)
+   * @param columns - the styles' own style columns
+   * @param columns.node - the node columns
+   * @param columns.edge - the edge columns
+   */
+  constructor(snapshot, lost, direction, columns) {
+    this.snapshot = snapshot;
+    this.lost = lost;
+    this.direction = direction;
+    this.touched = false;
+    this.columns = { node: new Map(columns.node), edge: new Map(columns.edge) };
+  }
+  /**
+   * A rule with every lost input it reads replaced by a copy of its values.
+   * @param rule - the rule
+   * @returns the rule read from copies, or the rule itself when it reads no lost input
+   */
+  carry(rule) {
+    this.touched = false;
+    const { ext, ...given } = rule;
+    const map = this.carryMap(rule);
+    const where = this.walk(rule, given.where);
+    if (!this.touched) {
+      return rule;
+    }
+    const { map: _given, ...unmapped } = given;
+    const plain = Object.keys(map).length === 0 ? { ...unmapped, where } : { ...unmapped, where, map };
+    const moved = JSON.parse(JSON.stringify(plain));
+    return ext === void 0 ? moved : { ...moved, ext };
+  }
+  /**
+   * A rule's mappings with their lost inputs replaced. A passthrough reads a data column as the property's value: its
+   * copy holds those values; one that gives no element a value (a list, text that is not a color) is left out, so
+   * no other value the file reads back in the column (a list written as text) is given either.
+   * @param rule - the rule
+   * @returns the mappings
+   */
+  carryMap(rule) {
+    const map = /* @__PURE__ */ Object.create(null);
+    const { table } = this.tableOf(rule.target);
+    for (const [property, mapping] of Object.entries(rule.map ?? {})) {
+      if (mapping === void 0) {
+        continue;
+      }
+      if (mapping.kind !== "passthrough") {
+        map[property] = this.walk(rule, mapping);
+        continue;
+      }
+      const name = mapping.by.data;
+      const lostColumn = typeof name === "string" && this.lost.has(name) && table.has(name);
+      const values = lostColumn ? this.cells(rule.target, name, canonicalFor(rule.target, property)) : null;
+      if (values !== null && !values.some((v) => v !== null)) {
+        this.touched = true;
+      } else if (values !== null && this.isLost(rule.target, name)) {
+        this.touched = true;
+        map[property] = { ...mapping, by: this.copy(rule.target, `${property}.data.${name}`, () => values) };
+      } else {
+        map[property] = mapping;
+      }
+    }
+    return map;
+  }
+  /**
+   * A value with every other reference to a lost input reading a copy of its values as they are.
+   * @param rule - the rule it belongs to
+   * @param value - the value
+   * @returns the value, references replaced
+   */
+  walk(rule, value) {
+    return JSON.parse(JSON.stringify(value, (_k, v) => this.replaced(rule, v)));
+  }
+  /**
+   * One reference with a lost input replaced by its copy: a data column, or a degree the file does not keep.
+   * @param rule - the rule it belongs to
+   * @param v - a value of the rule
+   * @returns the value, or the reference to the copy
+   */
+  replaced(rule, v) {
+    if (typeof v !== "object" || v === null || Array.isArray(v) || Object.keys(v).length !== 1) {
+      return v;
+    }
+    const ref = v;
+    if (this.isLost(rule.target, ref.data)) {
+      const name = ref.data;
+      this.touched = true;
+      return this.copy(
+        rule.target,
+        `data.${name}`,
+        () => this.cells(rule.target, name, (raw) => isStyleScalar(raw) ? raw : null)
+      );
+    }
+    const which = ref.computed;
+    if ((which === "indegree" || which === "outdegree") && this.direction && rule.target === "node") {
+      this.touched = true;
+      return this.copy(rule.target, `computed.${which}`, () => degreeValues(this.snapshot, which));
+    }
+    return v;
+  }
+  /**
+   * The reference to a copy of an input, made on first use and shared by every rule that reads it.
+   * @param target - nodes or edges
+   * @param base - what is copied
+   * @param values - its values
+   * @returns the reference
+   */
+  copy(target, base, values) {
+    const key = `input.${base}`;
+    const held = this.columns[target];
+    if (!held.has(key)) {
+      held.set(key, values());
+    }
+    return { style: key };
+  }
+  /**
+   * Whether a name is a lost input that can be copied: only a column of plain values can, and a list, or a column with
+   * no value, stays as it is.
+   * @param target - nodes or edges
+   * @param name - the name
+   * @returns true for a lost input
+   */
+  isLost(target, name) {
+    const { table, n } = this.tableOf(target);
+    return typeof name === "string" && this.lost.has(name) && table.has(name) && carriable(table, n, name);
+  }
+  /**
+   * Every element's value of a data column.
+   * @param target - nodes or edges
+   * @param name - the column
+   * @param read - the value of a cell
+   * @returns the values
+   */
+  cells(target, name, read) {
+    const { table, n } = this.tableOf(target);
+    return Array.from({ length: n }, (_u, i) => read(dataCell(table, name, i)));
+  }
+  /**
+   * A target's table and row count.
+   * @param target - nodes or edges
+   * @returns the table and its row count
+   */
+  tableOf(target) {
+    const { snapshot } = this;
+    return target === "node" ? { table: snapshot.nodes, n: snapshot.nodeCount } : { table: snapshot.edges, n: snapshot.edgeCount };
+  }
+}
+function carriable(table, n, name) {
+  let some = false;
+  for (let i = 0; i < n; i++) {
+    const cell = plainCell(table.value(name, i));
+    if (cell !== null && cell !== void 0) {
+      if (!isStyleScalar(cell)) {
+        return false;
+      }
+      some = true;
+    }
+  }
+  return some;
+}
+function isStyleScalar(v) {
+  return typeof v === "string" || typeof v === "boolean" || typeof v === "number" && Number.isFinite(v);
+}
+function keepsStyleBlock(exporter) {
+  const caps = exporter.styles?.capabilities;
+  return caps !== void 0 && (caps.block === "native" || caps.block === "attributes" && exporter.capabilities.graphAttributes);
+}
+function isKeptGraphtyProperty(note2, exporter) {
+  return note2.style?.property.startsWith("graphty:") === true && keepsStyleBlock(exporter);
+}
+function lossNotes(extracted, exporter, caps, picture, snapshot) {
+  const notes = [];
+  const kept = keepsStyleBlock(exporter);
+  for (const target of TARGETS) {
+    const written = new Set(caps?.[target] ?? []);
+    for (const property of ruleProperties(extracted.styles.rules, target)) {
+      if (written.has(property) || kept && property.startsWith("graphty:")) {
+        if (target === "edge") {
+          notes.push(...pairNotes(snapshot, exporter, property, picture("edge", property)));
+        }
+      } else {
+        notes.push(notWrittenNote(target, property, exporter, picture));
+      }
+    }
+  }
+  notes.push(...graphLossNotes(extracted, exporter, caps));
+  if (kept) {
+    notes.push(...styleBlockLosses(writeStyleBlock(extracted, { snapshot }), extracted.styles.rules.length));
+  } else if (extracted.styles.rules.length > 0) {
+    notes.push(
+      Object.freeze({
+        code: STYLE_ISSUE.RULES_NOT_KEPT,
+        message: `the style rules are not kept: the ${exporter.format} format has no place for them; importing the file infers them again from what it holds`,
+        column: null,
+        count: extracted.styles.rules.length
+      })
+    );
+  }
+  return notes;
+}
+function graphLossNotes(extracted, exporter, caps) {
+  const graphWritten = new Set(caps?.graph ?? []);
+  return Object.keys(extracted.styles.graph).filter((property) => !graphWritten.has(property)).map(
+    (property) => Object.freeze({
+      code: STYLE_ISSUE.NOT_WRITTEN,
+      message: `the graph's ${property} is not written: the ${exporter.format} format has no place for it`,
+      column: null,
+      count: 1,
+      style: Object.freeze({ target: "graph", property })
+    })
+  );
+}
+function ruleProperties(rules, target) {
+  return new Set(
+    rules.filter((rule) => rule.target === target).flatMap((rule) => [...Object.keys(rule.set ?? {}), ...Object.keys(rule.map ?? {})])
+  );
+}
+function notWrittenNote(target, property, exporter, picture) {
+  const count = picture(target, property).filter((v) => v !== null).length;
+  return Object.freeze({
+    code: STYLE_ISSUE.NOT_WRITTEN,
+    message: `${target} ${property} is not written: the ${exporter.format} format has no place for it (${String(count)} ${target}${plural(count)} ${agree(count, "has", "have")} a value)`,
+    column: null,
+    count,
+    style: Object.freeze({ target, property })
+  });
+}
+function pairNotes(snapshot, exporter, property, values) {
+  const pair = snapshot.edges.byRole("pair");
+  let count = 0;
+  for (let i = 0; pair !== null && i < values.length; i++) {
+    const other = pair.isSet(i) ? pair.value(i) : i;
+    if (other < i && values[i] !== values[other]) {
+      count++;
+    }
+  }
+  if (count === 0) {
+    return [];
+  }
+  return [
+    Object.freeze({
+      code: STYLE_ISSUE.APPROXIMATED,
+      message: `edge ${property}: ${String(count)} undirected edge${plural(count)} in a directed graph ${agree(count, "has", "have")} another value on each half; the ${exporter.format} format writes the edge once, with the first half's value`,
+      column: null,
+      count,
+      style: Object.freeze({ target: "edge", property })
+    })
+  ];
+}
+function styledSnapshot(snapshot, caps, tags, block, rules) {
+  const attributes = caps?.block === "attributes";
+  const stale = { node: staleTags(snapshot.nodes, rules, "node"), edge: staleTags(snapshot.edges, rules, "edge") };
+  const roles = { node: roledNames(snapshot.nodes, caps, "node"), edge: roledNames(snapshot.edges, caps, "edge") };
+  const staleBlock = snapshot.graph.has(STYLE_BLOCK_NAME);
+  const changes = [stale.node, stale.edge, roles.node, roles.edge].some((names) => names.length > 0);
+  if (!attributes && !staleBlock && !changes) {
+    return snapshot;
+  }
+  const out = snapshot.withColumns();
+  if (staleBlock) {
+    out.graph.remove(STYLE_BLOCK_NAME);
+  }
+  for (const target of TARGETS) {
+    const table = target === "node" ? out.nodes : out.edges;
+    for (const name of stale[target]) {
+      table.remove(name);
+    }
+    for (const name of roles[target]) {
+      const col = table.get(name);
+      if (col !== null) {
+        table.set(name, col, { role: void 0 });
+      }
+    }
+  }
+  if (attributes) {
+    setTagAttributes(out, tags);
+    out.graph.set(STYLE_BLOCK_NAME, [block], { dtype: "string" });
+  }
+  return out;
+}
+function staleTags(table, rules, target) {
+  const read = dataRead(rules, target);
+  return table.names().filter((name) => isStyleTagName(name) && !read.has(name));
+}
+function roledNames(table, caps, target) {
+  const writesLabel = (caps?.[target] ?? []).includes("label");
+  return table.names().filter((name) => {
+    const role = table.get(name)?.meta.role ?? "";
+    return STYLE_ROLES.has(role) || role === "label" && writesLabel;
+  });
+}
+function setTagAttributes(out, tags) {
+  for (const target of TARGETS) {
+    const table = target === "node" ? out.nodes : out.edges;
+    const prefix = styleTag(target, "");
+    for (const name of table.names().filter((c) => c.startsWith(prefix))) {
+      table.remove(name);
+    }
+    for (const [name, col] of tags[target]) {
+      const dtype = tagDtype(col);
+      table.set(name, dtype === "string" ? col.map((v) => v === null ? null : String(v)) : col, { dtype });
+    }
+  }
+}
+function isStyleTagName(name) {
+  return name.startsWith("graphty.style.") || name.startsWith("graphty_style_");
+}
+function dataRead(rules, target) {
+  const out = /* @__PURE__ */ new Set();
+  for (const { ext: _ext, ...rule } of rules.filter((r) => r.target === target)) {
+    JSON.stringify(rule, (_k, v) => {
+      const data = typeof v === "object" && v !== null && !Array.isArray(v) ? v.data : null;
+      if (typeof data === "string" && Object.keys(v).length === 1) {
+        out.add(data);
+      }
+      return v;
+    });
+  }
+  return out;
+}
+function tagDtype(col) {
+  let kind = null;
+  for (const v of col) {
+    if (v === null) {
+      continue;
+    }
+    if (kind === null) {
+      kind = typeof v;
+    } else if (kind !== typeof v) {
+      return "string";
+    }
+  }
+  if (kind === "number") {
+    return "f64";
+  }
+  return kind === "boolean" ? "bool" : "string";
+}
+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.backslashEscapes = false;
+    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 (this.backslashEscapes && text.includes("\\")) {
+      text = text.replaceAll(/\\([\s\S])/g, "$1");
+    }
+    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));
+  tokens.backslashEscapes = writtenByOgdf(text);
+  const lex = { text, tokens, i: 0, line: 1, spanningLine: 0 };
+  while (lex.i < text.length) {
+    const c = text.codePointAt(lex.i) ?? 0;
+    if (c === 34) {
+      lexString(lex);
+    } else if (c === 91 || c === 93) {
+      tokens.push(c === 91 ? TOKEN_OPEN : TOKEN_CLOSE, lex.i, lex.i + 1, lex.line);
+      lex.i++;
+    } else if (!skipSpace(lex, c)) {
+      lexBare(lex);
+    }
+  }
+  validateStructure(tokens);
+  return tokens;
+}
+function skipSpace(lex, c) {
+  const { text } = lex;
+  if (c === 10 || c === 13) {
+    lex.line++;
+    lex.i++;
+    if (c === 13 && lex.i < text.length && text.codePointAt(lex.i) === 10) {
+      lex.i++;
+    }
+  } else if (c === 32 || c === 9 || c === 11 || c === 12 || c === 65279) {
+    lex.i++;
+  } else if (c === 35) {
+    lex.i = endOfLine(text, lex.i);
+  } else {
+    return false;
+  }
+  return true;
+}
+function lexString(lex) {
+  const { text, tokens, i } = lex;
+  const close = tokens.backslashEscapes ? escapedClose(text, i + 1) : text.indexOf('"', i + 1);
+  if (close < 0) {
+    const hint = lex.spanningLine === 0 ? "" : `; the string opened at line ${lex.spanningLine} spans lines, so a quote may be missing there`;
+    throw new GmlSyntaxError(SYNTAX_STRING_CODE, `unclosed string opened at line ${lex.line}${hint}`, lex.line);
+  }
+  tokens.push(TOKEN_STRING, i + 1, close, lex.line);
+  const opened = lex.line;
+  for (let k = i + 1; k < close; k++) {
+    const d = text.codePointAt(k);
+    if (d === 10 || d === 13 && text.codePointAt(k + 1) !== 10) {
+      lex.line++;
+    }
+  }
+  if (lex.line !== opened && lex.spanningLine === 0) {
+    lex.spanningLine = opened;
+  }
+  lex.i = close + 1;
+}
+function lexBare(lex) {
+  const { text, i } = lex;
+  let j = i + 1;
+  while (j < text.length && !isDelimiter(text.codePointAt(j) ?? 0)) {
+    j++;
+  }
+  lex.tokens.push(classifyBare(text, i, j, lex.line), i, j, lex.line);
+  lex.i = j;
+}
+function writtenByOgdf(text) {
+  const end = Math.min(text.length, 512);
+  let i = 0;
+  while (i < end) {
+    const c = text.codePointAt(i);
+    if (c === 35) {
+      while (i < end && text.codePointAt(i) !== 10 && text.codePointAt(i) !== 13) {
+        i++;
+      }
+    } else if (c === 32 || c === 9 || c === 10 || c === 13 || c === 12 || c === 11) {
+      i++;
+    } else {
+      break;
+    }
+  }
+  return /^Creator\s+"ogdf::/.test(text.slice(i, i + 64));
+}
+function escapedClose(text, from) {
+  let k = from;
+  while (k < text.length) {
+    const c = text.codePointAt(k);
+    if (c === 34) {
+      return k;
+    }
+    k += c === 92 ? 2 : 1;
+  }
+  return -1;
+}
+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]
+      );
+    }
+    if (checkValue(tokens, i) === TOKEN_OPEN) {
+      stack.push(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 checkValue(tokens, key) {
+  const { kind } = tokens;
+  const value = key + 1;
+  const word = kind[value] === TOKEN_WORD && !NON_FINITE_WORD.test(tokens.textOf(value));
+  if (word && tokens.textOf(key) === "Creator") {
+    kind[value] = TOKEN_STRING;
+    return TOKEN_STRING;
+  }
+  if (kind[value] === TOKEN_CLOSE || word) {
+    throw new GmlSyntaxError(
+      SYNTAX_STRUCTURE_CODE,
+      `expected a value for key "${tokens.textOf(key)}" at line ${tokens.line[key]}, found ${describeToken(tokens, value)}`,
+      tokens.line[value]
+    );
+  }
+  return kind[value];
+}
+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);
+}
+const KEY_MANGLED_CODE = "W_GML_KEY_MANGLED";
+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 WRITERS = [
+  [
+    /^\s*(yfiles|yed)\b/i,
+    { dialect: "yed", tool: "yed", vocabulary: "yed", spelling: "yed", units: "px", labelKey: false }
+  ],
+  [
+    /^\s*cytoscape\b/i,
+    {
+      dialect: "cytoscape",
+      tool: "cytoscape",
+      vocabulary: "cytoscape",
+      spelling: "cytoscape",
+      units: "px",
+      labelKey: true
+    }
+  ],
+  [
+    /^\s*gephi\b/i,
+    {
+      dialect: "gephi",
+      tool: "gephi",
+      vocabulary: "graphlet",
+      spelling: "css",
+      units: "relative",
+      labelKey: false
+    }
+  ],
+  [
+    /^\s*ogdf::/i,
+    { dialect: "ogdf", tool: "ogdf", vocabulary: "ogdf", spelling: "css", units: "px", labelKey: true }
+  ],
+  // igraph writes a Creator line, but no drawing defaults of igraph's are stated by a primary source
+  [
+    /^\s*igraph\b/i,
+    { dialect: "igraph", tool: null, vocabulary: "graphlet", spelling: "css", units: "px", labelKey: true }
+  ]
+];
+const UNKNOWN_WRITER = {
+  dialect: "gml",
+  tool: null,
+  vocabulary: "graphlet",
+  spelling: "css",
+  units: "px",
+  labelKey: true
+};
+const GRAPHTY_WRITER = { ...WRITERS[0][1], tool: null };
+const GML_STYLE_BLOCK_KEY = mangleGmlKey(STYLE_BLOCK_NAME);
+const TAG_PREFIX = mangleGmlKey("graphty.style.");
+function tagKey(target, key) {
+  return mangleGmlKey(styleTag(target, key));
+}
+function graphText(snapshot, name) {
+  if (!snapshot.graph.has(name)) {
+    return null;
+  }
+  const v = plainCell(snapshot.graph.value(name, 0));
+  if (typeof v === "string") {
+    return v;
+  }
+  return typeof v === "number" ? String(v) : null;
+}
+function writerOf(snapshot) {
+  if (snapshot.graph.has(GML_STYLE_BLOCK_KEY)) {
+    return GRAPHTY_WRITER;
+  }
+  const creator = snapshot.meta.creator ?? graphText(snapshot, "Creator") ?? "";
+  for (const [pattern, writer] of WRITERS) {
+    if (pattern.test(creator)) {
+      return writer;
+    }
+  }
+  return UNKNOWN_WRITER;
+}
+const ARROW_ENDS = /* @__PURE__ */ new Map([
+  ["none", ["none", "none"]],
+  ["last", ["none", "triangle"]],
+  ["first", ["triangle", "none"]],
+  ["both", ["triangle", "triangle"]]
+]);
+const OGDF_STROKES = ["none", "solid", "dashed", "dotted", "dash-dot", "dash-dot"];
+const OGDF_SHAPES = /* @__PURE__ */ new Map([
+  ["rect", "rectangle"],
+  ["rhomb", "diamond"],
+  ["trapeze", "trapezoid"],
+  ["invtrapeze", "trapezoid"],
+  ["invtriangle", "triangle"],
+  ["invparallelogram", "parallelogram"]
+]);
+const YED_LABEL_KEYS = [
+  "outline",
+  "autoSizePolicy",
+  "model",
+  "configuration",
+  "borderDistance",
+  "modelName",
+  "modelPosition"
+];
+const cytoscapeArrow = CYTOSCAPE_LEXICON.edge.get("targetArrow")?.[0]?.[1];
+function sampleOf(raw) {
+  return typeof raw === "string" || typeof raw === "number" ? String(raw).slice(0, MAX_STYLE_VALUE_LENGTH) : "a record";
+}
+function isRec(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function first(r, ...keys) {
+  for (const k of keys) {
+    if (Object.hasOwn(r, k) && r[k] !== void 0) {
+      return r[k];
+    }
+  }
+  return void 0;
+}
+function readColor(raw, property, opacity, writer, put, at) {
+  if (raw === void 0) {
+    return;
+  }
+  const c = canonColor(raw, writer.spelling, at(property));
+  if (c === null) {
+    return;
+  }
+  put(property, c.color);
+  const alpha = colorOpacity(c, null, at(property), opacity !== null);
+  if (opacity !== null) {
+    put(opacity, alpha);
+  }
+}
+function strokeStyle(raw, kind, writer, at) {
+  if (raw === void 0) {
+    return null;
+  }
+  if (writer.vocabulary === "ogdf") {
+    const stroke = OGDF_STROKES[Number(raw)];
+    if (stroke === void 0 || stroke === "none") {
+      noteAt(at, STYLE_ISSUE.UNKNOWN_VALUE, sampleOf(raw));
+      return null;
+    }
+    return stroke;
+  }
+  return canonEnum(kind, raw, writer.spelling, at);
+}
+function readNodeGraphics(g, writer, put, at) {
+  const v = writer.vocabulary;
+  readNodeFill(g, writer, put, at);
+  readNodeOutline(g, writer, put, at);
+  put(
+    "borderStyle",
+    strokeStyle(v === "ogdf" ? g.stipple : g.outlineStyle, "borderStyle", writer, at("borderStyle"))
+  );
+  put("width", g.w === void 0 ? null : canonNumber(g.w, at("width")));
+  put("height", g.h === void 0 ? null : canonNumber(g.h, at("height")));
+  if (g.type !== void 0) {
+    const raw = v === "ogdf" && typeof g.type === "string" ? OGDF_SHAPES.get(g.type.toLowerCase()) ?? g.type : g.type;
+    put("shape", canonEnum("shape", raw, writer.spelling, at("shape")));
+  } else if (v === "yed" && typeof g.customconfiguration === "string") {
+    put("shape", flowchartShape(g.customconfiguration));
+  }
+}
+function readNodeFill(g, writer, put, at) {
+  if (writer.vocabulary === "yed" && Number(g.hasFill) === 0) {
+    noteAt(at("fill"), STYLE_ISSUE.NO_FILL, "hasFill 0");
+    put("fillOpacity", 0);
+    return;
+  }
+  readColor(g.fill, "fill", "fillOpacity", writer, put, at);
+  if (g.fill2 !== void 0) {
+    noteAt(at("fill"), STYLE_ISSUE.GRADIENT, sampleOf(g.fill2));
+  }
+}
+function readNodeOutline(g, writer, put, at) {
+  const v = writer.vocabulary;
+  if (v === "yed" && Number(g.hasOutline) === 0) {
+    put("borderWidth", 0);
+    return;
+  }
+  readColor(v === "ogdf" ? g.line : g.outline, "borderColor", null, writer, put, at);
+  const width = outlineWidthOf(g, v);
+  put("borderWidth", width === void 0 ? null : canonNumber(width, at("borderWidth")));
+}
+function outlineWidthOf(g, v) {
+  switch (v) {
+    case "yed":
+      return g.outlineWidth;
+    case "cytoscape":
+      return first(g, "outline_width", "width");
+    case "ogdf":
+      return g.lineWidth;
+    default:
+      return first(g, "width", "outlineWidth");
+  }
+}
+function readEdgeGraphics(g, writer, put, at) {
+  const v = writer.vocabulary;
+  readColor(g.fill, "color", "opacity", writer, put, at);
+  const width = v === "ogdf" ? first(g, "lineWidth", "width") : g.width;
+  put("width", width === void 0 ? null : canonNumber(width, at("width")));
+  put("lineStyle", strokeStyle(v === "ogdf" ? g.stipple : g.style, "lineStyle", writer, at("lineStyle")));
+  if (typeof g.arrow === "string") {
+    const ends = ARROW_ENDS.get(g.arrow.trim().toLowerCase());
+    if (ends === void 0) {
+      noteAt(at("targetArrow"), STYLE_ISSUE.UNKNOWN_VALUE, g.arrow.slice(0, MAX_STYLE_VALUE_LENGTH));
+    } else {
+      put("sourceArrow", ends[0]);
+      put("targetArrow", ends[1]);
+    }
+  }
+  for (const [keys, property] of [
+    [["sourceArrow", "source_arrow"], "sourceArrow"],
+    [["targetArrow", "target_arrow"], "targetArrow"]
+  ]) {
+    const raw = first(g, ...keys);
+    if (raw === void 0) {
+      continue;
+    }
+    put(
+      property,
+      v === "cytoscape" && cytoscapeArrow !== void 0 ? cytoscapeArrow(raw, at(property)) : canonEnum("arrow", raw, writer.spelling, at(property))
+    );
+  }
+  if (v === "yed") {
+    readYedCurve(g, put);
+  }
+}
+function readYedCurve(g, put) {
+  if (g.smoothBends !== void 0) {
+    const points = isRec(g.Line) ? g.Line.point : void 0;
+    put("curved", Number(g.smoothBends) === 1 && Array.isArray(points) && points.length > 2);
+  }
+}
+function readLabelGraphics(raw, writer, put, at) {
+  const visible = (Array.isArray(raw) ? raw : [raw]).filter((l) => isRec(l) && Number(l.visible) !== 0);
+  const lg = visible.at(0);
+  if (lg === void 0) {
+    return;
+  }
+  const extra = visible.slice(1).filter((l) => l.text !== void 0).length;
+  if (extra > 0) {
+    noteAt(at("label"), STYLE_ISSUE.EXTRA_LABELS, `${String(extra + 1)} labels`);
+  }
+  if (lg.text !== void 0) {
+    put("label", canonText(lg.text, at("label")));
+  }
+  const yedLabel = writer.vocabulary === "yed" || YED_LABEL_KEYS.some((k) => Object.hasOwn(lg, k));
+  if (lg.color !== void 0) {
+    readColor(lg.color, "labelColor", null, writer, put, at);
+  } else if (lg.fill !== void 0 && !yedLabel) {
+    readColor(lg.fill, "labelColor", null, writer, put, at);
+  }
+  if (lg.fill !== void 0 && yedLabel) {
+    noteAt(at("label"), STYLE_ISSUE.NOT_CARRIED, "label background");
+  }
+  readLabelFont(lg, put, at);
+}
+function readLabelFont(lg, put, at) {
+  put("labelSize", lg.fontSize === void 0 ? null : canonNumber(lg.fontSize, at("labelSize")));
+  put("labelFont", lg.fontName === void 0 ? null : canonText(lg.fontName, at("labelFont")));
+  const style = scalarText(lg.fontStyle, at("labelWeight"))?.trim().toLowerCase();
+  if (style !== void 0) {
+    const known = FONT_STYLES.get(style);
+    if (known === void 0) {
+      noteAt(at("labelWeight"), STYLE_ISSUE.UNKNOWN_VALUE, style.slice(0, MAX_STYLE_VALUE_LENGTH));
+    } else {
+      put("labelWeight", known[0]);
+      put("labelItalic", known[1]);
+    }
+  }
+}
+function readElement(target, g, lg, label, writer, put, at) {
+  let text = false;
+  const putLabel = (property, value) => {
+    text ||= property === "label" && value !== null;
+    put(property, value);
+  };
+  if (isRec(g)) {
+    (target === "node" ? readNodeGraphics : readEdgeGraphics)(g, writer, put, at);
+  }
+  if (lg !== null && lg !== void 0) {
+    readLabelGraphics(lg, writer, putLabel, at);
+  }
+  const drawn = writer.vocabulary === "cytoscape" ? target === "node" : writer.labelKey && (isRec(g) || lg !== void 0);
+  if (!text && drawn && label !== null && label !== void 0) {
+    put("label", canonText(label, at("label")));
+  }
+}
+function cellOf(table, name, i) {
+  if (!table.has(name)) {
+    return void 0;
+  }
+  const v = plainCell(table.value(name, i));
+  return v ?? void 0;
+}
+function centerOf(snapshot, i) {
+  const column = snapshot.nodes.byRole("position");
+  const v = column?.isSet(i) === true ? column.value(i) : null;
+  return v === null ? [Number.NaN, Number.NaN] : [v[0], v[1]];
+}
+function lineBends(snapshot, g, e) {
+  const raw = isRec(g) && isRec(g.Line) ? g.Line.point : void 0;
+  if (!Array.isArray(raw) || raw.length < 3) {
+    return null;
+  }
+  const points = raw.slice(1, -1).map((p) => isRec(p) ? [Number(p.x), Number(p.y)] : [Number.NaN, 0]);
+  return canonBends(
+    centerOf(snapshot, snapshot.edgeSource(e)),
+    centerOf(snapshot, snapshot.edgeTarget(e)),
+    points
+  );
+}
+function readValues(snapshot, writer, notes, context) {
+  let found = false;
+  const read = (target) => {
+    const table = target === "node" ? snapshot.nodes : snapshot.edges;
+    const n = target === "node" ? snapshot.nodeCount : snapshot.edgeCount;
+    const out = valueColumns(n);
+    if (!table.has("graphics") && !table.has("LabelGraphics") && writer.vocabulary !== "cytoscape") {
+      return out.values;
+    }
+    for (let i = 0; i < n; i++) {
+      context.budget.spend(target, 1);
+      const at = (property) => ({ notes, target, property, element: i, budget: context.budget });
+      readElement(
+        target,
+        cellOf(table, "graphics", i),
+        cellOf(table, "LabelGraphics", i),
+        cellOf(table, "label", i),
+        writer,
+        (property, value) => {
+          if (value !== null) {
+            found = true;
+            out.put(i, property, value);
+          }
+        },
+        at
+      );
+      if (target === "edge") {
+        const bends = lineBends(snapshot, cellOf(table, "graphics", i), i);
+        if (bends !== null) {
+          found = true;
+          out.put(i, "bends", bends);
+        }
+      }
+    }
+    return out.values;
+  };
+  const node = read("node");
+  const edge = read("edge");
+  return { node, edge, found };
+}
+function blockWithValues(snapshot, text) {
+  const parsed = parseStyleBlock(text, styleFingerprint(snapshot));
+  if (!parsed.ok || parsed.block.values !== void 0) {
+    return text;
+  }
+  const node = tagValues(snapshot, "node", parsed.block.columns.node);
+  const edge = tagValues(snapshot, "edge", parsed.block.columns.edge);
+  if (node === null || edge === null) {
+    return text;
+  }
+  const raw = JSON.parse(text);
+  return JSON.stringify({ ...raw, values: { node, edge } });
+}
+function tagValues(snapshot, target, keys) {
+  const table = target === "node" ? snapshot.nodes : snapshot.edges;
+  const n = target === "node" ? snapshot.nodeCount : snapshot.edgeCount;
+  const values = {};
+  for (const key of keys) {
+    const name = tagKey(target, key);
+    if (!table.has(name)) {
+      return null;
+    }
+    values[key] = Array.from({ length: n }, (_, i) => {
+      const v = plainCell(table.value(name, i));
+      return typeof v === "string" || typeof v === "number" || typeof v === "boolean" ? v : null;
+    });
+  }
+  return values;
+}
+function styleColumns(table) {
+  return [...table.names()].filter((c) => c === "graphics" || c === "LabelGraphics" || c.startsWith(TAG_PREFIX));
+}
+function gmlStyles(snapshot, context) {
+  const notes = new StyleNotes();
+  const writer = writerOf(snapshot);
+  const values = readValues(snapshot, writer, notes, context);
+  const blockText = graphText(snapshot, GML_STYLE_BLOCK_KEY);
+  const block = blockText === null ? null : blockWithValues(snapshot, blockText);
+  if (block !== null) {
+    exactFromBlock(snapshot, block, values);
+  }
+  if (writer.tool === null && !values.found && block === null) {
+    return null;
+  }
+  const gephi = writer.tool === "gephi" ? gephiRules(snapshot, values.node.fill, values.edge.color, context.budget, values.edge.width) : { rules: [], columns: /* @__PURE__ */ new Map() };
+  return {
+    canonical: true,
+    dialect: writer.dialect,
+    tool: writer.tool,
+    units: writer.units,
+    node: { values: values.node },
+    edge: { values: values.edge, rules: gephi.rules, columns: gephi.columns },
+    notes: notes.list(),
+    opacityInColor: true,
+    block,
+    // the graphics records and the per-element style values of a file graphty wrote hold styles, not data
+    readFrom: { node: styleColumns(snapshot.nodes), edge: styleColumns(snapshot.edges) }
+  };
+}
+const GML_STYLE_CAPABILITIES = Object.freeze({
+  node: Object.freeze([
+    "fill",
+    "fillOpacity",
+    "borderColor",
+    "borderWidth",
+    "borderStyle",
+    "shape",
+    "width",
+    "height",
+    "label",
+    "labelColor",
+    "labelSize",
+    "labelFont",
+    "labelWeight",
+    "labelItalic"
+  ]),
+  edge: Object.freeze([
+    "color",
+    "opacity",
+    "width",
+    "lineStyle",
+    "sourceArrow",
+    "targetArrow",
+    "curved",
+    "bends",
+    "label",
+    "labelColor",
+    "labelSize",
+    "labelFont",
+    "labelWeight",
+    "labelItalic"
+  ]),
+  block: "native"
+});
+const OWNED = {
+  node: /* @__PURE__ */ new Set([
+    "fill",
+    "fill2",
+    "hasFill",
+    "outline",
+    "hasOutline",
+    "outlineWidth",
+    "outline_width",
+    "outlineStyle",
+    "width",
+    "line",
+    "lineWidth",
+    "stipple",
+    "w",
+    "h",
+    "type"
+  ]),
+  edge: /* @__PURE__ */ new Set([
+    "fill",
+    "width",
+    "lineWidth",
+    "style",
+    "stipple",
+    "arrow",
+    "sourceArrow",
+    "targetArrow",
+    "source_arrow",
+    "target_arrow",
+    "smoothBends"
+  ]),
+  label: /* @__PURE__ */ new Set(["text", "color", "fill", "fontSize", "fontName", "fontStyle", "visible"])
+};
+function nodeGraphics(get, approximate) {
+  const g = {};
+  const width = get("width");
+  const height = get("height");
+  if (typeof width === "number") {
+    g.w = width;
+  }
+  if (typeof height === "number") {
+    g.h = height;
+  }
+  const shape = get("shape");
+  if (typeof shape === "string") {
+    const w = yedValue(YED_SHAPES, shape, shape === "vee" ? "triangle" : "rectangle");
+    if (!w.exact) {
+      approximate("shape", shape);
+    }
+    g.type = w.value;
+  }
+  const fill = get("fill");
+  const fillOpacity = get("fillOpacity");
+  if (typeof fill === "string") {
+    g.fill = yedColor(fill, fillOpacity);
+  } else if (fillOpacity === 0) {
+    g.hasFill = 0;
+  }
+  const borderColor = get("borderColor");
+  const borderWidth = get("borderWidth");
+  const borderStyle = get("borderStyle");
+  if (typeof borderColor === "string") {
+    g.outline = borderColor.toUpperCase();
+  }
+  if (typeof borderStyle === "string") {
+    const w = yedValue(YED_LINES, borderStyle, "line");
+    if (!w.exact) {
+      approximate("borderStyle", borderStyle);
+    }
+    g.outlineStyle = w.value;
+  }
+  if (borderWidth === 0) {
+    g.hasOutline = 0;
+  } else if (typeof borderWidth === "number") {
+    g.outlineWidth = borderWidth;
+  }
+  return g;
+}
+function edgeGraphics(get, approximate) {
+  const g = {};
+  const color = get("color");
+  if (typeof color === "string") {
+    g.fill = yedColor(color, get("opacity"));
+  }
+  const width = get("width");
+  if (typeof width === "number") {
+    g.width = width;
+  }
+  const lineStyle = get("lineStyle");
+  if (typeof lineStyle === "string") {
+    g.style = yedSpelled(
+      YED_LINES,
+      lineStyle,
+      lineStyle === "long-dash" ? "dashed" : "line",
+      "lineStyle",
+      approximate
+    );
+  }
+  for (const property of ["sourceArrow", "targetArrow"]) {
+    const arrow = get(property);
+    if (typeof arrow === "string") {
+      g[property] = yedSpelled(YED_ARROWS, arrow, "standard", property, approximate);
+    }
+  }
+  const curved = get("curved");
+  if (typeof curved === "boolean") {
+    g.smoothBends = curved ? 1 : 0;
+  }
+  return g;
+}
+function labelGraphics(get) {
+  const text = get("label");
+  if (typeof text !== "string" || text.trim().length === 0) {
+    return null;
+  }
+  const lg = { text };
+  const color = get("labelColor");
+  if (typeof color === "string") {
+    lg.color = color.toUpperCase();
+  }
+  const size = get("labelSize");
+  if (typeof size === "number") {
+    lg.fontSize = size;
+  }
+  const font = get("labelFont");
+  if (typeof font === "string") {
+    lg.fontName = font;
+  }
+  const weight = get("labelWeight");
+  const italic = get("labelItalic");
+  if (weight !== null || italic !== null) {
+    const style = (weight === "bold" ? "bold" : "") + (italic === true ? "italic" : "");
+    lg.fontStyle = style.length === 0 ? "plain" : style;
+  }
+  return lg;
+}
+function merged(old, owned, written) {
+  const out = {};
+  if (isRec(old)) {
+    for (const [k, v] of Object.entries(old)) {
+      if (!owned.has(k)) {
+        out[k] = v;
+      }
+    }
+  }
+  Object.assign(out, written);
+  return Object.keys(out).length === 0 ? void 0 : out;
+}
+function mergedLabels(old, written) {
+  const labels = Array.isArray(old) ? old : [old];
+  const head = merged(labels[0], OWNED.label, written ?? {});
+  const rest = labels.slice(1).filter((l) => l !== null && l !== void 0);
+  if (rest.length === 0) {
+    return head;
+  }
+  return head === void 0 ? rest : [head, ...rest];
+}
+function getter(picture, target) {
+  const columns = /* @__PURE__ */ new Map();
+  for (const p of GML_STYLE_CAPABILITIES[target]) {
+    columns.set(p, picture(target, p));
+  }
+  return (i) => (property) => columns.get(property)?.[i] ?? null;
+}
+function exactFromBlock(snapshot, text, read) {
+  const parsed = parseStyleBlock(text, styleFingerprint(snapshot));
+  const ex = parsed.ok ? blockStyles(parsed.block, snapshot, "gml") : null;
+  if (ex === null) {
+    return;
+  }
+  const notes = new StyleNotes();
+  for (const target of ["node", "edge"]) {
+    const n = target === "node" ? snapshot.nodeCount : snapshot.edgeCount;
+    const get = getter((t, p) => resolveStyles(ex, t, p, snapshot), target);
+    const values = read[target];
+    for (let i = 0; i < n; i++) {
+      const want = get(i);
+      const back = writtenAndReadBack(target, want, notes);
+      for (const property of GML_STYLE_CAPABILITIES[target]) {
+        const native = values[property]?.[i] ?? null;
+        const w = want(property);
+        if (native !== w && native === (back.get(property) ?? null)) {
+          values[property] ??= new Array(n).fill(null);
+          values[property][i] = w;
+        }
+      }
+    }
+  }
+}
+function writtenAndReadBack(target, want, notes) {
+  const ignore = () => void 0;
+  const g = target === "node" ? nodeGraphics(want, ignore) : edgeGraphics(want, ignore);
+  const back = /* @__PURE__ */ new Map();
+  readElement(
+    target,
+    g,
+    labelGraphics(want) ?? void 0,
+    void 0,
+    GRAPHTY_WRITER,
+    (property, value) => {
+      if (value !== null) {
+        back.set(property, value);
+      }
+    },
+    (property) => ({ notes, target, property })
+  );
+  return back;
+}
+function gmlStyledExport(snapshot, input) {
+  if (input === void 0) {
+    return null;
+  }
+  const approximated = new StyleApproximations();
+  const out = snapshot.withColumns();
+  const renames = [];
+  for (const target of ["node", "edge"]) {
+    const table = target === "node" ? out.nodes : out.edges;
+    writeGraphicsColumns(snapshot, input, target, table, approximated);
+    const read = dataRead(input.rules.styles.rules, target);
+    for (const name of table.names().filter((c) => mangleGmlKey(c).startsWith(TAG_PREFIX))) {
+      const col = table.get(name);
+      table.remove(name);
+      if (col !== null && !(name.startsWith(TAG_PREFIX) && !read.has(name))) {
+        renames.push(renameDataColumn(table, target, name, col));
+      }
+    }
+  }
+  let { block } = input;
+  const keys = [...input.rules.columns.node.keys()].map((k) => tagKey("node", k));
+  const edgeKeys = [...input.rules.columns.edge.keys()].map((k) => tagKey("edge", k));
+  if (new Set(keys).size !== keys.length || new Set(edgeKeys).size !== edgeKeys.length) {
+    block = writeStyleBlock(input.rules, { inlineColumns: true, snapshot });
+  } else {
+    setTagColumns(out, input);
+  }
+  out.graph.set(GML_STYLE_BLOCK_KEY, [block], { dtype: "string" });
+  const notes = [
+    ...renames,
+    ...block === input.block ? [] : styleBlockLosses(block, input.rules.styles.rules.length, "size"),
+    ...approximated.notes("yEd's GML")
+  ];
+  return { snapshot: out, notes };
+}
+function writeGraphicsColumns(snapshot, input, target, table, approximated) {
+  const n = target === "node" ? snapshot.nodeCount : snapshot.edgeCount;
+  const approximate = (property, value) => {
+    approximated.add(target, property, value);
+  };
+  const get = getter((t, p) => input.picture(t, p), target);
+  const graphics = [];
+  const labels = [];
+  for (let i = 0; i < n; i++) {
+    const g = target === "node" ? nodeGraphics(get(i), approximate) : edgeGraphics(get(i), approximate);
+    if (target === "edge") {
+      const line = bendsLine(snapshot, get(i)("bends"), i);
+      if (line !== null) {
+        g.Line = line;
+      }
+    }
+    graphics.push(merged(cellOf(table, "graphics", i), OWNED[target], g));
+    labels.push(mergedLabels(cellOf(table, "LabelGraphics", i), labelGraphics(get(i))));
+  }
+  for (const [name, cells] of [
+    ["graphics", graphics],
+    ["LabelGraphics", labels]
+  ]) {
+    if (cells.some((c) => c !== void 0)) {
+      table.set(name, cells, { dtype: "json", nullable: true });
+    } else if (table.has(name)) {
+      table.remove(name);
+    }
+  }
+}
+function bendsLine(snapshot, bends, e) {
+  const source = centerOf(snapshot, snapshot.edgeSource(e));
+  const target = centerOf(snapshot, snapshot.edgeTarget(e));
+  const points = typeof bends === "string" ? bendsToPoints(source, target, bends) : null;
+  if (points === null || ![...source, ...target].every(Number.isFinite)) {
+    return null;
+  }
+  return { point: [source, ...points, target].map(([x, y]) => ({ x, y })) };
+}
+function renameDataColumn(table, target, name, col) {
+  let renamed = `data_${name}`;
+  let k = 2;
+  while (table.has(renamed)) {
+    renamed = `data_${name}_${String(k)}`;
+    k++;
+  }
+  table.set(renamed, col);
+  return Object.freeze({
+    code: KEY_MANGLED_CODE,
+    message: `${target} column "${name}" is written as "${renamed}": keys starting with ${TAG_PREFIX} hold graphty's style values`,
+    column: name,
+    count: null
+  });
+}
+function setTagColumns(out, input) {
+  for (const target of ["node", "edge"]) {
+    const table = target === "node" ? out.nodes : out.edges;
+    for (const [key, col] of input.rules.columns[target]) {
+      const kinds = new Set(col.filter((v) => v !== null).map((v) => typeof v));
+      const text = kinds.size > 1 || kinds.has("string");
+      let dtype = kinds.has("boolean") ? "bool" : "f64";
+      if (text) {
+        dtype = "string";
+      }
+      table.set(tagKey(target, key), text ? col.map((v) => v === null ? null : String(v)) : col, { dtype });
+    }
+  }
+}
+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 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,
+  styles: Object.freeze({ capabilities: GML_STYLE_CAPABILITIES }),
+  /**
+   * Pre-flight: the common capability notes, the GML-specific ones and, with styles, the values written as the
+   * nearest ones yEd's GML has.
+   * @param snapshot - the snapshot
+   * @param options - the options
+   * @returns the notes, empty when the export is exact
+   */
+  check(snapshot, options) {
+    const styled = gmlStyledExport(snapshot, options?.styles);
+    if (styled === null) {
+      return check(snapshot, options);
+    }
+    return Object.freeze([...check(styled.snapshot, options), ...styled.notes]);
+  },
+  /**
+   * 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(gmlStyledExport(snapshot, options?.styles)?.snapshot ?? snapshot, options));
+}
+const GRAPHICS_COLUMN = "graphics";
+function gmlPositions(snapshot) {
+  if (snapshot.nodes.byRole("position") === null) {
+    return null;
+  }
+  const tool = toolOf(snapshot.meta.creator);
+  return {
+    units: "px",
+    // a z that is the same on every node collapses to 2D
+    sourceDims: 3,
+    yAxis: tool === "gephi" || tool === "tulip" ? "up" : "down",
+    tool,
+    medianNodeSize: graphicsMedian(snapshot)
+  };
+}
+function graphicsMedian(snapshot) {
+  const graphics = snapshot.nodes.get(GRAPHICS_COLUMN);
+  const sizes = [];
+  for (let row = 0; graphics !== null && row < graphics.length; row++) {
+    const g = graphics.isSet(row) ? graphics.value(row) : void 0;
+    const { w, h } = typeof g === "object" && g !== null ? g : {};
+    if (typeof w === "number" && typeof h === "number") {
+      sizes.push((w + h) / 2);
+    }
+  }
+  return median(sizes);
+}
+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 first2 = values[0];
+    const positionPlan = plan.position;
+    let rest = first2;
+    if (isRecord(first2) && positionPlan !== null) {
+      const left = this.writePosition(positionPlan, index, this.keepPositionSource ? { ...first2 } : first2, where);
+      rest = this.keepPositionSource ? first2 : left;
+    } else if (!isRecord(first2)) {
+      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,
+  styles: gmlStyles,
+  positions: gmlPositions,
+  /**
+   * 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 first2 = new ImportReportBuilder("gml", resolved.errorLimit);
+    reportUnusedOptions(options, first2, USED_OPTIONS);
+    const tokens = tokenize(await readText(input, first2, resolved), first2);
+    const reports = [];
+    let count = 1;
+    for (let i = 0; i < count; i++) {
+      throwIfAborted(resolved.signal);
+      const report = i === 0 ? first2 : 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", or a column renamed because its key would read back as a style value. */
+  KEY_MANGLED: KEY_MANGLED_CODE,
+  /** A position column with more than three components. */
+  POSITION_COMPONENTS: POSITION_COMPONENTS_CODE,
+  /** A graphics record whose x / y / z the position column overrides. */
+  GRAPHICS_OVERRIDDEN: GRAPHICS_OVERRIDDEN_CODE,
+  /** A graphics record that cannot hold the position. */
+  GRAPHICS_CONFLICT: GRAPHICS_CONFLICT_CODE
+});
+export {
+  GML_ISSUE as G,
+  gmlExporter as a,
+  GML_LOSS as b,
+  GML_STYLE_BLOCK_KEY as c,
+  GML_STYLE_CAPABILITIES as d,
+  gmlImporter as g,
+  isKeptGraphtyProperty as i,
+  prepareStyleExport as p
+};
+//# sourceMappingURL=index-B9fdNpTA.js.map