@graphty/graph-io 0.3.18 → 0.3.20

package/dist/chunks/importer-D_e7e7LX.js

@@ -0,0 +1,3055 @@
+import { INVALID_INDEX, GraphFormatError } from "@graphty/graph-format";
+import { af as MIXED_DIRECTION_CODE, D as DIRECTION_FORCED_CODE, a as DIRECTION_REFUSED_CODE, S as SINK_OPTION_CODE, O as OPTION_IGNORED_CODE, I as ID_MERGED_CODE, R as ROLE_TAKEN_CODE, C as COLUMN_RENAMED_CODE, A as AMBIGUOUS_GRAPH_NAME_CODE, G as GRAPH_NOT_FOUND_CODE, M as MULTIPLE_GRAPHS_CODE, au as STRAY_TEXT_CODE, Y as UNKNOWN_ELEMENT_CODE, k as UNKNOWN_ATTR_TYPE_CODE, am as EQUATION_AS_TEXT_CODE, h as PARENT_CYCLE_CODE, U as UNKNOWN_PARENT_CODE, i as DUPLICATE_ATTRIBUTE_CODE, j as DANGLING_REFERENCE_CODE, P as PRECISION_CODE, W as WIDENED_CODE, B as BAD_VALUE_CODE, c as DUPLICATE_EDGE_ID_CODE, d as DUPLICATE_NODE_CODE, e as MISSING_ENDPOINT_CODE, f as MISSING_ID_CODE, N as NO_GRAPH_CODE, q as UNKNOWN_ENCODING_CODE, E as ENCODING_FALLBACK_CODE, r as INVALID_ENCODING_CODE, s as INVALID_UTF8_CODE, u as EMPTY_INPUT_CODE, aw as XML_SYNTAX_CODE, a3 as STORAGE_CLASS_CODE, a7 as WEIGHT_KEY_CLASH_CODE, a6 as ROLE_ASSUMED_CODE, a5 as COLUMN_RENAMED_LOSS_CODE, b as ID_TEXT_TYPE_CODE, aa as MUTUAL_EXPANDED_CODE, ab as PARENTS_DROPPED_CODE, ac as ROLE_DROPPED_CODE, ad as TEMPORAL_TEXT_DROPPED_CODE, ae as TEMPORAL_DROPPED_CODE, a0 as XML_ILLEGAL_CHAR_CODE, Q as uniqueColumnName, L as declareResolved, _ as DictHeuristic, K as IdCoercer, J as DirectionResolver, y as throwIfAborted, F as reportSinkOptions, z as reportUnusedOptions, H as chooseGraph, v as resolveImportOptions, w as ImportReportBuilder, x as textChunks } from "./report-B1z4WT9e.js";
+import { l as localName, a as escapeXmlText, g as isWhitespace, e as escapeXmlAttribute, t as tokenizeXml, f as xmlDeclaredEncoding, X as XmlSyntaxError } from "./escape-B-tkk_Cl.js";
+import { p as parseWeightText } from "./weights-Dzba96G3.js";
+import { p as parseTextCell, i as inferTextDtype } from "./text-Dr0Ifpag.js";
+const FORMAT = "xgmml";
+const EXTENSIONS = Object.freeze([".xgmml", ".xml"]);
+const MIME_TYPES = Object.freeze(["application/xgmml", "text/xgmml", "text/xgmml+xml"]);
+const XGMML_NAMESPACE = "http://www.cs.rpi.edu/XGMML";
+const CY_NAMESPACE = "http://www.cytoscape.org";
+const XLINK_NAMESPACE = "http://www.w3.org/1999/xlink";
+const META_KEY = "xgmml";
+const LABEL_COLUMN = "label";
+const EDGE_ID_COLUMN = "id";
+const POSITION_COLUMN = "position";
+const Z_COLUMN = "z";
+const GRAPHICS_COLUMN = "graphics";
+const PARENT_COLUMN = "parent";
+const PARENTS_COLUMN = "parents";
+const SUBGRAPH_COLUMN = "xgmml.subgraph";
+const NESTED_NETWORK_COLUMN = "cytoscape.nestedNetwork";
+const NETWORK_POINTER_COLUMN = "xgmml.networkPointer";
+const NETWORKS_COLUMN = "xgmml.networks";
+const INTERACTION_COLUMN = "interaction";
+const XGMML_ORIGIN_NAMESPACE = "xgmml";
+const CYTOSCAPE_ORIGIN_NAMESPACE = "cytoscape";
+const XGMML_ISSUE = Object.freeze({
+  /** Fatal: the input is not well-formed XML. */
+  XML_SYNTAX: XML_SYNTAX_CODE,
+  /** Fatal: the input is empty or whitespace only. */
+  EMPTY_INPUT: EMPTY_INPUT_CODE,
+  /** Fatal: the input holds invalid UTF-8. */
+  INVALID_UTF8: INVALID_UTF8_CODE,
+  /** Fatal: bytes invalid in the encoding a BOM, a declaration or the option chose. */
+  INVALID_ENCODING: INVALID_ENCODING_CODE,
+  /** Undeclared non-UTF-8 bytes were read as windows-1252. */
+  ENCODING_FALLBACK: ENCODING_FALLBACK_CODE,
+  /** A declared encoding the platform cannot decode was ignored. */
+  UNKNOWN_ENCODING: UNKNOWN_ENCODING_CODE,
+  /** Fatal: the root element is not `<graph>` (an XHTML page embedding one, a GraphML file). */
+  NO_GRAPH: NO_GRAPH_CODE,
+  /** Fatal: a session view document (`cy:view="1"`): view SUIDs and no topology. */
+  VIEW_DOCUMENT: "E_XGMML_VIEW_DOCUMENT",
+  /** A node with neither an id nor a label; it is skipped with its subtree. */
+  MISSING_ID: MISSING_ID_CODE,
+  /** A node without an id; its label is used as the id. */
+  ID_FROM_LABEL: "W_XGMML_ID_FROM_LABEL",
+  /** An edge without a source or a target that no label alias resolves. */
+  MISSING_ENDPOINT: MISSING_ENDPOINT_CODE,
+  /** An edge endpoint that names no node (addMissingNodes false); the edge is skipped. */
+  UNKNOWN_NODE: "E_UNKNOWN_NODE",
+  /** Endpoints resolved through Cytoscape's `"a (pp) b"` label aliases; interactions filled from labels. */
+  LABEL_ALIAS: "W_XGMML_LABEL_ALIAS",
+  /** A node id declared twice; the declarations are merged. */
+  DUPLICATE_NODE: DUPLICATE_NODE_CODE,
+  /** An edge id used twice; the second edge is skipped. */
+  DUPLICATE_EDGE_ID: DUPLICATE_EDGE_ID_CODE,
+  /** A meta-edge the 2.x writer repeats inside a group; the copy is dropped. */
+  GROUP_DUPLICATE_EDGE: "W_XGMML_GROUP_DUPLICATE_EDGE",
+  /** A `directed` or `cy:directed` value other than 0 / 1. */
+  BAD_DIRECTED: "W_XGMML_BAD_DIRECTED",
+  /** A `documentVersion` that does not parse; the dialect is chosen from the content. */
+  DOCUMENT_VERSION: "W_XGMML_DOCUMENT_VERSION",
+  /** A root `<graph>` with neither the XGMML namespace nor an XGMML DOCTYPE. */
+  NO_NAMESPACE: "W_XGMML_NO_NAMESPACE",
+  /** A malformed `<att>`: a list with a value, a scalar with child atts, an att with no name. */
+  BAD_ATT: "W_XGMML_BAD_ATT",
+  /** A bare `&` read as `&amp;` under repairBareAmpersands. */
+  AMPERSAND_REPAIRED: "W_XGMML_AMPERSAND_REPAIRED",
+  /** Two surrogate character references joined under pairSurrogateReferences. */
+  SURROGATE_PAIRED: "W_XGMML_SURROGATE_PAIRED",
+  /** An empty list whose element type nothing states; a list of strings is assumed. */
+  EMPTY_LIST_TYPE: "W_XGMML_EMPTY_LIST_TYPE",
+  /** A record list, a list of lists, a 2.x map or foreign XML in an att, kept as json. */
+  RECORD_LIST: "W_XGMML_RECORD_LIST",
+  /** A pointer into another file (`file.xgmml#id`); kept as text. */
+  CROSS_FILE_REFERENCE: "W_XGMML_CROSS_FILE_REFERENCE",
+  /** A graph nested in an edge's att; there is no model for it. */
+  EDGE_NESTED_GRAPH: "W_XGMML_EDGE_NESTED_GRAPH",
+  /** Elements of a session network declared outside every registered subnetwork. */
+  ROOT_ONLY_ELEMENTS: "W_XGMML_ROOT_ONLY_ELEMENTS",
+  /** A value that does not parse as its declared type; the cell is unset. */
+  BAD_VALUE: BAD_VALUE_CODE,
+  /** A column widened because its values or declared types disagree. */
+  WIDENED: WIDENED_CODE,
+  /** A long or real beyond what a double holds exactly. */
+  PRECISION: PRECISION_CODE,
+  /** A reference (xlink:href, nested-network pointer) that names nothing. */
+  DANGLING_REFERENCE: DANGLING_REFERENCE_CODE,
+  /** The same attribute twice on one element; the later value wins. */
+  DUPLICATE_ATTRIBUTE: DUPLICATE_ATTRIBUTE_CODE,
+  /** A group membership naming no node. */
+  UNKNOWN_PARENT: UNKNOWN_PARENT_CODE,
+  /** A group membership that would close a parent cycle; that link is dropped. */
+  PARENT_CYCLE: PARENT_CYCLE_CODE,
+  /** A Cytoscape formula kept as its text. */
+  EQUATION_AS_TEXT: EQUATION_AS_TEXT_CODE,
+  /** An att type XGMML and Cytoscape do not define; kept as text. */
+  UNKNOWN_ATTR_TYPE: UNKNOWN_ATTR_TYPE_CODE,
+  /** An element XGMML does not define at that place; skipped with its subtree. */
+  UNKNOWN_ELEMENT: UNKNOWN_ELEMENT_CODE,
+  /** Character data where XGMML allows only elements, or inside an att. */
+  STRAY_TEXT: STRAY_TEXT_CODE,
+  /** A session network document holds several registered networks; one was read. */
+  MULTIPLE_GRAPHS: MULTIPLE_GRAPHS_CODE,
+  /** graphIndex / graphName names no network (fatal). */
+  GRAPH_NOT_FOUND: GRAPH_NOT_FOUND_CODE,
+  /** graphName names several networks (fatal). */
+  AMBIGUOUS_GRAPH_NAME: AMBIGUOUS_GRAPH_NAME_CODE,
+  /** A column renamed `<name>#<n>` because its name was taken. */
+  COLUMN_RENAMED: COLUMN_RENAMED_CODE,
+  /** A column declared without its role because the table already holds it. */
+  ROLE_TAKEN: ROLE_TAKEN_CODE,
+  /** Two id texts merged into one number under ids "number". */
+  ID_MERGED: ID_MERGED_CODE,
+  /** An option the format has no use for. */
+  OPTION_IGNORED: OPTION_IGNORED_CODE,
+  /** A builder-policy option the sink does not honour. */
+  SINK_OPTION: SINK_OPTION_CODE,
+  /** The sink refused the file's direction. */
+  DIRECTION_REFUSED: DIRECTION_REFUSED_CODE,
+  /** Edges forced to the policy's direction. */
+  DIRECTION_FORCED: DIRECTION_FORCED_CODE,
+  /** A mixed file under onMixedDirection "error" (fatal). */
+  MIXED_DIRECTION: MIXED_DIRECTION_CODE
+});
+const XGMML_LOSS = Object.freeze({
+  /** A json or nested-list column written as a string att. */
+  JSON_AS_STRING: "W_XGMML_JSON_AS_STRING",
+  /** A dtype written as a wider Cytoscape type (f32 as Double, u32 above i32 as Long, u8 as Integer, dict as String). */
+  WIDENED_TYPE: "W_XGMML_WIDENED_TYPE",
+  /** A string holding a character XML 1.0 cannot carry; export() throws. */
+  XML_ILLEGAL_CHAR: XML_ILLEGAL_CHAR_CODE,
+  /** A temporal column written as plain numbers. */
+  TEMPORAL_DROPPED: TEMPORAL_DROPPED_CODE,
+  /** A temporal text companion written as a plain string att. */
+  TEMPORAL_TEXT_DROPPED: TEMPORAL_TEXT_DROPPED_CODE,
+  /** A role the format has no slot for, written as a plain att. */
+  ROLE_DROPPED: ROLE_DROPPED_CODE,
+  /** A parents column not written because the snapshot also has a parent column. */
+  PARENTS_DROPPED: PARENTS_DROPPED_CODE,
+  /** A mutual pair written as two directed edges. */
+  MUTUAL_EXPANDED: MUTUAL_EXPANDED_CODE,
+  /** Node ids whose text reads back as the other type. */
+  ID_TEXT_TYPE: ID_TEXT_TYPE_CODE,
+  /** An edge id column of another dtype written as text; it reads back as strings. */
+  EDGE_ID_TEXT: "W_XGMML_EDGE_ID_TEXT",
+  /** Strings holding a literal backslash-n or backslash-t read back as newline / tab (Cytoscape's escapes). */
+  BACKSLASH_ESCAPE: "W_XGMML_BACKSLASH_ESCAPE",
+  /** A position that cannot be written as it is: another shape, a non-finite coordinate, a z read back in the z column. */
+  POSITION: "W_XGMML_POSITION",
+  /** Nodes whose parent chain never reaches a root are written at the top level. */
+  PARENT_CYCLE: "W_XGMML_PARENT_CYCLE",
+  /** A column named like a column the importer owns reads back renamed. */
+  COLUMN_NAME_CHANGED: COLUMN_RENAMED_LOSS_CODE,
+  /** A role-less column written into a slot reads back with the slot's role. */
+  ROLE_ASSUMED: ROLE_ASSUMED_CODE,
+  /** A plain `weight` edge column reads back as THE weight. */
+  WEIGHT_KEY_CLASH: WEIGHT_KEY_CLASH_CODE,
+  /** A string / dict column that reads back as the other storage class. */
+  STORAGE_CLASS_CHANGED: STORAGE_CLASS_CODE,
+  /** Edge labels shaped `a (i) b` read back with an `interaction` column (Cytoscape's label alias). */
+  INTERACTION_FROM_LABEL: "W_XGMML_INTERACTION_FROM_LABEL"
+});
+const NODE_READ = /* @__PURE__ */ new Set(["id", "label", "name", "xlink:href", "cy:nodeId"]);
+const EDGE_READ = /* @__PURE__ */ new Set([
+  "id",
+  "label",
+  "name",
+  "source",
+  "target",
+  "weight",
+  "cy:directed",
+  "xlink:href",
+  "cy:edgeId"
+]);
+const ATT_READ = /* @__PURE__ */ new Set([
+  "name",
+  "label",
+  "type",
+  "value",
+  "cy:type",
+  "cy:elementType",
+  "cy:hidden",
+  "cy:equation",
+  "cy:editable"
+]);
+const TRUE_TEXT = /^(1|true|yes)$/i;
+function isCyTrue(text) {
+  return text !== null && text !== void 0 && TRUE_TEXT.test(text.trim());
+}
+function normaliseName(name, xlinkPrefixes) {
+  const colon = name.indexOf(":");
+  if (colon > 0 && xlinkPrefixes.has(name.slice(0, colon))) {
+    return `xlink:${name.slice(colon + 1)}`;
+  }
+  return name;
+}
+class XgmmlParser {
+  /**
+   * Create a parser.
+   * @param report - the report issues are recorded in
+   */
+  constructor(report) {
+    this.frames = [];
+    this.xlinkPrefixes = /* @__PURE__ */ new Set(["xlink"]);
+    this.rootGraph = null;
+    this.nodes = [];
+    this.edges = [];
+    this.graphs = [];
+    this.cytoscape = false;
+    this.xgmmlNamespace = false;
+    this.rootPrefix = null;
+    this.rdf = {};
+    this.rdfXml = null;
+    this.rdfElement = null;
+    this.report = report;
+  }
+  /**
+   * The parsed document.
+   * @returns the document; E_NO_GRAPH (fatal) when no root graph was read
+   */
+  document() {
+    const root = this.rootGraph;
+    if (root === null) {
+      return this.report.fail(XGMML_ISSUE.NO_GRAPH, "the document has no <graph> element");
+    }
+    return {
+      root,
+      nodes: this.nodes,
+      edges: this.edges,
+      graphs: this.graphs,
+      cytoscape: this.cytoscape,
+      xgmmlNamespace: this.xgmmlNamespace,
+      rdf: this.rdf,
+      rdfXml: this.rdfXml
+    };
+  }
+  /**
+   * An element starts.
+   * @param rawName - the element name as written
+   * @param rawAttrs - its attributes
+   * @param line - the line
+   */
+  start(rawName, rawAttrs, line) {
+    const top = this.frames.length === 0 ? null : this.frames[this.frames.length - 1];
+    if (top === null) {
+      this.startRoot(rawName, rawAttrs, line);
+      return;
+    }
+    if (top.kind === "skip") {
+      this.frames.push(top);
+      return;
+    }
+    if (top.kind === "capture") {
+      this.capture(top, rawName, rawAttrs);
+      return;
+    }
+    const attrs = this.normalise(rawAttrs);
+    const name = localName(rawName);
+    switch (top.kind) {
+      case "graph":
+        this.startInGraph(top.graph, rawName, name, attrs, line);
+        return;
+      case "node":
+        this.startInElement(top.node, rawName, name, attrs, line);
+        return;
+      case "edge":
+        this.startInElement(top.edge, rawName, name, attrs, line);
+        return;
+      case "att":
+        this.startInAtt(top, rawName, name, attrs, line);
+        return;
+      case "graphics":
+        this.startInGraphics(top.target, rawName, name, attrs, line);
+        return;
+      case "line":
+        if (name === "point") {
+          top.points.push(Object.fromEntries(attrs));
+          this.frames.push({ kind: "skip" });
+          return;
+        }
+        this.unknownElement(rawName, line);
+        return;
+      default: {
+        const kind = top;
+        throw new Error(`unknown XGMML frame ${String(kind)}`);
+      }
+    }
+  }
+  /**
+   * An element ends.
+   * @param name - the element name
+   * @param _line - the line
+   */
+  end(name, _line) {
+    const frame = this.frames.pop();
+    const below = this.frames.length === 0 ? null : this.frames[this.frames.length - 1];
+    switch (frame?.kind) {
+      case "capture":
+        frame.att.xml = `${frame.att.xml ?? ""}</${name}>`;
+        frame.depth--;
+        if (frame.depth > 0) {
+          this.frames.push(frame);
+        } else if (frame.att.name === "networkMetadata") {
+          this.rdfXml = frame.att.xml;
+        }
+        this.rdfElement = null;
+        return;
+      case "att":
+        if (below?.kind === "graphics") {
+          this.graphicsAtt(below.target, frame.att);
+        }
+        return;
+      case "line":
+        if (below?.kind === "graphics") {
+          below.target.graphics = { ...below.target.graphics ?? {}, Line: frame.points };
+        }
+        return;
+    }
+  }
+  /**
+   * Character data.
+   * @param text - the text
+   * @param line - the line
+   */
+  text(text, line) {
+    const top = this.frames.length === 0 ? null : this.frames[this.frames.length - 1];
+    if (top === null || top.kind === "skip") {
+      return;
+    }
+    if (top.kind === "capture") {
+      top.att.xml = `${top.att.xml ?? ""}${escapeXmlText(text)}`;
+      this.captureRdfText(text);
+      return;
+    }
+    if (isWhitespace(text)) {
+      return;
+    }
+    if (top.kind === "att") {
+      top.att.text += text;
+    }
+    this.report.warnOnce(
+      "validation-error",
+      XGMML_ISSUE.STRAY_TEXT,
+      top.kind === "att" ? "text inside <att> is ignored; an XGMML value is the value attribute" : "text where XGMML allows only elements was ignored",
+      { line }
+    );
+  }
+  // ------------------------------------------------------------------ structure
+  /**
+   * The XML attribute map with every XLink prefix written `xlink:`.
+   * @param attrs - the attributes as written
+   * @returns the normalised map
+   */
+  normalise(attrs) {
+    const out = /* @__PURE__ */ new Map();
+    for (const [key2, value] of attrs) {
+      out.set(normaliseName(key2, this.xlinkPrefixes), value);
+    }
+    return out;
+  }
+  /**
+   * The root element: a `<graph>`, else the document is not XGMML.
+   * @param rawName - the name as written
+   * @param rawAttrs - its attributes
+   * @param line - the line
+   */
+  startRoot(rawName, rawAttrs, line) {
+    const local = localName(rawName);
+    const prefix = rawName.includes(":") ? rawName.slice(0, rawName.indexOf(":")) : null;
+    for (const [key2, value] of rawAttrs) {
+      if (key2.startsWith("xmlns:") && value === "http://www.w3.org/1999/xlink") {
+        this.xlinkPrefixes.add(key2.slice(6));
+      }
+      if (key2 === "xmlns:cy" || key2.startsWith("cy:")) {
+        this.cytoscape = true;
+      }
+    }
+    this.rootPrefix = prefix;
+    const nsKey = prefix === null ? "xmlns" : `xmlns:${prefix}`;
+    this.xgmmlNamespace = rawAttrs.get(nsKey) === XGMML_NAMESPACE;
+    if (local !== "graph") {
+      this.report.fail(
+        XGMML_ISSUE.NO_GRAPH,
+        `the root element is <${rawName}>, not <graph>; an XGMML graph embedded in another document is not read`,
+        { line }
+      );
+    }
+    const graph = this.newGraph(this.normalise(rawAttrs), line, null, null);
+    this.rootGraph = graph;
+    this.frames.push({ kind: "graph", graph });
+  }
+  /**
+   * A graph record, registered in the document.
+   * @param attrs - its attributes
+   * @param line - the line
+   * @param owner - the node whose att holds it, or null
+   * @param parent - the graph it is nested in, or null
+   * @returns the record
+   */
+  newGraph(attrs, line, owner, parent) {
+    const graph = {
+      id: attrs.get("id") ?? null,
+      label: attrs.get("label") ?? null,
+      href: attrs.get("xlink:href") ?? null,
+      registered: attrs.get("cy:registered") ?? null,
+      attrs,
+      atts: [],
+      graphics: null,
+      owner,
+      parent,
+      members: [],
+      subgraphs: [],
+      line
+    };
+    if (!this.cytoscape) {
+      for (const key2 of attrs.keys()) {
+        if (key2.startsWith("cy:")) {
+          this.cytoscape = true;
+        }
+      }
+    }
+    this.graphs.push(graph);
+    return graph;
+  }
+  /**
+   * A child of `<graph>`.
+   * @param graph - the graph
+   * @param rawName - the name as written
+   * @param name - its local name
+   * @param attrs - its attributes
+   * @param line - the line
+   */
+  startInGraph(graph, rawName, name, attrs, line) {
+    switch (name) {
+      case "node":
+        this.beginNode(graph, attrs, line);
+        return;
+      case "edge":
+        this.beginEdge(graph, attrs, line);
+        return;
+      case "att": {
+        const att = this.newAtt(attrs, line);
+        graph.atts.push(att);
+        this.beginAtt(att, attrs, "graph");
+        return;
+      }
+      case "graphics":
+        this.beginGraphics(graph, attrs);
+        return;
+      default:
+        this.unknownElement(rawName, line);
+    }
+  }
+  /**
+   * A child of `<node>` or `<edge>`.
+   * @param element - the node or edge
+   * @param rawName - the name as written
+   * @param name - its local name
+   * @param attrs - its attributes
+   * @param line - the line
+   */
+  startInElement(element, rawName, name, attrs, line) {
+    switch (name) {
+      case "att": {
+        const att = this.newAtt(attrs, line);
+        element.atts.push(att);
+        this.beginAtt(att, attrs, element.kind);
+        return;
+      }
+      case "graphics":
+        this.beginGraphics(element, attrs);
+        return;
+      default:
+        this.unknownElement(rawName, line);
+    }
+  }
+  /**
+   * A child of `<att>`: a child att, a nested graph, or foreign XML.
+   * @param frame - the att frame
+   * @param rawName - the name as written
+   * @param name - its local name
+   * @param attrs - its attributes
+   * @param line - the line
+   */
+  startInAtt(frame, rawName, name, attrs, line) {
+    const { att } = frame;
+    const xgmml = this.isXgmmlName(rawName);
+    if (name === "att" && xgmml) {
+      const child = this.newAtt(attrs, line);
+      att.children.push(child);
+      this.beginAtt(child, attrs, frame.owner === "graphics" ? "graphics" : "att");
+      return;
+    }
+    if (name === "graph" && xgmml) {
+      att.hasGraph = true;
+      this.beginNestedGraph(frame, attrs, line);
+      return;
+    }
+    att.xml ??= "";
+    const capture = { kind: "capture", att, depth: 0 };
+    this.frames.push(capture);
+    this.capture(capture, rawName, attrs);
+  }
+  /**
+   * Whether an element name inside an att is XGMML's own (unprefixed, or with the root's prefix,
+   * as in a document whose root is `<xgmml:graph>`) rather than foreign XML such as `rdf:RDF`.
+   * @param rawName - the name as written
+   * @returns true for an XGMML element name
+   */
+  isXgmmlName(rawName) {
+    const colon = rawName.indexOf(":");
+    return colon < 0 || this.rootPrefix !== null && rawName.slice(0, colon) === this.rootPrefix;
+  }
+  /**
+   * A `<graph>` inside an `<att>`: a subnetwork of the root, a group or nested-network pointer
+   * of a node, or (in an edge) a graph with no model.
+   * @param frame - the att frame
+   * @param attrs - the graph's attributes
+   * @param line - the line
+   */
+  beginNestedGraph(frame, attrs, line) {
+    const holder = this.attHolder();
+    if (holder === null || holder.kind === "edge" || frame.owner === "graphics") {
+      this.report.warnOnce(
+        "unsupported",
+        XGMML_ISSUE.EDGE_NESTED_GRAPH,
+        "a graph nested in an edge's (or a graphics) att has no model and was skipped with its content",
+        { line }
+      );
+      this.frames.push({ kind: "skip" });
+      return;
+    }
+    if (holder.kind === "node") {
+      const graph2 = this.newGraph(attrs, line, holder.node, holder.node.graph);
+      holder.node.nested.push(graph2);
+      this.frames.push({ kind: "graph", graph: graph2 });
+      return;
+    }
+    const graph = this.newGraph(attrs, line, null, holder.graph);
+    holder.graph.subgraphs.push(graph);
+    this.frames.push({ kind: "graph", graph });
+  }
+  /**
+   * The innermost node, edge or graph frame below the open atts.
+   * @returns the frame, or null
+   */
+  attHolder() {
+    for (let i = this.frames.length - 1; i >= 0; i--) {
+      const frame = this.frames[i];
+      if (frame.kind === "graph" || frame.kind === "node" || frame.kind === "edge") {
+        return frame;
+      }
+    }
+    return null;
+  }
+  /**
+   * Report an element XGMML does not define here and skip its subtree.
+   * @param rawName - the name as written
+   * @param line - the line
+   */
+  unknownElement(rawName, line) {
+    this.report.warnOnce(
+      "unsupported",
+      XGMML_ISSUE.UNKNOWN_ELEMENT,
+      `element <${rawName}> is not XGMML here and was skipped with its content`,
+      { line, element: rawName },
+      `${XGMML_ISSUE.UNKNOWN_ELEMENT}:${rawName}`
+    );
+    this.frames.push({ kind: "skip" });
+  }
+  // ------------------------------------------------------------------ nodes and edges
+  /**
+   * Open a `<node>`.
+   * @param graph - the graph it is in
+   * @param attrs - its attributes
+   * @param line - the line
+   */
+  beginNode(graph, attrs, line) {
+    const href = attrs.get("xlink:href") ?? null;
+    let id = attrs.get("id") ?? null;
+    const labelAttr = attrs.get("label") ?? null;
+    const nameAttr = attrs.get("name") ?? null;
+    const label = labelAttr ?? nameAttr;
+    if (href === null && id === null) {
+      if (label === null || label.length === 0) {
+        this.report.counts.skippedNodes++;
+        this.report.error("missing-value", XGMML_ISSUE.MISSING_ID, "<node> without an id or a label", {
+          line
+        });
+        this.frames.push({ kind: "skip" });
+        return;
+      }
+      this.report.warning(
+        "validation-error",
+        XGMML_ISSUE.ID_FROM_LABEL,
+        `<node> without an id: its label "${label}" is used as the id`,
+        { line, element: label }
+      );
+      id = label;
+    }
+    const node = {
+      kind: "node",
+      id: href === null ? id : null,
+      href,
+      label,
+      name: labelAttr !== null ? nameAttr : null,
+      xmlAttrs: otherAttributes(attrs, NODE_READ),
+      atts: [],
+      graphics: null,
+      x: null,
+      y: null,
+      z: null,
+      nested: [],
+      graph,
+      line,
+      viewId: attrs.get("cy:nodeId") ?? null
+    };
+    graph.members.push(node);
+    if (href === null) {
+      this.nodes.push(node);
+    }
+    this.frames.push({ kind: "node", node });
+  }
+  /**
+   * Open an `<edge>`.
+   * @param graph - the graph it is in
+   * @param attrs - its attributes
+   * @param line - the line
+   */
+  beginEdge(graph, attrs, line) {
+    const href = attrs.get("xlink:href") ?? null;
+    const edge = {
+      kind: "edge",
+      id: href === null ? attrs.get("id") ?? null : null,
+      href,
+      source: attrs.get("source") ?? null,
+      target: attrs.get("target") ?? null,
+      label: attrs.get("label") ?? null,
+      name: attrs.get("name") ?? null,
+      weight: attrs.get("weight") ?? null,
+      directed: attrs.get("cy:directed") ?? null,
+      xmlAttrs: otherAttributes(attrs, EDGE_READ),
+      atts: [],
+      graphics: null,
+      graph,
+      line,
+      viewId: attrs.get("cy:edgeId") ?? null
+    };
+    graph.members.push(edge);
+    if (href === null) {
+      this.edges.push(edge);
+    }
+    this.frames.push({ kind: "edge", edge });
+  }
+  // ------------------------------------------------------------------ atts
+  /**
+   * An att record from its XML attributes.
+   * @param attrs - the attributes
+   * @param line - the line
+   * @returns the record
+   */
+  newAtt(attrs, line) {
+    const extra = {};
+    for (const [key2, value] of attrs) {
+      if (!ATT_READ.has(key2) && key2 !== "xmlns" && !key2.startsWith("xmlns:")) {
+        extra[key2] = value;
+      }
+    }
+    return {
+      name: attrs.get("name") ?? attrs.get("label") ?? null,
+      type: attrs.get("type") ?? null,
+      cyType: attrs.get("cy:type") ?? null,
+      elementType: attrs.get("cy:elementType") ?? null,
+      value: attrs.get("value") ?? null,
+      hidden: isCyTrue(attrs.get("cy:hidden")),
+      equation: isCyTrue(attrs.get("cy:equation")),
+      children: [],
+      extra,
+      xml: null,
+      hasGraph: false,
+      text: "",
+      line
+    };
+  }
+  /**
+   * Open an `<att>`.
+   * @param att - the record
+   * @param _attrs - its attributes
+   * @param owner - what holds it
+   */
+  beginAtt(att, _attrs, owner) {
+    this.frames.push({ kind: "att", att, owner });
+  }
+  /**
+   * Serialize one start tag of foreign XML into the capturing att.
+   * @param frame - the capture frame
+   * @param rawName - the name as written
+   * @param attrs - its attributes
+   */
+  capture(frame, rawName, attrs) {
+    let tag = `<${rawName}`;
+    for (const [key2, value] of attrs) {
+      tag += ` ${key2}="${escapeXmlAttribute(value)}"`;
+    }
+    frame.att.xml = `${frame.att.xml ?? ""}${tag}>`;
+    frame.depth++;
+    if (frame.att.name === "networkMetadata") {
+      this.rdfElement = localName(rawName);
+    }
+  }
+  /**
+   * Keep the text of an RDF metadata field.
+   * @param text - the text
+   */
+  captureRdfText(text) {
+    if (this.rdfElement !== null && !isWhitespace(text)) {
+      this.rdf[this.rdfElement] = (this.rdf[this.rdfElement] ?? "") + text;
+    }
+  }
+  // ------------------------------------------------------------------ graphics
+  /**
+   * Open a `<graphics>`: x, y and z (draft and Cytoscape) are read as coordinates; every other
+   * attribute is kept as written, merged key by key with an earlier `<graphics>`.
+   * @param target - the node, edge or graph
+   * @param attrs - its attributes
+   */
+  beginGraphics(target, attrs) {
+    const graphics = { ...target.graphics ?? {} };
+    for (const [key2, value] of attrs) {
+      if ("x" in target && (key2 === "x" || key2 === "y" || key2 === "z")) {
+        target[key2] = value;
+      } else if (key2 !== "xmlns" && !key2.startsWith("xmlns:")) {
+        graphics[key2] = value;
+      }
+    }
+    target.graphics = graphics;
+    this.frames.push({ kind: "graphics", target });
+  }
+  /**
+   * A child of `<graphics>`: a visual-property att, a `<center>` or a `<Line>`.
+   * @param target - the graphics target
+   * @param rawName - the name as written
+   * @param name - its local name
+   * @param attrs - its attributes
+   * @param line - the line
+   */
+  startInGraphics(target, rawName, name, attrs, line) {
+    switch (name) {
+      case "att": {
+        this.frames.push({ kind: "att", att: this.newAtt(attrs, line), owner: "graphics" });
+        return;
+      }
+      case "center":
+        if ("x" in target) {
+          target.x ??= attrs.get("x") ?? null;
+          target.y ??= attrs.get("y") ?? null;
+          target.z ??= attrs.get("z") ?? null;
+        }
+        this.frames.push({ kind: "skip" });
+        return;
+      case "Line":
+      case "line":
+        this.frames.push({ kind: "line", points: [] });
+        return;
+      default:
+        this.unknownElement(rawName, line);
+    }
+  }
+  /**
+   * Keep a visual-property att of a `<graphics>` in its record, as written. A session view's
+   * `<att name="z">` repeats z and is read as z when the attributes gave none.
+   * @param target - the graphics target
+   * @param att - the att
+   */
+  graphicsAtt(target, att) {
+    if (att.name === "z" && "z" in target && att.children.length === 0) {
+      target.z ??= att.value;
+      return;
+    }
+    if (att.name === null) {
+      this.report.warnOnce(
+        "validation-error",
+        XGMML_ISSUE.BAD_ATT,
+        "a graphics <att> without a name was skipped",
+        { line: att.line },
+        `${XGMML_ISSUE.BAD_ATT}:graphics-name`
+      );
+      return;
+    }
+    target.graphics = { ...target.graphics ?? {}, [att.name]: attJson(att) };
+  }
+}
+function isListLike(att) {
+  const names = new Set(att.children.map((c) => c.name));
+  if (names.size !== 1) {
+    return false;
+  }
+  const [only] = names;
+  return only === null || only === att.name || att.children.length > 1;
+}
+function attJson(att) {
+  if (att.children.length === 0) {
+    if (att.value !== null) {
+      return att.value;
+    }
+    return Object.keys(att.extra).length > 0 ? { ...att.extra } : null;
+  }
+  if (isListLike(att)) {
+    return att.children.map(attJson);
+  }
+  const out = {};
+  for (const child of att.children) {
+    out[child.name ?? ""] = attJson(child);
+  }
+  return out;
+}
+function otherAttributes(attrs, read) {
+  const out = [];
+  for (const [key2, value] of attrs) {
+    if (!read.has(key2) && key2 !== "xmlns" && !key2.startsWith("xmlns:")) {
+      out.push([key2, value]);
+    }
+  }
+  return out;
+}
+const CY_TYPES = {
+  string: "string",
+  double: "real",
+  integer: "int",
+  long: "long",
+  boolean: "bool",
+  list: "list"
+};
+const XGMML_TYPES = {
+  string: "string",
+  real: "real",
+  integer: "int",
+  boolean: "bool",
+  list: "list",
+  map: "map"
+};
+function attType(att) {
+  let kind;
+  let declared = null;
+  if (att.cyType !== null && att.cyType.length > 0) {
+    kind = CY_TYPES[att.cyType.trim().toLowerCase()];
+    declared = att.cyType;
+  }
+  if (kind === void 0 && att.type !== null && att.type.length > 0) {
+    kind = XGMML_TYPES[att.type.trim().toLowerCase()];
+    declared = att.type;
+  }
+  if (kind === void 0) {
+    const unknown = declared ?? null;
+    return { kind: "string", declared, unknown };
+  }
+  if (kind === "int" && att.cyType === null && att.name?.endsWith(".SUID") === true) {
+    kind = "long";
+  }
+  return { kind, declared, unknown: null };
+}
+function elementKind(text) {
+  if (text === null) {
+    return null;
+  }
+  const kind = CY_TYPES[text.trim().toLowerCase()] ?? XGMML_TYPES[text.trim().toLowerCase()];
+  return kind === void 0 || kind === "list" || kind === "map" ? null : kind;
+}
+function widenScalar(a, b) {
+  if (a === b) {
+    return a;
+  }
+  if (a === "string" || b === "string" || a === "bool" || b === "bool") {
+    return "string";
+  }
+  if (a === "real" || b === "real") {
+    return "real";
+  }
+  return "long";
+}
+const INTEGER_TEXT = /^[+-]?[0-9]+$/;
+const REAL_TEXT = /^[+-]?(NaN|Infinity|([0-9]+\.?[0-9]*|\.[0-9]+)([eE][+-]?[0-9]+)?)$/;
+const I32_MIN = -2147483648;
+const I32_MAX = 2147483647;
+function parseScalar(text, kind, unescape) {
+  switch (kind) {
+    case "string":
+      return { value: unescape ? unescapeCytoscape(text) : text };
+    case "bool": {
+      const t = text.trim().toLowerCase();
+      if (t === "1" || t === "true" || t === "yes") {
+        return { value: true };
+      }
+      if (t === "0" || t === "false" || t === "no") {
+        return { value: false };
+      }
+      return null;
+    }
+    case "int":
+    case "long": {
+      const t = text.trim();
+      if (!INTEGER_TEXT.test(t)) {
+        return null;
+      }
+      const n = Number(t);
+      if (kind === "int" && (n < I32_MIN || n > I32_MAX)) {
+        return { value: n, overflow: Number.isSafeInteger(n) ? "i32" : "precision" };
+      }
+      return { value: n, overflow: Number.isSafeInteger(n) ? void 0 : "precision" };
+    }
+    case "real": {
+      const t = text.trim();
+      if (!REAL_TEXT.test(t)) {
+        return null;
+      }
+      const n = Number(t);
+      const overflow = !Number.isFinite(n) && !/Infinity|NaN/.test(t) ? "precision" : void 0;
+      return { value: n, overflow };
+    }
+    default: {
+      const name = kind;
+      throw new Error(`unknown scalar kind ${String(name)}`);
+    }
+  }
+}
+function unescapeCytoscape(text) {
+  return text.includes("\\") ? text.replace(/\\t/g, "	").replace(/\\n/g, "\n") : text;
+}
+const DTYPES = {
+  bool: "bool",
+  int: "i32",
+  long: "f64",
+  real: "f64",
+  string: "string"
+};
+class ColumnSet {
+  /**
+   * Create a column set.
+   * @param domain - the table
+   * @param report - the report
+   * @param options - the options
+   */
+  constructor(domain, report, options) {
+    this.plans = /* @__PURE__ */ new Map();
+    this.domain = domain;
+    this.report = report;
+    this.options = options;
+  }
+  /**
+   * Whether a column of that name (any namespace) was collected.
+   * @param name - the name
+   * @returns true when some row has a value or the column was declared
+   */
+  has(name) {
+    return this.plans.has(key(null, name));
+  }
+  /**
+   * Add one att of a row: parse it by its declared kind (E_BAD_VALUE for a value that does not
+   * parse; the cell stays unset). A second value of the same column on one row wins with
+   * W_DUPLICATE_ATTRIBUTE.
+   * @param row - the row
+   * @param att - the att
+   * @param where - the element, for issues
+   */
+  addAtt(row, att, where) {
+    const { name } = att;
+    if (name === null || name.length === 0) {
+      this.badAtt("an <att> without a name was skipped", att, "name");
+      return;
+    }
+    const plan = this.plan(name, att.namespace ?? null);
+    const type = attType(att);
+    plan.hidden ||= att.hidden;
+    plan.suid ||= name.endsWith(".SUID");
+    if (type.declared !== null) {
+      plan.declaredType ??= type.declared;
+    }
+    const at = { line: att.line, element: where.element ?? name };
+    if (type.unknown !== null) {
+      this.report.warnOnce(
+        "unsupported",
+        XGMML_ISSUE.UNKNOWN_ATTR_TYPE,
+        `att type "${type.unknown}" of "${name}" is not an XGMML or Cytoscape type; its values are kept as text`,
+        at,
+        `${XGMML_ISSUE.UNKNOWN_ATTR_TYPE}:${this.domain}:${name}`
+      );
+    }
+    let cell;
+    if (att.equation) {
+      plan.equation = true;
+      this.report.warnOnce(
+        "unsupported",
+        XGMML_ISSUE.EQUATION_AS_TEXT,
+        `"${name}" holds Cytoscape formulas; each is kept as its text, never evaluated`,
+        at,
+        `${XGMML_ISSUE.EQUATION_AS_TEXT}:${this.domain}:${name}`
+      );
+      cell = att.value === null ? null : scalarCell("string", att.value, att.value, true);
+      if (cell !== null) {
+        plan.declared.add("string");
+      }
+    } else if (type.kind === "list") {
+      cell = this.listCell(att, name, plan, at);
+      plan.declared.add("list");
+    } else if (type.kind === "map") {
+      cell = jsonCell(recordOf(att));
+      this.recordList(`"${name}" is a 2.x map; it is kept as a json record`, at);
+      plan.declared.add("json");
+    } else {
+      cell = this.scalarAtt(att, type.kind, plan, at);
+    }
+    if (cell !== null) {
+      this.set(plan, row, cell, at);
+    }
+  }
+  /**
+   * Add one value read by the 5.1 text grammar (an XML attribute of an element).
+   * @param row - the row
+   * @param name - the column name
+   * @param text - the text
+   * @param where - the element, for issues
+   */
+  addText(row, name, text, where) {
+    const plan = this.plan(name, null);
+    const value = parseTextCell(text);
+    const kind = textKind(inferTextDtype(text));
+    this.set(plan, row, { kind, value, text, items: [], itemKind: null, typed: false }, where);
+  }
+  /**
+   * Add one value of a known kind (a typed table cell of a session).
+   * @param row - the row
+   * @param name - the column name
+   * @param value - the value
+   * @param where - the element, for issues
+   */
+  addJson(row, name, value, where) {
+    this.set(this.plan(name, null), row, jsonCell(value), where);
+  }
+  /**
+   * Declare every collected column on the sink and write its values.
+   * @param sink - the sink
+   * @param rowIndex - the sink index of a row (node or edge index), or -1 when the row was not added
+   */
+  write(sink, rowIndex) {
+    const taken = new Set(this.options.reserved);
+    const ordered = [...this.plans.values()].sort(
+      (a, b) => Number(a.namespace !== null) - Number(b.namespace !== null)
+    );
+    for (const plan of ordered) {
+      let { name } = plan;
+      if (taken.has(name)) {
+        name = uniqueColumnName(plan.name, plan.namespace, (n) => taken.has(n));
+        this.report.warning(
+          "coercion",
+          XGMML_ISSUE.COLUMN_RENAMED,
+          `${this.domain} attribute "${plan.name}" renamed to "${name}": the name was taken`,
+          { element: plan.name }
+        );
+      }
+      taken.add(name);
+      this.writePlan(sink, plan, name, rowIndex);
+    }
+  }
+  // ------------------------------------------------------------------ cells
+  /**
+   * The plan of a column, created on first use.
+   * @param name - the attribute name
+   * @param namespace - the table namespace, or null
+   * @returns the plan
+   */
+  plan(name, namespace) {
+    const k = key(namespace, name);
+    let plan = this.plans.get(k);
+    if (plan === void 0) {
+      plan = {
+        name,
+        namespace,
+        cells: /* @__PURE__ */ new Map(),
+        declared: /* @__PURE__ */ new Set(),
+        lines: /* @__PURE__ */ new Map(),
+        declaredType: null,
+        hidden: false,
+        equation: false,
+        suid: false,
+        overflow: false,
+        precision: false
+      };
+      this.plans.set(k, plan);
+    }
+    return plan;
+  }
+  /**
+   * Store a cell, reporting a second value on the same row.
+   * @param plan - the column
+   * @param row - the row
+   * @param cell - the cell
+   * @param where - the location
+   */
+  set(plan, row, cell, where) {
+    if (plan.cells.has(row)) {
+      this.report.warning(
+        "validation-error",
+        XGMML_ISSUE.DUPLICATE_ATTRIBUTE,
+        `"${plan.name}" is given twice on one ${this.domain}; the later value is kept`,
+        { line: where.line ?? null, element: where.element ?? plan.name }
+      );
+    }
+    plan.cells.set(row, cell);
+    if (where.line !== void 0 && where.line !== null) {
+      plan.lines.set(row, where.line);
+    }
+  }
+  /**
+   * Parse a scalar att.
+   * @param att - the att
+   * @param kind - the declared kind
+   * @param plan - the column
+   * @param at - the location
+   * @returns the cell, or null when unset or invalid
+   */
+  scalarAtt(att, kind, plan, at) {
+    if (att.children.length > 0) {
+      this.badAtt(`the ${kind} att "${att.name ?? ""}" holds child atts; they are ignored`, att, "children");
+    }
+    if (att.xml !== null) {
+      this.recordList(`"${att.name ?? ""}" holds foreign XML; it is kept as text in a json column`, at);
+      plan.declared.add("json");
+      return jsonCell(att.xml);
+    }
+    if (att.value === null) {
+      plan.declared.add(kind);
+      return null;
+    }
+    const parsed = parseScalar(att.value, kind, this.options.unescape);
+    if (parsed === null || parsed.overflow !== void 0 && kind === "int" && exactInteger(att.cyType)) {
+      this.badValue(att.value, kind, at);
+      return null;
+    }
+    plan.declared.add(kind);
+    if (parsed.overflow === "i32") {
+      plan.overflow = true;
+    } else if (parsed.overflow === "precision") {
+      plan.precision = true;
+      plan.overflow ||= kind === "int";
+    }
+    return scalarCell(kind, parsed.value, att.value, true);
+  }
+  /**
+   * Parse a list att: items by `cy:elementType`, else by the widened kinds of the children.
+   * A list of lists, a list with records, or a list of named fields is a json value.
+   * @param att - the att
+   * @param name - the column name
+   * @param plan - the column (an item beyond i32 widens it, as a scalar does)
+   * @param at - the location
+   * @returns the cell
+   */
+  listCell(att, name, plan, at) {
+    if (att.value !== null) {
+      this.badAtt(`the list att "${name}" has a value; it is ignored`, att, "list-value");
+    }
+    const { children } = att;
+    const names = new Set(children.map((c) => c.name).filter((n) => n !== null && n !== name));
+    if (names.size > 1 || children.some((c) => c.children.length > 0 || c.xml !== null)) {
+      this.recordList(`"${name}" is a record or a list of lists; it is kept as json`, at);
+      return jsonCell(names.size > 1 ? recordOf(att) : children.map(jsonOfAtt));
+    }
+    let itemKind = elementKind(att.elementType);
+    if (itemKind === null) {
+      const kinds = /* @__PURE__ */ new Set();
+      for (const child of children) {
+        const type = attType(child);
+        const kind = type.kind === "list" || type.kind === "map" ? "string" : type.kind;
+        kinds.add(kind);
+        itemKind = itemKind === null ? kind : widenScalar(itemKind, kind);
+      }
+      if (kinds.size > 1) {
+        this.report.warnOnce(
+          "coercion",
+          XGMML_ISSUE.WIDENED,
+          `the items of list "${name}" declare different types; they are read as ${itemKind ?? "string"}`,
+          at,
+          `${XGMML_ISSUE.WIDENED}:${this.domain}:${name}`
+        );
+      }
+    }
+    const items = [];
+    for (const child of children) {
+      if (child.value === null) {
+        continue;
+      }
+      const parsed = parseScalar(child.value, itemKind ?? "string", this.options.unescape);
+      const exact = exactInteger(att.elementType) || exactInteger(child.cyType);
+      if (parsed === null || parsed.overflow !== void 0 && itemKind === "int" && exact) {
+        this.badValue(child.value, itemKind ?? "string", { line: child.line, element: at.element });
+        continue;
+      }
+      if (parsed.overflow === "i32") {
+        plan.overflow = true;
+      } else if (parsed.overflow === "precision") {
+        plan.precision = true;
+        plan.overflow ||= itemKind === "int";
+      }
+      items.push({ value: parsed.value, text: child.value });
+    }
+    return { kind: "list", value: null, text: "", items, itemKind, typed: true };
+  }
+  // ------------------------------------------------------------------ decision and writing
+  /**
+   * Decide one column's dtype, declare it and write its values.
+   * @param sink - the sink
+   * @param plan - the column
+   * @param name - the name to declare it under
+   * @param rowIndex - the row to sink index map
+   */
+  writePlan(sink, plan, name, rowIndex) {
+    const cells = [...plan.cells.values()];
+    const decision = this.decide(plan, cells);
+    const decl = {
+      name,
+      dtype: decision.dtype,
+      nullable: true,
+      origin: {
+        format: FORMAT,
+        id: null,
+        title: name === plan.name ? null : plan.name,
+        type: originType(plan, decision),
+        namespace: plan.namespace ?? (plan.hidden ? CYTOSCAPE_ORIGIN_NAMESPACE : null)
+      }
+    };
+    if (decision.itemDtype !== null) {
+      decl.itemDtype = decision.itemDtype;
+    }
+    const extra = {};
+    if (plan.hidden) {
+      extra.hidden = true;
+    }
+    if (plan.suid) {
+      extra.suidReference = true;
+    }
+    if (plan.equation) {
+      extra.equation = true;
+    }
+    if (Object.keys(extra).length > 0) {
+      decl.extra = extra;
+    }
+    const where = { element: name };
+    if (this.domain === "graph") {
+      const cell = plan.cells.get(0);
+      try {
+        sink.setGraphValue(name, cell === void 0 ? void 0 : convert(cell, decision), decl);
+      } catch (err) {
+        this.report.recordError(err, where);
+      }
+      return;
+    }
+    let handle;
+    try {
+      ({ handle } = declareResolved(sink, this.domain, decl, this.report, where));
+    } catch (err) {
+      this.report.recordError(err, where);
+      return;
+    }
+    for (const [row, cell] of plan.cells) {
+      const index = rowIndex(row);
+      if (index < 0) {
+        continue;
+      }
+      const value = convert(cell, decision);
+      try {
+        if (this.domain === "node") {
+          sink.setNodeValue(handle, index, value);
+        } else {
+          sink.setEdgeValue(handle, index, value);
+        }
+      } catch (err) {
+        this.report.recordError(err, { line: plan.lines.get(row) ?? null, element: name });
+      }
+    }
+  }
+  /**
+   * The dtype of a column from its cells, with the widening and precision warnings.
+   * @param plan - the column
+   * @param cells - its cells
+   * @returns the decision
+   */
+  decide(plan, cells) {
+    const where = { element: plan.name };
+    const typedKinds = new Set(cells.filter((c) => c.typed).map((c) => c.kind));
+    let widened = typedKinds.size > 1 || plan.declared.size > 1;
+    let decision;
+    if (cells.some((c) => c.kind === "json") || cells.some((c) => c.kind === "list") && cells.some((c) => c.kind !== "list")) {
+      decision = { dtype: "json", itemDtype: null, scalar: null, item: null, long: false };
+    } else if (cells.length > 0 && cells.every((c) => c.kind === "list")) {
+      let item = null;
+      for (const cell of cells) {
+        if (cell.itemKind !== null) {
+          widened ||= item !== null && item !== cell.itemKind;
+          item = item === null ? cell.itemKind : widenScalar(item, cell.itemKind);
+        }
+      }
+      if (item === null) {
+        this.report.warnOnce(
+          "coercion",
+          XGMML_ISSUE.EMPTY_LIST_TYPE,
+          `list "${plan.name}" has no element type and no items; it is a list of strings`,
+          where,
+          `${XGMML_ISSUE.EMPTY_LIST_TYPE}:${this.domain}:${plan.name}`
+        );
+        item = "string";
+      }
+      if (plan.overflow && item === "int") {
+        item = "real";
+        widened = true;
+      }
+      decision = { dtype: "list", itemDtype: DTYPES[item], scalar: null, item, long: item === "long" };
+    } else {
+      decision = this.decideScalar(plan, cells);
+      widened ||= plan.overflow && decision.scalar === "real" && plan.declared.has("int");
+    }
+    if (widened) {
+      this.report.warnOnce(
+        "coercion",
+        XGMML_ISSUE.WIDENED,
+        `${this.domain} column "${plan.name}" was widened to ${decision.dtype}: its values or declared types disagree`,
+        where,
+        `${XGMML_ISSUE.WIDENED}:${this.domain}:${plan.name}`
+      );
+    }
+    if (plan.precision) {
+      this.report.warnOnce(
+        "precision",
+        XGMML_ISSUE.PRECISION,
+        `values of "${plan.name}" beyond what a double holds exactly are stored as the nearest double (or infinity)`,
+        where,
+        `${XGMML_ISSUE.PRECISION}:${this.domain}:${plan.name}`
+      );
+    }
+    return decision;
+  }
+  /**
+   * The scalar decision of a column.
+   * @param plan - the column
+   * @param cells - its cells
+   * @returns the decision
+   */
+  decideScalar(plan, cells) {
+    let scalar = null;
+    for (const cell of cells) {
+      const kind = cell.kind;
+      scalar = scalar === null ? kind : widenScalar(scalar, kind);
+    }
+    if (scalar === null) {
+      const declared = [...plan.declared].find((k) => k in DTYPES);
+      scalar = declared ?? "string";
+    }
+    if (scalar === "int" && plan.overflow) {
+      scalar = "real";
+    }
+    const long = scalar === "long";
+    if (long && this.options.long === "string") {
+      return { dtype: "string", itemDtype: null, scalar: "string", item: null, long: true };
+    }
+    let dtype = DTYPES[scalar];
+    if (scalar === "string") {
+      const heuristic = new DictHeuristic();
+      for (const cell of cells) {
+        if (heuristic.observe(cell.text)) {
+          break;
+        }
+      }
+      dtype = heuristic.decide();
+    }
+    return { dtype, itemDtype: null, scalar, item: null, long };
+  }
+  /**
+   * Report a malformed att, once per kind of defect.
+   * @param message - the message
+   * @param att - the att
+   * @param kind - the defect, for the once key
+   */
+  badAtt(message, att, kind) {
+    this.report.warnOnce(
+      "parse-error",
+      XGMML_ISSUE.BAD_ATT,
+      message,
+      { line: att.line, element: att.name },
+      `${XGMML_ISSUE.BAD_ATT}:${kind}`
+    );
+  }
+  /**
+   * Report a value that does not parse as its declared kind (an error; the cell stays unset).
+   * @param text - the value
+   * @param kind - the kind
+   * @param at - the location
+   */
+  badValue(text, kind, at) {
+    this.report.error(
+      "validation-error",
+      XGMML_ISSUE.BAD_VALUE,
+      `value ${JSON.stringify(text)} is not a valid ${KIND_NAMES[kind]}; the cell is left unset`,
+      at
+    );
+  }
+  /**
+   * Report a record list, list of lists, map or foreign XML kept as json, once.
+   * @param message - the message
+   * @param at - the location
+   */
+  recordList(message, at) {
+    this.report.warnOnce("coercion", XGMML_ISSUE.RECORD_LIST, message, at);
+  }
+}
+function exactInteger(cyType) {
+  return cyType?.trim().toLowerCase() === "integer";
+}
+function originType(plan, decision) {
+  if (plan.equation) {
+    return "equation";
+  }
+  return decision.long ? "long" : plan.declaredType;
+}
+const KIND_NAMES = {
+  bool: "boolean (1, 0, true, false, yes, no)",
+  int: "integer",
+  long: "long integer",
+  real: "real number",
+  string: "string"
+};
+function key(namespace, name) {
+  return namespace === null ? name : `${namespace}\0${name}`;
+}
+function textKind(dtype) {
+  switch (dtype) {
+    case "bool":
+      return "bool";
+    case "i32":
+      return "int";
+    case "f64":
+      return "real";
+    default:
+      return "string";
+  }
+}
+function scalarCell(kind, value, text, typed) {
+  return { kind, value, text, items: [], itemKind: null, typed };
+}
+function jsonCell(value) {
+  return { kind: "json", value, text: JSON.stringify(value), items: [], itemKind: null, typed: true };
+}
+function recordOf(att) {
+  const out = {};
+  for (const child of att.children) {
+    out[child.name ?? ""] = jsonOfAtt(child);
+  }
+  return out;
+}
+function jsonOfAtt(att) {
+  if (att.xml !== null) {
+    return att.xml;
+  }
+  if (att.children.length === 0) {
+    return att.value;
+  }
+  return isListLike(att) ? att.children.map(jsonOfAtt) : recordOf(att);
+}
+function convert(cell, decision) {
+  if (decision.dtype === "json") {
+    if (cell.kind === "json") {
+      return cell.value;
+    }
+    return cell.kind === "list" ? cell.items.map((i) => i.value) : cell.value;
+  }
+  if (decision.dtype === "list") {
+    return cell.items.map((item) => convertScalar(item.value, item.text, decision.item ?? "string"));
+  }
+  return convertScalar(
+    cell.value,
+    cell.text,
+    decision.long && decision.dtype === "string" ? "string" : decision.scalar ?? "string"
+  );
+}
+function convertScalar(value, text, kind) {
+  switch (kind) {
+    case "bool":
+      return value;
+    case "int":
+    case "long":
+    case "real":
+      return Number(value);
+    default:
+      return typeof value === "string" ? value : text;
+  }
+}
+const META_ATTS = /* @__PURE__ */ new Set(["documentVersion", "networkMetadata"]);
+const GRAPH_STRUCTURE = /* @__PURE__ */ new Set([
+  "id",
+  "label",
+  "directed",
+  "xlink:href",
+  "cy:documentVersion",
+  "cy:view",
+  "cy:registered",
+  "cy:networkId",
+  "cy:visualStyle",
+  "cy:rendererId"
+]);
+const ABORT_CHECK_INTERVAL = 64;
+const ALIAS_SPLIT = /[()]/;
+function dialectOf(doc, report) {
+  const { root } = doc;
+  let versionText = root.attrs.get("cy:documentVersion") ?? null;
+  for (const att of root.atts) {
+    if (att.name === "documentVersion" && att.value !== null) {
+      versionText ??= att.value;
+    }
+  }
+  let version = 0;
+  if (versionText !== null) {
+    version = Number(versionText.trim());
+    if (!Number.isFinite(version) || versionText.trim().length === 0) {
+      report.warning(
+        "validation-error",
+        XGMML_ISSUE.DOCUMENT_VERSION,
+        `documentVersion "${versionText}" does not parse; the dialect is chosen from the content`,
+        { line: root.line }
+      );
+      version = 0;
+    }
+  }
+  const registered = root.subgraphs.some((g) => isCyTrue(g.registered));
+  return {
+    versionText,
+    version,
+    cytoscape: doc.cytoscape,
+    cy2: doc.cytoscape && version < 3,
+    session: root.registered !== null && !isCyTrue(root.registered) && registered,
+    view: isCyTrue(root.attrs.get("cy:view"))
+  };
+}
+function graphsOf(doc, dialect) {
+  return dialect.session ? doc.root.subgraphs.filter((g) => isCyTrue(g.registered)) : [doc.root];
+}
+function localRef(href) {
+  return href.startsWith("#") ? href.slice(1) : null;
+}
+function membersOf(doc, graph) {
+  if (graph === null) {
+    return { nodes: doc.nodes, edges: doc.edges, dangling: 0 };
+  }
+  const nodeById = indexById(doc.nodes);
+  const edgeById = indexById(doc.edges);
+  const nodes = [];
+  const edges = [];
+  let dangling = 0;
+  for (const member of graph.members) {
+    if (member.href === null) {
+      if (member.kind === "node") {
+        nodes.push(member);
+      } else {
+        edges.push(member);
+      }
+      continue;
+    }
+    const id = localRef(member.href);
+    let target;
+    if (id !== null) {
+      target = member.kind === "node" ? nodeById.get(id) : edgeById.get(id);
+    }
+    if (target === void 0) {
+      dangling++;
+    } else if (target.kind === "node") {
+      nodes.push(target);
+    } else {
+      edges.push(target);
+    }
+  }
+  return { nodes, edges, dangling };
+}
+function indexById(records) {
+  const out = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    if (record.id !== null && !out.has(record.id)) {
+      out.set(record.id, record);
+    }
+  }
+  return out;
+}
+class XgmmlEmitter {
+  /**
+   * Create an emitter for one graph.
+   * @param doc - the document
+   * @param dialect - its dialect
+   * @param sink - the sink
+   * @param report - the report
+   * @param options - the resolved common options
+   * @param settings - the XGMML options
+   * @param extras - what a session adds
+   */
+  constructor(doc, dialect, sink, report, options, settings, extras = {}) {
+    this.rows = /* @__PURE__ */ new Map();
+    this.rowList = [];
+    this.edgeIndex = [];
+    this.sinceCheck = 0;
+    this.aliasResolved = 0;
+    this.aliasInteractions = 0;
+    this.weighted = false;
+    this.directions = /* @__PURE__ */ new Map();
+    this.labelRows = null;
+    this.doc = doc;
+    this.dialect = dialect;
+    this.sink = sink;
+    this.report = report;
+    this.options = options;
+    this.settings = settings;
+    this.extras = extras;
+    this.coercer = new IdCoercer(options.ids);
+    this.direction = new DirectionResolver(sink, report, options.onMixedDirection);
+    const base = { unescape: settings.cytoscapeEscapes, long: options.long };
+    this.nodeColumns = new ColumnSet("node", report, {
+      ...base,
+      reserved: /* @__PURE__ */ new Set([
+        LABEL_COLUMN,
+        POSITION_COLUMN,
+        Z_COLUMN,
+        GRAPHICS_COLUMN,
+        PARENT_COLUMN,
+        PARENTS_COLUMN,
+        SUBGRAPH_COLUMN,
+        NESTED_NETWORK_COLUMN,
+        NETWORK_POINTER_COLUMN,
+        NETWORKS_COLUMN
+      ])
+    });
+    this.edgeColumns = new ColumnSet("edge", report, {
+      ...base,
+      reserved: /* @__PURE__ */ new Set([EDGE_ID_COLUMN, LABEL_COLUMN, GRAPHICS_COLUMN])
+    });
+    this.graphColumns = new ColumnSet("graph", report, { ...base, reserved: /* @__PURE__ */ new Set([GRAPHICS_COLUMN]) });
+  }
+  /**
+   * Push the graph: nodes, containment, positions, edges, columns, metadata.
+   * @param graph - the subnetwork, or null for the whole document
+   */
+  emit(graph) {
+    const members = membersOf(this.doc, graph);
+    if (members.dangling > 0) {
+      this.report.warning(
+        "validation-error",
+        XGMML_ISSUE.DANGLING_REFERENCE,
+        `${this.prefix()}${members.dangling} xlink:href member reference(s) name no node or edge of the document`,
+        { line: graph?.line ?? null }
+      );
+    }
+    const header = this.headerDirected();
+    this.direction.setHeader(this.sinkDirection(members.edges, header), { line: this.doc.root.line });
+    this.addNodes(members.nodes);
+    if (graph === null) {
+      this.checkReferences();
+    }
+    const containment = new Containment(this);
+    containment.resolve(this.rowList, this.groupTest());
+    this.writeNodeExtras(graph);
+    this.addEdges(members.edges, header);
+    this.finishAliases();
+    this.writeGraph(graph);
+    const nodeIndex = (row) => this.rowList[row].index;
+    this.nodeColumns.write(this.sink, nodeIndex);
+    this.edgeColumns.write(this.sink, (row) => this.edgeIndex[row] ?? -1);
+    containment.write();
+    this.writeMeta(graph);
+    throwIfAborted(this.options.signal);
+  }
+  // ------------------------------------------------------------------ shared helpers (also used by Containment)
+  /**
+   * The sink.
+   * @returns the sink
+   */
+  get target() {
+    return this.sink;
+  }
+  /**
+   * The report.
+   * @returns the report
+   */
+  get issues() {
+    return this.report;
+  }
+  /**
+   * The row of a node id in this graph.
+   * @param id - the id text
+   * @returns the row, or undefined
+   */
+  rowOf(id) {
+    return this.rows.get(id);
+  }
+  /**
+   * The network name a cross-file pointer names, when a session can tell.
+   * @param href - the pointer
+   * @returns the name, or null
+   */
+  resolvePointer(href) {
+    return this.extras.resolvePointer?.(href) ?? null;
+  }
+  /**
+   * Hand a group member the graph does not hold to the session, when one is reading.
+   * @param group - the group node's id
+   * @param member - the member's id
+   * @returns true when the session took it
+   */
+  missingMember(group, member) {
+    if (this.extras.onMissingMember === void 0) {
+      return false;
+    }
+    this.extras.onMissingMember(group, member);
+    return true;
+  }
+  /**
+   * The first graph of the document with an id.
+   * @param id - the id
+   * @returns the graph, or undefined
+   */
+  graphById(id) {
+    return this.doc.graphs.find((g) => g.id === id);
+  }
+  /**
+   * The prefix of every message (the session entry), or "".
+   * @returns the prefix
+   */
+  prefix() {
+    return this.extras.entry === void 0 ? "" : `${this.extras.entry}: `;
+  }
+  /**
+   * Check the cancellation signal every few dozen elements.
+   */
+  checkAbort() {
+    if (++this.sinceCheck >= ABORT_CHECK_INTERVAL) {
+      this.sinceCheck = 0;
+      throwIfAborted(this.options.signal);
+    }
+  }
+  /**
+   * Declare a column the importer owns on first use (the 5.6 rename rule applies).
+   * @param domain - node or edge
+   * @param decl - the declaration
+   * @returns the handle, or null when the sink refused it (recorded)
+   */
+  declare(domain, decl) {
+    try {
+      return declareResolved(this.sink, domain, decl, this.report, { element: decl.name }).handle;
+    } catch (err) {
+      this.report.recordError(err, { element: decl.name });
+      return null;
+    }
+  }
+  // ------------------------------------------------------------------ nodes
+  /**
+   * The header direction: the root's `directed` (0 by the DTD), else the defaultDirected option.
+   * @returns whether the graph is directed by default
+   */
+  headerDirected() {
+    const text = this.doc.root.attrs.get("directed");
+    if (text === void 0) {
+      return this.options.defaultDirected;
+    }
+    return this.flag(text, this.options.defaultDirected, { line: this.doc.root.line, element: "directed" });
+  }
+  /**
+   * The direction of one edge: its cy:directed, else the header.
+   * @param record - the edge
+   * @param header - the header direction
+   * @returns whether the edge is directed
+   */
+  edgeDirection(record, header) {
+    let directed = this.directions.get(record);
+    if (directed === void 0) {
+      directed = record.directed === null ? header : this.flag(record.directed, header, { line: record.line, element: record.id ?? record.label });
+      this.directions.set(record, directed);
+    }
+    return directed;
+  }
+  /**
+   * The direction the sink starts with: the one every edge has when they all agree (a
+   * Cytoscape file writes cy:directed on every edge and may omit the root attribute), else the
+   * header, so a graph of one direction is never expanded into a mixed one.
+   * @param edges - the edges of the graph
+   * @param header - the header direction
+   * @returns the sink direction
+   */
+  sinkDirection(edges, header) {
+    let first = null;
+    for (const edge of edges) {
+      const directed = this.edgeDirection(edge, header);
+      if (first === null) {
+        first = directed;
+      } else if (first !== directed) {
+        return header;
+      }
+    }
+    return first ?? header;
+  }
+  /**
+   * A 0 / 1 direction flag: true, false, yes and no are accepted with a warning; anything else
+   * falls back.
+   * @param text - the text
+   * @param fallback - the direction for an unreadable value
+   * @param where - the location
+   * @returns the direction
+   */
+  flag(text, fallback, where) {
+    const t = text.trim();
+    if (t === "1" || t === "0") {
+      return t === "1";
+    }
+    const lower = t.toLowerCase();
+    const readable = lower === "true" || lower === "yes" || lower === "false" || lower === "no";
+    this.report.warnOnce(
+      "validation-error",
+      XGMML_ISSUE.BAD_DIRECTED,
+      readable ? `${this.prefix()}directed="${text}" is not 0 or 1; read as ${lower === "true" || lower === "yes" ? "1" : "0"}` : `${this.prefix()}directed="${text}" is not 0 or 1; read as ${fallback ? "directed" : "undirected"}`,
+      where,
+      `${XGMML_ISSUE.BAD_DIRECTED}:${text}`
+    );
+    return readable ? lower === "true" || lower === "yes" : fallback;
+  }
+  /**
+   * Add every node record to the sink (one node per id; later declarations merge).
+   * @param records - the node records
+   */
+  addNodes(records) {
+    for (const record of records) {
+      const { id } = record;
+      if (id === null) {
+        continue;
+      }
+      const existing = this.rows.get(id);
+      if (existing !== void 0) {
+        existing.records.push(record);
+        this.report.warning(
+          "validation-error",
+          XGMML_ISSUE.DUPLICATE_NODE,
+          `${this.prefix()}node "${id}" is declared twice; the declarations are merged`,
+          { line: record.line, element: id }
+        );
+        continue;
+      }
+      const row = { id, records: [record], index: -1, row: this.rowList.length };
+      try {
+        row.index = this.sink.addNode(this.nodeId(id, record.line));
+        this.report.counts.nodes++;
+      } catch (err) {
+        this.report.counts.skippedNodes++;
+        this.report.recordError(err, { line: record.line, element: id });
+      }
+      this.rows.set(id, row);
+      this.rowList.push(row);
+      this.checkAbort();
+    }
+  }
+  /**
+   * The coerced id of a node text.
+   * @param text - the id text
+   * @param line - the line
+   * @returns the id
+   */
+  nodeId(text, line) {
+    const id = this.coercer.text(text);
+    const merge = this.coercer.lastMerge;
+    if (merge !== null) {
+      this.report.warning(
+        "coercion",
+        XGMML_ISSUE.ID_MERGED,
+        `id "${merge.text}" merged with "${merge.previousText}" as ${merge.id} under ids: "number"`,
+        { line, element: text }
+      );
+    }
+    return id;
+  }
+  /**
+   * Whether a node's nested graph is a group (containment) rather than a nested-network
+   * pointer: any graph in the 1.0 draft dialect, a 2.x node with `__groupState`, a 3.x node with
+   * `__isGroup` true, or a node the session lists.
+   * @returns the test
+   */
+  groupTest() {
+    const { groupNodes } = this.extras;
+    const { cytoscape } = this.dialect;
+    return (node) => {
+      if (!cytoscape) {
+        return true;
+      }
+      if (node.id !== null && groupNodes?.has(node.id) === true) {
+        return true;
+      }
+      return node.atts.some((a) => a.name === "__groupState" || a.name === "__isGroup" && isCyTrue(a.value));
+    };
+  }
+  /**
+   * W_DANGLING_REFERENCE for the `xlink:href` members of a generic document's non-group graphs
+   * that name no node or edge (a group's are E_UNKNOWN_PARENT, reported by the containment).
+   */
+  checkReferences() {
+    const isGroup = this.groupTest();
+    const edgeIds = new Set(this.doc.edges.map((e) => e.id));
+    let dangling = 0;
+    for (const graph of this.doc.graphs) {
+      if (graph.owner !== null && isGroup(graph.owner)) {
+        continue;
+      }
+      for (const member of graph.members) {
+        if (member.href === null) {
+          continue;
+        }
+        const id = localRef(member.href);
+        const known = id !== null && (member.kind === "node" ? this.rows.has(id) : edgeIds.has(id));
+        if (!known) {
+          dangling++;
+        }
+      }
+    }
+    if (dangling > 0) {
+      this.report.warning(
+        "validation-error",
+        XGMML_ISSUE.DANGLING_REFERENCE,
+        `${this.prefix()}${dangling} xlink:href reference(s) name no node or edge of the document`
+      );
+    }
+  }
+  /**
+   * Write the per-node values: label, attributes, XML attributes, graphics, positions, nested
+   * network pointers and subgraph memberships.
+   * @param graph - the subnetwork, or null
+   */
+  writeNodeExtras(graph) {
+    const labels = [];
+    const positions = new Positions(this, this.dialect.cytoscape ? this.settings.zAs : "position");
+    const graphics = new JsonColumn(this, "node", GRAPHICS_COLUMN, XGMML_ORIGIN_NAMESPACE, "graphics");
+    const pointers = new Pointers(this, this.groupTest());
+    for (const row of this.rowList) {
+      const where = { line: row.records[0].line, element: row.id };
+      const seen = /* @__PURE__ */ new Set();
+      for (const record of row.records) {
+        labels[row.row] ??= record.label ?? void 0;
+        this.addElementColumns(this.nodeColumns, row.row, record, seen, where);
+        positions.add(row, record);
+        if (record.graphics !== null && Object.keys(record.graphics).length > 0) {
+          graphics.set(row.index, record.graphics);
+        }
+        pointers.add(row, record);
+      }
+      this.checkAbort();
+    }
+    this.writeLabels("node", labels, (row) => this.rowList[row].index);
+    positions.write();
+    pointers.write();
+    if (graph === null) {
+      this.writeNetworks();
+    }
+  }
+  /**
+   * Add an element's XML attributes (text grammar) and atts to a column set; atts of a later
+   * duplicate declaration only fill names the earlier ones left unset.
+   * @param columns - the column set
+   * @param row - the row
+   * @param record - the node or edge
+   * @param seen - the names set by earlier declarations of the same node
+   * @param where - the location
+   */
+  addElementColumns(columns, row, record, seen, where) {
+    const merging = seen.size > 0;
+    const names = /* @__PURE__ */ new Set();
+    if (record.name !== null) {
+      if (!(merging && seen.has("name"))) {
+        columns.addText(row, "name", record.name, where);
+      }
+      names.add("name");
+    }
+    for (const [key2, value] of record.xmlAttrs) {
+      if (!(merging && seen.has(key2))) {
+        columns.addText(row, key2, value, where);
+      }
+      names.add(key2);
+    }
+    for (const att of record.atts) {
+      if (this.skipAtt(record, att) || merging && att.name !== null && seen.has(att.name)) {
+        continue;
+      }
+      if (record.kind === "node" && att.name === "__isGroup" && record.nested.length > 0 && isCyTrue(att.value)) {
+        continue;
+      }
+      if (att.hasGraph && att.name === null) {
+        continue;
+      }
+      columns.addAtt(row, att, where);
+      if (att.name !== null) {
+        names.add(att.name);
+      }
+    }
+    for (const name of names) {
+      seen.add(name);
+    }
+  }
+  /**
+   * Whether an att is not a column: an edge's weight att under weightFrom.
+   * @param record - the element
+   * @param att - the att
+   * @returns true to skip it
+   */
+  skipAtt(record, att) {
+    return record.kind === "edge" && record.weight === null && att.name === this.options.weightFrom;
+  }
+  /**
+   * Write a label column (role label).
+   * @param domain - node or edge
+   * @param labels - the label of each row
+   * @param index - the sink index of a row
+   */
+  writeLabels(domain, labels, index) {
+    if (!labels.some((l) => l !== void 0)) {
+      return;
+    }
+    const handle = this.declare(domain, {
+      name: LABEL_COLUMN,
+      dtype: "string",
+      role: "label",
+      nullable: true,
+      origin: { format: FORMAT, id: null, title: null, type: "label", namespace: null }
+    });
+    if (handle === null) {
+      return;
+    }
+    labels.forEach((label, row) => {
+      const i = index(row);
+      if (label !== void 0 && i >= 0) {
+        if (domain === "node") {
+          this.sink.setNodeValue(handle, i, label);
+        } else {
+          this.sink.setEdgeValue(handle, i, label);
+        }
+      }
+    });
+  }
+  /** The `xgmml.networks` membership of nodes in root-level subgraphs of a generic document. */
+  writeNetworks() {
+    const { subgraphs } = this.doc.root;
+    if (subgraphs.length === 0) {
+      return;
+    }
+    const member = /* @__PURE__ */ new Map();
+    for (const graph of subgraphs) {
+      const name = graph.id ?? graph.label ?? "";
+      for (const m of graph.members) {
+        const id = m.kind === "node" ? m.id ?? (m.href === null ? null : localRef(m.href)) : null;
+        const row = id === null ? void 0 : this.rows.get(id);
+        if (row !== void 0 && row.index >= 0) {
+          const list = member.get(row.index) ?? [];
+          list.push(name);
+          member.set(row.index, list);
+        }
+      }
+    }
+    if (member.size === 0) {
+      return;
+    }
+    const handle = this.declare("node", {
+      name: NETWORKS_COLUMN,
+      dtype: "list",
+      itemDtype: "string",
+      nullable: true,
+      origin: { format: FORMAT, id: null, title: null, type: "graph", namespace: XGMML_ORIGIN_NAMESPACE }
+    });
+    if (handle !== null) {
+      for (const [index, list] of member) {
+        this.sink.setNodeValue(handle, index, list);
+      }
+    }
+  }
+  // ------------------------------------------------------------------ edges
+  /**
+   * Push every edge record.
+   * @param records - the edge records
+   * @param header - the header direction
+   */
+  addEdges(records, header) {
+    const ids = /* @__PURE__ */ new Set();
+    const dedupe = this.dialect.cy2 && this.doc.nodes.some((n) => n.nested.length > 0) ? /* @__PURE__ */ new Set() : null;
+    const labels = [];
+    const edgeIds = [];
+    const graphics = [];
+    let row = 0;
+    for (const record of records) {
+      const where = { line: record.line, element: record.id ?? record.label };
+      const key2 = record.id ?? record.label;
+      if (dedupe !== null && key2 !== null) {
+        if (dedupe.has(key2)) {
+          this.report.warnOnce(
+            "merged",
+            XGMML_ISSUE.GROUP_DUPLICATE_EDGE,
+            `${this.prefix()}the Cytoscape 2.x writer repeats the edges of a group; each repeat is dropped`,
+            where
+          );
+          continue;
+        }
+        dedupe.add(key2);
+      }
+      const index = this.addEdge(record, header, ids, where);
+      this.checkAbort();
+      if (index < 0) {
+        continue;
+      }
+      this.edgeIndex[row] = index;
+      labels[row] = record.label ?? void 0;
+      edgeIds[row] = record.id ?? void 0;
+      this.addElementColumns(this.edgeColumns, row, record, /* @__PURE__ */ new Set(), where);
+      this.fillInteraction(record, row, where);
+      if (record.graphics !== null && Object.keys(record.graphics).length > 0) {
+        graphics.push([index, record.graphics]);
+      }
+      row++;
+    }
+    this.writeEdgeIds(edgeIds);
+    this.writeLabels("edge", labels, (r) => this.edgeIndex[r] ?? -1);
+    const column = new JsonColumn(this, "edge", GRAPHICS_COLUMN, XGMML_ORIGIN_NAMESPACE, "graphics");
+    for (const [index, value] of graphics) {
+      column.set(index, value);
+    }
+  }
+  /**
+   * Push one edge: endpoints (with label aliases), duplicate id check, direction and weight.
+   * @param record - the edge
+   * @param header - the header direction
+   * @param ids - the edge ids used so far
+   * @param where - the location
+   * @returns the edge index, or -1 when it was skipped
+   */
+  addEdge(record, header, ids, where) {
+    const alias = this.settings.labelAliases ? aliasesOf(record.label) : null;
+    let source;
+    let target;
+    try {
+      source = this.endpoint(record.source, alias?.[0] ?? null, "source", where);
+      target = this.endpoint(record.target, alias?.[2] ?? null, "target", where);
+    } catch (err) {
+      this.report.counts.skippedEdges++;
+      this.report.recordError(err, where);
+      return -1;
+    }
+    if (source === null || target === null) {
+      this.report.counts.skippedEdges++;
+      return -1;
+    }
+    if (record.id !== null && ids.has(record.id)) {
+      this.report.counts.skippedEdges++;
+      this.report.error(
+        "validation-error",
+        XGMML_ISSUE.DUPLICATE_EDGE_ID,
+        `${this.prefix()}edge id "${record.id}" is used twice; the second edge is skipped`,
+        where
+      );
+      return -1;
+    }
+    const directed = this.edgeDirection(record, header);
+    const kind = directed ? "directed" : "undirected";
+    let weight;
+    try {
+      weight = this.weightOf(record);
+      const before = this.sink.edgeCount;
+      const e = this.direction.addEdge(source, target, kind, weight, where);
+      this.report.counts.edges += this.sink.edgeCount - before;
+      if (record.id !== null) {
+        ids.add(record.id);
+      }
+      return e;
+    } catch (err) {
+      this.report.counts.skippedEdges++;
+      this.report.recordError(err, where);
+      return -1;
+    }
+  }
+  /**
+   * The weight of an edge: its `weight` XML attribute (or the att weightFrom names).
+   * @param record - the edge
+   * @returns the weight, or undefined
+   */
+  weightOf(record) {
+    const from = this.options.weightFrom;
+    if (from === null) {
+      return void 0;
+    }
+    let text = from === "weight" ? record.weight : null;
+    if (text === null) {
+      text = record.atts.find((a) => a.name === from && a.children.length === 0)?.value ?? null;
+    }
+    if (text === null) {
+      return void 0;
+    }
+    const weight = parseWeightText(text);
+    this.weighted ||= weight !== void 0;
+    return weight;
+  }
+  /**
+   * Resolve one endpoint: a node of this graph by id, else (under labelAliases) the label alias
+   * by id or by unique node label; a missing endpoint is E_MISSING_ENDPOINT, an unknown one
+   * E_UNKNOWN_NODE unless addMissingNodes adds it.
+   * @param text - the source or target text, or null
+   * @param alias - the label alias, or null
+   * @param side - which end
+   * @param where - the location
+   * @returns the node id, or null when the edge cannot be added
+   */
+  endpoint(text, alias, side, where) {
+    if (text !== null) {
+      const row = this.rows.get(text);
+      if (row !== void 0 && row.index >= 0) {
+        return this.coercer.text(text);
+      }
+    }
+    if (alias !== null) {
+      const resolved = this.aliasRow(alias);
+      if (resolved !== null) {
+        this.aliasResolved++;
+        return this.coercer.text(resolved.id);
+      }
+    }
+    if (text === null) {
+      this.report.error(
+        "missing-value",
+        XGMML_ISSUE.MISSING_ENDPOINT,
+        `${this.prefix()}<edge> without a ${side}`,
+        where
+      );
+      return null;
+    }
+    if (this.options.addMissingNodes) {
+      const id = this.coercer.text(text);
+      if (this.sink.indexOf(id) === INVALID_INDEX) {
+        this.sink.addNode(id);
+        this.report.counts.nodes++;
+      }
+      return id;
+    }
+    this.report.error(
+      "validation-error",
+      XGMML_ISSUE.UNKNOWN_NODE,
+      `${this.prefix()}edge ${side} "${text}" is not a node of this graph; the edge is skipped`,
+      where
+    );
+    return null;
+  }
+  /**
+   * The node a label alias names: by id, else by a label only one node has.
+   * @param alias - the alias
+   * @returns the row, or null
+   */
+  aliasRow(alias) {
+    const byId = this.rows.get(alias);
+    if (byId !== void 0 && byId.index >= 0) {
+      return byId;
+    }
+    if (this.labelRows === null) {
+      this.labelRows = /* @__PURE__ */ new Map();
+      for (const row of this.rowList) {
+        const { label } = row.records[0];
+        if (label !== null && row.index >= 0) {
+          this.labelRows.set(label, this.labelRows.has(label) ? null : row);
+        }
+      }
+    }
+    return this.labelRows.get(alias) ?? null;
+  }
+  /**
+   * Fill the interaction of an edge without one from its label alias, as Cytoscape does.
+   * @param record - the edge
+   * @param row - the edge row
+   * @param where - the location
+   */
+  fillInteraction(record, row, where) {
+    if (!this.settings.labelAliases || this.dialect.session || record.atts.some((a) => a.name === INTERACTION_COLUMN)) {
+      return;
+    }
+    const alias = aliasesOf(record.label);
+    if (alias !== null) {
+      this.edgeColumns.addText(row, INTERACTION_COLUMN, alias[1], where);
+      this.aliasInteractions++;
+    }
+  }
+  /** Report the label alias uses, once. */
+  finishAliases() {
+    if (this.aliasResolved === 0 && this.aliasInteractions === 0) {
+      return;
+    }
+    this.report.warning(
+      "coercion",
+      XGMML_ISSUE.LABEL_ALIAS,
+      `${this.prefix()}Cytoscape label aliases ("a (pp) b"): ${this.aliasResolved} endpoint(s) resolved, ${this.aliasInteractions} interaction(s) filled from edge labels`
+    );
+  }
+  /**
+   * Write the edge `id` column (role id, unique).
+   * @param ids - the id of each row
+   */
+  writeEdgeIds(ids) {
+    if (!ids.some((id) => id !== void 0)) {
+      return;
+    }
+    const handle = this.declare("edge", {
+      name: EDGE_ID_COLUMN,
+      dtype: "string",
+      role: "id",
+      unique: true,
+      nullable: true,
+      origin: { format: FORMAT, id: null, title: null, type: "id", namespace: null }
+    });
+    if (handle === null) {
+      return;
+    }
+    ids.forEach((id, row) => {
+      const e = this.edgeIndex[row];
+      if (id !== void 0 && e !== void 0) {
+        try {
+          this.sink.setEdgeValue(handle, e, id);
+        } catch (err) {
+          this.report.recordError(err, { element: id });
+        }
+      }
+    });
+  }
+  // ------------------------------------------------------------------ graph and metadata
+  /**
+   * The graph table: the graph's atts and other XML attributes, and its graphics.
+   * @param graph - the subnetwork, or null for the root
+   */
+  writeGraph(graph) {
+    const g = graph ?? this.doc.root;
+    const where = { line: g.line, element: g.id };
+    if (graph === null) {
+      for (const [key2, value] of g.attrs) {
+        if (!GRAPH_STRUCTURE.has(key2) && key2 !== "xmlns" && !key2.startsWith("xmlns:")) {
+          this.graphColumns.addText(0, key2, value, where);
+        }
+      }
+    }
+    for (const att of g.atts) {
+      if (att.name !== null && META_ATTS.has(att.name)) {
+        continue;
+      }
+      if (att.hasGraph && att.name === null) {
+        continue;
+      }
+      this.graphColumns.addAtt(0, att, where);
+    }
+    this.graphColumns.write(this.sink, () => 0);
+    const json = { ...this.extras.graphJson ?? {} };
+    if (g.graphics !== null && Object.keys(g.graphics).length > 0) {
+      json[GRAPHICS_COLUMN] = g.graphics;
+    }
+    for (const [name, value] of Object.entries(json)) {
+      this.sink.setGraphValue(name, value, {
+        name,
+        dtype: "json",
+        nullable: true,
+        origin: { format: FORMAT, id: null, title: null, type: name, namespace: XGMML_ORIGIN_NAMESPACE }
+      });
+    }
+  }
+  /**
+   * The graph metadata: name, description and date from the RDF metadata, the format, version
+   * and what the exporter needs.
+   * @param graph - the subnetwork, or null
+   */
+  writeMeta(graph) {
+    const g = graph ?? this.doc.root;
+    const { rdf } = this.doc;
+    const name = this.extras.graphName ?? g.label ?? rdf.title ?? g.id ?? void 0;
+    this.sink.setMeta({
+      name: name ?? void 0,
+      description: rdf.description ?? void 0,
+      created: rdf.date ?? void 0,
+      sourceFormat: this.extras.sourceFormat ?? FORMAT,
+      sourceVersion: this.dialect.versionText ?? void 0,
+      weightOrigin: this.weighted ? { format: FORMAT, id: "weight", title: null, type: "weight", namespace: null } : void 0,
+      extra: {
+        [META_KEY]: {
+          graphId: g.id,
+          directed: this.doc.root.attrs.get("directed") ?? null,
+          rdf: Object.keys(rdf).length > 0 ? { ...rdf } : null
+        },
+        ...this.extras.metaExtra ?? {}
+      }
+    });
+  }
+}
+function aliasesOf(label) {
+  if (label === null) {
+    return null;
+  }
+  const parts = label.split(ALIAS_SPLIT);
+  return parts.length === 3 ? [parts[0].trim(), parts[1], parts[2].trim()] : null;
+}
+class JsonColumn {
+  /**
+   * Create the column.
+   * @param emitter - the emitter
+   * @param domain - node or edge
+   * @param name - the column name
+   * @param namespace - its origin namespace
+   * @param type - its origin type
+   * @param dtype - json (default) or string
+   */
+  constructor(emitter, domain, name, namespace, type, dtype = "json") {
+    this.emitter = emitter;
+    this.domain = domain;
+    this.name = name;
+    this.namespace = namespace;
+    this.type = type;
+    this.dtype = dtype;
+  }
+  /**
+   * Set one value.
+   * @param index - the node or edge index
+   * @param value - the value
+   */
+  set(index, value) {
+    if (index < 0) {
+      return;
+    }
+    if (this.handle === void 0) {
+      this.handle = this.emitter.declare(this.domain, {
+        name: this.name,
+        dtype: this.dtype,
+        nullable: true,
+        origin: { format: FORMAT, id: null, title: null, type: this.type, namespace: this.namespace }
+      });
+    }
+    if (this.handle === null) {
+      return;
+    }
+    const sink = this.emitter.target;
+    if (this.domain === "node") {
+      sink.setNodeValue(this.handle, index, value);
+    } else {
+      sink.setEdgeValue(this.handle, index, value);
+    }
+  }
+}
+class Positions {
+  /**
+   * Create the collector.
+   * @param emitter - the emitter
+   * @param zAs - where z goes
+   */
+  constructor(emitter, zAs) {
+    this.emitter = emitter;
+    this.zAs = zAs;
+    this.values = /* @__PURE__ */ new Map();
+    this.zValues = /* @__PURE__ */ new Map();
+    this.hasZ = false;
+  }
+  /**
+   * Read one node record's coordinates.
+   * @param row - the node row
+   * @param record - the record
+   */
+  add(row, record) {
+    if (row.index < 0 || record.x === null && record.y === null && record.z === null) {
+      return;
+    }
+    const where = { line: record.line, element: row.id };
+    const x = this.number(record.x, where);
+    const y = this.number(record.y, where);
+    const z = this.number(record.z, where);
+    if (z !== null) {
+      this.hasZ = true;
+      if (this.zAs === "column") {
+        this.zValues.set(row.index, z);
+      }
+    }
+    if (x !== null && y !== null) {
+      const flipped = y === 0 ? 0 : -y;
+      this.values.set(row.index, [x, flipped, this.zAs === "position" ? z ?? 0 : 0]);
+    }
+  }
+  /**
+   * A coordinate.
+   * @param text - the text, or null
+   * @param where - the location
+   * @returns the number, or null when absent or invalid (recorded)
+   */
+  number(text, where) {
+    if (text === null) {
+      return null;
+    }
+    const n = Number(text.trim());
+    if (text.trim().length === 0 || !Number.isFinite(n)) {
+      this.emitter.issues.error(
+        "validation-error",
+        XGMML_ISSUE.BAD_VALUE,
+        `${this.emitter.prefix()}graphics coordinate "${text}" is not a number`,
+        where
+      );
+      return null;
+    }
+    return n;
+  }
+  /** Declare and write the position and z columns. */
+  write() {
+    const sink = this.emitter.target;
+    if (this.values.size > 0) {
+      const handle = this.emitter.declare("node", {
+        name: POSITION_COLUMN,
+        dtype: "f32",
+        components: 3,
+        role: "position",
+        nullable: true,
+        origin: { format: FORMAT, id: null, title: null, type: "graphics", namespace: XGMML_ORIGIN_NAMESPACE },
+        extra: { sourceDims: this.zAs === "position" && this.hasZ ? 3 : 2, units: "file" }
+      });
+      if (handle !== null) {
+        for (const [index, xyz] of this.values) {
+          sink.setNodeValue(handle, index, xyz);
+        }
+      }
+    }
+    if (this.zValues.size > 0) {
+      const handle = this.emitter.declare("node", {
+        name: Z_COLUMN,
+        dtype: "f64",
+        nullable: true,
+        origin: {
+          format: FORMAT,
+          id: null,
+          title: null,
+          type: "graphics",
+          namespace: CYTOSCAPE_ORIGIN_NAMESPACE
+        }
+      });
+      if (handle !== null) {
+        for (const [index, z] of this.zValues) {
+          sink.setNodeValue(handle, index, z);
+        }
+      }
+    }
+  }
+}
+class Pointers {
+  /**
+   * Create the collector.
+   * @param emitter - the emitter
+   * @param isGroup - the group test
+   */
+  constructor(emitter, isGroup) {
+    this.emitter = emitter;
+    this.isGroup = isGroup;
+    this.names = /* @__PURE__ */ new Map();
+    this.crossFile = /* @__PURE__ */ new Map();
+    this.dangling = 0;
+  }
+  /**
+   * Read one node record's pointers.
+   * @param row - the node row
+   * @param record - the record
+   */
+  add(row, record) {
+    if (record.nested.length === 0 || this.isGroup(record) || row.index < 0) {
+      return;
+    }
+    for (const graph of record.nested) {
+      if (graph.href === null) {
+        this.names.set(row.index, graph.label ?? graph.id ?? "");
+        continue;
+      }
+      const id = localRef(graph.href);
+      if (id === null) {
+        const resolved = this.emitter.resolvePointer(graph.href);
+        if (resolved !== null) {
+          this.names.set(row.index, resolved);
+        } else {
+          this.crossFile.set(row.index, graph.href);
+        }
+        continue;
+      }
+      const target = this.emitter.graphById(id);
+      if (target === void 0) {
+        this.dangling++;
+      } else {
+        this.names.set(row.index, target.label ?? target.id ?? id);
+      }
+    }
+  }
+  /** Write the pointer columns and their warnings. */
+  write() {
+    const prefix = this.emitter.prefix();
+    if (this.dangling > 0) {
+      this.emitter.issues.warning(
+        "validation-error",
+        XGMML_ISSUE.DANGLING_REFERENCE,
+        `${prefix}${this.dangling} nested-network pointer(s) name no graph of the document`
+      );
+    }
+    const names = new JsonColumn(
+      this.emitter,
+      "node",
+      NESTED_NETWORK_COLUMN,
+      CYTOSCAPE_ORIGIN_NAMESPACE,
+      "nestedNetwork",
+      "string"
+    );
+    for (const [index, name] of this.names) {
+      names.set(index, name);
+    }
+    if (this.crossFile.size > 0) {
+      this.emitter.issues.warning(
+        "unsupported",
+        XGMML_ISSUE.CROSS_FILE_REFERENCE,
+        `${prefix}${this.crossFile.size} nested-network pointer(s) point into another file; each is kept as text in ${NETWORK_POINTER_COLUMN}`
+      );
+      const column = new JsonColumn(
+        this.emitter,
+        "node",
+        NETWORK_POINTER_COLUMN,
+        XGMML_ORIGIN_NAMESPACE,
+        "xlink:href",
+        "string"
+      );
+      for (const [index, href] of this.crossFile) {
+        column.set(index, href);
+      }
+    }
+  }
+}
+class Containment {
+  /**
+   * Create the resolver.
+   * @param emitter - the emitter
+   */
+  constructor(emitter) {
+    this.emitter = emitter;
+    this.parents = /* @__PURE__ */ new Map();
+    this.subgraphs = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Collect the memberships of every group node of the graph.
+   * @param rows - the node rows
+   * @param isGroup - the group test
+   */
+  resolve(rows, isGroup) {
+    let unknown = 0;
+    for (const row of rows) {
+      for (const record of row.records) {
+        if (row.index < 0 || record.nested.length === 0 || !isGroup(record)) {
+          continue;
+        }
+        for (const graph of record.nested) {
+          const atts = graph.atts.filter((a) => a.name !== null);
+          if (graph.id !== null || graph.label !== null || atts.length > 0) {
+            this.subgraphs.set(row.index, {
+              id: graph.id,
+              label: graph.label,
+              atts: Object.fromEntries(atts.map((a) => [a.name, attJson(a)]))
+            });
+          }
+          for (const member of graph.members) {
+            if (member.kind !== "node") {
+              continue;
+            }
+            const id = member.id ?? (member.href === null ? null : localRef(member.href));
+            const child = id === null ? void 0 : this.emitter.rowOf(id);
+            if (child === void 0) {
+              if (id === null || !this.emitter.missingMember(row.id, id)) {
+                unknown++;
+              }
+              continue;
+            }
+            if (child.index >= 0) {
+              this.link(child.index, row.index, member.line);
+            }
+          }
+        }
+      }
+    }
+    if (unknown > 0) {
+      this.emitter.issues.error(
+        "missing-value",
+        XGMML_ISSUE.UNKNOWN_PARENT,
+        `${this.emitter.prefix()}${unknown} group member(s) name no node of this graph`
+      );
+    }
+  }
+  /**
+   * Add one membership unless it closes a parent cycle.
+   * @param child - the member's index
+   * @param parent - the group node's index
+   * @param line - the line
+   */
+  link(child, parent, line) {
+    if (child === parent || this.isAncestor(child, parent)) {
+      this.emitter.issues.error(
+        "validation-error",
+        XGMML_ISSUE.PARENT_CYCLE,
+        `${this.emitter.prefix()}a group membership would make a node its own ancestor; that membership is dropped`,
+        { line }
+      );
+      return;
+    }
+    const list = this.parents.get(child) ?? [];
+    if (!list.includes(parent)) {
+      list.push(parent);
+    }
+    this.parents.set(child, list);
+  }
+  /**
+   * Whether a node is an ancestor of another through the memberships so far.
+   * @param ancestor - the candidate ancestor
+   * @param node - the node
+   * @returns true when following parents from node reaches ancestor
+   */
+  isAncestor(ancestor, node) {
+    const stack = [node];
+    const seen = /* @__PURE__ */ new Set();
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n === ancestor) {
+        return true;
+      }
+      if (seen.has(n)) {
+        continue;
+      }
+      seen.add(n);
+      stack.push(...this.parents.get(n) ?? []);
+    }
+    return false;
+  }
+  /** Declare and write the parent (or parents) and subgraph columns. */
+  write() {
+    const sink = this.emitter.target;
+    if (this.parents.size > 0) {
+      const multi = [...this.parents.values()].some((list) => list.length > 1);
+      const handle = this.emitter.declare("node", {
+        name: multi ? PARENTS_COLUMN : PARENT_COLUMN,
+        dtype: multi ? "list" : "u32",
+        itemDtype: multi ? "u32" : void 0,
+        role: multi ? "parents" : "parent",
+        refersTo: "node",
+        nullable: true,
+        origin: { format: FORMAT, id: null, title: null, type: "graph", namespace: null }
+      });
+      if (handle !== null) {
+        for (const [child, list] of this.parents) {
+          sink.setNodeValue(handle, child, multi ? list : list[0]);
+        }
+      }
+    }
+    if (this.subgraphs.size > 0) {
+      const column = new JsonColumn(this.emitter, "node", SUBGRAPH_COLUMN, XGMML_ORIGIN_NAMESPACE, "graph");
+      for (const [index, value] of this.subgraphs) {
+        column.set(index, value);
+      }
+    }
+  }
+}
+const FORMAT_DEFAULTS = {
+  ids: "keep",
+  defaultDirected: false,
+  weightFrom: "weight",
+  addMissingNodes: false
+};
+const USED_OPTIONS = /* @__PURE__ */ new Set([
+  "ids",
+  "addMissingNodes",
+  "duplicateEdges",
+  "selfLoops",
+  "onMixedDirection",
+  "defaultDirected",
+  "weightFrom",
+  "weightDtype",
+  "long",
+  "errorLimit",
+  "signal",
+  "onProgress",
+  "encoding"
+]);
+const SNIFF_BYTES = 4096;
+const HEAD_CHARS = 2048;
+const XGMML_DOCTYPE = /<!DOCTYPE\s+graph\s[^<>]*xgmml\.dtd/i;
+function resolveSettings(options, cytoscape) {
+  const zAs = options?.zAs ?? "column";
+  if (zAs !== "column" && zAs !== "position") {
+    throw new GraphFormatError(
+      "E_UNSUPPORTED",
+      `option zAs: ${JSON.stringify(zAs)} is not "column" or "position"`,
+      {
+        option: "zAs",
+        found: zAs
+      }
+    );
+  }
+  return {
+    labelAliases: booleanOption("labelAliases", options?.labelAliases, cytoscape),
+    cytoscapeEscapes: booleanOption("cytoscapeEscapes", options?.cytoscapeEscapes, cytoscape),
+    zAs
+  };
+}
+function booleanOption(name, value, fallback) {
+  if (value === void 0) {
+    return fallback;
+  }
+  if (typeof value !== "boolean") {
+    throw new GraphFormatError("E_UNSUPPORTED", `option ${name}: ${JSON.stringify(value)} is not a boolean`, {
+      option: name,
+      found: value
+    });
+  }
+  return value;
+}
+async function parseXgmml(input, report, common, options) {
+  const repairs = {
+    bareAmpersand: booleanOption("repairBareAmpersands", options?.repairBareAmpersands, false) ? (line) => {
+      report.warning("parse-error", XGMML_ISSUE.AMPERSAND_REPAIRED, "a bare & was read as &amp;", { line });
+    } : void 0,
+    surrogatePair: booleanOption("pairSurrogateReferences", options?.pairSurrogateReferences, false) ? (line) => {
+      report.warning(
+        "parse-error",
+        XGMML_ISSUE.SURROGATE_PAIRED,
+        "two surrogate character references were joined into one character",
+        { line }
+      );
+    } : void 0
+  };
+  const parser = new XgmmlParser(report);
+  const seen = { head: "", content: false };
+  try {
+    await tokenizeXml(
+      watch(textChunks(input, report, { ...common, declaredEncoding: xmlDeclaredEncoding }), seen),
+      parser,
+      repairs
+    );
+  } catch (err) {
+    if (err instanceof XmlSyntaxError) {
+      if (!seen.content) {
+        report.fail(XGMML_ISSUE.EMPTY_INPUT, "the input is empty");
+      }
+      report.fail(XGMML_ISSUE.XML_SYNTAX, err.message, { line: err.line });
+    }
+    throw err;
+  }
+  const doc = parser.document();
+  if (!doc.xgmmlNamespace && !XGMML_DOCTYPE.test(seen.head)) {
+    report.warning(
+      "validation-error",
+      XGMML_ISSUE.NO_NAMESPACE,
+      "the root <graph> has neither the XGMML namespace nor an XGMML DOCTYPE; it is read as XGMML",
+      { line: doc.root.line }
+    );
+  }
+  return doc;
+}
+async function* watch(chunks, seen) {
+  for await (const chunk of chunks) {
+    if (seen.head.length < HEAD_CHARS) {
+      seen.head += chunk.slice(0, HEAD_CHARS - seen.head.length);
+    }
+    seen.content ||= !isWhitespace(chunk);
+    yield chunk;
+  }
+}
+async function prepare(input, sink, options) {
+  const common = resolveImportOptions(options, FORMAT_DEFAULTS);
+  const report = new ImportReportBuilder(FORMAT, common.errorLimit);
+  if (sink !== null) {
+    reportSinkOptions(sink, options, report, true);
+    reportUnusedOptions(options, report, USED_OPTIONS);
+  }
+  resolveSettings(options, false);
+  const doc = await parseXgmml(input, report, common, options);
+  const dialect = dialectOf(doc, report);
+  if (dialect.view) {
+    report.fail(
+      XGMML_ISSUE.VIEW_DOCUMENT,
+      "this is a Cytoscape session view file (cy:view): it holds positions keyed by view ids and no topology; open the session (.cys) instead",
+      { line: doc.root.line }
+    );
+  }
+  return {
+    report,
+    common,
+    doc,
+    dialect,
+    settings: resolveSettings(options, doc.cytoscape),
+    graphs: graphsOf(doc, dialect)
+  };
+}
+function emitOne(prepared, graph, sink, extras) {
+  const { doc, dialect, report, common, settings } = prepared;
+  const emitter = new XgmmlEmitter(doc, dialect, sink, report, common, settings, extras);
+  emitter.emit(dialect.session ? graph : null);
+  if (dialect.session) {
+    reportRootOnly(prepared);
+  }
+  throwIfAborted(common.signal);
+  return report.finish();
+}
+function reportRootOnly(prepared) {
+  const held = /* @__PURE__ */ new Set();
+  for (const graph of prepared.graphs) {
+    const members = membersOf(prepared.doc, graph);
+    members.nodes.forEach((n) => held.add(n));
+    members.edges.forEach((e) => held.add(e));
+  }
+  const nodes = prepared.doc.nodes.filter((n) => !held.has(n)).length;
+  const edges = prepared.doc.edges.filter((e) => !held.has(e)).length;
+  if (nodes + edges > 0) {
+    prepared.report.warning(
+      "unsupported",
+      XGMML_ISSUE.ROOT_ONLY_ELEMENTS,
+      `${nodes} node(s) and ${edges} edge(s) belong to no registered network (group meta-edges, collapsed group members) and were not read`
+    );
+  }
+}
+async function importXgmml(input, sink, options) {
+  const prepared = await prepare(input, sink, options);
+  const index = chooseGraph(
+    prepared.graphs.map((g) => graphName(g, prepared.doc)),
+    options,
+    prepared.report
+  );
+  if (prepared.graphs.length > 1) {
+    prepared.report.warning(
+      "unsupported",
+      XGMML_ISSUE.MULTIPLE_GRAPHS,
+      `the session network document holds ${prepared.graphs.length} registered networks; ${prepared.graphs.length - 1} were not read (use importAll, graphIndex or graphName)`
+    );
+  }
+  return emitOne(prepared, prepared.graphs[index], sink);
+}
+async function importAllXgmml(input, sinkFor, options) {
+  const bytes = await reread(input);
+  const first = await prepare(bytes, null, options);
+  const reports = [];
+  for (let i = 0; i < first.graphs.length; i++) {
+    const sink = sinkFor(i);
+    const prepared = i === 0 ? first : await prepare(bytes, null, options);
+    reportSinkOptions(sink, options, prepared.report, true);
+    reportUnusedOptions(options, prepared.report, USED_OPTIONS);
+    reports.push(emitOne(prepared, prepared.graphs[i], sink));
+  }
+  return reports;
+}
+async function listXgmmlGraphs(input, options) {
+  const prepared = await prepare(input, null, options);
+  return prepared.graphs.map((graph, index) => {
+    const members = membersOf(prepared.doc, prepared.dialect.session ? graph : null);
+    return Object.freeze({
+      index,
+      name: graphName(graph, prepared.doc),
+      nodes: new Set(members.nodes.map((n) => n.id)).size,
+      edges: members.edges.length
+    });
+  });
+}
+function graphName(graph, doc) {
+  return graph.label ?? (graph === doc.root ? doc.rdf.title ?? null : null) ?? graph.id ?? null;
+}
+async function reread(input) {
+  if (typeof input === "string" || input instanceof Uint8Array) {
+    return input;
+  }
+  const parts = [];
+  const iterable = typeof input.getReader === "function" ? streamIterable(input) : input;
+  for await (const chunk of iterable) {
+    parts.push(chunk);
+  }
+  if (parts.every((p) => typeof p === "string")) {
+    return parts.join("");
+  }
+  const bytes = parts.map((p) => typeof p === "string" ? new TextEncoder().encode(p) : p);
+  const out = new Uint8Array(bytes.reduce((n, b) => n + b.byteLength, 0));
+  let at = 0;
+  for (const b of bytes) {
+    out.set(b, at);
+    at += b.byteLength;
+  }
+  return out;
+}
+async function* streamIterable(stream) {
+  const reader = stream.getReader();
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) {
+        return;
+      }
+      yield value;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+function sniffXgmml(head) {
+  const text = new TextDecoder("utf-8", { fatal: false }).decode(head.subarray(0, SNIFF_BYTES));
+  if (!/^\uFEFF?\s*</.test(text)) {
+    return 0;
+  }
+  if (XGMML_DOCTYPE.test(text)) {
+    return 0.95;
+  }
+  const root = /<(?!\?|!)([A-Za-z_][\w.-]*:)?([A-Za-z_][\w.-]*)[\s/>]/.exec(text.replace(/<!--[\s\S]*?-->/g, ""));
+  if (root === null || root[2] !== "graph") {
+    return 0;
+  }
+  const tagEnd = text.indexOf(">", root.index);
+  const tag = text.slice(root.index, tagEnd < 0 ? void 0 : tagEnd);
+  return tag.includes("http://www.cs.rpi.edu/XGMML") ? 0.95 : 0.5;
+}
+const xgmmlImporter = Object.freeze({
+  format: FORMAT,
+  extensions: EXTENSIONS,
+  mimeTypes: MIME_TYPES,
+  sniff: sniffXgmml,
+  import: importXgmml,
+  importAll: importAllXgmml,
+  listGraphs: listXgmmlGraphs
+});
+export {
+  CY_NAMESPACE as C,
+  EDGE_ID_COLUMN as E,
+  FORMAT as F,
+  GRAPHICS_COLUMN as G,
+  INTERACTION_COLUMN as I,
+  LABEL_COLUMN as L,
+  META_KEY as M,
+  NESTED_NETWORK_COLUMN as N,
+  POSITION_COLUMN as P,
+  SUBGRAPH_COLUMN as S,
+  XGMML_ISSUE as X,
+  Z_COLUMN as Z,
+  XGMML_LOSS as a,
+  XLINK_NAMESPACE as b,
+  XGMML_NAMESPACE as c,
+  aliasesOf as d,
+  NETWORK_POINTER_COLUMN as e,
+  NETWORKS_COLUMN as f,
+  PARENT_COLUMN as g,
+  PARENTS_COLUMN as h,
+  XGMML_ORIGIN_NAMESPACE as i,
+  CYTOSCAPE_ORIGIN_NAMESPACE as j,
+  isCyTrue as k,
+  XgmmlEmitter as l,
+  membersOf as m,
+  dialectOf as n,
+  parseXgmml as p,
+  resolveSettings as r,
+  xgmmlImporter as x
+};
+//# sourceMappingURL=importer-D_e7e7LX.js.map