@graphty/graph-io 0.0.0 → 0.2.1

package/dist/gexf.js

@@ -0,0 +1,3466 @@
+import { aJ as TIME_TEXT_ROLE, aK as TIME_TEXT_SUFFIX, aC as resolveImportOptions, I as ImportReportBuilder, az as reportSinkOptions, aA as reportUnusedOptions, t as textChunks, a7 as XML_SYNTAX_CODE, a as throwIfAborted, s as IdCoercer, l as DirectionResolver, Y as STRAY_TEXT_CODE, G as NO_GRAPH_CODE, d as COUNT_HINT_CODE, at as isWeightField, aL as declareAttribute, af as declareResolved, w as MISSING_ID_CODE, k as DUPLICATE_NODE_CODE, a3 as UNKNOWN_PARENT_CODE, M as MISSING_ENDPOINT_CODE, i as DUPLICATE_EDGE_ID_CODE, ax as parseWeightText, aM as parseDeclaredTemporal, ae as declareCompanion, aN as parseDeclaredValue, aO as losesPrecision, R as PRECISION_CODE, aP as parseTimeText, aQ as splitListText, a2 as UNKNOWN_ELEMENT_CODE, n as ID_MERGED_CODE, aR as timeTextCompanion, aS as parseDecimalText, a9 as capabilities, L as LOSS, au as joinText, ah as encodeChunks, aD as sanitizeIds, aw as pairFolding, ai as explicitWeights, aB as resolveExportOptions, aa as checkCapabilities, aT as formatTimeValue, ak as formatF32, al as formatF64, aU as mapDeclaredType, aV as joinListText, aW as formatTemporal, an as formatInteger, aq as isCanonicalIntegerText, x as MIXED_DIRECTION_CODE, g as DIRECTION_FORCED_CODE, h as DIRECTION_REFUSED_CODE, W as SINK_OPTION_CODE, J as OPTION_IGNORED_CODE, V as ROLE_TAKEN_CODE, C as COLUMN_RENAMED_CODE, b as BAD_OPTIONS_CODE, B as BAD_DEFAULT_CODE, a1 as UNKNOWN_ATTR_TYPE_CODE, r as INVALID_UTF8_CODE } from "./chunks/writer-DxSKC7TL.js";
+import { GraphFormatError, INVALID_INDEX, MAX_COUNT } from "@graphty/graph-format";
+import { t as tokenizeXml, X as XmlSyntaxError, l as localName, d as isWhitespace, x as xmlIllegalTextNotes, e as escapeXmlText, f as escapeXmlAttribute } from "./chunks/escape-DyI8JofU.js";
+const GEXF_FORMAT = "gexf";
+const GEXF_NAMESPACES = {
+  "1.2": { gexf: "http://www.gexf.net/1.2draft", viz: "http://www.gexf.net/1.2draft/viz" },
+  "1.3": { gexf: "http://gexf.net/1.3", viz: "http://gexf.net/1.3/viz" }
+};
+const TIME_FORMATS = /* @__PURE__ */ new Set(["integer", "double", "date", "dateTime"]);
+const GRAPH_MODES = /* @__PURE__ */ new Set(["static", "dynamic", "slice"]);
+const TIME_REPRESENTATIONS = /* @__PURE__ */ new Set(["interval", "timestamp"]);
+const VIZ_NAMESPACE = "viz";
+const XML_ORIGIN = { format: GEXF_FORMAT };
+const VIZ_ORIGIN = { format: GEXF_FORMAT, namespace: VIZ_NAMESPACE };
+const NODE_COLUMNS = Object.freeze({
+  label: "label",
+  parent: "parent",
+  parents: "parents",
+  start: "start",
+  end: "end",
+  timestamp: "timestamp",
+  spells: "spells",
+  timestamps: "timestamps",
+  open: "open",
+  position: "position",
+  color: "color",
+  size: "size",
+  shape: "shape",
+  shapeUri: "shape.uri"
+});
+const EDGE_COLUMNS = Object.freeze({
+  id: "id",
+  label: "label",
+  kind: "kind",
+  start: "start",
+  end: "end",
+  timestamp: "timestamp",
+  spells: "spells",
+  timestamps: "timestamps",
+  open: "open",
+  color: "color",
+  thickness: "thickness",
+  shape: "shape"
+});
+const RESERVED_NODE_NAMES = /* @__PURE__ */ new Set([
+  ...Object.values(NODE_COLUMNS),
+  NODE_COLUMNS.start + TIME_TEXT_SUFFIX,
+  NODE_COLUMNS.end + TIME_TEXT_SUFFIX,
+  NODE_COLUMNS.timestamp + TIME_TEXT_SUFFIX
+]);
+const RESERVED_EDGE_NAMES = /* @__PURE__ */ new Set([
+  ...Object.values(EDGE_COLUMNS),
+  EDGE_COLUMNS.start + TIME_TEXT_SUFFIX,
+  EDGE_COLUMNS.end + TIME_TEXT_SUFFIX,
+  EDGE_COLUMNS.timestamp + TIME_TEXT_SUFFIX
+]);
+const NODE_DECLS = {
+  label: { name: NODE_COLUMNS.label, dtype: "string", role: "label", nullable: true, origin: XML_ORIGIN },
+  parent: {
+    name: NODE_COLUMNS.parent,
+    dtype: "u32",
+    role: "parent",
+    refersTo: "node",
+    nullable: true,
+    origin: XML_ORIGIN
+  },
+  parents: {
+    name: NODE_COLUMNS.parents,
+    dtype: "list",
+    itemDtype: "u32",
+    role: "parents",
+    refersTo: "node",
+    nullable: true,
+    origin: XML_ORIGIN
+  },
+  start: { name: NODE_COLUMNS.start, dtype: "f64", role: "start", nullable: true, origin: XML_ORIGIN },
+  end: { name: NODE_COLUMNS.end, dtype: "f64", role: "end", nullable: true, origin: XML_ORIGIN },
+  timestamp: { name: NODE_COLUMNS.timestamp, dtype: "f64", role: "timestamp", nullable: true, origin: XML_ORIGIN },
+  spells: {
+    name: NODE_COLUMNS.spells,
+    dtype: "list",
+    itemDtype: "f64",
+    itemComponents: 2,
+    role: "spells",
+    nullable: true,
+    origin: XML_ORIGIN
+  },
+  timestamps: {
+    name: NODE_COLUMNS.timestamps,
+    dtype: "list",
+    itemDtype: "f64",
+    role: "timestamps",
+    nullable: true,
+    origin: XML_ORIGIN
+  },
+  open: { name: NODE_COLUMNS.open, dtype: "u8", role: "open", nullable: true, origin: XML_ORIGIN },
+  position: {
+    name: NODE_COLUMNS.position,
+    dtype: "f32",
+    components: 3,
+    role: "position",
+    mutable: true,
+    nullable: true,
+    origin: VIZ_ORIGIN,
+    extra: { units: "file" }
+  },
+  color: {
+    name: NODE_COLUMNS.color,
+    dtype: "f32",
+    components: 4,
+    role: "color",
+    nullable: true,
+    origin: VIZ_ORIGIN
+  },
+  size: { name: NODE_COLUMNS.size, dtype: "f32", role: "size", nullable: true, origin: VIZ_ORIGIN },
+  shape: { name: NODE_COLUMNS.shape, dtype: "dict", role: "shape", nullable: true, origin: VIZ_ORIGIN },
+  shapeUri: { name: NODE_COLUMNS.shapeUri, dtype: "string", nullable: true, origin: VIZ_ORIGIN }
+};
+const EDGE_DECLS = {
+  id: { name: EDGE_COLUMNS.id, dtype: "string", role: "id", unique: true, nullable: true, origin: XML_ORIGIN },
+  label: { name: EDGE_COLUMNS.label, dtype: "string", role: "label", nullable: true, origin: XML_ORIGIN },
+  kind: { name: EDGE_COLUMNS.kind, dtype: "dict", role: "kind", nullable: true, origin: XML_ORIGIN },
+  start: { name: EDGE_COLUMNS.start, dtype: "f64", role: "start", nullable: true, origin: XML_ORIGIN },
+  end: { name: EDGE_COLUMNS.end, dtype: "f64", role: "end", nullable: true, origin: XML_ORIGIN },
+  timestamp: { name: EDGE_COLUMNS.timestamp, dtype: "f64", role: "timestamp", nullable: true, origin: XML_ORIGIN },
+  spells: {
+    name: EDGE_COLUMNS.spells,
+    dtype: "list",
+    itemDtype: "f64",
+    itemComponents: 2,
+    role: "spells",
+    nullable: true,
+    origin: XML_ORIGIN
+  },
+  timestamps: {
+    name: EDGE_COLUMNS.timestamps,
+    dtype: "list",
+    itemDtype: "f64",
+    role: "timestamps",
+    nullable: true,
+    origin: XML_ORIGIN
+  },
+  open: { name: EDGE_COLUMNS.open, dtype: "u8", role: "open", nullable: true, origin: XML_ORIGIN },
+  color: {
+    name: EDGE_COLUMNS.color,
+    dtype: "f32",
+    components: 4,
+    role: "color",
+    nullable: true,
+    origin: VIZ_ORIGIN
+  },
+  thickness: { name: EDGE_COLUMNS.thickness, dtype: "f32", role: "thickness", nullable: true, origin: VIZ_ORIGIN },
+  shape: { name: EDGE_COLUMNS.shape, dtype: "dict", role: "shape", nullable: true, origin: VIZ_ORIGIN }
+};
+const OPEN_START = 1;
+const OPEN_END = 2;
+const TEMPORAL_TABLE_PREFIX = "temporal:";
+const TEMPORAL_COLUMNS = Object.freeze({
+  element: "element",
+  start: "start",
+  end: "end",
+  value: "value",
+  open: "open",
+  startText: `start${TIME_TEXT_SUFFIX}`,
+  endText: `end${TIME_TEXT_SUFFIX}`,
+  valueText: `value${TIME_TEXT_SUFFIX}`
+});
+function temporalTableName(domain, column) {
+  return `${TEMPORAL_TABLE_PREFIX}${domain}:${column}`;
+}
+function parseTemporalTableName(name) {
+  if (!name.startsWith(TEMPORAL_TABLE_PREFIX)) {
+    return null;
+  }
+  const rest = name.slice(TEMPORAL_TABLE_PREFIX.length);
+  const colon = rest.indexOf(":");
+  if (colon < 0) {
+    return null;
+  }
+  const domain = rest.slice(0, colon);
+  if (domain !== "node" && domain !== "edge") {
+    return null;
+  }
+  return { domain, column: rest.slice(colon + 1) };
+}
+function temporalTableDecls(domain, value, temporalValue) {
+  const decls = [
+    { name: TEMPORAL_COLUMNS.element, dtype: "u32", refersTo: domain, nullable: false },
+    { name: TEMPORAL_COLUMNS.start, dtype: "f64", role: "start", nullable: true },
+    { name: TEMPORAL_COLUMNS.end, dtype: "f64", role: "end", nullable: true },
+    { name: TEMPORAL_COLUMNS.value, ...value, nullable: true },
+    {
+      name: TEMPORAL_COLUMNS.startText,
+      dtype: "string",
+      role: TIME_TEXT_ROLE,
+      nullable: true,
+      extra: { for: TEMPORAL_COLUMNS.start }
+    },
+    { name: TEMPORAL_COLUMNS.endText, dtype: "string", nullable: true, extra: { for: TEMPORAL_COLUMNS.end } },
+    { name: TEMPORAL_COLUMNS.open, dtype: "u8", role: "open", nullable: true }
+  ];
+  if (temporalValue) {
+    decls.push({
+      name: TEMPORAL_COLUMNS.valueText,
+      dtype: "string",
+      nullable: true,
+      extra: { for: TEMPORAL_COLUMNS.value }
+    });
+  }
+  return decls;
+}
+const TYPES_1_2 = /* @__PURE__ */ new Set(["integer", "long", "double", "float", "boolean", "string", "anyURI"]);
+const TYPES_1_3 = /* @__PURE__ */ new Set([
+  ...TYPES_1_2,
+  "bigdecimal",
+  "biginteger",
+  "byte",
+  "char",
+  "short",
+  "date",
+  "dateTime"
+]);
+function isScalarType(type, version) {
+  return (version === "1.2" ? TYPES_1_2 : TYPES_1_3).has(type);
+}
+function isListType(type, version) {
+  return type.startsWith("list") && type.length > 4 && isScalarType(type.slice(4), "1.3");
+}
+function canonicalScalarType(dtype) {
+  switch (dtype) {
+    case "bool":
+      return "boolean";
+    case "i32":
+    case "u8":
+      return "integer";
+    case "u32":
+      return "long";
+    case "f32":
+      return "float";
+    case "f64":
+      return "double";
+    case "dict":
+    case "string":
+    case "json":
+    case "list":
+      return "string";
+    default: {
+      const name = dtype;
+      return name;
+    }
+  }
+}
+const NOT_GEXF_CODE = "E_NOT_GEXF";
+const MISSING_NODES_CODE = "E_GEXF_MISSING_NODES";
+const EDGE_TYPE_CODE = "E_GEXF_EDGE_TYPE";
+const ATTRIBUTES_CLASS_CODE = "E_GEXF_ATTRIBUTES_CLASS";
+const ATTRIBUTE_ID_CODE = "E_GEXF_ATTRIBUTE_ID";
+const HEADER_VALUE_CODE = "W_GEXF_HEADER_VALUE";
+const DUPLICATE_ATTRIBUTE_CODE = "W_GEXF_DUPLICATE_ATTRIBUTE";
+const ATTRIBUTE_TYPE_CODE = "W_GEXF_ATTRIBUTE_TYPE";
+const UNKNOWN_ATTRIBUTE_CODE = "W_GEXF_UNKNOWN_ATTRIBUTE";
+const ATTVALUE_SHAPE_CODE = "W_GEXF_ATTVALUE_SHAPE";
+const TIMED_STATIC_CODE = "W_GEXF_TIMED_VALUE_ON_STATIC";
+const WEIGHT_IGNORED_CODE = "W_GEXF_WEIGHT_IGNORED";
+const VIZ_SKIPPED_CODE = "W_GEXF_VIZ_SKIPPED";
+const VIZ_DYNAMIC_CODE = "W_GEXF_VIZ_DYNAMIC_DROPPED";
+const SPELL_OPEN_CODE = "W_GEXF_SPELL_OPEN_DROPPED";
+const VIZ_VALUE_CODE = "W_GEXF_VIZ_VALUE";
+const OPEN_BOUND_CONFLICT_CODE = "W_GEXF_OPEN_BOUND_CONFLICT";
+const EDGE_TYPES = /* @__PURE__ */ new Set(["directed", "undirected", "mutual"]);
+const ABORT_CHECK_INTERVAL = 64;
+const NODE_ATTRIBUTES = /* @__PURE__ */ new Set([
+  "id",
+  "label",
+  "pid",
+  "start",
+  "end",
+  "timestamp",
+  "startopen",
+  "endopen",
+  "timestamps",
+  "intervals"
+]);
+const EDGE_ATTRIBUTES = /* @__PURE__ */ new Set([
+  "id",
+  "source",
+  "target",
+  "type",
+  "label",
+  "weight",
+  "kind",
+  "start",
+  "end",
+  "timestamp",
+  "startopen",
+  "endopen",
+  "timestamps",
+  "intervals"
+]);
+const USED_OPTIONS = /* @__PURE__ */ new Set([
+  "ids",
+  "addMissingNodes",
+  "duplicateEdges",
+  "selfLoops",
+  "onMixedDirection",
+  "defaultDirected",
+  "weightFrom",
+  "weightDtype",
+  "long",
+  "errorLimit",
+  "signal",
+  "onProgress"
+]);
+class LazyColumn {
+  /**
+   * Create a lazily declared column.
+   * @param domain - node or edge
+   * @param decl - the declaration
+   */
+  constructor(domain, decl) {
+    this.handle = INVALID_INDEX;
+    this.domain = domain;
+    this.decl = decl;
+  }
+  /**
+   * The handle, declaring the column on the first call (renamed or without its role when the
+   * sink already holds the name or the role, reported).
+   * @param sink - the sink
+   * @param report - the report
+   * @param where - the location of the first use
+   * @returns the handle
+   */
+  get(sink, report, where) {
+    if (this.handle === INVALID_INDEX) {
+      this.handle = declareResolved(sink, this.domain, this.decl, report, where).handle;
+    }
+    return this.handle;
+  }
+  /**
+   * Write one cell, declaring the column first when needed.
+   * @param sink - the sink
+   * @param report - the report
+   * @param index - the row
+   * @param value - the value
+   * @param where - the location, for a declaration issue
+   */
+  set(sink, report, index, value, where) {
+    const handle = this.get(sink, report, where);
+    if (this.domain === "node") {
+      sink.setNodeValue(handle, index, value);
+    } else {
+      sink.setEdgeValue(handle, index, value);
+    }
+  }
+}
+class TemporalColumn {
+  /**
+   * Create the pair.
+   * @param domain - node or edge
+   * @param decl - the numeric column's declaration
+   */
+  constructor(domain, decl) {
+    this.companion = INVALID_INDEX;
+    this.domain = domain;
+    this.name = decl.name;
+    this.column = new LazyColumn(domain, decl);
+  }
+  /**
+   * Write a parsed time value and, when its text must be kept, the companion cell.
+   * @param sink - the sink
+   * @param report - the report
+   * @param index - the row
+   * @param value - the parsed value
+   * @param where - the location, for a declaration issue
+   */
+  set(sink, report, index, value, where) {
+    this.column.set(sink, report, index, value.value, where);
+    if (value.text === null) {
+      return;
+    }
+    if (this.companion === INVALID_INDEX) {
+      this.companion = declareCompanion(sink, this.domain, timeTextCompanion(this.name), report);
+    }
+    if (this.domain === "node") {
+      sink.setNodeValue(this.companion, index, value.text);
+    } else {
+      sink.setEdgeValue(this.companion, index, value.text);
+    }
+  }
+}
+class GexfReader {
+  /**
+   * Set up one import.
+   * @param sink - the sink
+   * @param report - the report
+   * @param options - the resolved common options
+   * @param viz - whether viz elements are imported
+   */
+  constructor(sink, report, options, viz) {
+    this.ctx = [];
+    this.timeFormat = null;
+    this.defaultKind = "undirected";
+    this.meta = { sourceFormat: GEXF_FORMAT };
+    this.metaText = "";
+    this.metaField = null;
+    this.nodeAttrs = /* @__PURE__ */ new Map();
+    this.edgeAttrs = /* @__PURE__ */ new Map();
+    this.declaredNodeNames = /* @__PURE__ */ new Set();
+    this.declaredEdgeNames = /* @__PURE__ */ new Set();
+    this.weightAttr = null;
+    this.parentColumn = new LazyColumn("node", NODE_DECLS.parent);
+    this.parentsColumn = new LazyColumn("node", NODE_DECLS.parents);
+    this.positionColumn = null;
+    this.sizeColumn = new LazyColumn("node", NODE_DECLS.size);
+    this.shapeUriColumn = new LazyColumn("node", NODE_DECLS.shapeUri);
+    this.thicknessColumn = new LazyColumn("edge", EDGE_DECLS.thickness);
+    this.edgeIdColumn = new LazyColumn("edge", EDGE_DECLS.id);
+    this.edgeKindColumn = new LazyColumn("edge", EDGE_DECLS.kind);
+    this.edgeIds = /* @__PURE__ */ new Set();
+    this.parentRefs = [];
+    this.parentsRefs = [];
+    this.unknownAttributes = /* @__PURE__ */ new Set();
+    this.nodeStack = [];
+    this.edge = null;
+    this.edgeFrame = {
+      index: INVALID_INDEX,
+      mirror: INVALID_INDEX,
+      where: { line: 0, element: null }
+    };
+    this.valueWhere = { line: 0, element: null };
+    this.attributeGroup = null;
+    this.pendingAttribute = null;
+    this.attributeText = null;
+    this.attributeTextValue = "";
+    this.spellPairs = null;
+    this.spellsWhere = null;
+    this.parentIds = null;
+    this.nodesSeen = false;
+    this.graphSeen = false;
+    this.elementsSinceCheck = 0;
+    this.sink = sink;
+    this.report = report;
+    this.options = options;
+    this.viz = viz;
+    this.coercer = new IdCoercer(options.ids);
+    this.resolver = new DirectionResolver(sink, report, options.onMixedDirection);
+    this.nodeColumns = {
+      label: new LazyColumn("node", NODE_DECLS.label),
+      start: new TemporalColumn("node", NODE_DECLS.start),
+      end: new TemporalColumn("node", NODE_DECLS.end),
+      timestamp: new TemporalColumn("node", NODE_DECLS.timestamp),
+      spells: new LazyColumn("node", NODE_DECLS.spells),
+      timestamps: new LazyColumn("node", NODE_DECLS.timestamps),
+      open: new LazyColumn("node", NODE_DECLS.open),
+      color: new LazyColumn("node", NODE_DECLS.color),
+      shape: new LazyColumn("node", NODE_DECLS.shape)
+    };
+    this.edgeColumns = {
+      label: new LazyColumn("edge", EDGE_DECLS.label),
+      start: new TemporalColumn("edge", EDGE_DECLS.start),
+      end: new TemporalColumn("edge", EDGE_DECLS.end),
+      timestamp: new TemporalColumn("edge", EDGE_DECLS.timestamp),
+      spells: new LazyColumn("edge", EDGE_DECLS.spells),
+      timestamps: new LazyColumn("edge", EDGE_DECLS.timestamps),
+      open: new LazyColumn("edge", EDGE_DECLS.open),
+      color: new LazyColumn("edge", EDGE_DECLS.color),
+      shape: new LazyColumn("edge", EDGE_DECLS.shape)
+    };
+  }
+  // ---------------------------------------------------------------- events
+  start(name, attrs, line) {
+    const parent = this.ctx.length === 0 ? null : this.ctx[this.ctx.length - 1];
+    const local = localName(name);
+    switch (parent) {
+      case null:
+        if (local !== "gexf") {
+          this.report.fail(NOT_GEXF_CODE, `the root element is <${name}>, not <gexf>`, { line });
+        }
+        this.readRoot(attrs);
+        this.ctx.push(
+          0
+          /* Gexf */
+        );
+        return;
+      case 0:
+        this.startInGexf(name, local, attrs, line);
+        return;
+      case 1:
+        this.startInMeta(name, local, line);
+        return;
+      case 3:
+        this.startInGraph(name, local, attrs, line);
+        return;
+      case 4:
+        this.startInAttributes(name, local, attrs, line);
+        return;
+      case 5:
+        this.startInAttribute(name, local, line);
+        return;
+      case 7:
+        this.startInNodes(name, local, attrs, line);
+        return;
+      case 8:
+        this.startInNode(name, local, attrs, line);
+        return;
+      case 9:
+        this.startInAttvalues(name, local, attrs, line);
+        return;
+      case 10:
+        this.startInParents(name, local, attrs, line);
+        return;
+      case 11:
+        this.startInSpells(name, local, attrs, line);
+        return;
+      case 12:
+        this.startInEdges(name, local, attrs, line);
+        return;
+      case 13:
+        this.startInEdge(name, local, attrs, line);
+        return;
+      case 2:
+      case 6:
+      case 14:
+        this.ctx.push(
+          14
+          /* Skip */
+        );
+        return;
+      default:
+        this.unknownElement(name, line);
+    }
+  }
+  /**
+   * An element ends.
+   * @param _name - the element name
+   * @param _line - the line (unused: issues of an element cite its start line)
+   */
+  end(_name, _line) {
+    const ctx = this.ctx.pop();
+    switch (ctx) {
+      case 1:
+        this.finishMeta();
+        return;
+      case 2:
+        this.finishMetaText();
+        return;
+      case 3:
+        this.resolveParents();
+        return;
+      case 4:
+        this.attributeGroup = null;
+        return;
+      case 5:
+        this.finishAttribute();
+        return;
+      case 6:
+        this.finishAttributeText();
+        return;
+      case 8:
+        this.nodeStack.pop();
+        return;
+      case 13:
+        this.edge = null;
+        return;
+      case 10:
+        this.finishParents();
+        return;
+      case 11:
+        this.finishSpells();
+        return;
+      case 0:
+      case 7:
+      case 12:
+      case 9:
+      case 14:
+      case void 0:
+        return;
+      default: {
+        const value = ctx;
+        throw new GraphFormatError("E_UNSUPPORTED", `unknown reader state ${String(value)}`, {});
+      }
+    }
+  }
+  /**
+   * Character data: kept inside `<creator>` / `<description>` / `<keywords>` and `<default>` /
+   * `<options>`, ignored elsewhere (reported once when it is not whitespace).
+   * @param text - the text
+   * @param line - the line
+   */
+  text(text, line) {
+    const ctx = this.ctx.length === 0 ? null : this.ctx[this.ctx.length - 1];
+    switch (ctx) {
+      case 2:
+        this.metaText += text;
+        return;
+      case 6:
+        this.attributeTextValue += text;
+        return;
+      case 14:
+        return;
+      default:
+        if (!isWhitespace(text)) {
+          this.report.warnOnce(
+            "validation-error",
+            STRAY_TEXT_CODE,
+            "text where GEXF allows only elements was ignored",
+            { line }
+          );
+        }
+    }
+  }
+  /**
+   * Apply what the root and `<meta>` gave to the sink; called once the graph's header is read.
+   */
+  finish() {
+    if (!this.graphSeen) {
+      this.report.fail(NO_GRAPH_CODE, "the document has no <graph> element");
+    }
+  }
+  // ---------------------------------------------------------------- root, meta, graph
+  /**
+   * Record the root's version.
+   * @param attrs - the `<gexf>` attributes
+   */
+  readRoot(attrs) {
+    const version = attrs.get("version");
+    if (version !== void 0 && version.length > 0) {
+      this.meta.sourceVersion = version;
+    }
+  }
+  /**
+   * A child of `<gexf>`.
+   * @param name - the element name
+   * @param local - its local name
+   * @param attrs - its attributes
+   * @param line - the line
+   */
+  startInGexf(name, local, attrs, line) {
+    switch (local) {
+      case "meta": {
+        const modified = attrs.get("lastmodifieddate");
+        if (modified !== void 0 && modified.length > 0) {
+          this.meta.modified = modified;
+        }
+        this.ctx.push(
+          1
+          /* Meta */
+        );
+        return;
+      }
+      case "graph":
+        if (this.graphSeen) {
+          this.report.fail(NO_GRAPH_CODE, "a second <graph> element; a GEXF document has one graph", {
+            line
+          });
+        }
+        this.graphSeen = true;
+        this.readHeader(attrs, line);
+        this.ctx.push(
+          3
+          /* Graph */
+        );
+        return;
+      default:
+        this.unknownElement(name, line);
+    }
+  }
+  /**
+   * A child of `<meta>`.
+   * @param name - the element name
+   * @param local - its local name
+   * @param line - the line
+   */
+  startInMeta(name, local, line) {
+    if (local === "creator" || local === "description" || local === "keywords") {
+      this.metaField = local;
+      this.metaText = "";
+      this.ctx.push(
+        2
+        /* MetaText */
+      );
+      return;
+    }
+    this.unknownElement(name, line);
+  }
+  /** Close a `<creator>` / `<description>` / `<keywords>`. */
+  finishMetaText() {
+    const text = this.metaText;
+    switch (this.metaField) {
+      case "creator":
+        this.meta.creator = text;
+        break;
+      case "description":
+        this.meta.description = text;
+        break;
+      case "keywords":
+        this.meta.keywords = text.split(",").map((k) => k.trim()).filter((k) => k.length > 0);
+        break;
+    }
+    this.metaField = null;
+    this.metaText = "";
+  }
+  /** Close `<meta>`: nothing more to do (the patch is applied at `<graph>`). */
+  finishMeta() {
+  }
+  /**
+   * Read `<graph defaultedgetype mode timeformat timerepresentation idtype start end timestamp>`
+   * into the meta and the importer's own state, apply the meta patch and set the sink's
+   * direction; an unknown value is a warning and the default applies.
+   * @param attrs - the `<graph>` attributes
+   * @param line - the line
+   */
+  readHeader(attrs, line) {
+    const where = { line };
+    const patch = this.meta;
+    const edgeType2 = attrs.get("defaultedgetype");
+    if (edgeType2 === void 0) {
+      this.defaultKind = this.options.defaultDirected ? "directed" : "undirected";
+    } else if (EDGE_TYPES.has(edgeType2)) {
+      this.defaultKind = edgeType2;
+    } else {
+      this.defaultKind = this.options.defaultDirected ? "directed" : "undirected";
+      this.warnHeader("defaultedgetype", edgeType2, where);
+    }
+    const mode = attrs.get("mode") ?? attrs.get("type");
+    if (mode !== void 0) {
+      if (GRAPH_MODES.has(mode)) {
+        patch.mode = mode;
+      } else {
+        this.warnHeader("mode", mode, where);
+      }
+    }
+    const timeFormat = attrs.get("timeformat");
+    if (timeFormat !== void 0) {
+      if (TIME_FORMATS.has(timeFormat)) {
+        this.timeFormat = timeFormat;
+        patch.timeFormat = this.timeFormat;
+      } else {
+        this.warnHeader("timeformat", timeFormat, where);
+      }
+    }
+    const representation = attrs.get("timerepresentation");
+    if (representation !== void 0) {
+      if (TIME_REPRESENTATIONS.has(representation)) {
+        patch.timeRepresentation = representation;
+      } else {
+        this.warnHeader("timerepresentation", representation, where);
+      }
+    }
+    const idType = attrs.get("idtype");
+    if (idType !== void 0) {
+      if (idType === "string") {
+        patch.idType = "string";
+      } else if (idType === "integer" || idType === "long") {
+        patch.idType = "integer";
+      } else {
+        this.warnHeader("idtype", idType, where);
+      }
+    }
+    const extra = {};
+    for (const key of ["start", "end", "timestamp"]) {
+      const value = attrs.get(key);
+      if (value !== void 0) {
+        extra[key] = value;
+      }
+    }
+    if (Object.keys(extra).length > 0) {
+      patch.extra = { gexf: extra };
+    }
+    this.sink.setMeta(patch);
+    this.resolver.setHeader(this.defaultKind !== "undirected", where);
+  }
+  /**
+   * Record a header value outside its set.
+   * @param name - the attribute name
+   * @param value - the value found
+   * @param where - the header line
+   */
+  warnHeader(name, value, where) {
+    this.report.warning(
+      "validation-error",
+      HEADER_VALUE_CODE,
+      `<graph ${name}="${value}"> is not a known value; the default applies`,
+      { ...where, element: name }
+    );
+  }
+  /**
+   * A child of `<graph>`.
+   * @param name - the element name
+   * @param local - its local name
+   * @param attrs - its attributes
+   * @param line - the line
+   */
+  startInGraph(name, local, attrs, line) {
+    switch (local) {
+      case "attributes":
+        this.beginAttributes(attrs, line);
+        return;
+      case "nodes":
+        this.nodesSeen = true;
+        this.reserve(attrs, "node", line);
+        this.ctx.push(
+          7
+          /* Nodes */
+        );
+        return;
+      case "edges":
+        if (!this.nodesSeen) {
+          this.report.error(
+            "validation-error",
+            MISSING_NODES_CODE,
+            "the graph declares <edges> but no <nodes>",
+            { line }
+          );
+        }
+        this.resolveParents();
+        this.reserve(attrs, "edge", line);
+        this.ctx.push(
+          12
+          /* Edges */
+        );
+        return;
+      default:
+        this.unknownElement(name, line);
+    }
+  }
+  /**
+   * Pass a section's `count` hint to the sink; a hint the sink cannot reserve is a warning.
+   * @param attrs - the `<nodes>` or `<edges>` attributes
+   * @param domain - which count it is
+   * @param line - the line
+   */
+  reserve(attrs, domain, line) {
+    const text = attrs.get("count");
+    if (text === void 0) {
+      return;
+    }
+    const count = Number(text);
+    if (!Number.isInteger(count) || count < 0 || count > MAX_COUNT) {
+      this.report.warning(
+        "validation-error",
+        COUNT_HINT_CODE,
+        `<${domain}s count="${text}"> is not a count the sink can reserve; ignored`,
+        { line, element: "count" }
+      );
+      return;
+    }
+    if (count === 0) {
+      return;
+    }
+    try {
+      if (domain === "node") {
+        this.sink.reserve(count, void 0);
+      } else {
+        this.sink.reserve(void 0, count);
+      }
+    } catch (err) {
+      if (!(err instanceof GraphFormatError)) {
+        throw err;
+      }
+      this.report.warning("validation-error", COUNT_HINT_CODE, `count hint ${text} refused: ${err.message}`, {
+        line,
+        element: "count"
+      });
+    }
+  }
+  // ---------------------------------------------------------------- attribute declarations
+  /**
+   * Open an `<attributes class mode>` group.
+   * @param attrs - the group's attributes
+   * @param line - the line
+   */
+  beginAttributes(attrs, line) {
+    const cls = attrs.get("class");
+    const where = { line };
+    let domain = null;
+    if (cls === "node" || cls === "edge") {
+      domain = cls;
+    } else {
+      this.report.error(
+        "validation-error",
+        ATTRIBUTES_CLASS_CODE,
+        cls === void 0 ? "<attributes> without a class" : `<attributes class="${cls}"> is neither node nor edge`,
+        where
+      );
+    }
+    const mode = attrs.get("mode");
+    if (mode !== void 0 && mode !== "static" && mode !== "dynamic") {
+      this.warnHeader("mode", mode, where);
+    }
+    this.attributeGroup = { domain, dynamic: mode === "dynamic" };
+    this.ctx.push(
+      4
+      /* Attributes */
+    );
+  }
+  /**
+   * A child of `<attributes>`.
+   * @param name - the element name
+   * @param local - its local name
+   * @param attrs - its attributes
+   * @param line - the line
+   */
+  startInAttributes(name, local, attrs, line) {
+    if (local !== "attribute") {
+      this.unknownElement(name, line);
+      return;
+    }
+    const group = this.attributeGroup;
+    if (group === null || group.domain === null) {
+      this.ctx.push(
+        14
+        /* Skip */
+      );
+      return;
+    }
+    this.pendingAttribute = {
+      domain: group.domain,
+      dynamic: group.dynamic,
+      attrs,
+      line,
+      defaultText: null,
+      optionsText: null
+    };
+    this.ctx.push(
+      5
+      /* Attribute */
+    );
+  }
+  /**
+   * A child of `<attribute>`: `<default>` or `<options>`.
+   * @param name - the element name
+   * @param local - its local name
+   * @param line - the line
+   */
+  startInAttribute(name, local, line) {
+    if (local === "default" || local === "options") {
+      this.attributeText = local;
+      this.attributeTextValue = "";
+      this.ctx.push(
+        6
+        /* AttributeText */
+      );
+      return;
+    }
+    this.unknownElement(name, line);
+  }
+  /** Close a `<default>` / `<options>`. */
+  finishAttributeText() {
+    const pending = this.pendingAttribute;
+    if (pending !== null) {
+      if (this.attributeText === "default") {
+        pending.defaultText = this.attributeTextValue;
+      } else if (this.attributeText === "options") {
+        pending.optionsText = this.attributeTextValue;
+      }
+    }
+    this.attributeText = null;
+    this.attributeTextValue = "";
+  }
+  /** Close an `<attribute>`: declare it. */
+  finishAttribute() {
+    const pending = this.pendingAttribute;
+    this.pendingAttribute = null;
+    if (pending === null) {
+      return;
+    }
+    try {
+      this.declareOne(pending);
+    } catch (err) {
+      this.report.recordError(err, { line: pending.line, element: pending.attrs.get("id") ?? null });
+    }
+  }
+  /**
+   * Declare one `<attribute id title type>` with its `<default>` and `<options>` (design
+   * sections 5.1, 5.5, 5.6). The edge attribute titled `weightFrom` is the weight and gets no
+   * column; its declaration is recorded in meta.weightOrigin.
+   * @param pending - the attribute as read
+   */
+  declareOne(pending) {
+    const { report, sink, options } = this;
+    const { domain, dynamic, attrs } = pending;
+    const id = attrs.get("id");
+    const where = { line: pending.line, element: id ?? null };
+    if (id === void 0) {
+      report.error("validation-error", ATTRIBUTE_ID_CODE, "<attribute> without an id", where);
+      return;
+    }
+    const tracked = domain === "node" ? this.nodeAttrs : this.edgeAttrs;
+    if (tracked.has(id) || domain === "edge" && this.weightAttr !== null && this.weightAttr.id === id) {
+      report.warning(
+        "validation-error",
+        DUPLICATE_ATTRIBUTE_CODE,
+        `${domain} attribute "${id}" is declared twice; the first declaration is kept`,
+        where
+      );
+      return;
+    }
+    const title = attrs.get("title") ?? null;
+    const type = attrs.get("type") ?? null;
+    if (type === null) {
+      report.warning(
+        "validation-error",
+        ATTRIBUTE_TYPE_CODE,
+        `attribute "${id}" declares no type; read as string`,
+        where
+      );
+    }
+    const name = title !== null && title.length > 0 ? title : id;
+    if (domain === "edge" && isWeightField(name, options.weightFrom)) {
+      const declared2 = declareAttribute({ format: GEXF_FORMAT, id, title, type, long: options.long });
+      for (const issue of declared2.issues) {
+        report.warning(issue.category, issue.code, issue.message, where);
+      }
+      this.weightAttr = { id, spec: declared2.spec, table: INVALID_INDEX };
+      sink.setMeta({ weightOrigin: { format: GEXF_FORMAT, id, title, type, namespace: null } });
+      return;
+    }
+    const declaredNames = domain === "node" ? this.declaredNodeNames : this.declaredEdgeNames;
+    const reserved = domain === "node" ? RESERVED_NODE_NAMES : RESERVED_EDGE_NAMES;
+    const taken = (candidate) => reserved.has(candidate) || declaredNames.has(candidate);
+    const input = {
+      format: GEXF_FORMAT,
+      id,
+      title,
+      type,
+      defaultText: pending.defaultText,
+      optionsText: pending.optionsText,
+      listSyntax: "gexf",
+      dynamic,
+      long: options.long,
+      taken
+    };
+    const declared = declareAttribute(input);
+    for (const issue of declared.issues) {
+      report.warning(issue.category, issue.code, issue.message, where);
+    }
+    const resolved = declareResolved(sink, domain, declared.decl, report, where);
+    declaredNames.add(resolved.decl.name);
+    let companionDecl = null;
+    if (declared.companion !== null) {
+      companionDecl = {
+        ...declared.companion,
+        name: `${resolved.decl.name}.text`,
+        extra: { for: resolved.decl.name }
+      };
+      declaredNames.add(companionDecl.name);
+    }
+    const valueDecl = {
+      dtype: resolved.decl.dtype,
+      itemDtype: resolved.decl.itemDtype,
+      options: resolved.decl.options,
+      origin: resolved.decl.origin
+    };
+    tracked.set(id, {
+      id,
+      name: resolved.decl.name,
+      spec: declared.spec,
+      listSyntax: declared.listSyntax,
+      handle: resolved.handle,
+      companionDecl,
+      companion: INVALID_INDEX,
+      dynamic,
+      valueDecl,
+      table: INVALID_INDEX
+    });
+  }
+  // ---------------------------------------------------------------- nodes
+  /**
+   * A child of `<nodes>`.
+   * @param name - the element name
+   * @param local - its local name
+   * @param attrs - its attributes
+   * @param line - the line
+   */
+  startInNodes(name, local, attrs, line) {
+    if (local !== "node") {
+      this.unknownElement(name, line);
+      return;
+    }
+    this.beginNode(attrs, line);
+  }
+  /**
+   * Push one `<node>`.
+   * @param attrs - its attributes
+   * @param line - the line
+   */
+  beginNode(attrs, line) {
+    const { report, sink } = this;
+    this.checkAbort();
+    const enclosing = this.nodeStack.length === 0 ? INVALID_INDEX : this.nodeStack[this.nodeStack.length - 1].index;
+    const idText = attrs.get("id");
+    const where = { line, element: idText ?? attrs.get("label") ?? null };
+    this.checkAttributeNames(attrs, NODE_ATTRIBUTES, "node", where);
+    if (idText === void 0) {
+      report.error("missing-value", MISSING_ID_CODE, "<node> without an id", where);
+      report.counts.skippedNodes++;
+      this.nodeStack.push({ index: INVALID_INDEX, where });
+      this.ctx.push(
+        8
+        /* Node */
+      );
+      return;
+    }
+    let index;
+    try {
+      const id = this.coerceId(idText, where);
+      const existing = sink.indexOf(id);
+      if (existing !== INVALID_INDEX) {
+        report.warning(
+          "validation-error",
+          DUPLICATE_NODE_CODE,
+          `node "${idText}" is declared more than once; later attributes overwrite`,
+          where
+        );
+        index = existing;
+      } else {
+        index = sink.addNode(id);
+        report.counts.nodes++;
+      }
+    } catch (err) {
+      report.recordError(err, where);
+      report.counts.skippedNodes++;
+      this.nodeStack.push({ index: INVALID_INDEX, where });
+      this.ctx.push(
+        8
+        /* Node */
+      );
+      return;
+    }
+    this.nodeStack.push({ index, where });
+    this.ctx.push(
+      8
+      /* Node */
+    );
+    try {
+      const label = attrs.get("label");
+      if (label !== void 0) {
+        this.nodeColumns.label.set(sink, report, index, label, where);
+      }
+      const pid = attrs.get("pid");
+      if (pid !== void 0) {
+        this.parentRefs.push({
+          child: index,
+          parentId: this.coerceId(pid, where),
+          parentIndex: INVALID_INDEX,
+          where
+        });
+      } else if (enclosing !== INVALID_INDEX) {
+        this.parentRefs.push({ child: index, parentId: null, parentIndex: enclosing, where });
+      }
+      this.writeLifetime(attrs, index, this.nodeColumns, where);
+    } catch (err) {
+      report.recordError(err, where);
+    }
+  }
+  /**
+   * A child of `<node>`.
+   * @param name - the element name
+   * @param local - its local name
+   * @param attrs - its attributes
+   * @param line - the line
+   */
+  startInNode(name, local, attrs, line) {
+    const frame = this.nodeStack[this.nodeStack.length - 1];
+    if (frame.index === INVALID_INDEX && local !== "nodes") {
+      this.ctx.push(
+        14
+        /* Skip */
+      );
+      return;
+    }
+    switch (local) {
+      case "attvalues":
+        this.ctx.push(
+          9
+          /* Attvalues */
+        );
+        return;
+      case "parents":
+        this.parentIds = [];
+        this.ctx.push(
+          10
+          /* Parents */
+        );
+        return;
+      case "spells":
+        this.spellPairs = [];
+        this.spellsWhere = frame.where;
+        this.ctx.push(
+          11
+          /* Spells */
+        );
+        return;
+      case "nodes":
+        this.reserve(attrs, "node", line);
+        this.ctx.push(
+          7
+          /* Nodes */
+        );
+        return;
+      case "color":
+      case "position":
+      case "size":
+      case "shape":
+        this.writeViz(name, local, attrs, "node", frame.index, frame.where);
+        this.ctx.push(
+          14
+          /* Skip */
+        );
+        return;
+      default:
+        this.unknownElement(name, line);
+    }
+  }
+  /**
+   * A `<parent for>` inside `<parents>`.
+   * @param name - the element name
+   * @param local - its local name
+   * @param attrs - its attributes
+   * @param line - the line
+   */
+  startInParents(name, local, attrs, line) {
+    if (local !== "parent") {
+      this.unknownElement(name, line);
+      return;
+    }
+    this.ctx.push(
+      14
+      /* Skip */
+    );
+    const frame = this.nodeStack[this.nodeStack.length - 1];
+    const text = attrs.get("for");
+    if (text === void 0) {
+      this.report.warning("missing-value", ATTVALUE_SHAPE_CODE, "<parent> without a for attribute", frame.where);
+      return;
+    }
+    try {
+      this.parentIds?.push(this.coerceId(text, frame.where));
+    } catch (err) {
+      this.report.recordError(err, frame.where);
+    }
+  }
+  /** Close `<parents>`: queue the list for resolution. */
+  finishParents() {
+    const frame = this.nodeStack[this.nodeStack.length - 1];
+    if (this.parentIds !== null && frame.index !== INVALID_INDEX) {
+      this.parentsRefs.push({ child: frame.index, ids: this.parentIds, where: frame.where });
+    }
+    this.parentIds = null;
+  }
+  /**
+   * Resolve every `pid`, nested and `<parents>` reference read so far now that every node is
+   * declared (design section 8.4); an unknown parent is a missing-value error.
+   */
+  resolveParents() {
+    const { sink, report } = this;
+    const refs = this.parentRefs;
+    const lists = this.parentsRefs;
+    this.parentRefs = [];
+    this.parentsRefs = [];
+    for (const ref of refs) {
+      let parent = ref.parentIndex;
+      if (ref.parentId !== null) {
+        parent = sink.indexOf(ref.parentId);
+        if (parent === INVALID_INDEX) {
+          report.error(
+            "missing-value",
+            UNKNOWN_PARENT_CODE,
+            `pid "${String(ref.parentId)}" names a node the document does not declare`,
+            ref.where
+          );
+          continue;
+        }
+      }
+      try {
+        this.parentColumn.set(sink, report, ref.child, parent, ref.where);
+      } catch (err) {
+        report.recordError(err, ref.where);
+      }
+    }
+    for (const ref of lists) {
+      const indices = [];
+      for (const id of ref.ids) {
+        const parent = sink.indexOf(id);
+        if (parent === INVALID_INDEX) {
+          report.error(
+            "missing-value",
+            UNKNOWN_PARENT_CODE,
+            `<parent for="${String(id)}"> names a node the document does not declare`,
+            ref.where
+          );
+          continue;
+        }
+        indices.push(parent);
+      }
+      try {
+        this.parentsColumn.set(sink, report, ref.child, indices, ref.where);
+      } catch (err) {
+        report.recordError(err, ref.where);
+      }
+    }
+  }
+  // ---------------------------------------------------------------- edges
+  /**
+   * A child of `<edges>`.
+   * @param name - the element name
+   * @param local - its local name
+   * @param attrs - its attributes
+   * @param line - the line
+   */
+  startInEdges(name, local, attrs, line) {
+    if (local !== "edge") {
+      this.unknownElement(name, line);
+      return;
+    }
+    this.beginEdge(attrs, line);
+  }
+  /**
+   * Push one `<edge>`.
+   * @param attrs - its attributes
+   * @param line - the line
+   */
+  beginEdge(attrs, line) {
+    const { report, sink, options } = this;
+    this.checkAbort();
+    this.ctx.push(
+      13
+      /* Edge */
+    );
+    this.edge = null;
+    const sourceText = attrs.get("source");
+    const targetText = attrs.get("target");
+    const idText = attrs.get("id");
+    const { where } = this.edgeFrame;
+    where.line = line;
+    where.element = idText ?? edgeElement(sourceText, targetText);
+    this.checkAttributeNames(attrs, EDGE_ATTRIBUTES, "edge", where);
+    if (sourceText === void 0 || targetText === void 0) {
+      report.error(
+        "missing-value",
+        MISSING_ENDPOINT_CODE,
+        `<edge> without a ${sourceText === void 0 ? "source" : "target"}`,
+        where
+      );
+      report.counts.skippedEdges++;
+      return;
+    }
+    let kind = this.defaultKind;
+    const type = attrs.get("type");
+    if (type !== void 0) {
+      if (!EDGE_TYPES.has(type)) {
+        report.error(
+          "validation-error",
+          EDGE_TYPE_CODE,
+          `edge type "${type}" is not directed, undirected or mutual`,
+          where
+        );
+        report.counts.skippedEdges++;
+        return;
+      }
+      kind = type;
+    }
+    if (idText !== void 0) {
+      if (this.edgeIds.has(idText)) {
+        report.error(
+          "validation-error",
+          DUPLICATE_EDGE_ID_CODE,
+          `edge id "${idText}" is declared more than once; the edge is skipped`,
+          where
+        );
+        report.counts.skippedEdges++;
+        return;
+      }
+      this.edgeIds.add(idText);
+    }
+    let index;
+    try {
+      const source = this.coerceId(sourceText, where);
+      const target = this.coerceId(targetText, where);
+      if (!options.addMissingNodes) {
+        if (sink.indexOf(source) === INVALID_INDEX) {
+          throw new GraphFormatError("E_UNKNOWN_NODE", `edge references undeclared node "${sourceText}"`, {
+            id: source
+          });
+        }
+        if (sink.indexOf(target) === INVALID_INDEX) {
+          throw new GraphFormatError("E_UNKNOWN_NODE", `edge references undeclared node "${targetText}"`, {
+            id: target
+          });
+        }
+      }
+      const weight = this.xmlWeight(attrs, where);
+      const before = sink.edgeCount;
+      index = this.resolver.addEdge(source, target, kind, weight, where);
+      report.counts.edges += sink.edgeCount - before;
+    } catch (err) {
+      report.recordError(err, where);
+      report.counts.skippedEdges++;
+      return;
+    }
+    const frame = this.edgeFrame;
+    frame.index = index;
+    frame.mirror = this.resolver.lastMirror;
+    this.edge = frame;
+    try {
+      if (idText !== void 0) {
+        this.edgeIdColumn.set(sink, report, index, idText, where);
+      }
+      const label = attrs.get("label");
+      if (label !== void 0) {
+        this.edgeColumns.label.set(sink, report, index, label, where);
+      }
+      const edgeKind = attrs.get("kind");
+      if (edgeKind !== void 0) {
+        this.edgeKindColumn.set(sink, report, index, edgeKind, where);
+      }
+      this.writeLifetime(attrs, index, this.edgeColumns, where);
+    } catch (err) {
+      report.recordError(err, where);
+    }
+  }
+  /**
+   * The weight argument of one edge from its `weight` XML attribute; undefined when absent (the
+   * sink records a defaulted weight, design section 3.7).
+   * @param attrs - the edge's attributes
+   * @param where - the edge's location
+   * @returns the weight, or undefined
+   */
+  xmlWeight(attrs, where) {
+    const text = attrs.get("weight");
+    if (text === void 0) {
+      return void 0;
+    }
+    if (this.options.weightFrom === null) {
+      this.report.warnOnce(
+        "coercion",
+        WEIGHT_IGNORED_CODE,
+        "the weight attribute is ignored because weightFrom is null; edges are unweighted",
+        where
+      );
+      return void 0;
+    }
+    return parseWeightText(text);
+  }
+  /**
+   * A child of `<edge>`.
+   * @param name - the element name
+   * @param local - its local name
+   * @param attrs - its attributes
+   * @param line - the line
+   */
+  startInEdge(name, local, attrs, line) {
+    const { edge } = this;
+    if (edge === null) {
+      this.ctx.push(
+        14
+        /* Skip */
+      );
+      return;
+    }
+    switch (local) {
+      case "attvalues":
+        this.ctx.push(
+          9
+          /* Attvalues */
+        );
+        return;
+      case "spells":
+        this.spellPairs = [];
+        this.spellsWhere = edge.where;
+        this.ctx.push(
+          11
+          /* Spells */
+        );
+        return;
+      case "color":
+      case "thickness":
+      case "shape":
+        this.writeViz(name, local, attrs, "edge", edge.index, edge.where);
+        this.ctx.push(
+          14
+          /* Skip */
+        );
+        return;
+      default:
+        this.unknownElement(name, line);
+    }
+  }
+  // ---------------------------------------------------------------- attribute values
+  /**
+   * An `<attvalue>` of the open node or edge; a value that does not parse is recorded and skipped
+   * without losing the element or its other values.
+   * @param name - the element name
+   * @param local - its local name
+   * @param attrs - its attributes
+   * @param line - the line
+   */
+  startInAttvalues(name, local, attrs, line) {
+    if (local !== "attvalue") {
+      this.unknownElement(name, line);
+      return;
+    }
+    this.ctx.push(
+      14
+      /* Skip */
+    );
+    const { report, edge } = this;
+    const domain = edge === null ? "node" : "edge";
+    let index;
+    let element;
+    if (edge !== null) {
+      ({ index } = edge);
+      element = edge.where.element ?? null;
+    } else {
+      const frame = this.nodeStack[this.nodeStack.length - 1];
+      ({ index } = frame);
+      element = frame.where.element ?? null;
+    }
+    if (index === INVALID_INDEX) {
+      return;
+    }
+    const forId = attrs.get("for");
+    const { valueWhere } = this;
+    valueWhere.line = line;
+    valueWhere.element = element;
+    if (forId === void 0) {
+      report.warning("missing-value", ATTVALUE_SHAPE_CODE, "<attvalue> without a for attribute", valueWhere);
+      return;
+    }
+    const value = attrs.get("value");
+    if (value === void 0) {
+      report.warning(
+        "missing-value",
+        ATTVALUE_SHAPE_CODE,
+        `<attvalue for="${forId}"> without a value attribute`,
+        valueWhere
+      );
+      return;
+    }
+    try {
+      if (domain === "edge" && this.weightAttr !== null && this.weightAttr.id === forId) {
+        if (isTimed(attrs)) {
+          this.writeTimedWeight(attrs, value, index, valueWhere);
+        } else {
+          this.applyStaticWeight(value, valueWhere);
+        }
+        return;
+      }
+      const tracked = domain === "node" ? this.nodeAttrs : this.edgeAttrs;
+      const attribute = tracked.get(forId);
+      if (attribute === void 0) {
+        const key = `${domain}:${forId}`;
+        if (!this.unknownAttributes.has(key)) {
+          this.unknownAttributes.add(key);
+          report.warning(
+            "missing-value",
+            UNKNOWN_ATTRIBUTE_CODE,
+            `<attvalue for="${forId}"> names an undeclared ${domain} attribute; its values are dropped`,
+            { ...valueWhere, element: forId }
+          );
+        }
+        return;
+      }
+      if (isTimed(attrs)) {
+        this.writeTimedValue(attribute, domain, attrs, value, index, valueWhere);
+      } else {
+        this.writeStaticValue(attribute, domain, value, index, valueWhere);
+      }
+    } catch (err) {
+      report.recordError(err, { ...valueWhere, element: `${element ?? "?"}[${forId}]` });
+    }
+  }
+  /**
+   * A static value of the attribute titled `weightFrom` overrides the XML weight of the open
+   * edge (and of its mirror half, design section 3.6).
+   * @param text - the value text
+   * @param where - the value's location
+   */
+  applyStaticWeight(text, where) {
+    const { edge, sink } = this;
+    if (edge === null) {
+      return;
+    }
+    const weight = parseWeightText(text);
+    if (weight === void 0) {
+      throw new GraphFormatError("E_INVALID_WEIGHT", "an edge weight cannot be blank", {
+        value: text,
+        line: where.line ?? null
+      });
+    }
+    sink.setEdgeWeight(edge.index, weight);
+    if (edge.mirror !== INVALID_INDEX) {
+      sink.setEdgeWeight(edge.mirror, weight);
+    }
+  }
+  /**
+   * Parse a value by its declaration and write the cell (and the temporal companion, declared
+   * on the first value whose text is not canonical, design section 5.1).
+   * @param attribute - the declaration
+   * @param domain - node or edge
+   * @param text - the value text
+   * @param index - the element's index
+   * @param where - the value's location
+   */
+  writeStaticValue(attribute, domain, text, index, where) {
+    const { spec } = attribute;
+    if (spec.temporal !== null && !spec.list) {
+      const parsed = parseDeclaredTemporal(text, spec);
+      this.setCell(domain, attribute.handle, index, parsed.value);
+      if (parsed.text !== null && attribute.companionDecl !== null) {
+        if (attribute.companion === INVALID_INDEX) {
+          attribute.companion = declareCompanion(this.sink, domain, attribute.companionDecl, this.report);
+        }
+        this.setCell(domain, attribute.companion, index, parsed.text);
+      }
+      return;
+    }
+    const value = parseDeclaredValue(text, spec, attribute.listSyntax);
+    if (losesPrecision(spec, text)) {
+      this.report.warning(
+        "precision",
+        PRECISION_CODE,
+        `long value ${text.trim()} of "${attribute.name}" exceeds 2^53 and was rounded`,
+        where
+      );
+    }
+    this.setCell(domain, attribute.handle, index, value);
+  }
+  /**
+   * Append a timed value to the attribute's temporal table (design section 5.10), creating the
+   * table on first use.
+   * @param attribute - the declaration
+   * @param domain - node or edge
+   * @param attrs - the `<attvalue>` attributes carrying the bounds
+   * @param text - the value text
+   * @param index - the element's index
+   * @param where - the value's location
+   */
+  writeTimedValue(attribute, domain, attrs, text, index, where) {
+    const { sink, report } = this;
+    if (!attribute.dynamic) {
+      report.warnOnce(
+        "validation-error",
+        TIMED_STATIC_CODE,
+        `attribute "${attribute.name}" is declared static but has timed values; they are stored as dynamic`,
+        where
+      );
+    }
+    const { spec } = attribute;
+    const temporalValue = spec.temporal !== null && !spec.list;
+    if (attribute.table === INVALID_INDEX) {
+      attribute.table = sink.addExtensionTable(
+        temporalTableName(domain, attribute.name),
+        temporalTableDecls(domain, attribute.valueDecl, temporalValue)
+      );
+    }
+    let value;
+    let valueText = null;
+    if (temporalValue) {
+      const parsed = parseDeclaredTemporal(text, spec);
+      ({ value } = parsed);
+      valueText = parsed.text;
+    } else {
+      value = parseDeclaredValue(text, spec, attribute.listSyntax);
+      if (losesPrecision(spec, text)) {
+        report.warning(
+          "precision",
+          PRECISION_CODE,
+          `long value ${text.trim()} of "${attribute.name}" exceeds 2^53 and was rounded`,
+          where
+        );
+      }
+    }
+    const row = this.temporalRow(attrs, index, value, where);
+    if (temporalValue) {
+      row.push(valueText ?? void 0);
+    }
+    sink.addExtensionRow(attribute.table, row);
+  }
+  /**
+   * Append a timed weight to the `temporal:edge:weight` table (design section 5.10).
+   * @param attrs - the `<attvalue>` attributes carrying the bounds
+   * @param text - the value text
+   * @param index - the edge index
+   * @param where - the value's location
+   */
+  writeTimedWeight(attrs, text, index, where) {
+    const { weightAttr } = this;
+    if (weightAttr === null) {
+      return;
+    }
+    const { sink } = this;
+    if (weightAttr.table === INVALID_INDEX) {
+      weightAttr.table = sink.addExtensionTable(
+        temporalTableName("edge", this.options.weightFrom ?? "weight"),
+        temporalTableDecls(
+          "edge",
+          {
+            dtype: "f64",
+            origin: { format: GEXF_FORMAT, id: weightAttr.id, type: weightAttr.spec.declared }
+          },
+          false
+        )
+      );
+    }
+    const value = parseWeightText(text);
+    if (value === void 0) {
+      throw new GraphFormatError("E_INVALID_WEIGHT", "a timed edge weight cannot be blank", {
+        value: text,
+        line: where.line ?? null
+      });
+    }
+    sink.addExtensionRow(weightAttr.table, this.temporalRow(attrs, index, value, where));
+  }
+  /**
+   * The row of a temporal table for one timed value: element, bounds, value, bound texts, open bits.
+   * @param attrs - the attributes carrying `start` / `end` / `timestamp` / `startopen` / `endopen`
+   * @param index - the element's index
+   * @param value - the parsed value
+   * @param where - the value's location
+   * @returns the row, without the optional value text
+   */
+  temporalRow(attrs, index, value, where) {
+    const bounds = this.readBounds(attrs, where);
+    return [
+      index,
+      bounds.start.value,
+      bounds.end.value,
+      value,
+      bounds.start.text ?? void 0,
+      bounds.end.text ?? void 0,
+      bounds.open === 0 ? void 0 : bounds.open
+    ];
+  }
+  /**
+   * The interval of an element or timed value: `timestamp`, or `start` / `startopen` and `end` /
+   * `endopen` (GEXF 1.2: the open form carries the bound's time and marks the bound open, design
+   * section 5.1); missing bounds are unbounded.
+   * @param attrs - the attributes
+   * @param where - the location, for the conflict warning
+   * @returns the bounds and the open bits
+   */
+  readBounds(attrs, where) {
+    let start = { value: -Infinity, text: null };
+    let end = { value: Infinity, text: null };
+    let open = 0;
+    const timestamp = attrs.get("timestamp");
+    if (timestamp !== void 0) {
+      start = parseTimeText(timestamp, this.timeFormat);
+      end = start;
+    }
+    const startText = attrs.get("start");
+    const startOpen = attrs.get("startopen");
+    if (startText !== void 0) {
+      start = parseTimeText(startText, this.timeFormat);
+      if (startOpen !== void 0) {
+        this.warnOpenConflict("start", where);
+      }
+    } else if (startOpen !== void 0) {
+      start = parseTimeText(startOpen, this.timeFormat);
+      open |= OPEN_START;
+    }
+    const endText = attrs.get("end");
+    const endOpen = attrs.get("endopen");
+    if (endText !== void 0) {
+      end = parseTimeText(endText, this.timeFormat);
+      if (endOpen !== void 0) {
+        this.warnOpenConflict("end", where);
+      }
+    } else if (endOpen !== void 0) {
+      end = parseTimeText(endOpen, this.timeFormat);
+      open |= OPEN_END;
+    }
+    return { start, end, open };
+  }
+  /**
+   * Record a `start` next to a `startopen` (or `end` next to `endopen`), which the 1.2 primer forbids.
+   * @param bound - which bound
+   * @param where - the location
+   */
+  warnOpenConflict(bound, where) {
+    this.report.warnOnce(
+      "validation-error",
+      OPEN_BOUND_CONFLICT_CODE,
+      `both ${bound} and ${bound}open are given; the closed bound is kept`,
+      where
+    );
+  }
+  // ---------------------------------------------------------------- lifetimes
+  /**
+   * Write an element's lifetime: `start` / `end` / `timestamp` (with text companions), the 1.2
+   * `startopen` / `endopen` bounds and bits, and the 1.3 `timestamps` / `intervals` attributes.
+   * @param attrs - the node or edge attributes
+   * @param index - its index
+   * @param columns - the domain's columns
+   * @param where - the element's location
+   */
+  writeLifetime(attrs, index, columns, where) {
+    const { sink, report } = this;
+    if (attrs.has("start") || attrs.has("end") || attrs.has("timestamp") || attrs.has("startopen") || attrs.has("endopen")) {
+      const bounds = this.readBounds(attrs, where);
+      const timestamp = attrs.get("timestamp");
+      if (timestamp !== void 0) {
+        columns.timestamp.set(sink, report, index, bounds.start, where);
+      }
+      if (attrs.has("start") || attrs.has("startopen")) {
+        columns.start.set(sink, report, index, bounds.start, where);
+      }
+      if (attrs.has("end") || attrs.has("endopen")) {
+        columns.end.set(sink, report, index, bounds.end, where);
+      }
+      if (bounds.open !== 0) {
+        columns.open.set(sink, report, index, bounds.open, where);
+      }
+    }
+    const timestamps = attrs.get("timestamps");
+    if (timestamps !== void 0) {
+      const items = splitListText(stripAngles(timestamps), "brackets");
+      columns.timestamps.set(
+        sink,
+        report,
+        index,
+        items.map((item) => parseTimeText(item, this.timeFormat).value),
+        where
+      );
+    }
+    const intervals = attrs.get("intervals");
+    if (intervals !== void 0) {
+      columns.spells.set(sink, report, index, this.parseIntervals(intervals, where), where);
+    }
+  }
+  /**
+   * Parse a 1.3 `intervals="<[s, e]; [s, e]>"` attribute into spell pairs.
+   * @param text - the attribute text
+   * @param where - the element's location, for the error
+   * @returns the pairs
+   */
+  parseIntervals(text, where) {
+    const pairs = [];
+    for (const part of stripAngles(text).split(";")) {
+      if (part.trim().length === 0) {
+        continue;
+      }
+      const items = splitListText(part, "brackets");
+      if (items.length !== 2) {
+        throw new GraphFormatError("E_COLUMN_TYPE", `interval "${part.trim()}" is not a [start, end] pair`, {
+          value: part,
+          line: where.line ?? null
+        });
+      }
+      pairs.push([
+        parseTimeText(items[0], this.timeFormat).value,
+        parseTimeText(items[1], this.timeFormat).value
+      ]);
+    }
+    return pairs;
+  }
+  /**
+   * A `<spell>` inside `<spells>`.
+   * @param name - the element name
+   * @param local - its local name
+   * @param attrs - its attributes
+   * @param line - the line
+   */
+  startInSpells(name, local, attrs, line) {
+    if (local !== "spell") {
+      this.unknownElement(name, line);
+      return;
+    }
+    this.ctx.push(
+      14
+      /* Skip */
+    );
+    const where = this.spellsWhere ?? { line };
+    try {
+      const bounds = this.readBounds(attrs, where);
+      if (bounds.open !== 0) {
+        this.report.warnOnce(
+          "unsupported",
+          SPELL_OPEN_CODE,
+          "startopen / endopen on a <spell> cannot be kept; the spell is stored closed",
+          where
+        );
+      }
+      this.spellPairs?.push([bounds.start.value, bounds.end.value]);
+    } catch (err) {
+      this.report.recordError(err, where);
+    }
+  }
+  /** Close `<spells>`: write the pairs into the open element's spells column. */
+  finishSpells() {
+    const pairs = this.spellPairs;
+    const where = this.spellsWhere ?? void 0;
+    this.spellPairs = null;
+    this.spellsWhere = null;
+    if (pairs === null) {
+      return;
+    }
+    try {
+      if (this.edge !== null) {
+        this.edgeColumns.spells.set(this.sink, this.report, this.edge.index, pairs, where);
+      } else {
+        const frame = this.nodeStack[this.nodeStack.length - 1];
+        if (frame.index !== INVALID_INDEX) {
+          this.nodeColumns.spells.set(this.sink, this.report, frame.index, pairs, where);
+        }
+      }
+    } catch (err) {
+      this.report.recordError(err, where);
+    }
+  }
+  // ---------------------------------------------------------------- viz
+  /**
+   * Write one viz element into its role column; a value that does not parse is a recorded
+   * warning and the element is skipped.
+   * @param name - the element name as written
+   * @param local - its local name
+   * @param attrs - its attributes
+   * @param domain - node or edge
+   * @param index - the element's index
+   * @param where - the element's location
+   */
+  writeViz(name, local, attrs, domain, index, where) {
+    const { sink, report } = this;
+    if (!this.viz) {
+      report.warnOnce("unsupported", VIZ_SKIPPED_CODE, "viz elements are skipped (option viz: false)", where);
+      return;
+    }
+    if (isTimed(attrs)) {
+      report.warnOnce(
+        "unsupported",
+        VIZ_DYNAMIC_CODE,
+        "dynamic viz elements are not supported; the bounds are dropped and the last value kept",
+        where
+      );
+    }
+    const columns = domain === "node" ? this.nodeColumns : this.edgeColumns;
+    try {
+      switch (local) {
+        case "color":
+          columns.color.set(sink, report, index, parseColor(attrs), where);
+          break;
+        case "position": {
+          const x = vizNumber(attrs, "x");
+          const y = vizNumber(attrs, "y");
+          const z = attrs.has("z") ? vizNumber(attrs, "z") : 0;
+          this.positionColumn ??= new LazyColumn("node", {
+            ...NODE_DECLS.position,
+            extra: { ...NODE_DECLS.position.extra, sourceDims: attrs.has("z") ? 3 : 2 }
+          });
+          this.positionColumn.set(sink, report, index, [x, y, z], where);
+          break;
+        }
+        case "size":
+          this.sizeColumn.set(sink, report, index, vizNumber(attrs, "value"), where);
+          break;
+        case "thickness":
+          this.thicknessColumn.set(sink, report, index, vizNumber(attrs, "value"), where);
+          break;
+        case "shape": {
+          const value = attrs.get("value");
+          if (value === void 0) {
+            throw new GraphFormatError("E_COLUMN_TYPE", "<viz:shape> without a value", { element: name });
+          }
+          columns.shape.set(sink, report, index, value, where);
+          const uri = attrs.get("uri");
+          if (domain === "node" && uri !== void 0) {
+            this.shapeUriColumn.set(sink, report, index, uri, where);
+          }
+          break;
+        }
+        default:
+          break;
+      }
+    } catch (err) {
+      if (!(err instanceof GraphFormatError) || err.code !== "E_COLUMN_TYPE") {
+        throw err;
+      }
+      report.warning("validation-error", VIZ_VALUE_CODE, `<${name}> skipped: ${err.message}`, where);
+    }
+  }
+  // ---------------------------------------------------------------- helpers
+  /**
+   * Report an element the schema does not define at this place and skip its subtree.
+   * @param name - the element name
+   * @param line - the line
+   */
+  unknownElement(name, line) {
+    this.report.warnOnce("unsupported", UNKNOWN_ELEMENT_CODE, `element <${name}> is not GEXF and was skipped`, {
+      line,
+      element: name
+    });
+    this.ctx.push(
+      14
+      /* Skip */
+    );
+  }
+  /**
+   * Report XML attributes the importer does not read (once per attribute name and domain).
+   * @param attrs - the element's attributes
+   * @param known - the attribute names read
+   * @param domain - node or edge
+   * @param where - the element's location
+   */
+  checkAttributeNames(attrs, known, domain, where) {
+    for (const key of attrs.keys()) {
+      if (!known.has(key)) {
+        const seen = `${domain}@${key}`;
+        if (!this.unknownAttributes.has(seen)) {
+          this.unknownAttributes.add(seen);
+          this.report.warning(
+            "unsupported",
+            UNKNOWN_ELEMENT_CODE,
+            `attribute ${key} of <${domain}> is not GEXF and was ignored`,
+            { ...where, element: key }
+          );
+        }
+      }
+    }
+  }
+  /**
+   * Write one cell of a domain.
+   * @param domain - node or edge
+   * @param handle - the column
+   * @param index - the row
+   * @param value - the value
+   */
+  setCell(domain, handle, index, value) {
+    if (domain === "node") {
+      this.sink.setNodeValue(handle, index, value);
+    } else {
+      this.sink.setEdgeValue(handle, index, value);
+    }
+  }
+  /**
+   * Coerce an id text, recording a merge under ids "number".
+   * @param text - the id text
+   * @param where - the location, for the merge warning
+   * @returns the id
+   */
+  coerceId(text, where) {
+    const id = this.coercer.text(text);
+    const merge = this.coercer.lastMerge;
+    if (merge !== null) {
+      this.report.warning(
+        "coercion",
+        ID_MERGED_CODE,
+        `id text "${merge.text}" merged with "${merge.previousText}" as ${merge.id} under ids "number"`,
+        where
+      );
+    }
+    return id;
+  }
+  /** Check the cancellation signal every ABORT_CHECK_INTERVAL elements. */
+  checkAbort() {
+    if (++this.elementsSinceCheck >= ABORT_CHECK_INTERVAL) {
+      this.elementsSinceCheck = 0;
+      throwIfAborted(this.options.signal);
+    }
+  }
+}
+function edgeElement(source, target) {
+  return `${source ?? "?"}->${target ?? "?"}`;
+}
+function isTimed(attrs) {
+  return attrs.has("start") || attrs.has("end") || attrs.has("timestamp") || attrs.has("startopen") || attrs.has("endopen");
+}
+function stripAngles(text) {
+  let inner = text.trim();
+  if (inner.startsWith("<")) {
+    inner = inner.slice(1);
+  }
+  if (inner.endsWith(">")) {
+    inner = inner.slice(0, -1);
+  }
+  return inner;
+}
+function vizNumber(attrs, name) {
+  const text = attrs.get(name);
+  if (text === void 0) {
+    throw new GraphFormatError("E_COLUMN_TYPE", `viz element without a ${name} attribute`, { attribute: name });
+  }
+  const value = parseDecimalText(text);
+  if (Number.isNaN(value)) {
+    throw new GraphFormatError("E_COLUMN_TYPE", `viz ${name}="${text}" is not a number`, { attribute: name });
+  }
+  return value;
+}
+function parseColor(attrs) {
+  let r;
+  let g;
+  let b;
+  const hex = attrs.get("hex");
+  if (hex !== void 0 && !attrs.has("r")) {
+    const digits = hex.startsWith("#") ? hex.slice(1) : hex;
+    if (!/^[0-9a-fA-F]{6}$/.test(digits)) {
+      throw new GraphFormatError("E_COLUMN_TYPE", `viz hex="${hex}" is not a #RRGGBB colour`, {
+        attribute: "hex"
+      });
+    }
+    r = Number.parseInt(digits.slice(0, 2), 16);
+    g = Number.parseInt(digits.slice(2, 4), 16);
+    b = Number.parseInt(digits.slice(4, 6), 16);
+  } else {
+    r = vizNumber(attrs, "r");
+    g = vizNumber(attrs, "g");
+    b = vizNumber(attrs, "b");
+  }
+  const a = attrs.has("a") ? vizNumber(attrs, "a") : 1;
+  return [r / 255, g / 255, b / 255, a];
+}
+function sniffGexf(head) {
+  const text = new TextDecoder("utf-8", { fatal: false }).decode(head);
+  if (/<(\w+:)?gexf[\s>]/.test(text)) {
+    return 1;
+  }
+  return text.includes("gexf.net") ? 0.8 : 0;
+}
+function resolveGexfOptions(options) {
+  const viz = options?.viz;
+  if (viz === void 0) {
+    return true;
+  }
+  if (typeof viz !== "boolean") {
+    throw new GraphFormatError("E_UNSUPPORTED", `option viz: ${typeof viz} is not a boolean`, {
+      option: "viz",
+      found: viz
+    });
+  }
+  return viz;
+}
+const gexfImporter = Object.freeze({
+  format: GEXF_FORMAT,
+  extensions: Object.freeze([".gexf"]),
+  mimeTypes: Object.freeze(["application/gexf+xml", "application/xml", "text/xml"]),
+  sniff: sniffGexf,
+  /**
+   * Read a GEXF document into the sink in one streaming pass.
+   * @param input - the document as text, bytes, a stream or chunks
+   * @param sink - the sink
+   * @param options - format-specific and common options
+   * @returns the report
+   */
+  async import(input, sink, options) {
+    const resolved = resolveImportOptions(options, {
+      ids: "canonical",
+      defaultDirected: false,
+      weightFrom: "weight",
+      addMissingNodes: false
+    });
+    const viz = resolveGexfOptions(options);
+    const report = new ImportReportBuilder(GEXF_FORMAT, resolved.errorLimit);
+    reportSinkOptions(sink, options, report, true);
+    reportUnusedOptions(options, report, USED_OPTIONS);
+    const reader = new GexfReader(sink, report, resolved, viz);
+    try {
+      await tokenizeXml(textChunks(input, report, resolved), reader);
+    } catch (err) {
+      if (err instanceof XmlSyntaxError) {
+        report.fail(XML_SYNTAX_CODE, err.message, { line: err.line });
+      }
+      throw err;
+    }
+    reader.finish();
+    throwIfAborted(resolved.signal);
+    return report.finish();
+  }
+});
+const GEXF_LOSS = Object.freeze({
+  /** GEXF 1.2 has no parallel-edge `kind`; the kind column is dropped. */
+  KIND_DROPPED: "W_GEXF_KIND_DROPPED",
+  /** GEXF 1.2 has no timestamps; a timestamp becomes a closed interval [t, t]. */
+  TIMESTAMP_AS_INTERVAL: "W_TIMESTAMP_AS_INTERVAL",
+  /** GEXF 1.2 liststring items are separated by `|`; an item containing one cannot be split back. */
+  LIST_SEPARATOR: "W_LIST_SEPARATOR",
+  /** A role column of a shape GEXF cannot map (a string `start`, a 2-component color); written as a plain attribute. */
+  ROLE_SHAPE: "W_ROLE_SHAPE",
+  /** A temporal extension table without the element / start / end / value columns of design section 5.10. */
+  TEMPORAL_TABLE_SHAPE: "W_TEMPORAL_TABLE_SHAPE",
+  /** An attribute whose title the importer would rename on re-import (a reserved name). */
+  ATTRIBUTE_RENAMED: "W_ATTRIBUTE_RENAMED",
+  /** A cell, default or option the declared type cannot express (skipped). */
+  VALUE_UNWRITABLE: "W_VALUE_UNWRITABLE",
+  /** A declared type the target version lacks (1.2: date, dateTime, typed lists...); the canonical type is written. */
+  DECLARED_TYPE: "W_DECLARED_TYPE",
+  /** A node id whose text reads back as the other type under the canonical rule (design section 4.1): a non-integer number, a string of integer text. */
+  ID_TEXT_TYPE: LOSS.ID_TEXT_TYPE,
+  /** A viz role column (position, color, size, thickness) that is not f32; the importer reads viz values as f32. */
+  VIZ_DTYPE: "W_GEXF_VIZ_DTYPE",
+  /** A plain `weight` edge column reads back as THE weight (the importer's weightFrom default). */
+  WEIGHT_KEY_CLASH: LOSS.WEIGHT_KEY_CLASH,
+  /** A dict column without declared options gains one from its dictionary on re-import. */
+  OPTIONS_GAINED: LOSS.OPTIONS_GAINED,
+  /** A string cell holding a character XML 1.0 forbids; export() throws E_COLUMN_TYPE. */
+  XML_ILLEGAL_CHAR: LOSS.XML_ILLEGAL_CHAR
+});
+const DTYPES_KEPT = ["f32", "f64", "i32", "bool", "dict", "string"];
+const CAPABILITIES_1_3 = capabilities({
+  mixedDirection: true,
+  multiEdges: true,
+  selfLoops: true,
+  edgeIds: "optional",
+  idCharset: "any",
+  dtypes: DTYPES_KEPT,
+  lists: true,
+  defaults: true,
+  options: true,
+  hierarchy: true,
+  temporal: "dynamic-values",
+  positions: true,
+  viz: true
+});
+const CAPABILITIES_1_2 = capabilities({
+  ...CAPABILITIES_1_3,
+  multiEdges: false,
+  edgeIds: "required"
+});
+const STRUCTURAL_ROLES = /* @__PURE__ */ new Set(["directed", "pair", "mutual", "weight", "timeText"]);
+const DEFAULT_WEIGHT_TITLE = "weight";
+const NUMERIC_DTYPES = /* @__PURE__ */ new Set(["f32", "f64", "i32", "u32", "u8"]);
+const TEXT_DTYPES = /* @__PURE__ */ new Set(["string", "dict"]);
+function resolveVersion(options) {
+  const version = options?.version;
+  if (version === void 0) {
+    return "1.3";
+  }
+  if (version !== "1.2" && version !== "1.3") {
+    throw new GraphFormatError(
+      "E_UNSUPPORTED",
+      `option version: ${JSON.stringify(version)} is not "1.2" or "1.3"`,
+      {
+        option: "version",
+        found: version,
+        supported: ["1.2", "1.3"]
+      }
+    );
+  }
+  return version;
+}
+function planExport(snapshot, options) {
+  const version = resolveVersion(options);
+  const resolved = resolveExportOptions(options);
+  const caps = version === "1.2" ? CAPABILITIES_1_2 : CAPABILITIES_1_3;
+  const notes = [
+    ...checkCapabilities(snapshot, caps, resolved, {
+      openIntervals: version === "1.2",
+      temporalText: true,
+      positionDtype: "f32",
+      roles: MAPPED_ROLES,
+      roleNames: ROLE_NAMES
+    })
+  ];
+  const note = (code, message, column = null, count = null) => {
+    notes.push(Object.freeze({ code, message, column, count }));
+  };
+  notes.push(...xmlIllegalTextNotes(snapshot));
+  let typeChanges = 0;
+  for (let i = 0; i < snapshot.nodeCount; i++) {
+    const id = snapshot.ids.idOf(i);
+    if (typeof id === "number" ? !Number.isSafeInteger(id) : isCanonicalIntegerText(id)) {
+      typeChanges++;
+    }
+  }
+  if (typeChanges > 0) {
+    note(
+      GEXF_LOSS.ID_TEXT_TYPE,
+      `${typeChanges} node id(s) change type when read back under ids: "canonical" (string ids that are integer text, non-integer numbers); the file's idtype is not honoured by the importer`,
+      null,
+      typeChanges
+    );
+  }
+  const tables = collectTemporalTables(snapshot, version, note);
+  const nodeRoles = collectRoles(snapshot.nodes, "node", note);
+  const edgeRoles = collectRoles(snapshot.edges, "edge", note);
+  const nodeAttrs = collectAttributes(snapshot, "node", nodeRoles, tables.get("node") ?? /* @__PURE__ */ new Map(), version, note);
+  const edgeAttrs = collectAttributes(snapshot, "edge", edgeRoles, tables.get("edge") ?? /* @__PURE__ */ new Map(), version, note);
+  const temporal = hasLifetime(nodeRoles) || hasLifetime(edgeRoles) || nodeAttrs.some((a) => a.dynamic) || edgeAttrs.some((a) => a.dynamic);
+  if (version === "1.2") {
+    for (const [domain, roles] of [
+      ["node", nodeRoles],
+      ["edge", edgeRoles]
+    ]) {
+      if (roles.timestamp !== null || roles.timestamps !== null) {
+        note(
+          GEXF_LOSS.TIMESTAMP_AS_INTERVAL,
+          `${domain} timestamps are written as closed intervals; GEXF 1.2 has no timestamp representation`,
+          (roles.timestamp ?? roles.timestamps)?.meta.name ?? null,
+          null
+        );
+      }
+    }
+    if (edgeRoles.kind !== null) {
+      note(
+        GEXF_LOSS.KIND_DROPPED,
+        `edge column "${edgeRoles.kind.meta.name}" (kind) cannot be written; GEXF 1.2 has no edge kind`,
+        edgeRoles.kind.meta.name,
+        edgeRoles.kind.length - edgeRoles.kind.nullCount
+      );
+    }
+  }
+  const { meta } = snapshot;
+  let { timeRepresentation } = meta;
+  if (timeRepresentation === null && temporal) {
+    const timestampOnly = (nodeRoles.timestamp !== null || edgeRoles.timestamp !== null) && nodeRoles.start === null && nodeRoles.end === null && edgeRoles.start === null && edgeRoles.end === null;
+    timeRepresentation = timestampOnly ? "timestamp" : null;
+  }
+  return {
+    version,
+    options: resolved,
+    notes,
+    nodeRoles,
+    edgeRoles,
+    nodeAttrs,
+    edgeAttrs,
+    timeFormat: meta.timeFormat,
+    temporal,
+    timeRepresentation
+  };
+}
+function hasLifetime(roles) {
+  return roles.start !== null || roles.end !== null || roles.timestamp !== null || roles.spells !== null || roles.timestamps !== null;
+}
+function isNumericScalar(column) {
+  return NUMERIC_DTYPES.has(column.dtype) && column.meta.components === 1;
+}
+function isNumericVector(column, components) {
+  return NUMERIC_DTYPES.has(column.dtype) && components.includes(column.meta.components);
+}
+function isText(column) {
+  return TEXT_DTYPES.has(column.dtype);
+}
+function isNumericList(column, itemComponents) {
+  return column.dtype === "list" && column.meta.itemDtype !== null && NUMERIC_DTYPES.has(column.meta.itemDtype) && (column.meta.itemComponents ?? 1) === itemComponents;
+}
+function roleShapeOk(role, column, domain) {
+  switch (role) {
+    case "label":
+    case "shape":
+      return isText(column);
+    case "kind":
+      return domain === "edge" && isText(column);
+    case "id":
+      return domain === "edge" && (isText(column) || isNumericScalar(column));
+    case "start":
+    case "end":
+    case "timestamp":
+    case "open":
+      return isNumericScalar(column);
+    case "size":
+      return domain === "node" && isNumericScalar(column);
+    case "thickness":
+      return domain === "edge" && isNumericScalar(column);
+    case "spells":
+      return isNumericList(column, 2);
+    case "timestamps":
+      return isNumericList(column, 1);
+    case "position":
+      return domain === "node" && isNumericVector(column, [2, 3]);
+    case "color":
+      return isNumericVector(column, [3, 4]);
+    case "parent":
+      return domain === "node" && column.dtype === "u32" && column.meta.components === 1;
+    case "parents":
+      return domain === "node" && column.dtype === "list" && column.meta.itemDtype === "u32";
+    default:
+      return false;
+  }
+}
+const VIZ_NUMERIC_ROLES = /* @__PURE__ */ new Set(["position", "color", "size", "thickness"]);
+const MAPPED_ROLES = /* @__PURE__ */ new Set([
+  "label",
+  "id",
+  "kind",
+  "start",
+  "end",
+  "timestamp",
+  "spells",
+  "timestamps",
+  "open",
+  "position",
+  "color",
+  "size",
+  "shape",
+  "thickness",
+  "parent",
+  "parents"
+]);
+const ROLE_NAMES = Object.freeze({
+  label: NODE_COLUMNS.label,
+  id: "id",
+  kind: "kind",
+  start: NODE_COLUMNS.start,
+  end: NODE_COLUMNS.end,
+  timestamp: NODE_COLUMNS.timestamp,
+  spells: NODE_COLUMNS.spells,
+  timestamps: NODE_COLUMNS.timestamps,
+  open: NODE_COLUMNS.open,
+  position: NODE_COLUMNS.position,
+  color: NODE_COLUMNS.color,
+  size: NODE_COLUMNS.size,
+  shape: NODE_COLUMNS.shape,
+  thickness: "thickness",
+  parent: NODE_COLUMNS.parent,
+  parents: NODE_COLUMNS.parents
+});
+function collectRoles(table, domain, note) {
+  const companions = /* @__PURE__ */ new Map();
+  const roles = {
+    label: null,
+    id: null,
+    kind: null,
+    start: null,
+    end: null,
+    timestamp: null,
+    spells: null,
+    timestamps: null,
+    open: null,
+    position: null,
+    color: null,
+    size: null,
+    shape: null,
+    shapeUri: null,
+    thickness: null,
+    parent: null,
+    parents: null,
+    companions
+  };
+  for (const column of table) {
+    const { meta } = column;
+    const forName = meta.extra.for;
+    if ((meta.role === "timeText" || typeof forName === "string") && column.dtype === "string") {
+      if (typeof forName === "string") {
+        companions.set(forName, column);
+      }
+      continue;
+    }
+    if (domain === "node" && meta.name === NODE_COLUMNS.shapeUri && meta.origin?.namespace === VIZ_NAMESPACE) {
+      roles.shapeUri = column.dtype === "string" ? column : null;
+      continue;
+    }
+    const { role } = meta;
+    if (role === null || !MAPPED_ROLES.has(role)) {
+      continue;
+    }
+    if (!roleShapeOk(role, column, domain)) {
+      note(
+        GEXF_LOSS.ROLE_SHAPE,
+        `${domain} column "${meta.name}" (${role}) has a shape GEXF cannot map (${describeShape(column)}); written as a plain attribute`,
+        meta.name,
+        null
+      );
+      const set = column.length - column.nullCount;
+      if (NUMERIC_DTYPES.has(column.dtype) && meta.components > 1) {
+        note(
+          LOSS.COMPONENTS,
+          `${domain} column "${meta.name}" has ${meta.components} components; written as a list`,
+          meta.name,
+          set
+        );
+      }
+      if (column.dtype === "json") {
+        note(
+          LOSS.JSON,
+          `${domain} column "${meta.name}" holds nested values; written as JSON text`,
+          meta.name,
+          set
+        );
+      }
+      if (column.dtype === "u32" || column.dtype === "u8") {
+        note(
+          LOSS.DTYPE,
+          `${domain} column "${meta.name}" is ${column.dtype}; the format cannot keep that dtype`,
+          meta.name,
+          set
+        );
+      }
+      continue;
+    }
+    if (VIZ_NUMERIC_ROLES.has(role) && column.dtype !== "f32") {
+      note(
+        GEXF_LOSS.VIZ_DTYPE,
+        `${domain} column "${meta.name}" (${role}) is ${column.dtype}; viz values read back as f32`,
+        meta.name,
+        column.length - column.nullCount
+      );
+    }
+    roles[role] = column;
+  }
+  return roles;
+}
+function describeShape(column) {
+  if (column.dtype === "list") {
+    return `list of ${column.meta.itemDtype ?? "?"} x ${column.meta.itemComponents ?? 1}`;
+  }
+  return `${column.dtype} x ${column.meta.components}`;
+}
+function collectTemporalTables(snapshot, version, note) {
+  const out = /* @__PURE__ */ new Map();
+  for (const [name, table] of snapshot.extensions) {
+    const parsed = parseTemporalTableName(name);
+    if (parsed === null) {
+      continue;
+    }
+    const element = table.get(TEMPORAL_COLUMNS.element);
+    const start = table.get(TEMPORAL_COLUMNS.start);
+    const end = table.get(TEMPORAL_COLUMNS.end);
+    const value = table.get(TEMPORAL_COLUMNS.value);
+    if (element === null || element.dtype !== "u32" || start === null || !isNumericScalar(start) || end === null || !isNumericScalar(end) || value === null) {
+      note(
+        GEXF_LOSS.TEMPORAL_TABLE_SHAPE,
+        `extension table "${name}" lacks the element / start / end / value columns and cannot be written`,
+        name,
+        table.rowCount
+      );
+      continue;
+    }
+    const rows = /* @__PURE__ */ new Map();
+    for (let r = 0; r < table.rowCount; r++) {
+      if (!element.isSet(r)) {
+        continue;
+      }
+      const e = element.value(r);
+      const list = rows.get(e);
+      if (list === void 0) {
+        rows.set(e, [r]);
+      } else {
+        list.push(r);
+      }
+    }
+    const typed = attributeType(value, version);
+    const open = optionalNumeric(table.get(TEMPORAL_COLUMNS.open));
+    if (version === "1.3" && open !== null && open.length - open.nullCount > 0) {
+      note(
+        LOSS.OPEN_INTERVAL,
+        `dynamic values of "${name}" carry open intervals, which GEXF 1.3 cannot write`,
+        name,
+        open.length - open.nullCount
+      );
+    }
+    const resolved = {
+      element,
+      start,
+      end,
+      value,
+      startText: optionalText(table.get(TEMPORAL_COLUMNS.startText)),
+      endText: optionalText(table.get(TEMPORAL_COLUMNS.endText)),
+      valueText: isTemporalType(typed.type) ? optionalText(table.get(TEMPORAL_COLUMNS.valueText)) : null,
+      open,
+      rows,
+      format: typed.format
+    };
+    let byDomain = out.get(parsed.domain);
+    if (byDomain === void 0) {
+      byDomain = /* @__PURE__ */ new Map();
+      out.set(parsed.domain, byDomain);
+    }
+    byDomain.set(parsed.column, resolved);
+  }
+  return out;
+}
+function optionalText(column) {
+  return column !== null && column.dtype === "string" ? column : null;
+}
+function optionalNumeric(column) {
+  return column !== null && isNumericScalar(column) ? column : null;
+}
+function attributeType(column, version) {
+  const { meta } = column;
+  const originType = meta.origin?.type ?? null;
+  if (meta.dtype === "list" || NUMERIC_DTYPES.has(meta.dtype) && meta.components > 1) {
+    const itemDtype = meta.dtype === "list" ? meta.itemDtype ?? "string" : meta.dtype;
+    let itemType = canonicalScalarType(itemDtype);
+    if (originType !== null && meta.dtype === "list" && isListType(originType) && agrees(originType, "list", itemDtype)) {
+      itemType = originType.slice(4);
+    }
+    if (version === "1.2") {
+      const itemFormat = scalarFormatter(itemType, itemDtype);
+      return {
+        type: "liststring",
+        list: true,
+        itemType: "string",
+        format: listFormatter(itemFormat, version),
+        dropped: itemType === "string" ? null : `list${itemType}`
+      };
+    }
+    return {
+      type: `list${itemType}`,
+      list: true,
+      itemType,
+      format: listFormatter(scalarFormatter(itemType, itemDtype), version),
+      dropped: null
+    };
+  }
+  let type = canonicalScalarType(meta.dtype);
+  let dropped = null;
+  const temporal = originType === null || meta.dtype !== "f64" ? null : gexfTemporalType(originType);
+  if (temporal !== null) {
+    if (isScalarType(temporal, version)) {
+      type = temporal;
+    } else {
+      dropped = temporal;
+    }
+  } else if (originType !== null && agrees(originType, meta.dtype, null)) {
+    if (isScalarType(originType, version)) {
+      type = originType;
+    } else if (isScalarType(originType, "1.3")) {
+      dropped = originType;
+    }
+  }
+  return { type, list: false, itemType: type, format: scalarFormatter(type, meta.dtype), dropped };
+}
+function gexfTemporalType(originType) {
+  switch (originType.toLowerCase()) {
+    case "date":
+      return "date";
+    case "datetime":
+    case "localdatetime":
+      return "dateTime";
+    default:
+      return null;
+  }
+}
+function agrees(type, dtype, itemDtype) {
+  const spec = mapDeclaredType("gexf", type, "f64");
+  if (spec === null) {
+    return false;
+  }
+  if (dtype === "list") {
+    return spec.list && spec.itemDtype === itemDtype;
+  }
+  if (spec.list) {
+    return false;
+  }
+  return spec.dtype === dtype || dtype === "dict" && spec.dtype === "string";
+}
+function scalarFormatter(type, dtype) {
+  switch (type) {
+    case "boolean":
+      return (value) => {
+        if (typeof value === "boolean") {
+          return value ? "true" : "false";
+        }
+        if (typeof value !== "number") {
+          return null;
+        }
+        return value !== 0 ? "true" : "false";
+      };
+    case "integer":
+    case "long":
+    case "byte":
+    case "short":
+    case "biginteger":
+      return (value) => {
+        if (typeof value === "number") {
+          return Number.isInteger(value) ? formatInteger(value) : formatF64(value);
+        }
+        return typeof value === "string" ? value : null;
+      };
+    case "float":
+      return (value) => typeof value === "number" ? formatF32(value) : null;
+    case "double":
+    case "bigdecimal":
+      return (value) => {
+        if (typeof value === "number") {
+          return dtype === "f32" ? formatF32(value) : formatF64(value);
+        }
+        return typeof value === "string" ? value : null;
+      };
+    case "date":
+    case "dateTime":
+      return (value) => {
+        if (typeof value === "number") {
+          return formatTemporal(value, type);
+        }
+        return typeof value === "string" ? value : null;
+      };
+    default:
+      return (value) => {
+        switch (typeof value) {
+          case "string":
+            return value;
+          case "number":
+            return dtype === "f32" ? formatF32(value) : formatF64(value);
+          case "boolean":
+            return value ? "true" : "false";
+          case "object":
+            return value === null ? null : JSON.stringify(value);
+          default:
+            return null;
+        }
+      };
+  }
+}
+function listFormatter(item, version) {
+  return (value) => {
+    if (!Array.isArray(value) && !ArrayBuffer.isView(value)) {
+      return null;
+    }
+    const items = [];
+    for (const entry of Array.from(value)) {
+      const text = item(entry);
+      if (text === null) {
+        return null;
+      }
+      items.push(text);
+    }
+    return joinListText(items, version === "1.2" ? "pipe" : "gexf");
+  };
+}
+function collectAttributes(snapshot, domain, roles, tables, version, note) {
+  const table = domain === "node" ? snapshot.nodes : snapshot.edges;
+  const reserved = domain === "node" ? RESERVED_NODE_NAMES : RESERVED_EDGE_NAMES;
+  const roleColumns = /* @__PURE__ */ new Set();
+  for (const value of Object.values(roles)) {
+    if (value !== null && !(value instanceof Map)) {
+      roleColumns.add(value);
+    }
+  }
+  const usedIds = /* @__PURE__ */ new Set();
+  const specs = [];
+  const usedTables = /* @__PURE__ */ new Set();
+  const declare = (column, name, origin, typed, dynamic, temporal) => {
+    const id = uniqueId(origin.id ?? name, name, usedIds);
+    const title = origin.title ?? name;
+    if (typed.dropped !== null) {
+      note(
+        GEXF_LOSS.DECLARED_TYPE,
+        `${domain} column "${name}" is declared ${typed.dropped}, which GEXF ${version} lacks; written as ${typed.type}`,
+        name,
+        null
+      );
+    }
+    if (domain === "edge" && column !== null && column.meta.role === null && title === DEFAULT_WEIGHT_TITLE) {
+      note(
+        GEXF_LOSS.WEIGHT_KEY_CLASH,
+        `edge column "${name}" is written as an attribute titled "${title}", which the importer reads as THE weight (weightFrom); it reads back as the weight, not as a column`,
+        name,
+        column.length - column.nullCount
+      );
+    }
+    const reimportName = reserved.has(title) ? `${title}#${id}` : title;
+    if (reimportName !== name) {
+      note(
+        GEXF_LOSS.ATTRIBUTE_RENAMED,
+        `${domain} column "${name}" is written with title "${title}" and reads back as "${reimportName}"`,
+        name,
+        null
+      );
+    }
+    const { defaultText, optionsText } = column === null ? { defaultText: null, optionsText: null } : declaredTexts(column, domain, typed, version, note);
+    const companion = column === null ? null : roles.companions.get(name) ?? null;
+    if (companion !== null && !isTemporalType(typed.type)) {
+      note(
+        LOSS.TEMPORAL_TEXT,
+        `${domain} column "${companion.meta.name}" (the lexical form of "${name}") cannot be written: "${name}" is written as ${typed.type}, not a GEXF temporal type`,
+        companion.meta.name,
+        companion.length - companion.nullCount
+      );
+    }
+    specs.push({
+      id,
+      title,
+      type: typed.type,
+      column,
+      companion: isTemporalType(typed.type) ? companion : null,
+      format: typed.format,
+      defaultText,
+      optionsText,
+      dynamic,
+      table: temporal
+    });
+  };
+  for (const column of table) {
+    const { meta } = column;
+    if (roleColumns.has(column) || meta.role !== null && STRUCTURAL_ROLES.has(meta.role)) {
+      continue;
+    }
+    if (typeof meta.extra.for === "string" && column.dtype === "string") {
+      continue;
+    }
+    if (domain === "node" && column === roles.shapeUri) {
+      continue;
+    }
+    const temporal = tables.get(meta.name) ?? null;
+    if (temporal !== null) {
+      usedTables.add(meta.name);
+    }
+    declare(
+      column,
+      meta.name,
+      { id: meta.origin?.id ?? null, title: meta.origin?.title ?? null },
+      attributeType(column, version),
+      meta.dynamic || temporal !== null,
+      temporal
+    );
+  }
+  for (const [name, temporal] of tables) {
+    if (usedTables.has(name)) {
+      continue;
+    }
+    const { origin } = temporal.value.meta;
+    const { weightOrigin } = snapshot.meta;
+    const weightId = domain === "edge" && weightOrigin !== null && (weightOrigin.title ?? weightOrigin.id) === name ? weightOrigin.id : null;
+    declare(
+      null,
+      name,
+      { id: origin?.id ?? weightId, title: null },
+      attributeType(temporal.value, version),
+      true,
+      temporal
+    );
+  }
+  return specs;
+}
+function declaredTexts(column, domain, typed, version, note) {
+  const { meta } = column;
+  const { name } = meta;
+  let defaultText = null;
+  let optionsText = null;
+  if (meta.default !== void 0) {
+    defaultText = typed.format(meta.default);
+    if (defaultText === null) {
+      note(
+        GEXF_LOSS.VALUE_UNWRITABLE,
+        `${domain} column "${name}": the default cannot be written as ${typed.type}`,
+        name,
+        null
+      );
+    }
+  }
+  const options = meta.options ?? (column.dtype === "dict" ? column.dictionary : null);
+  if (meta.options === null && options !== null && options.length > 0) {
+    note(
+      GEXF_LOSS.OPTIONS_GAINED,
+      `${domain} column "${name}" declares no options; its dictionary is written as <options> and reads back as declared options`,
+      name,
+      null
+    );
+  }
+  if (options !== null) {
+    const itemFormat = typed.list ? scalarFormatter(typed.itemType, meta.itemDtype ?? "string") : typed.format;
+    const texts = [];
+    let ok = true;
+    for (const option of options) {
+      const text = itemFormat(option);
+      if (text === null) {
+        ok = false;
+        break;
+      }
+      texts.push(text);
+    }
+    if (ok) {
+      optionsText = joinListText(texts, version === "1.2" ? "pipe" : "gexf");
+    } else {
+      note(
+        GEXF_LOSS.VALUE_UNWRITABLE,
+        `${domain} column "${name}": the options cannot be written as ${typed.type}`,
+        name,
+        null
+      );
+    }
+  }
+  if (version === "1.2" && column.dtype === "list") {
+    let count = 0;
+    for (let r = 0; r < column.length; r++) {
+      if (column.isSet(r) && listItems(column, r).some((item) => String(item).includes("|"))) {
+        count++;
+      }
+    }
+    if (count > 0) {
+      note(
+        GEXF_LOSS.LIST_SEPARATOR,
+        `${domain} column "${name}": ${count} row(s) hold an item containing "|", the 1.2 list separator`,
+        name,
+        count
+      );
+    }
+  }
+  return { defaultText, optionsText };
+}
+function isTemporalType(type) {
+  return type === "date" || type === "dateTime";
+}
+function uniqueId(preferred, name, used) {
+  const candidates = [preferred, name];
+  for (const candidate of candidates) {
+    if (candidate.length > 0 && !used.has(candidate)) {
+      used.add(candidate);
+      return candidate;
+    }
+  }
+  for (let n = 2; ; n++) {
+    const candidate = `${name}#${n}`;
+    if (!used.has(candidate)) {
+      used.add(candidate);
+      return candidate;
+    }
+  }
+}
+function timeText(column, companion, row, timeFormat) {
+  if (companion !== null && companion.isSet(row)) {
+    return companion.value(row);
+  }
+  return formatTimeValue(column.value(row), timeFormat);
+}
+function lifetimeAttrs(roles, row, plan) {
+  let out = "";
+  const { timeFormat, version } = plan;
+  let bits = 0;
+  if (version === "1.2" && roles.open !== null && roles.open.isSet(row)) {
+    bits = roles.open.value(row);
+  }
+  const write = (name, column, open) => {
+    if (column === null || !column.isSet(row)) {
+      return;
+    }
+    const value = column.value(row);
+    if (!Number.isFinite(value)) {
+      return;
+    }
+    const text = timeText(column, roles.companions.get(column.meta.name) ?? null, row, timeFormat);
+    out += ` ${open ? `${name}open` : name}="${escapeXmlAttribute(text)}"`;
+  };
+  if (roles.timestamp !== null && roles.timestamp.isSet(row)) {
+    if (version === "1.3" && plan.timeRepresentation === "timestamp") {
+      write("timestamp", roles.timestamp, false);
+    } else {
+      write("start", roles.timestamp, false);
+      write("end", roles.timestamp, false);
+    }
+  } else {
+    write("start", roles.start, (bits & OPEN_START) !== 0);
+    write("end", roles.end, (bits & OPEN_END) !== 0);
+  }
+  if (version === "1.3" && roles.timestamps !== null && roles.timestamps.isSet(row)) {
+    const items = listItems(roles.timestamps, row).map((t) => formatTimeValue(t, timeFormat));
+    out += ` timestamps="${escapeXmlAttribute(`<[${items.join(", ")}]>`)}"`;
+  }
+  return out;
+}
+function spellsElement(roles, row, plan, indent) {
+  const pairs = [];
+  if (roles.spells !== null && roles.spells.isSet(row)) {
+    for (const pair of listItems(roles.spells, row)) {
+      const [s, e] = Array.from(pair);
+      pairs.push([s, e]);
+    }
+  }
+  if (plan.version === "1.2" && roles.timestamps !== null && roles.timestamps.isSet(row)) {
+    for (const t of listItems(roles.timestamps, row)) {
+      pairs.push([t, t]);
+    }
+  }
+  if (pairs.length === 0) {
+    return "";
+  }
+  let out = `${indent}<spells>
+`;
+  for (const [s, e] of pairs) {
+    let attrs = "";
+    if (Number.isFinite(s)) {
+      attrs += ` start="${escapeXmlAttribute(formatTimeValue(s, plan.timeFormat))}"`;
+    }
+    if (Number.isFinite(e)) {
+      attrs += ` end="${escapeXmlAttribute(formatTimeValue(e, plan.timeFormat))}"`;
+    }
+    out += `${indent}  <spell${attrs}/>
+`;
+  }
+  return `${out}${indent}</spells>
+`;
+}
+function attvaluesElement(attrs, row, plan, indent) {
+  let out = "";
+  for (const spec of attrs) {
+    const { column } = spec;
+    if (column !== null && column.isSet(row)) {
+      let text;
+      if (spec.companion !== null && spec.companion.isSet(row)) {
+        text = spec.companion.value(row);
+      } else {
+        text = spec.format(cellValue(column, row));
+      }
+      if (text !== null) {
+        out += `${indent}  <attvalue for="${escapeXmlAttribute(spec.id)}" value="${escapeXmlAttribute(text)}"/>
+`;
+      }
+    }
+    const { table } = spec;
+    if (table === null) {
+      continue;
+    }
+    const rows = table.rows.get(row);
+    if (rows === void 0) {
+      continue;
+    }
+    for (const r of rows) {
+      if (!table.value.isSet(r)) {
+        continue;
+      }
+      let text;
+      if (table.valueText !== null && table.valueText.isSet(r)) {
+        text = table.valueText.value(r);
+      } else {
+        text = table.format(cellValue(table.value, r));
+      }
+      if (text === null) {
+        continue;
+      }
+      out += `${indent}  <attvalue for="${escapeXmlAttribute(spec.id)}" value="${escapeXmlAttribute(text)}"${timedAttrs(table, r, plan)}/>
+`;
+    }
+  }
+  return out.length === 0 ? "" : `${indent}<attvalues>
+${out}${indent}</attvalues>
+`;
+}
+function timedAttrs(table, r, plan) {
+  const start = table.start.isSet(r) ? table.start.value(r) : -Infinity;
+  const end = table.end.isSet(r) ? table.end.value(r) : Infinity;
+  let out = "";
+  if (plan.version === "1.3" && plan.timeRepresentation === "timestamp" && start === end && Number.isFinite(start)) {
+    return ` timestamp="${escapeXmlAttribute(timeText(table.start, table.startText, r, plan.timeFormat))}"`;
+  }
+  let bits = 0;
+  if (plan.version === "1.2" && table.open !== null && table.open.isSet(r)) {
+    bits = table.open.value(r);
+  }
+  if (Number.isFinite(start)) {
+    const name = (bits & OPEN_START) !== 0 ? "startopen" : "start";
+    out += ` ${name}="${escapeXmlAttribute(timeText(table.start, table.startText, r, plan.timeFormat))}"`;
+  }
+  if (Number.isFinite(end)) {
+    const name = (bits & OPEN_END) !== 0 ? "endopen" : "end";
+    out += ` ${name}="${escapeXmlAttribute(timeText(table.end, table.endText, r, plan.timeFormat))}"`;
+  }
+  return out;
+}
+function cellValue(column, row) {
+  switch (column.dtype) {
+    case "list":
+      return column.sliceOf(row);
+    case "json":
+      return column.values[row];
+    default: {
+      const value = column.value(row);
+      return ArrayBuffer.isView(value) ? Array.from(value) : value;
+    }
+  }
+}
+function positionWritesZ(position) {
+  if (position === null || position.meta.components < 3) {
+    return false;
+  }
+  if (position.meta.extra.sourceDims !== 2) {
+    return true;
+  }
+  const { components } = position.meta;
+  let data;
+  switch (position.dtype) {
+    case "f32":
+    case "f64":
+    case "i32":
+    case "u32":
+    case "u8":
+      ({ data } = position);
+      break;
+    default:
+      return true;
+  }
+  for (let i = 0; i < position.length; i++) {
+    if (position.isSet(i) && data[i * components + 2] !== 0) {
+      return true;
+    }
+  }
+  return false;
+}
+function listItems(column, row) {
+  return column.dtype === "list" ? column.sliceOf(row) : [];
+}
+function vizElements(roles, row, indent, writeZ) {
+  let out = "";
+  const { color } = roles;
+  if (color !== null && color.isSet(row)) {
+    const lanes = Array.from(color.value(row));
+    const scale = color.dtype === "u8" ? 1 : 255;
+    const channel = (v) => String(Math.max(0, Math.min(255, Math.round(v * scale))));
+    let attrs = ` r="${channel(lanes[0])}" g="${channel(lanes[1])}" b="${channel(lanes[2])}"`;
+    if (lanes.length > 3) {
+      const a = color.dtype === "u8" ? lanes[3] / 255 : lanes[3];
+      if (a !== 1) {
+        attrs += ` a="${formatF32(Math.fround(a))}"`;
+      }
+    }
+    out += `${indent}<viz:color${attrs}/>
+`;
+  }
+  const { position } = roles;
+  if (position !== null && position.isSet(row)) {
+    const lanes = Array.from(position.value(row));
+    const fmt = position.dtype === "f32" ? formatF32 : formatF64;
+    let attrs = ` x="${fmt(lanes[0])}" y="${fmt(lanes[1])}"`;
+    if (lanes.length > 2 && writeZ) {
+      attrs += ` z="${fmt(lanes[2])}"`;
+    }
+    out += `${indent}<viz:position${attrs}/>
+`;
+  }
+  for (const [name, column] of [
+    ["size", roles.size],
+    ["thickness", roles.thickness]
+  ]) {
+    if (column !== null && column.isSet(row)) {
+      const value = column.value(row);
+      const text = column.dtype === "f32" ? formatF32(value) : formatF64(value);
+      out += `${indent}<viz:${name} value="${escapeXmlAttribute(text)}"/>
+`;
+    }
+  }
+  const { shape } = roles;
+  if (shape !== null && shape.isSet(row)) {
+    let attrs = ` value="${escapeXmlAttribute(String(shape.value(row)))}"`;
+    if (roles.shapeUri !== null && roles.shapeUri.isSet(row)) {
+      attrs += ` uri="${escapeXmlAttribute(roles.shapeUri.value(row))}"`;
+    }
+    out += `${indent}<viz:shape${attrs}/>
+`;
+  }
+  return out;
+}
+function attributesGroups(cls, specs, indent) {
+  let out = "";
+  for (const mode of ["static", "dynamic"]) {
+    const group = specs.filter((s) => s.dynamic === (mode === "dynamic"));
+    if (group.length === 0) {
+      continue;
+    }
+    out += `${indent}<attributes class="${cls}" mode="${mode}">
+`;
+    for (const spec of group) {
+      const head = `${indent}  <attribute id="${escapeXmlAttribute(spec.id)}" title="${escapeXmlAttribute(spec.title)}" type="${spec.type}"`;
+      if (spec.defaultText === null && spec.optionsText === null) {
+        out += `${head}/>
+`;
+        continue;
+      }
+      out += `${head}>
+`;
+      if (spec.defaultText !== null) {
+        out += `${indent}    <default>${escapeXmlText(spec.defaultText)}</default>
+`;
+      }
+      if (spec.optionsText !== null) {
+        out += `${indent}    <options>${escapeXmlText(spec.optionsText)}</options>
+`;
+      }
+      out += `${indent}  </attribute>
+`;
+    }
+    out += `${indent}</attributes>
+`;
+  }
+  return out;
+}
+function edgeType(snapshot, e, folding) {
+  if (!snapshot.directed) {
+    return "undirected";
+  }
+  if (folding.folded(e)) {
+    return null;
+  }
+  if (!folding.sourceDirected(e)) {
+    return "undirected";
+  }
+  if (folding.mateOf(e) !== INVALID_INDEX || folding.isMutual(e)) {
+    return "mutual";
+  }
+  return "directed";
+}
+function* writeGexf(snapshot, options) {
+  const plan = planExport(snapshot, options);
+  const { version } = plan;
+  const ids = sanitizeIds(snapshot, "any", plan.options.sanitizeIds);
+  const idText = (index) => escapeXmlAttribute(String(ids.idAt(index)));
+  const ns = GEXF_NAMESPACES[version];
+  const { meta } = snapshot;
+  yield '<?xml version="1.0" encoding="UTF-8"?>\n';
+  yield `<gexf xmlns="${ns.gexf}" xmlns:viz="${ns.viz}" version="${version}">
+`;
+  yield metaElement(meta);
+  yield graphStart(snapshot, plan);
+  yield attributesGroups("node", plan.nodeAttrs, "    ");
+  yield attributesGroups("edge", plan.edgeAttrs, "    ");
+  const { nodeRoles } = plan;
+  const writeZ = positionWritesZ(nodeRoles.position);
+  yield `    <nodes count="${snapshot.nodeCount}">
+`;
+  for (let i = 0; i < snapshot.nodeCount; i++) {
+    let attrs = ` id="${idText(i)}"`;
+    if (nodeRoles.label !== null && nodeRoles.label.isSet(i)) {
+      attrs += ` label="${escapeXmlAttribute(String(nodeRoles.label.value(i)))}"`;
+    }
+    if (nodeRoles.parent !== null && nodeRoles.parent.isSet(i)) {
+      attrs += ` pid="${idText(nodeRoles.parent.value(i))}"`;
+    }
+    attrs += lifetimeAttrs(nodeRoles, i, plan);
+    let body = attvaluesElement(plan.nodeAttrs, i, plan, "        ");
+    if (nodeRoles.parents !== null && nodeRoles.parents.isSet(i)) {
+      const parents = listItems(nodeRoles.parents, i);
+      if (parents.length > 0) {
+        body += "        <parents>\n";
+        for (const p of parents) {
+          body += `          <parent for="${idText(p)}"/>
+`;
+        }
+        body += "        </parents>\n";
+      }
+    }
+    body += spellsElement(nodeRoles, i, plan, "        ");
+    body += vizElements(nodeRoles, i, "        ", writeZ);
+    yield body.length === 0 ? `      <node${attrs}/>
+` : `      <node${attrs}>
+${body}      </node>
+`;
+  }
+  yield "    </nodes>\n";
+  const { edgeRoles } = plan;
+  const edgeList = snapshot.edgeList();
+  const folding = pairFolding(snapshot, { foldMutual: true });
+  const weights = explicitWeights(snapshot);
+  const defaultType = snapshot.directed ? "directed" : "undirected";
+  let written = 0;
+  for (let e = 0; e < snapshot.edgeCount; e++) {
+    if (edgeType(snapshot, e, folding) !== null) {
+      written++;
+    }
+  }
+  yield `    <edges count="${written}">
+`;
+  for (let e = 0; e < snapshot.edgeCount; e++) {
+    const type = edgeType(snapshot, e, folding);
+    if (type === null) {
+      continue;
+    }
+    let attrs = "";
+    if (edgeRoles.id !== null && edgeRoles.id.isSet(e)) {
+      attrs += ` id="${escapeXmlAttribute(String(edgeRoles.id.value(e)))}"`;
+    } else if (version === "1.2") {
+      attrs += ` id="e${e}"`;
+    }
+    attrs += ` source="${idText(edgeList.src[e])}" target="${idText(edgeList.dst[e])}"`;
+    if (type !== defaultType) {
+      attrs += ` type="${type}"`;
+    }
+    const weight = weights.text(e);
+    if (weight !== null) {
+      attrs += ` weight="${weight}"`;
+    }
+    if (edgeRoles.label !== null && edgeRoles.label.isSet(e)) {
+      attrs += ` label="${escapeXmlAttribute(String(edgeRoles.label.value(e)))}"`;
+    }
+    if (version === "1.3" && edgeRoles.kind !== null && edgeRoles.kind.isSet(e)) {
+      attrs += ` kind="${escapeXmlAttribute(String(edgeRoles.kind.value(e)))}"`;
+    }
+    attrs += lifetimeAttrs(edgeRoles, e, plan);
+    let body = attvaluesElement(plan.edgeAttrs, e, plan, "        ");
+    body += spellsElement(edgeRoles, e, plan, "        ");
+    body += vizElements(edgeRoles, e, "        ", false);
+    yield body.length === 0 ? `      <edge${attrs}/>
+` : `      <edge${attrs}>
+${body}      </edge>
+`;
+  }
+  yield "    </edges>\n";
+  yield "  </graph>\n";
+  yield "</gexf>\n";
+}
+function metaElement(meta) {
+  let body = "";
+  if (meta.creator !== null) {
+    body += `    <creator>${escapeXmlText(meta.creator)}</creator>
+`;
+  }
+  if (meta.description !== null) {
+    body += `    <description>${escapeXmlText(meta.description)}</description>
+`;
+  }
+  if (meta.keywords.length > 0) {
+    body += `    <keywords>${escapeXmlText(meta.keywords.join(", "))}</keywords>
+`;
+  }
+  const modified = meta.modified === null ? "" : ` lastmodifieddate="${escapeXmlAttribute(meta.modified)}"`;
+  if (body.length === 0 && modified.length === 0) {
+    return "";
+  }
+  return body.length === 0 ? `  <meta${modified}/>
+` : `  <meta${modified}>
+${body}  </meta>
+`;
+}
+function graphStart(snapshot, plan) {
+  const { meta } = snapshot;
+  let attrs = ` defaultedgetype="${snapshot.directed ? "directed" : "undirected"}"`;
+  let mode = meta.mode ?? "static";
+  if (plan.temporal && mode === "static") {
+    mode = "dynamic";
+  }
+  if (plan.version === "1.2" && mode === "slice") {
+    mode = "dynamic";
+  }
+  attrs += ` mode="${mode}"`;
+  let { idType } = meta;
+  if (idType === null) {
+    const { kind } = snapshot.ids;
+    if (kind === "string") {
+      idType = "string";
+    } else if (kind !== "mixed") {
+      idType = "integer";
+    }
+  }
+  if (idType === "integer" || idType === "string") {
+    attrs += ` idtype="${idType}"`;
+  }
+  if (plan.timeFormat !== null) {
+    attrs += ` timeformat="${plan.timeFormat}"`;
+  } else if (plan.temporal) {
+    attrs += ' timeformat="double"';
+  }
+  if (plan.version === "1.3" && plan.timeRepresentation !== null) {
+    attrs += ` timerepresentation="${plan.timeRepresentation}"`;
+  }
+  const gexfExtra = meta.extra.gexf;
+  if (typeof gexfExtra === "object" && gexfExtra !== null) {
+    for (const key of ["start", "end", "timestamp"]) {
+      const value = gexfExtra[key];
+      if (typeof value === "string") {
+        attrs += ` ${key}="${escapeXmlAttribute(value)}"`;
+      }
+    }
+  }
+  return `  <graph${attrs}>
+`;
+}
+const gexfExporter = Object.freeze({
+  format: GEXF_FORMAT,
+  capabilities: CAPABILITIES_1_3,
+  /**
+   * Pre-flight: what export() would lose.
+   * @param snapshot - the snapshot
+   * @param options - format-specific and common options
+   * @returns the loss notes, empty when the export is exact
+   */
+  check(snapshot, options) {
+    return Object.freeze(planExport(snapshot, options).notes);
+  },
+  /**
+   * Write the snapshot as UTF-8 chunks.
+   * @param snapshot - the snapshot
+   * @param options - format-specific and common options
+   * @returns the chunks
+   */
+  export(snapshot, options) {
+    return encodeChunks(writeGexf(snapshot, options));
+  },
+  /**
+   * Write the snapshot as one string.
+   * @param snapshot - the snapshot
+   * @param options - format-specific and common options
+   * @returns the document
+   */
+  async exportToString(snapshot, options) {
+    return joinText(writeGexf(snapshot, options));
+  }
+});
+const GEXF_1_2_CAPABILITIES = CAPABILITIES_1_2;
+const GEXF_ISSUE = Object.freeze({
+  /** The XML is not well-formed (fatal). */
+  XML_SYNTAX: XML_SYNTAX_CODE,
+  /** The input holds invalid UTF-8 (fatal). */
+  INVALID_UTF8: INVALID_UTF8_CODE,
+  /** The root element is not `<gexf>` (fatal). */
+  NOT_GEXF: NOT_GEXF_CODE,
+  /** The document has no `<graph>` (fatal). */
+  NO_GRAPH: NO_GRAPH_CODE,
+  /** `<edges>` without `<nodes>`. */
+  MISSING_NODES: MISSING_NODES_CODE,
+  /** A node without an id. */
+  MISSING_ID: MISSING_ID_CODE,
+  /** An edge without a source or target. */
+  MISSING_ENDPOINT: MISSING_ENDPOINT_CODE,
+  /** An edge `type` outside directed / undirected / mutual. */
+  EDGE_TYPE: EDGE_TYPE_CODE,
+  /** A `pid` / `<parent for>` naming an unknown node. */
+  UNKNOWN_PARENT: UNKNOWN_PARENT_CODE,
+  /** An `<attributes class>` outside node / edge. */
+  ATTRIBUTES_CLASS: ATTRIBUTES_CLASS_CODE,
+  /** An `<attribute>` without an id. */
+  ATTRIBUTE_ID: ATTRIBUTE_ID_CODE,
+  /** A `<graph>` header attribute with an unknown value. */
+  HEADER_VALUE: HEADER_VALUE_CODE,
+  /** A `count` hint the sink cannot reserve (ignored). */
+  COUNT_HINT: COUNT_HINT_CODE,
+  /** A node id declared twice. */
+  DUPLICATE_NODE: DUPLICATE_NODE_CODE,
+  /** An edge id declared twice (the second edge is skipped). */
+  DUPLICATE_EDGE_ID: DUPLICATE_EDGE_ID_CODE,
+  /** An attribute id declared twice in one class. */
+  DUPLICATE_ATTRIBUTE: DUPLICATE_ATTRIBUTE_CODE,
+  /** An attribute type the importer maps to string. */
+  ATTRIBUTE_TYPE: ATTRIBUTE_TYPE_CODE,
+  /** A declared type the format does not define (kept as string). */
+  UNKNOWN_ATTR_TYPE: UNKNOWN_ATTR_TYPE_CODE,
+  /** A default that does not parse as the declared type. */
+  BAD_DEFAULT: BAD_DEFAULT_CODE,
+  /** Options that do not parse as the declared type. */
+  BAD_OPTIONS: BAD_OPTIONS_CODE,
+  /** A column renamed `<name>#<id>` because the name was taken (design section 5.6). */
+  COLUMN_RENAMED: COLUMN_RENAMED_CODE,
+  /** A column declared without its role because the table already holds it. */
+  ROLE_TAKEN: ROLE_TAKEN_CODE,
+  /** An `<attvalue for>` naming an undeclared attribute. */
+  UNKNOWN_ATTRIBUTE: UNKNOWN_ATTRIBUTE_CODE,
+  /** An `<attvalue>` without a value. */
+  ATTVALUE_SHAPE: ATTVALUE_SHAPE_CODE,
+  /** A timed value on an attribute of a static group. */
+  TIMED_VALUE_ON_STATIC: TIMED_STATIC_CODE,
+  /** A long value beyond 2^53 rounded. */
+  PRECISION: PRECISION_CODE,
+  /** Two id texts merged into one number under ids "number". */
+  ID_MERGED: ID_MERGED_CODE,
+  /** The XML weight attribute ignored under weightFrom null. */
+  WEIGHT_IGNORED: WEIGHT_IGNORED_CODE,
+  /** viz elements skipped under viz: false. */
+  VIZ_SKIPPED: VIZ_SKIPPED_CODE,
+  /** A 1.2 dynamic viz element whose bounds were dropped. */
+  VIZ_DYNAMIC_DROPPED: VIZ_DYNAMIC_CODE,
+  /** A 1.2 startopen / endopen spell stored closed. */
+  SPELL_OPEN_DROPPED: SPELL_OPEN_CODE,
+  /** A viz value that could not be read. */
+  VIZ_VALUE: VIZ_VALUE_CODE,
+  /** Both `start` and `startopen` (or `end` and `endopen`) on one element. */
+  OPEN_BOUND_CONFLICT: OPEN_BOUND_CONFLICT_CODE,
+  /** An element or attribute GEXF does not define was skipped. */
+  UNKNOWN_ELEMENT: UNKNOWN_ELEMENT_CODE,
+  /** Text where GEXF allows only elements was ignored. */
+  STRAY_TEXT: STRAY_TEXT_CODE,
+  /** A common option the importer has no use for was given. */
+  OPTION_IGNORED: OPTION_IGNORED_CODE,
+  /** A builder-policy option the sink does not honour. */
+  SINK_OPTION: SINK_OPTION_CODE,
+  /** The sink refused the file's direction. */
+  DIRECTION_REFUSED: DIRECTION_REFUSED_CODE,
+  /** Edges forced to the policy's direction. */
+  DIRECTION_FORCED: DIRECTION_FORCED_CODE,
+  /** A mixed file under onMixedDirection "error" (fatal). */
+  MIXED_DIRECTION: MIXED_DIRECTION_CODE
+});
+export {
+  GEXF_1_2_CAPABILITIES,
+  GEXF_ISSUE,
+  GEXF_LOSS,
+  gexfExporter,
+  gexfImporter
+};
+//# sourceMappingURL=gexf.js.map