@graphty/graph-io 0.0.0 → 0.2.0

package/dist/chunks/importer-GozH8DkN.js

@@ -0,0 +1,3050 @@
+import { GraphFormatError, INVALID_INDEX, MAX_COUNT } from "@graphty/graph-format";
+import { c as childrenCsr } from "./children-CL3Cy0ez.js";
+import { x as MIXED_DIRECTION_CODE, g as DIRECTION_FORCED_CODE, h as DIRECTION_REFUSED_CODE, W as SINK_OPTION_CODE, R as PRECISION_CODE, B as BAD_DEFAULT_CODE, a1 as UNKNOWN_ATTR_TYPE_CODE, V as ROLE_TAKEN_CODE, C as COLUMN_RENAMED_CODE, J as OPTION_IGNORED_CODE, n as ID_MERGED_CODE, Y as STRAY_TEXT_CODE, a2 as UNKNOWN_ELEMENT_CODE, H as HYPEREDGE_CODE, d as COUNT_HINT_CODE, y as MULTIPLE_GRAPHS_CODE, i as DUPLICATE_EDGE_ID_CODE, k as DUPLICATE_NODE_CODE, M as MISSING_ENDPOINT_CODE, w as MISSING_ID_CODE, j as DUPLICATE_KEY_CODE, G as NO_GRAPH_CODE, r as INVALID_UTF8_CODE, a7 as XML_SYNTAX_CODE, p as ID_TEXT_TYPE_CODE, U as ROLE_DROPPED_CODE, K as PARENTS_DROPPED_CODE, z as MUTUAL_AS_UNDIRECTED_CODE, aB as resolveExportOptions, au as joinText, ah as encodeChunks, a9 as capabilities, aa as checkCapabilities, L as LOSS, aw as pairFolding, aD as sanitizeIds, ai as explicitWeights, as as isNmtoken, aq as isCanonicalIntegerText, av as mangleNmtoken, an as formatInteger, al as formatF64, ak as formatF32, aC as resolveImportOptions, I as ImportReportBuilder, az as reportSinkOptions, aA as reportUnusedOptions, t as textChunks, a as throwIfAborted, s as IdCoercer, l as DirectionResolver, at as isWeightField, aL as declareAttribute, aI as uniqueColumnName, af as declareResolved, aZ as takenIn, ax as parseWeightText, aN as parseDeclaredValue, aO as losesPrecision } from "./writer-DxSKC7TL.js";
+import { e as escapeXmlText, d as isWhitespace, k as isXmlName, f as escapeXmlAttribute, x as xmlIllegalTextNotes, t as tokenizeXml, X as XmlSyntaxError, l as localName } from "./escape-DyI8JofU.js";
+const GRAPHML_NAMESPACE = "http://graphml.graphdrawing.org/xmlns";
+const YFILES_NAMESPACE = "http://www.yworks.com/xml/graphml";
+const XSI_NAMESPACE = "http://www.w3.org/2001/XMLSchema-instance";
+const SCHEMA_LOCATION = "http://graphml.graphdrawing.org/xmlns http://graphml.graphdrawing.org/xmlns/1.0/graphml.xsd";
+const FORMAT = "graphml";
+const EXTENSIONS = Object.freeze([".graphml", ".xml"]);
+const MIME_TYPES = Object.freeze(["application/graphml+xml", "application/xml", "text/xml"]);
+const ORIGINAL_ID_ATTRIBUTE = "graphty:originalId";
+const ORIGINAL_ID_COLUMN = "graphty.originalId";
+const EDGE_ID_COLUMN = "id";
+const SOURCE_PORT_COLUMN = "sourceport";
+const TARGET_PORT_COLUMN = "targetport";
+const PARENT_COLUMN = "parent";
+const HYPEREDGE_HUB_COLUMN = "graphty.hyperedge";
+const LABEL_COLUMN = "label";
+const RESERVED_EDGE_NAMES = /* @__PURE__ */ new Set([
+  EDGE_ID_COLUMN,
+  SOURCE_PORT_COLUMN,
+  TARGET_PORT_COLUMN
+]);
+const RESERVED_NODE_NAMES = /* @__PURE__ */ new Set([PARENT_COLUMN]);
+const META_KEY = "graphml";
+const GRAPHML_ISSUE = Object.freeze({
+  /** Fatal: the input is not well-formed XML. */
+  XML_SYNTAX: XML_SYNTAX_CODE,
+  /** Fatal: the input holds invalid UTF-8. */
+  INVALID_UTF8: INVALID_UTF8_CODE,
+  /** Fatal: the root element is not `<graphml>`. */
+  NOT_GRAPHML: "E_NOT_GRAPHML",
+  /** Fatal: the document has no `<graph>`. */
+  NO_GRAPH: NO_GRAPH_CODE,
+  /** A `<key>` without an id. */
+  KEY_MISSING_ID: "E_GRAPHML_KEY_MISSING_ID",
+  /** Two `<key>` elements with the same id. */
+  DUPLICATE_KEY: DUPLICATE_KEY_CODE,
+  /** A key declared for hyperedges, ports or endpoints (never used). */
+  KEY_DOMAIN_UNSUPPORTED: "W_GRAPHML_KEY_DOMAIN_UNSUPPORTED",
+  /** A `<node>` without an id. */
+  MISSING_ID: MISSING_ID_CODE,
+  /** An `<edge>` without a source or a target. */
+  MISSING_ENDPOINT: MISSING_ENDPOINT_CODE,
+  /** A `<data>` whose key was never declared. */
+  UNKNOWN_KEY: "E_GRAPHML_UNKNOWN_KEY",
+  /** A `<data>` whose key is declared for another domain. */
+  KEY_DOMAIN: "W_GRAPHML_KEY_DOMAIN",
+  /** A `<data>` without a key attribute. */
+  DATA_MISSING_KEY: "E_GRAPHML_DATA_MISSING_KEY",
+  /** A `<key>` whose `for` is not a GraphML domain. */
+  KEY_FOR_INVALID: "E_GRAPHML_KEY_FOR_INVALID",
+  /** Data of a nested `<graph>`; only the top-level graph has attributes. */
+  NESTED_GRAPH_DATA: "W_GRAPHML_NESTED_GRAPH_DATA",
+  /** Data of a hyperedge expanded to a star or clique. */
+  HYPEREDGE_DATA_DROPPED: "W_GRAPHML_HYPEREDGE_DATA_DROPPED",
+  /** Nested elements in the `<data>` of a typed (non-yfiles) key. */
+  DATA_NESTED: "E_GRAPHML_DATA_NESTED",
+  /** A `<node>` declared twice. */
+  DUPLICATE_NODE: DUPLICATE_NODE_CODE,
+  /** An edge id already used by another edge. */
+  DUPLICATE_EDGE_ID: DUPLICATE_EDGE_ID_CODE,
+  /** A `directed` attribute that is neither true nor false. */
+  INVALID_DIRECTED: "E_GRAPHML_INVALID_DIRECTED",
+  /** An `edgedefault` that is neither directed nor undirected. */
+  INVALID_EDGEDEFAULT: "E_GRAPHML_INVALID_EDGEDEFAULT",
+  /** A `<graph>` without edgedefault; the `defaultDirected` option applies. */
+  EDGEDEFAULT_MISSING: "W_GRAPHML_EDGEDEFAULT_MISSING",
+  /** A second top-level `<graph>`; its nodes and edges are merged into the first. */
+  MULTIPLE_GRAPHS: MULTIPLE_GRAPHS_CODE,
+  /** A `parse.nodes` / `parse.edges` hint the sink cannot reserve (ignored). */
+  COUNT_HINT: COUNT_HINT_CODE,
+  /** A hyperedge under `hyperedges: "error"`. */
+  HYPEREDGE: HYPEREDGE_CODE,
+  /** Hyperedges skipped under `hyperedges: "skip"`. */
+  HYPEREDGE_SKIPPED: "W_GRAPHML_HYPEREDGE_SKIPPED",
+  /** An endpoint of a hyperedge without a node, or with an unknown type. */
+  HYPEREDGE_ENDPOINT: "E_GRAPHML_HYPEREDGE_ENDPOINT",
+  /** `<port>` declarations (and their data) are not kept; sourceport / targetport edge attributes are. */
+  PORT_DECLARATION: "W_GRAPHML_PORT_DECLARATION",
+  /** A `<locator>` element. */
+  LOCATOR_DROPPED: "W_GRAPHML_LOCATOR_DROPPED",
+  /** A `<desc>` of a node, an edge or a hyperedge. */
+  DESC_DROPPED: "W_GRAPHML_DESC_DROPPED",
+  /** An element the GraphML schema does not define at that place. */
+  UNKNOWN_ELEMENT: UNKNOWN_ELEMENT_CODE,
+  /** Non-whitespace text where the schema allows only elements. */
+  STRAY_TEXT: STRAY_TEXT_CODE,
+  /** Two distinct id texts merged into one number under `ids: "number"`. */
+  ID_MERGED: ID_MERGED_CODE,
+  /** An option GraphML has no use for (`nodeIdFrom`: nodes are identified by their id attribute). */
+  OPTION_IGNORED: OPTION_IGNORED_CODE,
+  /** A yFiles key under `yfiles: "skip"`. */
+  YFILES_SKIPPED: "W_GRAPHML_YFILES_SKIPPED",
+  /** A key renamed `<name>#<id>` because the name was taken (design section 5.6). */
+  COLUMN_RENAMED: COLUMN_RENAMED_CODE,
+  /** A key declared without its role because the table already holds it. */
+  ROLE_TAKEN: ROLE_TAKEN_CODE,
+  /** A declared type the format does not define (kept as string). */
+  UNKNOWN_ATTR_TYPE: UNKNOWN_ATTR_TYPE_CODE,
+  /** A default that does not parse as the declared type. */
+  BAD_DEFAULT: BAD_DEFAULT_CODE,
+  /** A long value beyond 2^53 rounded. */
+  PRECISION: PRECISION_CODE,
+  /** A builder-policy option the sink does not honour. */
+  SINK_OPTION: SINK_OPTION_CODE,
+  /** The sink refused the file's direction. */
+  DIRECTION_REFUSED: DIRECTION_REFUSED_CODE,
+  /** Edges forced to the policy's direction. */
+  DIRECTION_FORCED: DIRECTION_FORCED_CODE,
+  /** A mixed file under onMixedDirection "error" (fatal). */
+  MIXED_DIRECTION: MIXED_DIRECTION_CODE
+});
+const GRAPHML_LOSS = Object.freeze({
+  /** yFiles nested XML kept as a JSON tree: structure preserved, not byte-exact. */
+  YFILES_JSON: "W_GRAPHML_YFILES_JSON",
+  /** A mutual pair written as one undirected edge; the mark is lost. */
+  MUTUAL_AS_UNDIRECTED: MUTUAL_AS_UNDIRECTED_CODE,
+  /** A `parents` (multi-parent) column cannot be written as nested graphs. */
+  PARENTS_DROPPED: PARENTS_DROPPED_CODE,
+  /** A role column GraphML has no slot for (kind, node ids, ...) written as a plain attribute. */
+  ROLE_DROPPED: ROLE_DROPPED_CODE,
+  /** Containment order differs from index order; node indices change after a round trip. */
+  HIERARCHY_REORDERED: "W_GRAPHML_HIERARCHY_REORDERED",
+  /** Nodes whose parent chain never reaches a root are written at the top level. */
+  PARENT_CYCLE: "W_GRAPHML_PARENT_CYCLE",
+  /** Node ids that change type after a round trip under the canonical rule (design section 4.1). */
+  ID_TEXT_TYPE: ID_TEXT_TYPE_CODE,
+  /** A numeric edge id column reads back as string. */
+  EDGE_ID_TEXT: "W_GRAPHML_EDGE_ID_TEXT",
+  /** A yfiles json value that is not a serialisable tree: export() will throw E_COLUMN_TYPE. */
+  YFILES_TREE: "E_GRAPHML_YFILES_TREE"
+});
+const ATTRIBUTE_PREFIX = "@_";
+const TEXT_KEY = "#text";
+class XmlTreeBuilder {
+  /** Create a builder whose implicit root is the containing element. */
+  constructor() {
+    this.frames = [];
+    this.root = { name: "", node: {}, hasAttrs: false, hasChildren: false, text: "" };
+  }
+  /**
+   * Whether the builder is inside a child element (as opposed to at the root level).
+   * @returns true while at least one child element is open
+   */
+  get open() {
+    return this.frames.length > 0;
+  }
+  /**
+   * An element starts.
+   * @param name - the element name as written
+   * @param attrs - its attributes
+   */
+  start(name, attrs) {
+    const node = {};
+    let hasAttrs = false;
+    for (const [key, value] of attrs) {
+      node[ATTRIBUTE_PREFIX + key] = value;
+      hasAttrs = true;
+    }
+    this.frames.push({ name, node, hasAttrs, hasChildren: false, text: "" });
+  }
+  /**
+   * Character data inside the current element.
+   * @param text - the text
+   */
+  text(text) {
+    const frame = this.frames.length > 0 ? this.frames[this.frames.length - 1] : this.root;
+    frame.text += text;
+  }
+  /** The current element ends; its value is attached to its parent. */
+  end() {
+    const frame = this.frames.pop();
+    if (frame === void 0) {
+      throw new GraphFormatError("E_COLUMN_TYPE", "XmlTreeBuilder.end() without a matching start()", {
+        reason: "tree builder underflow"
+      });
+    }
+    const parent = this.frames.length > 0 ? this.frames[this.frames.length - 1] : this.root;
+    attachChild(parent, frame.name, valueOf(frame));
+  }
+  /**
+   * The content of the containing element: its text when it has no child elements, otherwise
+   * the object of its children (with `#text` for non-whitespace mixed content).
+   * @returns the value to store in the json column
+   */
+  finish() {
+    if (this.frames.length > 0) {
+      throw new GraphFormatError("E_COLUMN_TYPE", "XmlTreeBuilder.finish() with open elements", {
+        reason: "tree builder open"
+      });
+    }
+    const { root } = this;
+    if (!root.hasChildren) {
+      return root.text;
+    }
+    if (!isWhitespace(root.text)) {
+      root.node[TEXT_KEY] = root.text;
+    }
+    return root.node;
+  }
+}
+function valueOf(frame) {
+  if (!frame.hasAttrs && !frame.hasChildren) {
+    return frame.text;
+  }
+  if (!isWhitespace(frame.text)) {
+    frame.node[TEXT_KEY] = frame.text;
+  }
+  return frame.node;
+}
+function attachChild(parent, name, value) {
+  parent.hasChildren = true;
+  const existing = parent.node[name];
+  if (existing === void 0) {
+    parent.node[name] = value;
+  } else if (Array.isArray(existing)) {
+    existing.push(value);
+  } else {
+    parent.node[name] = [existing, value];
+  }
+}
+function treeProblem(value) {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return null;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      if (Array.isArray(item)) {
+        return "nested arrays cannot be written as elements";
+      }
+      const problem = treeProblem(item);
+      if (problem !== null) {
+        return problem;
+      }
+    }
+    return null;
+  }
+  if (typeof value !== "object") {
+    return `a ${typeof value} cannot be written as XML`;
+  }
+  for (const [key, child] of Object.entries(value)) {
+    if (key === TEXT_KEY) {
+      if (child !== null && typeof child === "object") {
+        return "#text must be a scalar";
+      }
+      continue;
+    }
+    if (key.startsWith(ATTRIBUTE_PREFIX)) {
+      const name = key.slice(ATTRIBUTE_PREFIX.length);
+      if (!isXmlName(name)) {
+        return `"${name}" is not an XML attribute name`;
+      }
+      if (child !== null && typeof child === "object") {
+        return `attribute ${name} must be a scalar`;
+      }
+      continue;
+    }
+    if (!isXmlName(key)) {
+      return `"${key}" is not an XML element name`;
+    }
+    const problem = treeProblem(child);
+    if (problem !== null) {
+      return problem;
+    }
+  }
+  return null;
+}
+function writeXmlTree(value, indent, out) {
+  const problem = treeProblem(value);
+  if (problem !== null) {
+    throw new GraphFormatError("E_COLUMN_TYPE", `a yfiles value cannot be written as XML: ${problem}`, {
+      reason: "xml tree"
+    });
+  }
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    out.push(escapeXmlText(scalarText(value)));
+    return;
+  }
+  const object = value;
+  let text = null;
+  for (const [key, child] of Object.entries(object)) {
+    if (key === TEXT_KEY) {
+      text = scalarText(child);
+    } else if (!key.startsWith(ATTRIBUTE_PREFIX)) {
+      writeElements(key, child, indent, out);
+    }
+  }
+  if (text !== null) {
+    out.push(escapeXmlText(text));
+  }
+}
+function writeElements(name, value, indent, out) {
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      writeElements(name, item, indent, out);
+    }
+    return;
+  }
+  if (value === null || typeof value !== "object") {
+    const text2 = scalarText(value);
+    out.push(text2.length === 0 ? `
+${indent}<${name}/>` : `
+${indent}<${name}>${escapeXmlText(text2)}</${name}>`);
+    return;
+  }
+  const object = value;
+  let attrs = "";
+  let text = null;
+  let hasChildren = false;
+  for (const [key, child] of Object.entries(object)) {
+    if (key === TEXT_KEY) {
+      text = scalarText(child);
+    } else if (key.startsWith(ATTRIBUTE_PREFIX)) {
+      attrs += ` ${key.slice(ATTRIBUTE_PREFIX.length)}="${escapeXmlAttribute(scalarText(child))}"`;
+    } else {
+      hasChildren = true;
+    }
+  }
+  if (!hasChildren) {
+    out.push(
+      text === null || text.length === 0 ? `
+${indent}<${name}${attrs}/>` : `
+${indent}<${name}${attrs}>${escapeXmlText(text)}</${name}>`
+    );
+    return;
+  }
+  out.push(`
+${indent}<${name}${attrs}>`);
+  const inner = `${indent}  `;
+  for (const [key, child] of Object.entries(object)) {
+    if (key !== TEXT_KEY && !key.startsWith(ATTRIBUTE_PREFIX)) {
+      writeElements(key, child, inner, out);
+    }
+  }
+  if (text !== null) {
+    out.push(escapeXmlText(text));
+  }
+  out.push(`
+${indent}</${name}>`);
+}
+function scalarText(value) {
+  switch (typeof value) {
+    case "string":
+      return value;
+    case "number":
+    case "boolean":
+    case "bigint":
+      return String(value);
+    default:
+      return "";
+  }
+}
+const CAPABILITIES = capabilities({
+  mixedDirection: true,
+  multiEdges: true,
+  selfLoops: true,
+  edgeIds: "optional",
+  idCharset: "nmtoken",
+  dtypes: ["bool", "i32", "f32", "f64", "string"],
+  components: false,
+  lists: false,
+  json: false,
+  defaults: true,
+  options: false,
+  hierarchy: true,
+  temporal: "none",
+  graphAttributes: true,
+  positions: false,
+  viz: false
+});
+const STRUCTURAL_ROLES = /* @__PURE__ */ new Set([
+  "directed",
+  "pair",
+  "mutual",
+  "weight",
+  "timeText",
+  "originalId"
+]);
+const DROPPED_ROLES = /* @__PURE__ */ new Set([
+  "position",
+  "color",
+  "size",
+  "shape",
+  "thickness",
+  "start",
+  "end",
+  "timestamp",
+  "timestamps",
+  "spells",
+  "open"
+]);
+const SLOT_ROLES = /* @__PURE__ */ new Set(["label", "id", "sourcePort", "targetPort", "parent"]);
+const SLOT_ROLES_BY_DOMAIN = {
+  graph: /* @__PURE__ */ new Set(),
+  node: /* @__PURE__ */ new Set(["parent"]),
+  edge: /* @__PURE__ */ new Set(["id", "sourcePort", "targetPort"])
+};
+const ROLE_NAMES = Object.freeze({
+  label: LABEL_COLUMN,
+  id: EDGE_ID_COLUMN,
+  sourcePort: SOURCE_PORT_COLUMN,
+  targetPort: TARGET_PORT_COLUMN,
+  parent: PARENT_COLUMN
+});
+const DEFAULT_WEIGHT_NAME = "weight";
+const TYPE_DTYPES = {
+  boolean: "bool",
+  int: "i32",
+  long: "f64",
+  float: "f32",
+  double: "f64",
+  string: "string"
+};
+const I32_MAX = 2147483647;
+const DEFAULT_YFILES_TYPES = {
+  node: "nodegraphics",
+  edge: "edgegraphics",
+  graph: "resources"
+};
+function resolveFormatOptions(options) {
+  const pretty = options?.pretty ?? true;
+  if (typeof pretty !== "boolean") {
+    throw new GraphFormatError("E_UNSUPPORTED", "option pretty must be a boolean", {
+      option: "pretty",
+      found: typeof pretty
+    });
+  }
+  const edgedefault = options?.edgedefault ?? null;
+  if (edgedefault !== null && edgedefault !== "directed" && edgedefault !== "undirected") {
+    throw new GraphFormatError(
+      "E_UNSUPPORTED",
+      `option edgedefault: ${JSON.stringify(edgedefault)} is not "directed" or "undirected"`,
+      { option: "edgedefault", found: edgedefault }
+    );
+  }
+  return { pretty, edgedefault };
+}
+function graphmlMetaOf(snapshot) {
+  const value = snapshot.meta.extra[META_KEY];
+  if (typeof value !== "object" || value === null) {
+    return null;
+  }
+  const record = value;
+  const graphId = typeof record.graphId === "string" ? record.graphId : null;
+  const edgedefault = record.edgedefault === "directed" || record.edgedefault === "undirected" ? record.edgedefault : null;
+  const namespaces = {};
+  if (typeof record.namespaces === "object" && record.namespaces !== null) {
+    for (const [prefix, uri] of Object.entries(record.namespaces)) {
+      if (typeof uri === "string") {
+        namespaces[prefix] = uri;
+      }
+    }
+  }
+  return { graphId, edgedefault, namespaces };
+}
+function planExport(snapshot, options, format) {
+  const notes = checkCapabilities(snapshot, CAPABILITIES, options, {
+    roles: SLOT_ROLES,
+    roleNames: ROLE_NAMES
+  }).filter((n) => n.code !== LOSS.JSON);
+  const note = (code, message, column = null, count = null) => {
+    notes.push(Object.freeze({ code, message, column, count }));
+  };
+  notes.push(...xmlIllegalTextNotes(snapshot));
+  const meta = graphmlMetaOf(snapshot);
+  const keyIds = new KeyIds();
+  const graphColumns = planTable(snapshot.graph, "graph", notes, note);
+  const nodeColumns = planTable(snapshot.nodes, "node", notes, note);
+  const edgeColumns = planTable(snapshot.edges, "edge", notes, note);
+  const keys = planKeys([...graphColumns, ...nodeColumns, ...edgeColumns], keyIds);
+  reservedNameNotes(nodeColumns, RESERVED_NODE_NAMES, note);
+  reservedNameNotes(edgeColumns, RESERVED_EDGE_NAMES, note);
+  const weight = planWeight(snapshot, edgeColumns, keyIds, keys, note);
+  const idTypeChanges = countIdTypeChanges(snapshot);
+  if (idTypeChanges > 0) {
+    note(
+      GRAPHML_LOSS.ID_TEXT_TYPE,
+      `${idTypeChanges} node id(s) change type when read back under ids: "canonical" (string ids that are integer text, non-integer numbers)`,
+      null,
+      idTypeChanges
+    );
+  }
+  const edgeIdColumn = snapshot.edges.byRole("id");
+  if (edgeIdColumn !== null) {
+    planEdgeIds(snapshot, edgeIdColumn, options, note);
+  }
+  const unrepresentable = countUnrepresentableNodeIds(snapshot);
+  const needsOriginalIdKey = unrepresentable > 0 && options.sanitizeIds === "mangle";
+  const originalIdKey = needsOriginalIdKey ? keyIds.next(null) : null;
+  const folding = pairFolding(snapshot, { foldMutual: true });
+  if (folding.mutualCount > 0) {
+    note(
+      GRAPHML_LOSS.MUTUAL_AS_UNDIRECTED,
+      `${folding.mutualCount} mutual pair(s) are written as undirected edges; the mutual mark is lost`,
+      null,
+      folding.mutualCount
+    );
+  }
+  const edgedefault = planEdgedefault(snapshot, folding, format, meta);
+  const hierarchy = planHierarchy(snapshot);
+  if (hierarchy.reordered) {
+    note(
+      GRAPHML_LOSS.HIERARCHY_REORDERED,
+      "nodes are written in containment order (children nested under their parent); node indices change after a round trip",
+      hierarchy.parent?.meta.name ?? null
+    );
+  }
+  if (hierarchy.unreachable > 0) {
+    note(
+      GRAPHML_LOSS.PARENT_CYCLE,
+      `${hierarchy.unreachable} node(s) whose parent chain never reaches a root are written at the top level`,
+      hierarchy.parent?.meta.name ?? null,
+      hierarchy.unreachable
+    );
+  }
+  return {
+    options,
+    pretty: format.pretty,
+    notes,
+    keys,
+    graphColumns,
+    nodeColumns,
+    edgeColumns,
+    weight,
+    originalIdKey,
+    edgedefault,
+    folding,
+    edgeIdColumn,
+    sourcePortColumn: snapshot.edges.byRole("sourcePort"),
+    targetPortColumn: snapshot.edges.byRole("targetPort"),
+    hierarchy,
+    meta,
+    needsOriginalIdKey
+  };
+}
+function reservedNameNotes(plans, reserved, note) {
+  for (const plan of plans) {
+    const { column, attrName, keyId } = plan;
+    if (attrName === null || !reserved.has(attrName)) {
+      continue;
+    }
+    note(
+      LOSS.COLUMN_NAME_CHANGED,
+      `${plan.domain} column "${column.meta.name}" is titled like the importer's ${attrName} column and reads back as "${attrName}#${keyId}"`,
+      column.meta.name,
+      column.length - column.nullCount
+    );
+  }
+}
+class KeyIds {
+  constructor() {
+    this.used = /* @__PURE__ */ new Set();
+    this.counter = 0;
+  }
+  /**
+   * Take a key id.
+   * @param preferred - the id to keep when it is an NMTOKEN not handed out yet, or null
+   * @returns the id
+   */
+  next(preferred) {
+    if (preferred !== null && isNmtoken(preferred) && !this.used.has(preferred)) {
+      this.used.add(preferred);
+      return preferred;
+    }
+    for (; ; ) {
+      const candidate = `d${this.counter}`;
+      this.counter++;
+      if (!this.used.has(candidate)) {
+        this.used.add(candidate);
+        return candidate;
+      }
+    }
+  }
+}
+function planKeys(all, keyIds) {
+  const keys = [];
+  const byOrigin = /* @__PURE__ */ new Map();
+  for (const plan of all) {
+    const { origin } = plan.column.meta;
+    if (origin !== null && origin.format === FORMAT && origin.id !== null) {
+      const group = byOrigin.get(origin.id) ?? [];
+      group.push(plan);
+      byOrigin.set(origin.id, group);
+    }
+  }
+  const planned = /* @__PURE__ */ new Set();
+  for (const plan of all) {
+    if (planned.has(plan)) {
+      continue;
+    }
+    const { origin } = plan.column.meta;
+    const group = origin !== null && origin.format === FORMAT && origin.id !== null ? byOrigin.get(origin.id) ?? [plan] : [plan];
+    const shared = group.length > 1 && group.every((other) => other === plan || sameKey(plan, other));
+    const members = shared ? group : [plan];
+    const id = keyIds.next(origin !== null && origin.format === FORMAT ? origin.id : null);
+    for (const member of members) {
+      member.keyId = id;
+      planned.add(member);
+    }
+    const domains = members.map((member) => member.domain);
+    const yfilesName = plan.column.meta.origin?.title ?? plan.column.meta.name;
+    let { attrName } = plan;
+    if (plan.yfiles) {
+      attrName = yfilesName === id ? null : yfilesName;
+    }
+    keys.push({
+      id,
+      domains: domains.length > 1 ? ["graph", "node", "edge"] : domains,
+      attrName,
+      attrType: plan.attrType,
+      yfilesType: plan.yfilesType,
+      column: plan.column
+    });
+  }
+  return keys;
+}
+function planWeight(snapshot, edgeColumns, keyIds, keys, note) {
+  const weights = explicitWeights(snapshot);
+  const origin = snapshot.meta.weightOrigin;
+  const fromGraphml = weights.weighted && origin !== null && origin.format === FORMAT;
+  const attrName = fromGraphml && origin.title !== null ? origin.title : DEFAULT_WEIGHT_NAME;
+  for (const plan of edgeColumns) {
+    if (plan.attrName === attrName) {
+      note(
+        LOSS.WEIGHT_KEY_CLASH,
+        `edge column "${plan.column.meta.name}" is written as a key titled "${attrName}", which the importer reads as THE weight (weightFrom); it reads back as the weight, not as a column`,
+        plan.column.meta.name,
+        plan.column.length - plan.column.nullCount
+      );
+    }
+  }
+  if (!weights.weighted) {
+    return null;
+  }
+  let attrType = "double";
+  if (fromGraphml && origin.type !== null) {
+    const declared = origin.type.trim().toLowerCase();
+    if (declared === "float" || declared === "double" || declared === "long" || declared === "int") {
+      attrType = declared;
+    }
+  }
+  if ((attrType === "int" || attrType === "long") && !weightsIntegral(snapshot, weights)) {
+    attrType = "double";
+  }
+  const id = keyIds.next(fromGraphml ? origin.id : null);
+  keys.push({ id, domains: ["edge"], attrName, attrType, yfilesType: null, column: null });
+  return { keyId: id, attrType, weights };
+}
+function planEdgeIds(snapshot, column, options, note) {
+  if (column.dtype !== "string" && column.dtype !== "dict") {
+    note(
+      GRAPHML_LOSS.EDGE_ID_TEXT,
+      `edge id column "${column.meta.name}" is ${column.dtype}; GraphML edge ids read back as strings`,
+      column.meta.name,
+      snapshot.edgeCount - column.nullCount
+    );
+  }
+  const bad = countBadEdgeIds(column);
+  if (bad === 0) {
+    return;
+  }
+  if (options.sanitizeIds === "mangle") {
+    note(LOSS.ID_MANGLED, `${bad} edge id(s) outside the nmtoken charset are rewritten`, column.meta.name, bad);
+  } else {
+    note(
+      LOSS.ID_CHARSET,
+      `${bad} edge id(s) outside the nmtoken charset; export() will throw unless sanitizeIds is "mangle"`,
+      column.meta.name,
+      bad
+    );
+  }
+}
+function planEdgedefault(snapshot, folding, format, meta) {
+  if (format.edgedefault !== null) {
+    return format.edgedefault;
+  }
+  if (!snapshot.directed) {
+    return "undirected";
+  }
+  let directedCount = 0;
+  let undirectedCount = 0;
+  for (let e = 0; e < snapshot.edgeCount; e++) {
+    if (folding.folded(e)) {
+      continue;
+    }
+    if (isDirectedEdge(folding, e)) {
+      directedCount++;
+    } else {
+      undirectedCount++;
+    }
+  }
+  if (undirectedCount === 0) {
+    return "directed";
+  }
+  const recorded = meta === null ? null : meta.edgedefault;
+  if (recorded !== null) {
+    return recorded;
+  }
+  return undirectedCount > directedCount ? "undirected" : "directed";
+}
+function sameKey(a, b) {
+  return a.attrName === b.attrName && a.attrType === b.attrType && a.yfilesType === b.yfilesType && a.domain !== b.domain && JSON.stringify(a.column.meta.default ?? null) === JSON.stringify(b.column.meta.default ?? null);
+}
+function planTable(table, domain, notes, note) {
+  const plans = [];
+  const columns = [...table];
+  const names = new Set(columns.map((column) => column.meta.name));
+  for (const column of columns) {
+    const { meta } = column;
+    const { role, name } = meta;
+    if (role === "parents") {
+      note(
+        GRAPHML_LOSS.PARENTS_DROPPED,
+        `${domain} column "${name}" (parents) cannot be written: nested graphs hold one parent per node`,
+        name,
+        column.length - column.nullCount
+      );
+      continue;
+    }
+    if (role !== null && (STRUCTURAL_ROLES.has(role) || DROPPED_ROLES.has(role) || SLOT_ROLES_BY_DOMAIN[domain].has(role))) {
+      continue;
+    }
+    if (role !== null && role !== "label" && SLOT_ROLES.has(role)) {
+      withdrawNameChange(notes, name);
+      note(
+        LOSS.ROLE,
+        `${domain} column "${name}" (${role}) is written as a plain attribute; GraphML has no ${role} slot for a ${domain} and the role is lost`,
+        name,
+        column.length - column.nullCount
+      );
+    }
+    const yfiles = meta.dtype === "json" && meta.origin?.namespace === "yfiles";
+    if (meta.dtype === "json" && !yfiles) {
+      note(
+        LOSS.JSON,
+        `${domain} column "${name}" holds nested values; written as JSON text, which reads back as string`,
+        name,
+        column.length - column.nullCount
+      );
+    }
+    if (yfiles) {
+      const bad = countBadTrees(column);
+      if (bad > 0) {
+        note(
+          GRAPHML_LOSS.YFILES_TREE,
+          `${bad} value(s) of yfiles column "${name}" are not XML trees; export() will throw E_COLUMN_TYPE`,
+          name,
+          bad
+        );
+      }
+    }
+    const { origin } = meta;
+    const fromGraphml = origin !== null && origin.format === FORMAT;
+    let attrName = null;
+    if (!yfiles) {
+      attrName = fromGraphml && origin.title !== null ? origin.title : name;
+      if (role === "label" && domain !== "graph" && attrName !== LABEL_COLUMN) {
+        attrName = labelSlot(column, domain, names, notes, note);
+      } else if (role === null && domain !== "graph" && attrName === LABEL_COLUMN) {
+        note(
+          LOSS.ROLE_ASSUMED,
+          `${domain} column "${name}" has no role but is titled "${LABEL_COLUMN}", which the importer reads back with the label role`,
+          name,
+          column.length - column.nullCount
+        );
+      }
+    }
+    plans.push({
+      column,
+      domain,
+      keyId: "",
+      attrType: yfiles ? null : attrTypeFor(column),
+      attrName,
+      yfilesType: yfiles ? origin?.type ?? DEFAULT_YFILES_TYPES[domain] : null,
+      yfiles
+    });
+  }
+  return plans;
+}
+function labelSlot(column, domain, names, notes, note) {
+  const { name } = column.meta;
+  if (!names.has(LABEL_COLUMN)) {
+    return LABEL_COLUMN;
+  }
+  withdrawNameChange(notes, name);
+  note(
+    LOSS.ROLE,
+    `${domain} column "${name}" (label) is written as a plain attribute: the label slot (a key titled "${LABEL_COLUMN}") is taken by column "${LABEL_COLUMN}" and the role is lost`,
+    name,
+    column.length - column.nullCount
+  );
+  return name;
+}
+function withdrawNameChange(notes, name) {
+  const at = notes.findIndex((n) => n.code === LOSS.COLUMN_NAME_CHANGED && n.column === name);
+  if (at >= 0) {
+    notes.splice(at, 1);
+  }
+}
+function attrTypeFor(column) {
+  const { meta } = column;
+  const { origin } = meta;
+  const declared = origin !== null && origin.format === FORMAT && origin.type !== null ? origin.type : null;
+  if (meta.components > 1) {
+    return "string";
+  }
+  switch (meta.dtype) {
+    case "bool":
+      return "boolean";
+    case "i32":
+      return "int";
+    case "f32":
+      return "float";
+    case "f64": {
+      if (declared !== null && declared.trim().toLowerCase() === "long" && columnIntegral(column)) {
+        return "long";
+      }
+      return "double";
+    }
+    case "u8":
+      return "int";
+    case "u32":
+      return columnMax(column) <= I32_MAX ? "int" : "long";
+    case "string":
+      if (declared !== null && TYPE_DTYPES[declared.trim().toLowerCase()] === void 0) {
+        return declared;
+      }
+      return "string";
+    case "dict":
+    case "list":
+    case "json":
+      return "string";
+    default: {
+      const { dtype } = meta;
+      throw new GraphFormatError("E_UNSUPPORTED", `unknown dtype ${String(dtype)}`, { dtype });
+    }
+  }
+}
+function columnIntegral(column) {
+  if (column.dtype !== "f64") {
+    return false;
+  }
+  const { data } = column;
+  for (let r = 0; r < column.length; r++) {
+    if (column.isSet(r) && !Number.isInteger(data[r])) {
+      return false;
+    }
+  }
+  return true;
+}
+function columnMax(column) {
+  if (column.dtype !== "u32") {
+    return 0;
+  }
+  let max = 0;
+  const { data } = column;
+  for (let r = 0; r < column.length; r++) {
+    if (column.isSet(r) && data[r] > max) {
+      max = data[r];
+    }
+  }
+  return max;
+}
+function weightsIntegral(snapshot, weights) {
+  for (let e = 0; e < snapshot.edgeCount; e++) {
+    if (weights.isExplicit(e) && !Number.isInteger(weights.value(e))) {
+      return false;
+    }
+  }
+  return true;
+}
+function countBadTrees(column) {
+  if (column.dtype !== "json") {
+    return 0;
+  }
+  let bad = 0;
+  for (let r = 0; r < column.length; r++) {
+    if (column.isSet(r) && treeProblem(column.values[r]) !== null) {
+      bad++;
+    }
+  }
+  return bad;
+}
+function countIdTypeChanges(snapshot) {
+  const { ids } = snapshot;
+  if (ids.kind === "identity" || ids.kind === "dense") {
+    return 0;
+  }
+  let count = 0;
+  for (let i = 0; i < ids.size; i++) {
+    const id = ids.idOf(i);
+    if (typeof id === "string" ? isNmtoken(id) && isCanonicalIntegerText(id) : !Number.isSafeInteger(id)) {
+      count++;
+    }
+  }
+  return count;
+}
+function countUnrepresentableNodeIds(snapshot) {
+  const { ids } = snapshot;
+  if (ids.kind === "identity" || ids.kind === "dense") {
+    return 0;
+  }
+  let count = 0;
+  for (let i = 0; i < ids.size; i++) {
+    if (!isNmtoken(String(ids.idOf(i)))) {
+      count++;
+    }
+  }
+  return count;
+}
+function countBadEdgeIds(column) {
+  let bad = 0;
+  for (let e = 0; e < column.length; e++) {
+    if (column.isSet(e) && !isNmtoken(edgeIdText(column, e))) {
+      bad++;
+    }
+  }
+  return bad;
+}
+function edgeIdText(column, e) {
+  const value = column.value(e);
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number") {
+    return Number.isInteger(value) ? formatInteger(value) : formatF64(value);
+  }
+  return String(value);
+}
+function isDirectedEdge(folding, e) {
+  return folding.mateOf(e) === INVALID_INDEX && folding.sourceDirected(e);
+}
+function planHierarchy(snapshot) {
+  const parent = snapshot.nodes.byRole("parent");
+  const csr = childrenCsr(snapshot, { column: parent !== null && parent.dtype === "u32" ? parent : null });
+  const walk = csr.depthFirst();
+  const roots = walk.order.filter((u) => walk.depth[u] === 0);
+  return {
+    parent: csr.column,
+    roots,
+    childStart: csr.rowPtr,
+    childList: csr.children,
+    reordered: walk.reordered,
+    unreachable: csr.unreachable
+  };
+}
+function cellText(column, row, attrType) {
+  if (column.meta.components > 1) {
+    const value = column.value(row);
+    return JSON.stringify(Array.from(value));
+  }
+  switch (column.dtype) {
+    case "bool":
+      return column.value(row) === true ? "true" : "false";
+    case "i32":
+    case "u32":
+    case "u8":
+      return String(column.data[row]);
+    case "f32":
+      return formatF32(column.data[row]);
+    case "f64": {
+      const value = column.data[row];
+      return (attrType === "long" || attrType === "int") && Number.isInteger(value) ? formatInteger(value) : formatF64(value);
+    }
+    case "string":
+      return column.valueAt(row);
+    case "dict":
+      return column.dictionary[column.codes[row]];
+    case "list":
+      return JSON.stringify(Array.from(column.sliceOf(row)));
+    case "json":
+      return JSON.stringify(column.values[row]) ?? "";
+    default: {
+      const dtype = column;
+      throw new GraphFormatError("E_UNSUPPORTED", `unknown dtype ${String(dtype)}`, {});
+    }
+  }
+}
+function defaultText(column, attrType) {
+  const value = column.meta.default;
+  if (value === void 0) {
+    return null;
+  }
+  switch (typeof value) {
+    case "boolean":
+      return value ? "true" : "false";
+    case "number":
+      if (column.dtype === "f32") {
+        return formatF32(value);
+      }
+      return (attrType === "long" || attrType === "int") && Number.isInteger(value) ? formatInteger(value) : formatF64(value);
+    case "string":
+      return value;
+    default:
+      return JSON.stringify(value) ?? "";
+  }
+}
+function writeData(plan, row, indent, out) {
+  const { column } = plan;
+  if (!column.isSet(row)) {
+    return;
+  }
+  if (plan.yfiles && column.dtype === "json") {
+    writeTreeData(plan.keyId, column.values[row], indent, out);
+    return;
+  }
+  out.push(`
+${indent}<data key="${plan.keyId}">${escapeXmlText(cellText(column, row, plan.attrType))}</data>`);
+}
+function writeTreeData(keyId, value, indent, out) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    const parts = [];
+    writeXmlTree(value, indent, parts);
+    out.push(`
+${indent}<data key="${keyId}">${parts.join("")}</data>`);
+    return;
+  }
+  out.push(`
+${indent}<data key="${keyId}">`);
+  writeXmlTree(value, `${indent}  `, out);
+  out.push(`
+${indent}</data>`);
+}
+function keyElement(key, indent) {
+  const domain = key.domains.length === 3 ? "all" : key.domains[0];
+  let text = `${indent}<key id="${escapeXmlAttribute(key.id)}" for="${domain}"`;
+  if (key.attrName !== null) {
+    text += ` attr.name="${escapeXmlAttribute(key.attrName)}"`;
+  }
+  if (key.attrType !== null) {
+    text += ` attr.type="${escapeXmlAttribute(key.attrType)}"`;
+  }
+  if (key.yfilesType !== null) {
+    text += ` yfiles.type="${escapeXmlAttribute(key.yfilesType)}"`;
+  }
+  const { column } = key;
+  const desc = column?.meta.extra.desc;
+  const hasDefault = column !== null && column.meta.default !== void 0;
+  if (column === null || typeof desc !== "string" && !hasDefault) {
+    return `${text}/>
+`;
+  }
+  const parts = [`${text}>`];
+  const inner = `${indent}  `;
+  if (typeof desc === "string") {
+    parts.push(`
+${inner}<desc>${escapeXmlText(desc)}</desc>`);
+  }
+  if (hasDefault) {
+    if (key.yfilesType !== null) {
+      const value = column.meta.default;
+      if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+        parts.push(`
+${inner}<default>`);
+        writeXmlTree(value, `${inner}  `, parts);
+        parts.push(`
+${inner}</default>`);
+      } else {
+        const tree = [];
+        writeXmlTree(value, inner, tree);
+        parts.push(`
+${inner}<default>${tree.join("")}</default>`);
+      }
+    } else {
+      parts.push(`
+${inner}<default>${escapeXmlText(defaultText(column, key.attrType) ?? "")}</default>`);
+    }
+  }
+  parts.push(`
+${indent}</key>
+`);
+  return parts.join("");
+}
+function sanitizeEdgeIds(column, mode, edgeCount) {
+  const out = new Array(edgeCount).fill(null);
+  if (column === null) {
+    return out;
+  }
+  const used = /* @__PURE__ */ new Set();
+  const bad = [];
+  for (let e = 0; e < edgeCount; e++) {
+    if (!column.isSet(e)) {
+      continue;
+    }
+    const text = edgeIdText(column, e);
+    if (isNmtoken(text)) {
+      out[e] = text;
+      used.add(text);
+    } else {
+      bad.push(e);
+    }
+  }
+  if (bad.length > 0 && mode === "error") {
+    throw new GraphFormatError(
+      "E_INVALID_ID",
+      `${bad.length} edge id(s) cannot be written as nmtoken (first: ${JSON.stringify(edgeIdText(column, bad[0]))} at edge ${bad[0]}); pass sanitizeIds: "mangle" to rewrite them`,
+      { reason: "charset", charset: "nmtoken", count: bad.length, edge: bad[0] }
+    );
+  }
+  for (const e of bad) {
+    const base = mangleNmtoken(edgeIdText(column, e));
+    let candidate = base;
+    for (let k = 2; used.has(candidate); k++) {
+      candidate = `${base}_${k}`;
+    }
+    used.add(candidate);
+    out[e] = candidate;
+  }
+  return out;
+}
+function* writeGraphml(snapshot, plan) {
+  const ids = sanitizeIds(snapshot, "nmtoken", plan.options.sanitizeIds);
+  const edgeIds = sanitizeEdgeIds(plan.edgeIdColumn, plan.options.sanitizeIds, snapshot.edgeCount);
+  const i1 = plan.pretty ? "  " : "";
+  const i2 = plan.pretty ? "    " : "";
+  const i3 = plan.pretty ? "      " : "";
+  const step = plan.pretty ? "  " : "";
+  yield '<?xml version="1.0" encoding="UTF-8"?>\n';
+  let root = `<graphml xmlns="${GRAPHML_NAMESPACE}"`;
+  const namespaces = { ...plan.meta?.namespaces ?? {} };
+  if ((plan.nodeColumns.some((c) => c.yfiles) || plan.edgeColumns.some((c) => c.yfiles) || plan.graphColumns.some((c) => c.yfiles)) && !Object.values(namespaces).includes(YFILES_NAMESPACE)) {
+    namespaces.y = YFILES_NAMESPACE;
+  }
+  if (!Object.values(namespaces).includes(XSI_NAMESPACE)) {
+    namespaces.xsi = XSI_NAMESPACE;
+  }
+  for (const [prefix, uri] of Object.entries(namespaces)) {
+    root += ` xmlns:${prefix}="${escapeXmlAttribute(uri)}"`;
+  }
+  const xsiPrefix = Object.entries(namespaces).find(([, uri]) => uri === XSI_NAMESPACE)?.[0] ?? "xsi";
+  root += ` ${xsiPrefix}:schemaLocation="${SCHEMA_LOCATION}">
+`;
+  yield root;
+  for (const key of plan.keys) {
+    yield keyElement(key, i1);
+  }
+  if (plan.originalIdKey !== null) {
+    yield `${i1}<key id="${plan.originalIdKey}" for="node" attr.name="${ORIGINAL_ID_ATTRIBUTE}" attr.type="string"/>
+`;
+  }
+  const graphId = plan.meta?.graphId ?? "G";
+  yield `${i1}<graph id="${escapeXmlAttribute(graphId)}" edgedefault="${plan.edgedefault}">`;
+  const { description } = snapshot.meta;
+  if (description !== null) {
+    yield `
+${i2}<desc>${escapeXmlText(description)}</desc>`;
+  }
+  const graphParts = [];
+  for (const column of plan.graphColumns) {
+    writeData(column, 0, i2, graphParts);
+  }
+  if (graphParts.length > 0) {
+    yield graphParts.join("");
+  }
+  const { hierarchy } = plan;
+  const nested = hierarchy.childList.length > 0;
+  const stackNode = [];
+  const stackCursor = [];
+  const written = nested ? new Uint8Array(snapshot.nodeCount) : null;
+  for (const rootNode of hierarchy.roots) {
+    yield* writeNodeSubtree(rootNode, plan, ids, i2, step, stackNode, stackCursor, written);
+  }
+  const list = snapshot.edgeList();
+  const { folding } = plan;
+  for (let e = 0; e < snapshot.edgeCount; e++) {
+    if (folding.folded(e)) {
+      continue;
+    }
+    const parts = [`
+${i2}<edge`];
+    const id = edgeIds[e];
+    if (id !== null) {
+      parts.push(` id="${escapeXmlAttribute(id)}"`);
+    }
+    parts.push(
+      ` source="${escapeXmlAttribute(String(ids.idAt(list.src[e])))}" target="${escapeXmlAttribute(String(ids.idAt(list.dst[e])))}"`
+    );
+    const directed = snapshot.directed && isDirectedEdge(folding, e);
+    if (directed !== (plan.edgedefault === "directed")) {
+      parts.push(` directed="${directed ? "true" : "false"}"`);
+    }
+    const sourcePort = portText(plan.sourcePortColumn, e);
+    if (sourcePort !== null) {
+      parts.push(` sourceport="${escapeXmlAttribute(sourcePort)}"`);
+    }
+    const targetPort = portText(plan.targetPortColumn, e);
+    if (targetPort !== null) {
+      parts.push(` targetport="${escapeXmlAttribute(targetPort)}"`);
+    }
+    const open = parts.length;
+    if (plan.weight !== null) {
+      const { keyId, attrType } = plan.weight;
+      const weight = plan.weight.weights.text(e, attrType === "int" || attrType === "long");
+      if (weight !== null) {
+        parts.push(`
+${i3}<data key="${keyId}">${escapeXmlText(weight)}</data>`);
+      }
+    }
+    for (const column of plan.edgeColumns) {
+      writeData(column, e, i3, parts);
+    }
+    if (parts.length === open) {
+      parts.push("/>");
+    } else {
+      parts.splice(open, 0, ">");
+      parts.push(`
+${i2}</edge>`);
+    }
+    yield parts.join("");
+  }
+  yield `
+${i1}</graph>
+</graphml>
+`;
+}
+function portText(column, e) {
+  if (column === null || !column.isSet(e)) {
+    return null;
+  }
+  const value = column.value(e);
+  return typeof value === "string" ? value : String(value);
+}
+function* writeNodeSubtree(root, plan, ids, indent, step, stackNode, stackCursor, written) {
+  const { hierarchy } = plan;
+  const hasChildren = (u) => hierarchy.childStart[u + 1] > hierarchy.childStart[u];
+  const openNode = (u, depth) => {
+    const pad = indent + step.repeat(depth * 2);
+    const parts = [`
+${pad}<node id="${escapeXmlAttribute(String(ids.idAt(u)))}"`];
+    const open = parts.length;
+    if (plan.originalIdKey !== null && ids.isChanged(u)) {
+      parts.push(
+        `
+${pad}${step}<data key="${plan.originalIdKey}">${escapeXmlText(String(ids.originalAt(u)))}</data>`
+      );
+    }
+    for (const column of plan.nodeColumns) {
+      writeData(column, u, pad + step, parts);
+    }
+    if (hasChildren(u)) {
+      parts.splice(open, 0, ">");
+      parts.push(
+        `
+${pad}${step}<graph id="${escapeXmlAttribute(`${String(ids.idAt(u))}:`)}" edgedefault="${plan.edgedefault}">`
+      );
+      return parts.join("");
+    }
+    if (parts.length === open) {
+      parts.push("/>");
+    } else {
+      parts.splice(open, 0, ">");
+      parts.push(`
+${pad}</node>`);
+    }
+    return parts.join("");
+  };
+  const closeNode = (depth) => {
+    const pad = indent + step.repeat(depth * 2);
+    return `
+${pad}${step}</graph>
+${pad}</node>`;
+  };
+  if (written !== null) {
+    written[root] = 1;
+  }
+  yield openNode(root, 0);
+  if (!hasChildren(root)) {
+    return;
+  }
+  stackNode.push(root);
+  stackCursor.push(hierarchy.childStart[root]);
+  while (stackNode.length > 0) {
+    const top = stackNode.length - 1;
+    const u = stackNode[top];
+    const cursor = stackCursor[top];
+    if (cursor >= hierarchy.childStart[u + 1]) {
+      stackNode.pop();
+      stackCursor.pop();
+      yield closeNode(top);
+      continue;
+    }
+    stackCursor[top] = cursor + 1;
+    const v = hierarchy.childList[cursor];
+    if (written !== null && written[v] === 1) {
+      continue;
+    }
+    if (written !== null) {
+      written[v] = 1;
+    }
+    yield openNode(v, top + 1);
+    if (hasChildren(v)) {
+      stackNode.push(v);
+      stackCursor.push(hierarchy.childStart[v]);
+    }
+  }
+}
+const graphmlExporter = Object.freeze({
+  format: FORMAT,
+  capabilities: CAPABILITIES,
+  /**
+   * Pre-flight: every loss the export would incur.
+   * @param snapshot - the snapshot
+   * @param options - format-specific and common options
+   * @returns the notes
+   */
+  check(snapshot, options) {
+    const plan = planExport(snapshot, resolveExportOptions(options), resolveFormatOptions(options));
+    return Object.freeze(plan.notes);
+  },
+  /**
+   * Write the document as UTF-8 chunks.
+   * @param snapshot - the snapshot
+   * @param options - format-specific and common options
+   * @returns the chunks
+   */
+  export(snapshot, options) {
+    const plan = planExport(snapshot, resolveExportOptions(options), resolveFormatOptions(options));
+    return encodeChunks(writeGraphml(snapshot, plan));
+  },
+  /**
+   * Write the document as one string.
+   * @param snapshot - the snapshot
+   * @param options - format-specific and common options
+   * @returns the document
+   */
+  exportToString(snapshot, options) {
+    const plan = planExport(snapshot, resolveExportOptions(options), resolveFormatOptions(options));
+    return joinText(writeGraphml(snapshot, plan));
+  }
+});
+const FORMAT_DEFAULTS = { ids: "canonical", defaultDirected: false, weightFrom: "weight" };
+const SNIFF_BYTES = 4096;
+const YFILES_MODES = /* @__PURE__ */ new Set(["json", "skip"]);
+const ABORT_CHECK_INTERVAL = 64;
+const USED_OPTIONS = /* @__PURE__ */ new Set([
+  "ids",
+  "addMissingNodes",
+  "duplicateEdges",
+  "selfLoops",
+  "onMixedDirection",
+  "defaultDirected",
+  "weightFrom",
+  "weightDtype",
+  "long",
+  "restoreMangledIds",
+  "hyperedges",
+  "errorLimit",
+  "signal",
+  "onProgress"
+]);
+class IndexFlags {
+  constructor() {
+    this.words = new Uint32Array(64);
+  }
+  /**
+   * Whether an index is marked.
+   * @param index - the node index
+   * @returns true when set
+   */
+  has(index) {
+    const w = index >>> 5;
+    return w < this.words.length && (this.words[w] >>> (index & 31) & 1) === 1;
+  }
+  /**
+   * Mark an index.
+   * @param index - the node index
+   */
+  add(index) {
+    const w = index >>> 5;
+    if (w >= this.words.length) {
+      let size = this.words.length * 2;
+      while (size <= w) {
+        size *= 2;
+      }
+      const grown = new Uint32Array(size);
+      grown.set(this.words);
+      this.words = grown;
+    }
+    this.words[w] |= 1 << (index & 31);
+  }
+}
+class GraphmlReader {
+  /**
+   * Create a reader for one import call.
+   * @param sink - the sink
+   * @param report - the report
+   * @param options - the resolved common options
+   * @param yfilesMode - the resolved yfiles option
+   */
+  constructor(sink, report, options, yfilesMode) {
+    this.ctx = [];
+    this.keys = /* @__PURE__ */ new Map();
+    this.graphs = [];
+    this.nodes = [];
+    this.declared = new IndexFlags();
+    this.edgeIds = /* @__PURE__ */ new Set();
+    this.elementsSinceCheck = 0;
+    this.restored = /* @__PURE__ */ new Map();
+    this.graphColumnNames = /* @__PURE__ */ new Set();
+    this.pendingKey = null;
+    this.edge = null;
+    this.hyperedge = null;
+    this.content = {
+      key: null,
+      pendingKey: null,
+      domain: "node",
+      text: "",
+      tree: null,
+      line: 0
+    };
+    this.descTarget = null;
+    this.descText = "";
+    this.description = null;
+    this.graphSeen = false;
+    this.graphId = null;
+    this.edgedefault = null;
+    this.namespaces = {};
+    this.weightOrigin = null;
+    this.yfilesLossNoted = false;
+    this.hyperedgeCount = 0;
+    this.edgeIdHandle = INVALID_INDEX;
+    this.sourcePortHandle = INVALID_INDEX;
+    this.targetPortHandle = INVALID_INDEX;
+    this.parentHandle = INVALID_INDEX;
+    this.hubHandle = INVALID_INDEX;
+    this.sink = sink;
+    this.report = report;
+    this.options = options;
+    this.yfilesMode = yfilesMode;
+    this.coercer = new IdCoercer(options.ids);
+    this.direction = new DirectionResolver(sink, report, options.onMixedDirection);
+  }
+  // ------------------------------------------------------------------ tokenizer events
+  /**
+   * An element starts.
+   * @param name - the element name
+   * @param attrs - its attributes
+   * @param line - the line
+   */
+  start(name, attrs, line) {
+    const parent = this.ctx.length === 0 ? null : this.ctx[this.ctx.length - 1];
+    switch (parent) {
+      case 9:
+        this.captureStart(name, attrs);
+        return;
+      case 10:
+      case 1:
+        this.ctx.push(
+          10
+          /* Skip */
+        );
+        return;
+      case 8:
+      case 3:
+        this.captureStart(name, attrs);
+        return;
+    }
+    const local = localName(name);
+    switch (parent) {
+      case null:
+        if (local !== "graphml") {
+          this.report.fail(GRAPHML_ISSUE.NOT_GRAPHML, `the root element is <${name}>, not <graphml>`, {
+            line
+          });
+        }
+        this.readRoot(attrs);
+        this.ctx.push(
+          0
+          /* Graphml */
+        );
+        return;
+      case 0:
+        this.startInGraphml(name, local, attrs, line);
+        return;
+      case 2:
+        this.startInKey(name, local, line);
+        return;
+      case 4:
+        this.startInGraph(name, local, attrs, line);
+        return;
+      case 5:
+        this.startInNode(name, local, attrs, line);
+        return;
+      case 6:
+        this.startInEdge(name, local, attrs, line);
+        return;
+      case 7:
+        this.startInHyperedge(name, local, attrs, line);
+        return;
+      default:
+        this.unknownElement(name, line);
+    }
+  }
+  /**
+   * An element ends.
+   * @param name - the element name
+   * @param _line - the line (unused: issues of an element cite its start line)
+   */
+  end(name, _line) {
+    const ctx = this.ctx.pop();
+    switch (ctx) {
+      case 9:
+        this.captureEnd();
+        return;
+      case 10:
+      case 0:
+      case void 0:
+        return;
+      case 1:
+        this.finishDesc();
+        return;
+      case 2:
+        this.finishKey();
+        return;
+      case 3:
+        this.finishDefault();
+        return;
+      case 8:
+        this.finishData();
+        return;
+      case 5:
+        this.finishNode();
+        return;
+      case 6:
+        this.finishEdge();
+        return;
+      case 7:
+        this.finishHyperedge();
+        return;
+      case 4:
+        this.graphs.pop();
+        return;
+      default: {
+        const value = ctx;
+        throw new GraphFormatError("E_UNSUPPORTED", `unknown reader state ${String(value)}`, { name });
+      }
+    }
+  }
+  /**
+   * Character data.
+   * @param text - the text
+   * @param line - the line
+   */
+  text(text, line) {
+    const ctx = this.ctx.length === 0 ? null : this.ctx[this.ctx.length - 1];
+    switch (ctx) {
+      case 9:
+        this.content.tree?.text(text);
+        return;
+      case 8:
+      case 3:
+        if (this.content.tree === null) {
+          this.content.text += text;
+        } else {
+          this.content.tree.text(text);
+        }
+        return;
+      case 1:
+        this.descText += text;
+        return;
+      case 10:
+        return;
+      default:
+        if (!isWhitespace(text)) {
+          this.report.warnOnce(
+            "validation-error",
+            GRAPHML_ISSUE.STRAY_TEXT,
+            "text where GraphML allows only elements was ignored",
+            { line }
+          );
+        }
+    }
+  }
+  /**
+   * After the last event: the document must have held a graph; the metadata is written.
+   */
+  finish() {
+    if (!this.graphSeen) {
+      this.report.fail(GRAPHML_ISSUE.NO_GRAPH, "the document has no <graph> element");
+    }
+    const meta = { graphId: this.graphId, edgedefault: this.edgedefault, namespaces: this.namespaces };
+    this.sink.setMeta({
+      sourceFormat: FORMAT,
+      description: this.description ?? void 0,
+      weightOrigin: this.weightOrigin === null ? void 0 : {
+        format: FORMAT,
+        id: this.weightOrigin.id,
+        title: this.weightOrigin.title,
+        type: this.weightOrigin.type,
+        namespace: null
+      },
+      extra: { [META_KEY]: meta }
+    });
+  }
+  // ------------------------------------------------------------------ structure
+  /**
+   * Record the root element's namespace declarations.
+   * @param attrs - the root attributes
+   */
+  readRoot(attrs) {
+    for (const [key, value] of attrs) {
+      if (key.startsWith("xmlns:") && value !== GRAPHML_NAMESPACE && value !== XSI_NAMESPACE) {
+        this.namespaces[key.slice(6)] = value;
+      }
+    }
+  }
+  /**
+   * A child of `<graphml>`.
+   * @param name - the element name
+   * @param local - its local name
+   * @param attrs - its attributes
+   * @param line - the line
+   */
+  startInGraphml(name, local, attrs, line) {
+    switch (local) {
+      case "desc":
+        this.beginDesc("graph");
+        return;
+      case "key":
+        this.beginKey(attrs, line);
+        return;
+      case "graph":
+        this.beginGraph(attrs, line, INVALID_INDEX);
+        return;
+      case "data":
+        this.beginData(attrs, line, "graph");
+        return;
+      default:
+        this.unknownElement(name, line);
+    }
+  }
+  /**
+   * A child of `<key>`.
+   * @param name - the element name
+   * @param local - its local name
+   * @param line - the line
+   */
+  startInKey(name, local, line) {
+    switch (local) {
+      case "desc":
+        this.beginDesc("key");
+        return;
+      case "default":
+        this.content.key = null;
+        this.content.pendingKey = this.pendingKey;
+        this.content.text = "";
+        this.content.tree = null;
+        this.content.line = line;
+        this.ctx.push(
+          3
+          /* Default */
+        );
+        return;
+      default:
+        this.unknownElement(name, line);
+    }
+  }
+  /**
+   * A child of `<graph>`.
+   * @param name - the element name
+   * @param local - its local name
+   * @param attrs - its attributes
+   * @param line - the line
+   */
+  startInGraph(name, local, attrs, line) {
+    switch (local) {
+      case "desc":
+        if (this.graphs.length === 1) {
+          this.beginDesc("graph");
+        } else {
+          this.ctx.push(
+            10
+            /* Skip */
+          );
+        }
+        return;
+      case "data":
+        if (this.graphs.length === 1) {
+          this.beginData(attrs, line, "graph");
+        } else {
+          this.report.warnOnce(
+            "unsupported",
+            GRAPHML_ISSUE.NESTED_GRAPH_DATA,
+            "data of a nested <graph> cannot be kept; only the top-level graph has attributes",
+            { line }
+          );
+          this.ctx.push(
+            10
+            /* Skip */
+          );
+        }
+        return;
+      case "node":
+        this.beginNode(attrs, line);
+        return;
+      case "edge":
+        this.beginEdge(attrs, line);
+        return;
+      case "hyperedge":
+        this.beginHyperedge(attrs, line);
+        return;
+      case "locator":
+        this.report.warnOnce(
+          "unsupported",
+          GRAPHML_ISSUE.LOCATOR_DROPPED,
+          "<locator> references are not followed",
+          { line }
+        );
+        this.ctx.push(
+          10
+          /* Skip */
+        );
+        return;
+      default:
+        this.unknownElement(name, line);
+    }
+  }
+  /**
+   * A child of `<node>`.
+   * @param name - the element name
+   * @param local - its local name
+   * @param attrs - its attributes
+   * @param line - the line
+   */
+  startInNode(name, local, attrs, line) {
+    switch (local) {
+      case "desc":
+        this.report.warnOnce(
+          "unsupported",
+          GRAPHML_ISSUE.DESC_DROPPED,
+          "node and edge <desc> texts are not kept",
+          {
+            line
+          }
+        );
+        this.ctx.push(
+          10
+          /* Skip */
+        );
+        return;
+      case "data":
+        this.beginData(attrs, line, "node");
+        return;
+      case "port":
+        this.report.warnOnce(
+          "unsupported",
+          GRAPHML_ISSUE.PORT_DECLARATION,
+          "<port> declarations are not kept; sourceport / targetport edge attributes are",
+          { line }
+        );
+        this.ctx.push(
+          10
+          /* Skip */
+        );
+        return;
+      case "graph": {
+        const node = this.nodes[this.nodes.length - 1];
+        this.materializeNode(node);
+        this.beginGraph(attrs, line, node.index);
+        return;
+      }
+      case "locator":
+        this.report.warnOnce(
+          "unsupported",
+          GRAPHML_ISSUE.LOCATOR_DROPPED,
+          "<locator> references are not followed",
+          { line }
+        );
+        this.ctx.push(
+          10
+          /* Skip */
+        );
+        return;
+      default:
+        this.unknownElement(name, line);
+    }
+  }
+  /**
+   * A child of `<edge>`.
+   * @param name - the element name
+   * @param local - its local name
+   * @param attrs - its attributes
+   * @param line - the line
+   */
+  startInEdge(name, local, attrs, line) {
+    switch (local) {
+      case "desc":
+        this.report.warnOnce(
+          "unsupported",
+          GRAPHML_ISSUE.DESC_DROPPED,
+          "node and edge <desc> texts are not kept",
+          {
+            line
+          }
+        );
+        this.ctx.push(
+          10
+          /* Skip */
+        );
+        return;
+      case "data":
+        this.beginData(attrs, line, "edge");
+        return;
+      default:
+        this.unknownElement(name, line);
+    }
+  }
+  /**
+   * A child of `<hyperedge>` (under the star / clique policies).
+   * @param name - the element name
+   * @param local - its local name
+   * @param attrs - its attributes
+   * @param line - the line
+   */
+  startInHyperedge(name, local, attrs, line) {
+    switch (local) {
+      case "endpoint":
+        this.readEndpoint(attrs, line);
+        this.ctx.push(
+          10
+          /* Skip */
+        );
+        return;
+      case "data":
+        this.report.warnOnce(
+          "unsupported",
+          GRAPHML_ISSUE.HYPEREDGE_DATA_DROPPED,
+          "hyperedge data are not kept by the star / clique expansions",
+          { line }
+        );
+        this.ctx.push(
+          10
+          /* Skip */
+        );
+        return;
+      case "desc":
+        this.ctx.push(
+          10
+          /* Skip */
+        );
+        return;
+      default:
+        this.unknownElement(name, line);
+    }
+  }
+  /**
+   * Report an element the schema does not define at this place and skip its subtree.
+   * @param name - the element name
+   * @param line - the line
+   */
+  unknownElement(name, line) {
+    this.report.warnOnce(
+      "unsupported",
+      GRAPHML_ISSUE.UNKNOWN_ELEMENT,
+      `element <${name}> is not GraphML and was skipped`,
+      {
+        line,
+        element: name
+      }
+    );
+    this.ctx.push(
+      10
+      /* Skip */
+    );
+  }
+  /**
+   * Open a `<desc>`.
+   * @param target - what the text describes
+   */
+  beginDesc(target) {
+    this.descTarget = target;
+    this.descText = "";
+    this.ctx.push(
+      1
+      /* Desc */
+    );
+  }
+  /** Close a `<desc>`. */
+  finishDesc() {
+    const text = this.descText.trim();
+    if (this.descTarget === "key" && this.pendingKey !== null) {
+      this.pendingKey.desc = text;
+    } else if (this.descTarget === "graph" && text.length > 0) {
+      this.description = text;
+    }
+    this.descTarget = null;
+    this.descText = "";
+  }
+  // ------------------------------------------------------------------ graphs
+  /**
+   * Open a `<graph>`: the top-level one sets the sink's direction (rule 1 of design section
+   * 8.4); a nested one records its container as the parent of its nodes.
+   * @param attrs - the graph attributes
+   * @param line - the line
+   * @param parent - the containing node's index, or INVALID_INDEX
+   */
+  beginGraph(attrs, line, parent) {
+    const top = this.graphs.length === 0;
+    const edgedefault = attrs.get("edgedefault");
+    let directed;
+    if (edgedefault === "directed" || edgedefault === "undirected") {
+      directed = edgedefault === "directed";
+    } else if (edgedefault === void 0) {
+      directed = top ? this.options.defaultDirected : this.graphs[this.graphs.length - 1].directed;
+      this.report.warning(
+        "validation-error",
+        GRAPHML_ISSUE.EDGEDEFAULT_MISSING,
+        `<graph> has no edgedefault; read as ${directed ? "directed" : "undirected"}`,
+        { line }
+      );
+    } else {
+      directed = top ? this.options.defaultDirected : this.graphs[this.graphs.length - 1].directed;
+      this.report.error(
+        "validation-error",
+        GRAPHML_ISSUE.INVALID_EDGEDEFAULT,
+        `edgedefault "${edgedefault}" is neither directed nor undirected; read as ${directed ? "directed" : "undirected"}`,
+        { line }
+      );
+    }
+    if (top && this.graphSeen) {
+      this.report.warnOnce(
+        "unsupported",
+        GRAPHML_ISSUE.MULTIPLE_GRAPHS,
+        "the document holds more than one top-level <graph>; their nodes and edges are merged into one graph",
+        { line, element: attrs.get("id") ?? null }
+      );
+    } else if (top) {
+      this.graphSeen = true;
+      this.graphId = attrs.get("id") ?? null;
+      this.edgedefault = directed ? "directed" : "undirected";
+      this.direction.setHeader(directed, { line });
+      const nodes = this.hint(attrs.get("parse.nodes"), "parse.nodes", line);
+      const edges = this.hint(attrs.get("parse.edges"), "parse.edges", line);
+      if (nodes !== null || edges !== null) {
+        try {
+          this.sink.reserve(nodes ?? void 0, edges ?? void 0);
+        } catch (err) {
+          if (!(err instanceof GraphFormatError)) {
+            throw err;
+          }
+          this.report.warning(
+            "validation-error",
+            GRAPHML_ISSUE.COUNT_HINT,
+            `count hint refused: ${err.message}`,
+            {
+              line
+            }
+          );
+        }
+      }
+    }
+    this.graphs.push({ directed, parent });
+    this.ctx.push(
+      4
+      /* Graph */
+    );
+  }
+  /**
+   * A `parse.nodes` / `parse.edges` hint the sink can reserve; anything else is reported and ignored.
+   * @param text - the attribute text, or undefined
+   * @param name - the attribute name
+   * @param line - the line
+   * @returns the count, or null
+   */
+  hint(text, name, line) {
+    if (text === void 0) {
+      return null;
+    }
+    const n = hint(text);
+    if (n === null || n > MAX_COUNT) {
+      this.report.warning(
+        "validation-error",
+        GRAPHML_ISSUE.COUNT_HINT,
+        `<graph ${name}="${text}"> is not a count the sink can reserve; ignored`,
+        { line, element: name }
+      );
+      return null;
+    }
+    return n;
+  }
+  // ------------------------------------------------------------------ keys
+  /**
+   * Open a `<key>`; the column is declared at `</key>` once its default is known.
+   * @param attrs - the key attributes
+   * @param line - the line
+   */
+  beginKey(attrs, line) {
+    const id = attrs.get("id") ?? null;
+    const forText = attrs.get("for") ?? "all";
+    let domains;
+    switch (forText) {
+      case "all":
+        domains = ["graph", "node", "edge"];
+        break;
+      case "graph":
+      case "node":
+      case "edge":
+        domains = [forText];
+        break;
+      case "hyperedge":
+      case "port":
+      case "endpoint":
+        this.report.warning(
+          "unsupported",
+          GRAPHML_ISSUE.KEY_DOMAIN_UNSUPPORTED,
+          `key "${id ?? ""}" is declared for ${forText} elements, which are not kept`,
+          { line, element: id }
+        );
+        domains = [];
+        break;
+      default:
+        this.report.error(
+          "validation-error",
+          GRAPHML_ISSUE.KEY_FOR_INVALID,
+          `key "${id ?? ""}" has an unknown for="${forText}"`,
+          { line, element: id }
+        );
+        domains = [];
+    }
+    this.pendingKey = {
+      id,
+      attrName: attrs.get("attr.name") ?? null,
+      attrType: attrs.get("attr.type") ?? null,
+      yfilesType: attrs.get("yfiles.type") ?? null,
+      domains,
+      line,
+      desc: "",
+      defaultText: null,
+      defaultTree: void 0
+    };
+    this.ctx.push(
+      2
+      /* Key */
+    );
+  }
+  /** Close a `<key>`: declare its columns. */
+  finishKey() {
+    const key = this.pendingKey;
+    this.pendingKey = null;
+    if (key === null) {
+      return;
+    }
+    const where = { line: key.line, element: key.id };
+    if (key.id === null || key.id.length === 0) {
+      this.report.error("validation-error", GRAPHML_ISSUE.KEY_MISSING_ID, "<key> without an id", where);
+      return;
+    }
+    if (this.keys.has(key.id)) {
+      this.report.error(
+        "validation-error",
+        GRAPHML_ISSUE.DUPLICATE_KEY,
+        `key "${key.id}" is declared twice`,
+        where
+      );
+      return;
+    }
+    const yfiles = key.yfilesType !== null;
+    const name = key.attrName !== null && key.attrName.length > 0 ? key.attrName : key.id;
+    const skipped = yfiles && this.yfilesMode === "skip";
+    if (skipped) {
+      this.report.warning(
+        "unsupported",
+        GRAPHML_ISSUE.YFILES_SKIPPED,
+        `yFiles key "${key.id}" (${key.yfilesType ?? ""}) skipped per the yfiles option`,
+        where
+      );
+    }
+    let weight = false;
+    let originalId = false;
+    let node = null;
+    let edge = null;
+    let graph = null;
+    for (const domain of key.domains) {
+      if (skipped) {
+        continue;
+      }
+      if (domain === "edge" && !yfiles && isWeightField(name, this.options.weightFrom)) {
+        weight = true;
+        this.weightOrigin ??= { id: key.id, title: key.attrName, type: key.attrType };
+        continue;
+      }
+      if (domain === "node" && !yfiles && name === ORIGINAL_ID_ATTRIBUTE) {
+        if (this.options.restoreMangledIds) {
+          originalId = true;
+          continue;
+        }
+        node = this.declareOriginalIdColumn(key);
+        continue;
+      }
+      try {
+        const target = yfiles ? this.declareYfiles(key, name, domain) : this.declareTyped(key, name, domain);
+        if (domain === "node") {
+          node = target;
+        } else if (domain === "edge") {
+          edge = target;
+        } else {
+          graph = target;
+        }
+      } catch (err) {
+        this.report.recordError(err, where);
+      }
+    }
+    this.keys.set(key.id, {
+      id: key.id,
+      name,
+      node,
+      edge,
+      graph,
+      weight,
+      originalId,
+      yfiles,
+      skipped,
+      domains: key.domains
+    });
+  }
+  /**
+   * Declare the column of a typed (or untyped, then string) key in one domain.
+   * @param key - the key
+   * @param name - the resolved attribute name
+   * @param domain - the domain
+   * @returns the column target
+   */
+  declareTyped(key, name, domain) {
+    const id = key.id ?? "";
+    const declared = declareAttribute({
+      format: FORMAT,
+      id,
+      title: key.attrName !== null && key.attrName.length > 0 ? key.attrName : null,
+      type: key.attrType,
+      defaultText: key.defaultTree === void 0 ? key.defaultText : null,
+      listSyntax: "comma",
+      role: domain !== "graph" && name === LABEL_COLUMN ? "label" : null,
+      long: this.options.long,
+      taken: this.takenIn(domain)
+    });
+    for (const issue of declared.issues) {
+      this.report.warning(issue.category, issue.code, issue.message, { line: key.line, element: id });
+    }
+    if (key.defaultTree !== void 0) {
+      this.report.warning(
+        "validation-error",
+        GRAPHML_ISSUE.DATA_NESTED,
+        `the <default> of key "${id}" holds elements; a ${key.attrType ?? "string"} default must be text`,
+        { line: key.line, element: id }
+      );
+    }
+    const { decl } = declared;
+    if (key.desc.length > 0) {
+      decl.extra = { desc: key.desc };
+    }
+    return this.declareTarget(domain, decl, declared.spec, declared.listSyntax);
+  }
+  /**
+   * Declare the json column of a yFiles key in one domain.
+   * @param key - the key
+   * @param name - the resolved attribute name
+   * @param domain - the domain
+   * @returns the column target
+   */
+  declareYfiles(key, name, domain) {
+    const id = key.id ?? "";
+    const columnName = uniqueColumnName(name, id, this.takenIn(domain));
+    const decl = {
+      name: columnName,
+      dtype: "json",
+      nullable: true,
+      origin: {
+        format: FORMAT,
+        id,
+        title: key.attrName !== null && key.attrName !== columnName ? key.attrName : null,
+        type: key.yfilesType,
+        namespace: "yfiles"
+      }
+    };
+    if (key.defaultTree !== void 0) {
+      decl.default = key.defaultTree;
+    } else if (key.defaultText !== null) {
+      decl.default = key.defaultText;
+    }
+    if (key.desc.length > 0) {
+      decl.extra = { desc: key.desc };
+    }
+    return this.declareTarget(domain, decl, null, "comma");
+  }
+  /**
+   * Declare the `graphty.originalId` column that keeps the exporter's original ids when
+   * restoreMangledIds is off.
+   * @param key - the key
+   * @returns the column target
+   */
+  declareOriginalIdColumn(key) {
+    const decl = {
+      name: uniqueColumnName(ORIGINAL_ID_COLUMN, key.id, this.takenIn("node")),
+      dtype: "string",
+      nullable: true,
+      role: "originalId",
+      origin: { format: FORMAT, id: key.id, title: key.attrName, type: key.attrType, namespace: null }
+    };
+    return this.declareTarget("node", decl, null, "comma");
+  }
+  /**
+   * Push a declaration into the sink for one domain through the shared design section 5.6 rule:
+   * a role another column already holds is dropped (reported), a name the sink holds with
+   * another shape is renamed `<name>#<id>` (reported).
+   * @param domain - the domain
+   * @param decl - the declaration
+   * @param spec - the value spec, or null for json
+   * @param listSyntax - the list syntax
+   * @returns the target
+   */
+  declareTarget(domain, decl, spec, listSyntax) {
+    if (domain === "graph") {
+      this.sink.setGraphValue(decl.name, void 0, decl);
+      this.graphColumnNames.add(decl.name);
+      return { name: decl.name, handle: INVALID_INDEX, decl, spec, listSyntax };
+    }
+    const resolved = declareResolved(this.sink, domain, decl, this.report, { element: decl.name });
+    return { name: resolved.decl.name, handle: resolved.handle, decl: resolved.decl, spec, listSyntax };
+  }
+  /**
+   * The `taken` predicate of a domain: the reserved XML-derived names plus the sink's columns.
+   * @param domain - the domain
+   * @returns the predicate
+   */
+  takenIn(domain) {
+    if (domain === "graph") {
+      return (name) => this.graphColumnNames.has(name);
+    }
+    const reserved = domain === "node" ? RESERVED_NODE_NAMES : RESERVED_EDGE_NAMES;
+    const inSink = takenIn(this.sink, domain);
+    return (name) => reserved.has(name) || inSink(name);
+  }
+  // ------------------------------------------------------------------ data and defaults
+  /**
+   * Open a `<data>`.
+   * @param attrs - its attributes
+   * @param line - the line
+   * @param domain - the domain of the element holding it
+   */
+  beginData(attrs, line, domain) {
+    const keyId = attrs.get("key");
+    const { content } = this;
+    content.key = null;
+    content.pendingKey = null;
+    content.domain = domain;
+    content.text = "";
+    content.tree = null;
+    content.line = line;
+    if (keyId === void 0) {
+      this.report.error("validation-error", GRAPHML_ISSUE.DATA_MISSING_KEY, "<data> without a key attribute", {
+        line
+      });
+    } else {
+      const key = this.keys.get(keyId);
+      if (key === void 0) {
+        this.report.error(
+          "validation-error",
+          GRAPHML_ISSUE.UNKNOWN_KEY,
+          `<data> references undeclared key "${keyId}"`,
+          { line, element: keyId }
+        );
+      } else if (!key.skipped && !key.domains.includes(domain)) {
+        this.report.warnOnce(
+          "validation-error",
+          GRAPHML_ISSUE.KEY_DOMAIN,
+          `key "${keyId}" is declared for ${key.domains.join(" / ")} elements but used on a ${domain}; ignored`,
+          { line, element: keyId }
+        );
+      } else {
+        content.key = key;
+      }
+    }
+    this.ctx.push(
+      8
+      /* Data */
+    );
+  }
+  /**
+   * A child element inside `<data>` / `<default>`: the content becomes a tree.
+   * @param name - the element name
+   * @param attrs - its attributes
+   */
+  captureStart(name, attrs) {
+    const { content } = this;
+    if (content.tree === null) {
+      content.tree = new XmlTreeBuilder();
+      if (content.text.length > 0) {
+        content.tree.text(content.text);
+        content.text = "";
+      }
+    }
+    content.tree.start(name, attrs);
+    this.ctx.push(
+      9
+      /* Capture */
+    );
+  }
+  /** A captured element ends. */
+  captureEnd() {
+    this.content.tree?.end();
+  }
+  /** Close a `<default>`: keep its text or tree for the key. */
+  finishDefault() {
+    const { content } = this;
+    const key = content.pendingKey;
+    if (key === null) {
+      return;
+    }
+    if (content.tree !== null) {
+      key.defaultTree = content.tree.finish();
+    } else {
+      key.defaultText = content.text;
+    }
+    content.tree = null;
+    content.text = "";
+    content.pendingKey = null;
+  }
+  /** Close a `<data>`: parse the value and route it to its element. */
+  finishData() {
+    const { content } = this;
+    const { key } = content;
+    const value = content.tree === null ? content.text : content.tree.finish();
+    content.tree = null;
+    content.text = "";
+    content.key = null;
+    if (key === null || key.skipped) {
+      return;
+    }
+    const where = { line: content.line, element: key.id };
+    switch (content.domain) {
+      case "node": {
+        const node = this.nodes[this.nodes.length - 1];
+        if (key.originalId) {
+          if (typeof value === "string") {
+            node.restoredId = value;
+          }
+          return;
+        }
+        if (key.node === null) {
+          return;
+        }
+        const parsed = this.parseValue(key.node, value, where);
+        if (parsed === void 0) {
+          return;
+        }
+        if (node.index === INVALID_INDEX) {
+          node.pending.push(key.node.handle, parsed);
+        } else if (!node.failed) {
+          this.sink.setNodeValue(key.node.handle, node.index, parsed);
+        }
+        return;
+      }
+      case "edge": {
+        const { edge } = this;
+        if (edge === null) {
+          return;
+        }
+        if (key.weight) {
+          if (typeof value !== "string") {
+            this.report.error(
+              "validation-error",
+              GRAPHML_ISSUE.DATA_NESTED,
+              "a weight value must be text",
+              where
+            );
+            return;
+          }
+          try {
+            edge.weight = parseWeightText(value);
+          } catch (err) {
+            this.skipEdge(edge);
+            this.report.recordError(err, where);
+          }
+          return;
+        }
+        if (key.edge === null) {
+          return;
+        }
+        const parsed = this.parseValue(key.edge, value, where);
+        if (parsed !== void 0) {
+          edge.pending.push(key.edge.handle, parsed);
+        }
+        return;
+      }
+      case "graph": {
+        if (key.graph === null) {
+          return;
+        }
+        const parsed = this.parseValue(key.graph, value, where);
+        if (parsed !== void 0) {
+          try {
+            this.sink.setGraphValue(key.graph.name, parsed, key.graph.decl);
+          } catch (err) {
+            this.report.recordError(err, where);
+          }
+        }
+        return;
+      }
+      default: {
+        const { domain } = content;
+        throw new GraphFormatError("E_UNSUPPORTED", `unknown data domain ${String(domain)}`, {});
+      }
+    }
+  }
+  /**
+   * Parse the content of a `<data>` by its column's declaration.
+   * @param target - the column
+   * @param value - the text, or the tree of a nested subtree
+   * @param where - the location for issues
+   * @returns the value to write, or undefined when there is none (blank, or an error was recorded)
+   */
+  parseValue(target, value, where) {
+    if (target.spec === null) {
+      if (!this.yfilesLossNoted) {
+        this.yfilesLossNoted = true;
+        this.report.loss(
+          GRAPHML_LOSS.YFILES_JSON,
+          "yFiles nested XML is kept as a JSON tree: structure preserved, not byte-exact",
+          target.name
+        );
+      }
+      return value;
+    }
+    if (typeof value !== "string") {
+      this.report.error(
+        "validation-error",
+        GRAPHML_ISSUE.DATA_NESTED,
+        `<data> of the ${target.spec.declared} attribute "${target.name}" holds elements, not text`,
+        where
+      );
+      return void 0;
+    }
+    const { spec } = target;
+    if (spec.kind !== "string" && isWhitespace(value)) {
+      return void 0;
+    }
+    try {
+      const parsed = parseDeclaredValue(value, spec, target.listSyntax);
+      if (spec.precision && losesPrecision(spec, value)) {
+        this.report.warnOnce(
+          "precision",
+          PRECISION_CODE,
+          `long values of "${target.name}" beyond 2^53 are stored as the nearest double`,
+          { line: where.line, element: target.name }
+        );
+      }
+      return parsed;
+    } catch (err) {
+      this.report.recordError(err, where);
+      return void 0;
+    }
+  }
+  // ------------------------------------------------------------------ nodes
+  /**
+   * Open a `<node>`; it is added to the sink when its data is complete (or a nested graph
+   * starts), so a `graphty:originalId` value can replace its id.
+   * @param attrs - the node attributes
+   * @param line - the line
+   */
+  beginNode(attrs, line) {
+    const graph = this.graphs[this.graphs.length - 1];
+    const state = {
+      id: null,
+      idText: null,
+      index: INVALID_INDEX,
+      parent: graph.parent,
+      pending: [],
+      restoredId: null,
+      failed: false,
+      line
+    };
+    const idText = attrs.get("id");
+    if (idText === void 0 || idText.length === 0) {
+      this.skipNode(state);
+      this.report.error("missing-value", GRAPHML_ISSUE.MISSING_ID, "<node> without an id", { line });
+    } else {
+      try {
+        state.id = this.coercer.text(idText);
+        state.idText = idText;
+        this.reportMerge(idText, line);
+      } catch (err) {
+        this.skipNode(state);
+        this.report.recordError(err, { line, element: idText });
+      }
+    }
+    this.nodes.push(state);
+    this.ctx.push(
+      5
+      /* Node */
+    );
+  }
+  /**
+   * Add a node to the sink and flush its pending values.
+   * @param node - the node state
+   */
+  materializeNode(node) {
+    if (node.index !== INVALID_INDEX || node.failed) {
+      return;
+    }
+    const id = node.restoredId ?? node.id;
+    if (id === null) {
+      node.failed = true;
+      return;
+    }
+    if (node.restoredId !== null && node.idText !== null) {
+      this.restored.set(node.idText, node.restoredId);
+    }
+    try {
+      const existing = this.sink.indexOf(id);
+      const index = this.sink.addNode(id);
+      if (existing !== INVALID_INDEX && this.declared.has(index)) {
+        this.report.warning(
+          "validation-error",
+          GRAPHML_ISSUE.DUPLICATE_NODE,
+          `node "${String(id)}" is declared twice; the declarations are merged`,
+          { line: node.line, element: String(id) }
+        );
+      } else {
+        this.report.counts.nodes++;
+      }
+      this.declared.add(index);
+      node.index = index;
+      this.checkAbort();
+      if (node.parent !== INVALID_INDEX) {
+        this.sink.setNodeValue(this.parentColumn(), index, node.parent);
+      }
+      const { pending } = node;
+      for (let i = 0; i < pending.length; i += 2) {
+        this.sink.setNodeValue(pending[i], index, pending[i + 1]);
+      }
+      pending.length = 0;
+    } catch (err) {
+      this.skipNode(node);
+      this.report.recordError(err, { line: node.line, element: String(id) });
+    }
+  }
+  /**
+   * Mark a node element skipped (once) before its error is recorded, so the report's counts
+   * include it even when that error is the one that exceeds the limit.
+   * @param node - the node state
+   */
+  skipNode(node) {
+    if (!node.failed) {
+      node.failed = true;
+      this.report.counts.skippedNodes++;
+    }
+  }
+  /** Close a `<node>`. */
+  finishNode() {
+    const node = this.nodes.pop();
+    if (node !== void 0) {
+      this.materializeNode(node);
+    }
+  }
+  /**
+   * The `parent` column, declared on first use.
+   * @returns the handle
+   */
+  parentColumn() {
+    if (this.parentHandle === INVALID_INDEX) {
+      this.parentHandle = this.sink.declareNodeColumn({
+        name: PARENT_COLUMN,
+        dtype: "u32",
+        role: "parent",
+        refersTo: "node",
+        nullable: true,
+        origin: { format: FORMAT, id: null, title: null, type: "graph", namespace: null }
+      });
+    }
+    return this.parentHandle;
+  }
+  // ------------------------------------------------------------------ edges
+  /**
+   * Open an `<edge>`; it is pushed at `</edge>` once its weight and data are known.
+   * @param attrs - the edge attributes
+   * @param line - the line
+   */
+  beginEdge(attrs, line) {
+    const graph = this.graphs[this.graphs.length - 1];
+    const edge = {
+      source: null,
+      target: null,
+      id: attrs.get("id") ?? null,
+      kind: graph.directed ? "directed" : "undirected",
+      sourcePort: attrs.get("sourceport") ?? null,
+      targetPort: attrs.get("targetport") ?? null,
+      weight: void 0,
+      pending: [],
+      failed: false,
+      line
+    };
+    const where = { line, element: edge.id };
+    const sourceText = attrs.get("source");
+    const targetText = attrs.get("target");
+    if (sourceText === void 0 || sourceText.length === 0) {
+      this.skipEdge(edge);
+      this.report.error("missing-value", GRAPHML_ISSUE.MISSING_ENDPOINT, "<edge> without a source", where);
+    }
+    if (targetText === void 0 || targetText.length === 0) {
+      this.skipEdge(edge);
+      this.report.error("missing-value", GRAPHML_ISSUE.MISSING_ENDPOINT, "<edge> without a target", where);
+    }
+    if (!edge.failed && sourceText !== void 0 && targetText !== void 0) {
+      try {
+        edge.source = this.endpointId(sourceText, line);
+        edge.target = this.endpointId(targetText, line);
+      } catch (err) {
+        this.skipEdge(edge);
+        this.report.recordError(err, where);
+      }
+    }
+    const directedText = attrs.get("directed");
+    if (directedText !== void 0) {
+      if (directedText === "true") {
+        edge.kind = "directed";
+      } else if (directedText === "false") {
+        edge.kind = "undirected";
+      } else {
+        this.skipEdge(edge);
+        this.report.error(
+          "validation-error",
+          GRAPHML_ISSUE.INVALID_DIRECTED,
+          `directed="${directedText}" is neither true nor false`,
+          where
+        );
+      }
+    }
+    this.edge = edge;
+    this.ctx.push(
+      6
+      /* Edge */
+    );
+  }
+  /**
+   * Close an `<edge>`: push it through the direction resolver and write its values.
+   */
+  finishEdge() {
+    const { edge } = this;
+    this.edge = null;
+    if (edge === null) {
+      return;
+    }
+    if (edge.failed || edge.source === null || edge.target === null) {
+      this.skipEdge(edge);
+      return;
+    }
+    const element = edge.id ?? `${String(edge.source)} -> ${String(edge.target)}`;
+    const where = { line: edge.line, element };
+    try {
+      if (!this.options.addMissingNodes) {
+        this.requireNode(edge.source);
+        this.requireNode(edge.target);
+      }
+      if (edge.id !== null && this.edgeIds.has(edge.id)) {
+        throw new GraphFormatError("E_DUPLICATE_EDGE_ID", `edge id "${edge.id}" is used twice`, {
+          id: edge.id
+        });
+      }
+      const before = this.sink.edgeCount;
+      this.countEndpoints(edge.source, edge.target);
+      const e = this.direction.addEdge(edge.source, edge.target, edge.kind, edge.weight, where);
+      this.report.counts.edges += this.sink.edgeCount - before;
+      this.checkAbort();
+      if (edge.id !== null) {
+        this.edgeIds.add(edge.id);
+        this.sink.setEdgeValue(this.edgeIdColumn(), e, edge.id);
+      }
+      if (edge.sourcePort !== null) {
+        this.sink.setEdgeValue(this.portColumn("source"), e, edge.sourcePort);
+      }
+      if (edge.targetPort !== null) {
+        this.sink.setEdgeValue(this.portColumn("target"), e, edge.targetPort);
+      }
+      const { pending } = edge;
+      for (let i = 0; i < pending.length; i += 2) {
+        this.sink.setEdgeValue(pending[i], e, pending[i + 1]);
+      }
+    } catch (err) {
+      this.skipEdge(edge);
+      this.report.recordError(err, where);
+    }
+  }
+  /**
+   * Mark an edge (or hyperedge) element skipped once, before its error is recorded.
+   * @param edge - the edge state
+   */
+  skipEdge(edge) {
+    if (!edge.failed) {
+      edge.failed = true;
+      this.report.counts.skippedEdges++;
+    }
+  }
+  /**
+   * E_UNKNOWN_NODE when an endpoint was never declared (addMissingNodes false enforced by the
+   * importer, whatever the sink allows).
+   * @param id - the endpoint id
+   */
+  requireNode(id) {
+    if (this.sink.indexOf(id) === INVALID_INDEX) {
+      throw new GraphFormatError("E_UNKNOWN_NODE", `edge endpoint "${String(id)}" is not a declared node`, {
+        id
+      });
+    }
+  }
+  /**
+   * The edge `id` column (role id, unique), declared on first use.
+   * @returns the handle
+   */
+  edgeIdColumn() {
+    if (this.edgeIdHandle === INVALID_INDEX) {
+      this.edgeIdHandle = this.sink.declareEdgeColumn({
+        name: EDGE_ID_COLUMN,
+        dtype: "string",
+        role: "id",
+        unique: true,
+        nullable: true,
+        origin: { format: FORMAT, id: null, title: null, type: "id", namespace: null }
+      });
+    }
+    return this.edgeIdHandle;
+  }
+  /**
+   * The sourceport / targetport column, declared on first use.
+   * @param side - which end
+   * @returns the handle
+   */
+  portColumn(side) {
+    if (side === "source") {
+      if (this.sourcePortHandle === INVALID_INDEX) {
+        this.sourcePortHandle = this.sink.declareEdgeColumn({
+          name: SOURCE_PORT_COLUMN,
+          dtype: "string",
+          role: "sourcePort",
+          nullable: true,
+          origin: { format: FORMAT, id: null, title: null, type: "sourceport", namespace: null }
+        });
+      }
+      return this.sourcePortHandle;
+    }
+    if (this.targetPortHandle === INVALID_INDEX) {
+      this.targetPortHandle = this.sink.declareEdgeColumn({
+        name: TARGET_PORT_COLUMN,
+        dtype: "string",
+        role: "targetPort",
+        nullable: true,
+        origin: { format: FORMAT, id: null, title: null, type: "targetport", namespace: null }
+      });
+    }
+    return this.targetPortHandle;
+  }
+  // ------------------------------------------------------------------ hyperedges
+  /**
+   * Open a `<hyperedge>` per the hyperedges option.
+   * @param attrs - its attributes
+   * @param line - the line
+   */
+  beginHyperedge(attrs, line) {
+    const id = attrs.get("id") ?? null;
+    const where = { line, element: id };
+    switch (this.options.hyperedges) {
+      case "error":
+        this.report.error(
+          "unsupported",
+          GRAPHML_ISSUE.HYPEREDGE,
+          'hyperedge refused (hyperedges: "error")',
+          where
+        );
+        throw this.report.abort("hyperedge refused", { code: GRAPHML_ISSUE.HYPEREDGE });
+      case "skip":
+        this.report.warnOnce(
+          "unsupported",
+          GRAPHML_ISSUE.HYPEREDGE_SKIPPED,
+          'hyperedges are skipped (hyperedges: "skip"); use "star" or "clique" to expand them',
+          where
+        );
+        this.report.counts.skippedEdges++;
+        this.ctx.push(
+          10
+          /* Skip */
+        );
+        return;
+      case "star":
+      case "clique":
+        this.hyperedge = { id, endpoints: [], failed: false, line };
+        this.ctx.push(
+          7
+          /* Hyperedge */
+        );
+        return;
+      default: {
+        const policy = this.options.hyperedges;
+        throw new GraphFormatError("E_UNSUPPORTED", `unknown hyperedges policy ${String(policy)}`, {
+          option: "hyperedges"
+        });
+      }
+    }
+  }
+  /**
+   * An `<endpoint>` of the open hyperedge.
+   * @param attrs - its attributes
+   * @param line - the line
+   */
+  readEndpoint(attrs, line) {
+    const { hyperedge } = this;
+    if (hyperedge === null) {
+      return;
+    }
+    const where = { line, element: hyperedge.id };
+    const nodeText = attrs.get("node");
+    const typeText = attrs.get("type") ?? "undir";
+    if (nodeText === void 0 || nodeText.length === 0) {
+      this.skipEdge(hyperedge);
+      this.report.error("missing-value", GRAPHML_ISSUE.HYPEREDGE_ENDPOINT, "<endpoint> without a node", where);
+      return;
+    }
+    if (typeText !== "in" && typeText !== "out" && typeText !== "undir") {
+      this.skipEdge(hyperedge);
+      this.report.error(
+        "validation-error",
+        GRAPHML_ISSUE.HYPEREDGE_ENDPOINT,
+        `endpoint type "${typeText}" is not in, out or undir`,
+        where
+      );
+      return;
+    }
+    try {
+      const node = this.endpointId(nodeText, line);
+      hyperedge.endpoints.push({ node, type: typeText });
+    } catch (err) {
+      this.skipEdge(hyperedge);
+      this.report.recordError(err, where);
+    }
+  }
+  /** Close a `<hyperedge>`: expand it to a star or a clique. */
+  finishHyperedge() {
+    const { hyperedge } = this;
+    this.hyperedge = null;
+    if (hyperedge === null) {
+      return;
+    }
+    if (hyperedge.failed) {
+      return;
+    }
+    const where = { line: hyperedge.line, element: hyperedge.id };
+    try {
+      if (this.options.hyperedges === "star") {
+        this.expandStar(hyperedge, where);
+      } else {
+        this.expandClique(hyperedge, where);
+      }
+    } catch (err) {
+      this.skipEdge(hyperedge);
+      this.report.recordError(err, where);
+    }
+  }
+  /**
+   * Star expansion: a synthetic hub node (marked in the `graphty.hyperedge` column) joined to
+   * every endpoint; `in` endpoints point at the hub, `out` endpoints are pointed at by it,
+   * `undir` endpoints are undirected.
+   * @param hyperedge - the hyperedge
+   * @param where - the location for issues
+   */
+  expandStar(hyperedge, where) {
+    this.hyperedgeCount++;
+    let hubId = hyperedge.id ?? `hyperedge${this.hyperedgeCount}`;
+    for (let n = 2; this.sink.indexOf(hubId) !== INVALID_INDEX; n++) {
+      hubId = `${hyperedge.id ?? `hyperedge${this.hyperedgeCount}`}#${n}`;
+    }
+    const hub = this.sink.addNode(hubId);
+    this.declared.add(hub);
+    this.report.counts.nodes++;
+    if (this.hubHandle === INVALID_INDEX) {
+      this.hubHandle = this.sink.declareNodeColumn({
+        name: HYPEREDGE_HUB_COLUMN,
+        dtype: "bool",
+        nullable: true,
+        origin: { format: FORMAT, id: null, title: null, type: "hyperedge", namespace: null }
+      });
+    }
+    this.sink.setNodeValue(this.hubHandle, hub, true);
+    for (const endpoint of hyperedge.endpoints) {
+      const before = this.sink.edgeCount;
+      switch (endpoint.type) {
+        case "in":
+          this.direction.addEdge(endpoint.node, hubId, "directed", void 0, where);
+          break;
+        case "out":
+          this.direction.addEdge(hubId, endpoint.node, "directed", void 0, where);
+          break;
+        case "undir":
+          this.direction.addEdge(endpoint.node, hubId, "undirected", void 0, where);
+          break;
+        default: {
+          const { type } = endpoint;
+          throw new GraphFormatError("E_UNSUPPORTED", `unknown endpoint type ${String(type)}`, {});
+        }
+      }
+      this.report.counts.edges += this.sink.edgeCount - before;
+    }
+  }
+  /**
+   * Clique expansion: every `in` endpoint points at every `out` endpoint; `undir` endpoints are
+   * joined undirected to every other endpoint; two endpoints of the same direction are not joined.
+   * @param hyperedge - the hyperedge
+   * @param where - the location for issues
+   */
+  expandClique(hyperedge, where) {
+    const { endpoints } = hyperedge;
+    for (let i = 0; i < endpoints.length; i++) {
+      for (let j = i + 1; j < endpoints.length; j++) {
+        const a = endpoints[i];
+        const b = endpoints[j];
+        const before = this.sink.edgeCount;
+        if (a.type === "undir" || b.type === "undir") {
+          this.direction.addEdge(a.node, b.node, "undirected", void 0, where);
+        } else if (a.type === "in" && b.type === "out") {
+          this.direction.addEdge(a.node, b.node, "directed", void 0, where);
+        } else if (a.type === "out" && b.type === "in") {
+          this.direction.addEdge(b.node, a.node, "directed", void 0, where);
+        } else {
+          continue;
+        }
+        this.report.counts.edges += this.sink.edgeCount - before;
+      }
+    }
+  }
+  // ------------------------------------------------------------------ options and ids
+  /**
+   * Count the endpoints of an edge the file never declared as nodes of the sink (created under
+   * addMissingNodes), so the report describes what the sink holds (design section 8.6).
+   * @param source - the source id
+   * @param target - the target id
+   */
+  countEndpoints(source, target) {
+    if (!this.options.addMissingNodes) {
+      return;
+    }
+    let created = 0;
+    if (this.sink.indexOf(source) === INVALID_INDEX) {
+      created++;
+    }
+    if (source !== target && this.sink.indexOf(target) === INVALID_INDEX) {
+      created++;
+    }
+    this.report.counts.nodes += created;
+  }
+  /** Check the cancellation signal every ABORT_CHECK_INTERVAL elements. */
+  checkAbort() {
+    if (++this.elementsSinceCheck >= ABORT_CHECK_INTERVAL) {
+      this.elementsSinceCheck = 0;
+      throwIfAborted(this.options.signal);
+    }
+  }
+  /**
+   * The id an edge endpoint refers to: the original id when the text is a mangled id restored
+   * from `graphty:originalId` (the exporter writes endpoints with the mangled id), else the
+   * coerced text.
+   * @param text - the source / target / endpoint node text
+   * @param line - the line
+   * @returns the node id
+   */
+  endpointId(text, line) {
+    const restored = this.restored.get(text);
+    if (restored !== void 0) {
+      return restored;
+    }
+    const id = this.coercer.text(text);
+    this.reportMerge(text, line);
+    return id;
+  }
+  /**
+   * Report a merge the coercer detected under ids: "number".
+   * @param text - the id text just coerced
+   * @param line - the line
+   */
+  reportMerge(text, line) {
+    const merge = this.coercer.lastMerge;
+    if (merge !== null) {
+      this.report.warning(
+        "coercion",
+        GRAPHML_ISSUE.ID_MERGED,
+        `id "${merge.text}" merged with "${merge.previousText}" as ${merge.id} under ids: "number"`,
+        { line, element: text }
+      );
+    }
+  }
+}
+function hint(text) {
+  if (text === void 0 || !/^[0-9]+$/.test(text)) {
+    return null;
+  }
+  const n = Number(text);
+  return Number.isSafeInteger(n) ? n : null;
+}
+function resolveYfiles(options) {
+  const value = options?.yfiles;
+  if (value === void 0) {
+    return "json";
+  }
+  if (typeof value !== "string" || !YFILES_MODES.has(value)) {
+    throw new GraphFormatError("E_UNSUPPORTED", `option yfiles: ${JSON.stringify(value)} is not "json" or "skip"`, {
+      option: "yfiles",
+      found: value
+    });
+  }
+  return value;
+}
+function sniffGraphml(head) {
+  const text = new TextDecoder("utf-8", { fatal: false }).decode(head.subarray(0, SNIFF_BYTES));
+  const root = text.indexOf("<graphml");
+  if (root >= 0) {
+    return text.includes(GRAPHML_NAMESPACE, root) ? 1 : 0.9;
+  }
+  return /^\s*<(\?xml|!--|!DOCTYPE)/.test(text) ? 0.05 : 0;
+}
+async function importGraphml(input, sink, options) {
+  const common = resolveImportOptions(options, FORMAT_DEFAULTS);
+  const yfilesMode = resolveYfiles(options);
+  const report = new ImportReportBuilder(FORMAT, common.errorLimit);
+  reportSinkOptions(sink, options, report, true);
+  reportUnusedOptions(options, report, USED_OPTIONS);
+  const reader = new GraphmlReader(sink, report, common, yfilesMode);
+  try {
+    await tokenizeXml(textChunks(input, report, common), reader);
+  } catch (err) {
+    if (err instanceof XmlSyntaxError) {
+      report.fail(GRAPHML_ISSUE.XML_SYNTAX, err.message, { line: err.line });
+    }
+    throw err;
+  }
+  reader.finish();
+  throwIfAborted(common.signal);
+  return report.finish();
+}
+const graphmlImporter = Object.freeze({
+  format: FORMAT,
+  extensions: EXTENSIONS,
+  mimeTypes: MIME_TYPES,
+  sniff: sniffGraphml,
+  import: importGraphml
+});
+export {
+  GRAPHML_ISSUE as G,
+  GRAPHML_LOSS as a,
+  graphmlImporter as b,
+  graphmlExporter as g
+};
+//# sourceMappingURL=importer-GozH8DkN.js.map