@graphty/graph-io 0.3.25 → 0.3.26

package/dist/gexf.js

@@ -1,9 +1,7 @@
-import { aI as TIME_TEXT_ROLE, aJ as TIME_TEXT_SUFFIX, v as resolveImportOptions, w as ImportReportBuilder, F as reportSinkOptions, z as reportUnusedOptions, x as textChunks, aw as XML_SYNTAX_CODE, y as throwIfAborted, K as IdCoercer, J as DirectionResolver, au as STRAY_TEXT_CODE, N as NO_GRAPH_CODE, ai as COUNT_HINT_CODE, i as DUPLICATE_ATTRIBUTE_CODE, aK as declareAttribute, L as declareResolved, f as MISSING_ID_CODE, d as DUPLICATE_NODE_CODE, U as UNKNOWN_PARENT_CODE, e as MISSING_ENDPOINT_CODE, c as DUPLICATE_EDGE_ID_CODE, aL as parseDeclaredTemporal, aA as declareCompanion, aM as parseDeclaredValue, aN as losesPrecision, P as PRECISION_CODE, aO as parseTimeText, aP as splitListText, Y as UNKNOWN_ELEMENT_CODE, I as ID_MERGED_CODE, aQ as timeTextCompanion, aH as parseDecimalText, X as pairFolding, V as resolveExportOptions, aR as formatTimeValue, aS as mapDeclaredType, aT as joinListText, aU as formatTemporal, aE as isCanonicalIntegerText, af as MIXED_DIRECTION_CODE, D as DIRECTION_FORCED_CODE, a as DIRECTION_REFUSED_CODE, S as SINK_OPTION_CODE, O as OPTION_IGNORED_CODE, R as ROLE_TAKEN_CODE, C as COLUMN_RENAMED_CODE, ah as BAD_OPTIONS_CODE, Z as BAD_DEFAULT_CODE, k as UNKNOWN_ATTR_TYPE_CODE, q as UNKNOWN_ENCODING_CODE, E as ENCODING_FALLBACK_CODE, r as INVALID_ENCODING_CODE, s as INVALID_UTF8_CODE } from "./chunks/report-B1z4WT9e.js";
+import { bG as TIME_TEXT_ROLE, bH as TIME_TEXT_SUFFIX, al as resolveImportOptions, a8 as ImportReportBuilder, ao as reportSinkOptions, an as reportUnusedOptions, a4 as textChunks, E as EMPTY_INPUT_CODE, X as XML_SYNTAX_CODE, am as throwIfAborted, ar as IdCoercer, aq as DirectionResolver, f as STRAY_TEXT_CODE, N as NO_GRAPH_CODE, h as UNKNOWN_XML_ATTRIBUTE_CODE, l as MULTIPLE_GRAPHS_CODE, j as COUNT_MISMATCH_CODE, k as COUNT_HINT_CODE, o as DUPLICATE_ATTRIBUTE_CODE, aK as isWeightField, bI as declareAttribute, a1 as declareResolved, t as MISSING_ID_CODE, n as DUPLICATE_NODE_CODE, q as UNKNOWN_PARENT_CODE, ai as PARENT_CYCLE_CODE, s as MISSING_ENDPOINT_CODE, m as DUPLICATE_EDGE_ID_CODE, aL as parseWeightText, bJ as overflowsToInfinity, P as PRECISION_CODE, bK as parseDeclaredTemporal, bs as declareCompanion, bL as parseDeclaredValue, bM as losesPrecision, bN as parseTimeText, a3 as BAD_VALUE_CODE, bO as splitListText, g as UNKNOWN_ELEMENT_CODE, I as ID_MERGED_CODE, bP as timeTextCompanion, bQ as parseDecimalText, c as capabilities, L as LOSS, aE as sanitizeIds, p as pairFolding, e as explicitWeights, r as resolveExportOptions, a as checkCapabilities, bR as formatTimeValue, aa as formatF32, ab as formatF64, bS as mapDeclaredType, bT as joinListText, bU as formatTemporal, aG as formatInteger, b as plural, $ as agree, by as isCanonicalIntegerText, M as MIXED_DIRECTION_CODE, D as DIRECTION_FORCED_CODE, d as DIRECTION_REFUSED_CODE, S as SINK_OPTION_CODE, O as OPTION_IGNORED_CODE, R as ROLE_TAKEN_CODE, C as COLUMN_RENAMED_CODE, a_ as BAD_OPTIONS_CODE, B as BAD_DEFAULT_CODE, U as UNKNOWN_ATTR_TYPE_CODE, v as ENCODING_CONFLICT_CODE, w as UNKNOWN_ENCODING_CODE, x as ENCODING_FALLBACK_CODE, y as INVALID_ENCODING_CODE, z as INVALID_UTF8_CODE, A as COLUMN_TYPE_CODE, F as ELEMENT_ISSUE, G as INPUT_ISSUE } from "./chunks/export-BTI4yQgy.js";
 import { GraphFormatError, INVALID_INDEX, MAX_COUNT } from "@graphty/graph-format";
-import { i as isWeightField, p as parseWeightText, e as explicitWeights, f as formatF32, a as formatF64, d as formatInteger } from "./chunks/weights-Dzba96G3.js";
-import { t as tokenizeXml, f as xmlDeclaredEncoding, X as XmlSyntaxError, l as localName, g as isWhitespace, x as xmlIllegalTextNotes, a as escapeXmlText, e as escapeXmlAttribute } from "./chunks/escape-B-tkk_Cl.js";
-import { c as capabilities, L as LOSS, s as sanitizeIds, a as checkCapabilities } from "./chunks/export-Bh60Dv-n.js";
-import { j as joinText, e as encodeChunks } from "./chunks/writer-C7flM-Ih.js";
+import { t as tokenizeXml, f as xmlDeclaredEncoding, g as XmlEmptyInputError, X as XmlSyntaxError, s as sniffXmlText, l as localName, j as isWhitespace, x as xmlIllegalTextNotes, a as escapeXmlText, e as escapeXmlAttribute } from "./chunks/escape-D0g6NNUy.js";
+import { j as joinText, e as encodeChunks } from "./chunks/writer-DxjgHwSe.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" },
@@ -287,6 +285,54 @@ 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 TIMESTAMP_CONFLICT_CODE = "W_GEXF_TIMESTAMP_CONFLICT";
+const VALUE_OUTSIDE_OPTIONS_CODE = "W_GEXF_VALUE_OUTSIDE_OPTIONS";
+const VERSIONS = /* @__PURE__ */ new Set(["1.0", "1.1", "1.2", "1.3"]);
+function namespaceVersion(ns) {
+  const match = ns === null ? null : /gexf\.net\/(1\.[0-3])/.exec(ns);
+  return match === null ? null : match[1];
+}
+function isVizNamespace(ns) {
+  return ns !== null && /(gexf\.net\/.*viz|gephi\.org\/gexf\/viz)\/?$/.test(ns);
+}
+const MAX_UNKNOWN_ATTRIBUTE_NAMES = 16;
+const ELEMENT_ATTRIBUTES = {
+  gexf: /* @__PURE__ */ new Set(["version", "variant"]),
+  meta: /* @__PURE__ */ new Set(["lastmodifieddate"]),
+  graph: /* @__PURE__ */ new Set([
+    "defaultedgetype",
+    "mode",
+    "type",
+    "timeformat",
+    "timerepresentation",
+    "idtype",
+    "start",
+    "end",
+    "timestamp",
+    "startopen",
+    "endopen"
+  ]),
+  // `type` is GEXF 1.0's name for `mode` (static | dynamic)
+  attributes: /* @__PURE__ */ new Set(["class", "mode", "type", "start", "end", "startopen", "endopen"]),
+  attribute: /* @__PURE__ */ new Set(["id", "title", "type"]),
+  attvalue: /* @__PURE__ */ new Set(["for", "value", "start", "end", "timestamp", "startopen", "endopen", "id"]),
+  spell: /* @__PURE__ */ new Set(["start", "end", "timestamp", "startopen", "endopen"]),
+  parent: /* @__PURE__ */ new Set(["for"]),
+  nodes: /* @__PURE__ */ new Set(["count"]),
+  edges: /* @__PURE__ */ new Set(["count"])
+};
+const COUNT_TEXT = /^\d+$/;
+const DATE_TEXT = /^-?\d{4,}-\d{2}-\d{2}(.*)$/s;
+const TIME_TEXT = /^T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?/;
+const ZONE_TEXT = /^(?:Z|[+-]\d{2}:\d{2})?$/;
+function isDateText(text) {
+  const m = DATE_TEXT.exec(text);
+  if (m === null) {
+    return false;
+  }
+  const time = TIME_TEXT.exec(m[1])?.[0] ?? "";
+  return ZONE_TEXT.test(m[1].slice(time.length));
+}
 const EDGE_TYPES = /* @__PURE__ */ new Set(["directed", "undirected", "mutual"]);
 function edgeTypeKeyword(text) {
   return text.trim().toLowerCase();
@@ -448,8 +494,13 @@ class GexfReader {
     this.edgeFrame = {
       index: INVALID_INDEX,
       mirror: INVALID_INDEX,
-      where: { line: 0, element: null }
+      where: { line: 0, element: null },
+      xmlWeight: null
     };
+    this.attvalueIds = /* @__PURE__ */ new Set();
+    this.sections = [];
+    this.unknownNames = /* @__PURE__ */ new Map();
+    this.unknownOverflow = /* @__PURE__ */ new Map();
     this.valueWhere = { line: 0, element: null };
     this.attributeGroup = null;
     this.pendingAttribute = null;
@@ -494,15 +545,20 @@ class GexfReader {
     };
   }
   // ---------------------------------------------------------------- events
-  start(name, attrs, line) {
+  start(name, attrs, line, ns = "") {
     const parent = this.ctx.length === 0 ? null : this.ctx[this.ctx.length - 1];
     const local = localName(name);
+    if (ns === null && parent !== null && parent !== 14 && parent !== 2 && parent !== 6 && !name.startsWith("viz:")) {
+      this.unknownElement(name, line);
+      return;
+    }
     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.checkAttributes("gexf", attrs, line);
+        this.readRoot(attrs, ns, line);
         this.ctx.push(
           0
           /* Gexf */
@@ -527,7 +583,7 @@ class GexfReader {
         this.startInNodes(name, local, attrs, line);
         return;
       case 8:
-        this.startInNode(name, local, attrs, line);
+        this.startInNode(name, local, attrs, line, ns);
         return;
       case 9:
         this.startInAttvalues(name, local, attrs, line);
@@ -542,7 +598,7 @@ class GexfReader {
         this.startInEdges(name, local, attrs, line);
         return;
       case 13:
-        this.startInEdge(name, local, attrs, line);
+        this.startInEdge(name, local, attrs, line, ns);
         return;
       case 2:
       case 6:
@@ -585,6 +641,10 @@ class GexfReader {
       case 8:
         this.nodeStack.pop();
         return;
+      case 7:
+      case 12:
+        this.finishSection();
+        return;
       case 13:
         this.edge = null;
         return;
@@ -595,8 +655,6 @@ class GexfReader {
         this.finishSpells();
         return;
       case 0:
-      case 7:
-      case 12:
       case 9:
       case 14:
       case void 0:
@@ -642,16 +700,40 @@ class GexfReader {
     if (!this.graphSeen) {
       this.report.fail(NO_GRAPH_CODE, "the document has no <graph> element");
     }
+    for (const [kind, more] of this.unknownOverflow) {
+      this.report.warning(
+        "unsupported",
+        UNKNOWN_XML_ATTRIBUTE_CODE,
+        `${more} more distinct attribute names on <${kind}> are not GEXF attributes and are not kept (not listed one by one)`,
+        { element: kind }
+      );
+    }
   }
   // ---------------------------------------------------------------- root, meta, graph
   /**
-   * Record the root's version.
+   * Record the root's version: as written when known; the namespace's when absent; an unknown
+   * one is kept as written and reported.
    * @param attrs - the `<gexf>` attributes
+   * @param ns - the root's namespace
+   * @param line - the line
    */
-  readRoot(attrs) {
+  readRoot(attrs, ns, line) {
     const version = attrs.get("version");
     if (version !== void 0 && version.length > 0) {
       this.meta.sourceVersion = version;
+      if (!VERSIONS.has(version)) {
+        this.report.warning(
+          "validation-error",
+          HEADER_VALUE_CODE,
+          `<gexf version="${version}"> is not a GEXF version graph-io knows (1.0 to 1.3); read as GEXF 1.3`,
+          { line, element: "version" }
+        );
+      }
+      return;
+    }
+    const implied = namespaceVersion(ns);
+    if (implied !== null) {
+      this.meta.sourceVersion = implied;
     }
   }
   /**
@@ -664,9 +746,18 @@ class GexfReader {
   startInGexf(name, local, attrs, line) {
     switch (local) {
       case "meta": {
+        this.checkAttributes("meta", attrs, line);
         const modified = attrs.get("lastmodifieddate");
         if (modified !== void 0 && modified.length > 0) {
           this.meta.modified = modified;
+          if (!isDateText(modified.trim())) {
+            this.report.warning(
+              "validation-error",
+              HEADER_VALUE_CODE,
+              `<meta lastmodifieddate="${modified}"> is not an xs:date; kept as written`,
+              { line, element: "lastmodifieddate" }
+            );
+          }
         }
         this.ctx.push(
           1
@@ -675,13 +766,18 @@ class GexfReader {
         return;
       }
       case "graph":
+        this.checkAttributes("graph", attrs, line);
         if (this.graphSeen) {
-          this.report.fail(NO_GRAPH_CODE, "a second <graph> element; a GEXF document has one graph", {
-            line
-          });
+          this.report.warnOnce(
+            "unsupported",
+            MULTIPLE_GRAPHS_CODE,
+            "a second <graph> element; its nodes and edges are merged into the first and its header is ignored",
+            { line }
+          );
+        } else {
+          this.graphSeen = true;
+          this.readHeader(attrs, line);
         }
-        this.graphSeen = true;
-        this.readHeader(attrs, line);
         this.ctx.push(
           3
           /* Graph */
@@ -726,8 +822,11 @@ class GexfReader {
     this.metaField = null;
     this.metaText = "";
   }
-  /** Close `<meta>`: nothing more to do (the patch is applied at `<graph>`). */
+  /** Close `<meta>`: the patch is applied with the graph header, or now when `<meta>` follows the graph. */
   finishMeta() {
+    if (this.graphSeen) {
+      this.sink.setMeta(this.meta);
+    }
   }
   /**
    * Read `<graph defaultedgetype mode timeformat timerepresentation idtype start end timestamp>`
@@ -824,11 +923,7 @@ class GexfReader {
         return;
       case "nodes":
         this.nodesSeen = true;
-        this.reserve(attrs, "node", line);
-        this.ctx.push(
-          7
-          /* Nodes */
-        );
+        this.beginSection(attrs, "node", line);
         return;
       case "edges":
         if (!this.nodesSeen) {
@@ -840,39 +935,64 @@ class GexfReader {
           );
         }
         this.resolveParents();
-        this.reserve(attrs, "edge", line);
-        this.ctx.push(
-          12
-          /* Edges */
-        );
+        this.beginSection(attrs, "edge", line);
         return;
       default:
         this.unknownElement(name, line);
     }
   }
+  /**
+   * Open a `<nodes>` / `<edges>` section: its count hint is reserved and later compared with the
+   * elements the section holds.
+   * @param attrs - the section's attributes
+   * @param domain - node or edge
+   * @param line - the line
+   */
+  beginSection(attrs, domain, line) {
+    this.checkAttributes(`${domain}s`, attrs, line);
+    this.sections.push({ domain, hint: this.reserve(attrs, domain, line), seen: 0, line });
+    this.ctx.push(
+      domain === "node" ? 7 : 12
+      /* Edges */
+    );
+  }
+  /** Close a `<nodes>` / `<edges>` section: a count hint that disagrees is reported. */
+  finishSection() {
+    const section = this.sections.pop();
+    if (section?.hint === void 0 || section.hint === null || section.hint === section.seen) {
+      return;
+    }
+    this.report.warning(
+      "validation-error",
+      COUNT_MISMATCH_CODE,
+      `<${section.domain}s count="${section.hint}"> but the section holds ${section.seen} <${section.domain}> elements (nested ones included)`,
+      { line: section.line, element: "count" }
+    );
+  }
   /**
    * 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
+   * @returns the hint, or null when absent or ignored
    */
   reserve(attrs, domain, line) {
     const text = attrs.get("count");
     if (text === void 0) {
-      return;
+      return null;
     }
-    const count = Number(text);
-    if (!Number.isInteger(count) || count < 0 || count > MAX_COUNT) {
+    const count = COUNT_TEXT.test(text) ? Number(text) : Number.NaN;
+    if (!Number.isSafeInteger(count) || 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;
+      return null;
     }
     if (count === 0) {
-      return;
+      return count;
     }
     try {
       if (domain === "node") {
@@ -889,6 +1009,7 @@ class GexfReader {
         element: "count"
       });
     }
+    return count;
   }
   // ---------------------------------------------------------------- attribute declarations
   /**
@@ -897,6 +1018,7 @@ class GexfReader {
    * @param line - the line
    */
   beginAttributes(attrs, line) {
+    this.checkAttributes("attributes", attrs, line);
     const cls = attrs.get("class");
     const where = { line };
     let domain = null;
@@ -910,7 +1032,7 @@ class GexfReader {
         where
       );
     }
-    const mode = attrs.get("mode");
+    const mode = attrs.get("mode") ?? attrs.get("type");
     if (mode !== void 0 && mode !== "static" && mode !== "dynamic") {
       this.warnHeader("mode", mode, where);
     }
@@ -932,6 +1054,7 @@ class GexfReader {
       this.unknownElement(name, line);
       return;
     }
+    this.checkAttributes("attribute", attrs, line);
     const group = this.attributeGroup;
     if (group === null || group.domain === null) {
       this.ctx.push(
@@ -1022,6 +1145,14 @@ class GexfReader {
       );
       return;
     }
+    if (this.unknownAttributes.has(`${domain}:${id}`)) {
+      report.warning(
+        "missing-value",
+        UNKNOWN_ATTRIBUTE_CODE,
+        `${domain} attribute "${id}" is declared after values that use it; those values were dropped (declare <attributes> before <nodes>)`,
+        where
+      );
+    }
     const title = attrs.get("title") ?? null;
     const type = attrs.get("type") ?? null;
     if (type === null) {
@@ -1033,7 +1164,14 @@ class GexfReader {
       );
     }
     const name = title !== null && title.length > 0 ? title : id;
-    if (domain === "edge" && isWeightField(name, options.weightFrom)) {
+    if (domain === "edge" && this.weightAttr !== null && isWeightField(name, options.weightFrom)) {
+      report.warning(
+        "validation-error",
+        DUPLICATE_ATTRIBUTE_CODE,
+        `edge attribute "${id}" is also titled ${name}; attribute "${this.weightAttr.id}" is the weight, "${id}" is kept as a column`,
+        where
+      );
+    } else 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);
@@ -1044,7 +1182,8 @@ class GexfReader {
     }
     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 weightName = domain === "edge" && this.weightAttr !== null ? options.weightFrom : null;
+    const taken = (candidate) => reserved.has(candidate) || declaredNames.has(candidate) || candidate === weightName;
     const input = {
       format: GEXF_FORMAT,
       id,
@@ -1117,6 +1256,7 @@ class GexfReader {
     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.countInSection("node");
     this.checkAttributeNames(attrs, NODE_ATTRIBUTES, "node", where);
     if (idText === void 0) {
       report.error("missing-value", MISSING_ID_CODE, "<node> without an id", where);
@@ -1128,6 +1268,15 @@ class GexfReader {
       );
       return;
     }
+    if (this.meta.idType === "integer" && !/^\s*[+-]?\d+\s*$/.test(idText)) {
+      report.warnOnce(
+        "validation-error",
+        HEADER_VALUE_CODE,
+        `node id "${idText}" is not an integer although the graph declares idtype="integer"; ids follow the ids option`,
+        where,
+        `${HEADER_VALUE_CODE}:idtype`
+      );
+    }
     let index;
     try {
       const id = this.coerceId(idText, where);
@@ -1164,6 +1313,10 @@ class GexfReader {
       if (label !== void 0) {
         this.nodeColumns.label.set(sink, report, index, label, where);
       }
+    } catch (err) {
+      report.recordError(err, where);
+    }
+    try {
       const pid = attrs.get("pid");
       if (pid !== void 0) {
         this.parentRefs.push({
@@ -1175,19 +1328,36 @@ class GexfReader {
       } else if (enclosing !== INVALID_INDEX) {
         this.parentRefs.push({ child: index, parentId: null, parentIndex: enclosing, where });
       }
+    } catch (err) {
+      report.recordError(err, where);
+    }
+    try {
       this.writeLifetime(attrs, index, this.nodeColumns, where);
     } catch (err) {
       report.recordError(err, where);
     }
   }
+  /**
+   * Count a `<node>` / `<edge>` element in the open sections of its kind, for the count hint
+   * check: a `<nodes count>` counts the nodes nested in its nodes too.
+   * @param domain - node or edge
+   */
+  countInSection(domain) {
+    for (const section of this.sections) {
+      if (section.domain === domain) {
+        section.seen++;
+      }
+    }
+  }
   /**
    * A child of `<node>`.
    * @param name - the element name
    * @param local - its local name
    * @param attrs - its attributes
    * @param line - the line
+   * @param ns - the element's namespace
    */
-  startInNode(name, local, attrs, line) {
+  startInNode(name, local, attrs, line, ns) {
     const frame = this.nodeStack[this.nodeStack.length - 1];
     if (frame.index === INVALID_INDEX && local !== "nodes") {
       this.ctx.push(
@@ -1196,8 +1366,17 @@ class GexfReader {
       );
       return;
     }
+    if (frame.index === INVALID_INDEX) {
+      this.report.error(
+        "missing-value",
+        UNKNOWN_PARENT_CODE,
+        "the nodes nested in this skipped <node> lose their parent; they are read as top-level nodes",
+        { line }
+      );
+    }
     switch (local) {
       case "attvalues":
+        this.attvalueIds.clear();
         this.ctx.push(
           9
           /* Attvalues */
@@ -1220,16 +1399,16 @@ class GexfReader {
         );
         return;
       case "nodes":
-        this.reserve(attrs, "node", line);
-        this.ctx.push(
-          7
-          /* Nodes */
-        );
+        this.beginSection(attrs, "node", line);
         return;
       case "color":
       case "position":
       case "size":
       case "shape":
+        if (!isViz(name, ns)) {
+          this.unknownElement(name, line);
+          return;
+        }
         this.writeViz(name, local, attrs, "node", frame.index, frame.where);
         this.ctx.push(
           14
@@ -1256,10 +1435,16 @@ class GexfReader {
       14
       /* Skip */
     );
+    this.checkAttributes("parent", attrs, line);
     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);
+      this.report.error(
+        "missing-value",
+        UNKNOWN_PARENT_CODE,
+        "<parent> without a for attribute names no parent",
+        frame.where
+      );
       return;
     }
     try {
@@ -1286,6 +1471,15 @@ class GexfReader {
     const lists = this.parentsRefs;
     this.parentRefs = [];
     this.parentsRefs = [];
+    const parentOf = /* @__PURE__ */ new Map();
+    const isAncestorOrSelf = (candidate, of) => {
+      for (let at = of; at !== void 0; at = parentOf.get(at)) {
+        if (at === candidate) {
+          return true;
+        }
+      }
+      return false;
+    };
     for (const ref of refs) {
       let parent = ref.parentIndex;
       if (ref.parentId !== null) {
@@ -1300,8 +1494,21 @@ class GexfReader {
           continue;
         }
       }
+      if (parentOf.get(ref.child) === parent) {
+        continue;
+      }
+      if (isAncestorOrSelf(ref.child, parent)) {
+        report.error(
+          "validation-error",
+          PARENT_CYCLE_CODE,
+          `the parent link of node "${ref.where.element ?? "?"}" would close a parent cycle; it is dropped`,
+          ref.where
+        );
+        continue;
+      }
       try {
         this.parentColumn.set(sink, report, ref.child, parent, ref.where);
+        parentOf.set(ref.child, parent);
       } catch (err) {
         report.recordError(err, ref.where);
       }
@@ -1362,6 +1569,7 @@ class GexfReader {
     const { where } = this.edgeFrame;
     where.line = line;
     where.element = idText ?? edgeElement(sourceText, targetText);
+    this.countInSection("edge");
     this.checkAttributeNames(attrs, EDGE_ATTRIBUTES, "edge", where);
     if (sourceText === void 0 || targetText === void 0) {
       report.error(
@@ -1389,18 +1597,15 @@ class GexfReader {
       }
       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);
+    if (idText !== void 0 && 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;
     }
     let index;
     try {
@@ -1427,9 +1632,13 @@ class GexfReader {
       report.counts.skippedEdges++;
       return;
     }
+    if (idText !== void 0) {
+      this.edgeIds.add(idText);
+    }
     const frame = this.edgeFrame;
     frame.index = index;
     frame.mirror = this.resolver.lastMirror;
+    frame.xmlWeight = attrs.get("weight") ?? null;
     this.edge = frame;
     try {
       if (idText !== void 0) {
@@ -1469,7 +1678,26 @@ class GexfReader {
       );
       return void 0;
     }
-    return parseWeightText(text);
+    const weight = parseWeightText(text, this.report);
+    this.checkOverflow(text, where);
+    return weight;
+  }
+  /**
+   * Report (once) a weight text too large for a double, stored as Infinity; `INF` itself is a
+   * legal weight (design section 3.7) and is not reported.
+   * @param text - the weight text
+   * @param where - the location
+   */
+  checkOverflow(text, where) {
+    if (overflowsToInfinity(text)) {
+      this.report.warnOnce(
+        "precision",
+        PRECISION_CODE,
+        `weight ${text.trim()} is beyond the double range and is stored as Infinity`,
+        where,
+        `${PRECISION_CODE}:weight`
+      );
+    }
   }
   /**
    * A child of `<edge>`.
@@ -1477,8 +1705,9 @@ class GexfReader {
    * @param local - its local name
    * @param attrs - its attributes
    * @param line - the line
+   * @param ns - the element's namespace
    */
-  startInEdge(name, local, attrs, line) {
+  startInEdge(name, local, attrs, line, ns) {
     const { edge } = this;
     if (edge === null) {
       this.ctx.push(
@@ -1489,6 +1718,7 @@ class GexfReader {
     }
     switch (local) {
       case "attvalues":
+        this.attvalueIds.clear();
         this.ctx.push(
           9
           /* Attvalues */
@@ -1506,6 +1736,10 @@ class GexfReader {
       case "color":
       case "thickness":
       case "shape":
+        if (!isViz(name, ns)) {
+          this.unknownElement(name, line);
+          return;
+        }
         this.writeViz(name, local, attrs, "edge", edge.index, edge.where);
         this.ctx.push(
           14
@@ -1534,6 +1768,7 @@ class GexfReader {
       14
       /* Skip */
     );
+    this.checkAttributes("attvalue", attrs, line);
     const { report, edge } = this;
     const domain = edge === null ? "node" : "edge";
     let index;
@@ -1567,6 +1802,17 @@ class GexfReader {
       );
       return;
     }
+    if (!isTimed(attrs)) {
+      if (this.attvalueIds.has(forId)) {
+        report.warning(
+          "validation-error",
+          DUPLICATE_ATTRIBUTE_CODE,
+          `a second static <attvalue for="${forId}"> on one ${domain}; the later value "${value}" is kept`,
+          { ...valueWhere, element: forId }
+        );
+      }
+      this.attvalueIds.add(forId);
+    }
     try {
       if (domain === "edge" && this.weightAttr !== null && this.weightAttr.id === forId) {
         if (isTimed(attrs)) {
@@ -1611,12 +1857,18 @@ class GexfReader {
     if (edge === null) {
       return;
     }
-    const weight = parseWeightText(text);
+    const weight = parseWeightText(text, this.report);
     if (weight === void 0) {
-      throw new GraphFormatError("E_INVALID_WEIGHT", "an edge weight cannot be blank", {
-        value: text,
-        line: where.line ?? null
-      });
+      return;
+    }
+    this.checkOverflow(text, where);
+    if (edge.xmlWeight !== null) {
+      this.report.warning(
+        "validation-error",
+        DUPLICATE_ATTRIBUTE_CODE,
+        `the edge has both weight="${edge.xmlWeight}" and a weight attvalue "${text}"; the attvalue is kept`,
+        where
+      );
     }
     sink.setEdgeWeight(edge.index, weight);
     if (edge.mirror !== INVALID_INDEX) {
@@ -1653,9 +1905,42 @@ class GexfReader {
         `long value ${text.trim()} of "${attribute.name}" exceeds 2^53 and was rounded`,
         where
       );
+    } else if (typeof value === "number" && overflowsToInfinity(text)) {
+      this.report.warnOnce(
+        "precision",
+        PRECISION_CODE,
+        `values of "${attribute.name}" beyond the double range (${text.trim()}) are stored as Infinity`,
+        where,
+        `${PRECISION_CODE}:overflow:${attribute.name}`
+      );
     }
+    this.checkOptions(attribute, value, where);
     this.setCell(domain, attribute.handle, index, value);
   }
+  /**
+   * Report (once per attribute) a value outside the `<options>` the attribute declares; the
+   * value is kept.
+   * @param attribute - the declaration
+   * @param value - the parsed value (a list checks each item)
+   * @param where - the value's location
+   */
+  checkOptions(attribute, value, where) {
+    const { options } = attribute.valueDecl;
+    if (options === void 0 || options.length === 0) {
+      return;
+    }
+    const items = Array.isArray(value) ? value : [value];
+    const outside = items.find((item) => !options.includes(item));
+    if (typeof outside === "string" || typeof outside === "number" || typeof outside === "boolean") {
+      this.report.warnOnce(
+        "validation-error",
+        VALUE_OUTSIDE_OPTIONS_CODE,
+        `"${outside}" is not among the options of attribute "${attribute.name}"; the value is kept`,
+        where,
+        `${VALUE_OUTSIDE_OPTIONS_CODE}:${attribute.name}`
+      );
+    }
+  }
   /**
    * Append a timed value to the attribute's temporal table (design section 5.10), creating the
    * table on first use.
@@ -1702,6 +1987,9 @@ class GexfReader {
       }
     }
     const row = this.temporalRow(attrs, index, value, where);
+    if (row === null) {
+      return;
+    }
     if (temporalValue) {
       row.push(valueText ?? void 0);
     }
@@ -1733,14 +2021,14 @@ class GexfReader {
         )
       );
     }
-    const value = parseWeightText(text);
+    const value = parseWeightText(text, this.report);
     if (value === void 0) {
-      throw new GraphFormatError("E_INVALID_WEIGHT", "a timed edge weight cannot be blank", {
-        value: text,
-        line: where.line ?? null
-      });
+      return;
+    }
+    const row = this.temporalRow(attrs, index, value, where);
+    if (row !== null) {
+      sink.addExtensionRow(weightAttr.table, row);
     }
-    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.
@@ -1748,10 +2036,13 @@ class GexfReader {
    * @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
+   * @returns the row, without the optional value text; null when the interval is inverted (recorded)
    */
   temporalRow(attrs, index, value, where) {
     const bounds = this.readBounds(attrs, where);
+    if (bounds === null) {
+      return null;
+    }
     return [
       index,
       bounds.start.value,
@@ -1768,7 +2059,7 @@ class GexfReader {
    * 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
+   * @returns the bounds and the open bits; null (recorded as E_BAD_VALUE) when the interval is inverted
    */
   readBounds(attrs, where) {
     let start = { value: -Infinity, text: null };
@@ -1778,6 +2069,14 @@ class GexfReader {
     if (timestamp !== void 0) {
       start = parseTimeText(timestamp, this.timeFormat);
       end = start;
+      if (attrs.has("start") || attrs.has("end") || attrs.has("startopen") || attrs.has("endopen")) {
+        this.report.warnOnce(
+          "validation-error",
+          TIMESTAMP_CONFLICT_CODE,
+          "both timestamp and start / end are given; start / end set the interval and the timestamp is kept as written",
+          where
+        );
+      }
     }
     const startText = attrs.get("start");
     const startOpen = attrs.get("startopen");
@@ -1801,6 +2100,15 @@ class GexfReader {
       end = parseTimeText(endOpen, this.timeFormat);
       open |= OPEN_END;
     }
+    if (start.value > end.value) {
+      this.report.error(
+        "validation-error",
+        BAD_VALUE_CODE,
+        `the interval starts after it ends (${start.text ?? String(start.value)} > ${end.text ?? String(end.value)}); it is not kept`,
+        where
+      );
+      return null;
+    }
     return { start, end, open };
   }
   /**
@@ -1829,9 +2137,12 @@ class GexfReader {
     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);
+      if (bounds === null) {
+        return;
+      }
       const timestamp = attrs.get("timestamp");
       if (timestamp !== void 0) {
-        columns.timestamp.set(sink, report, index, bounds.start, where);
+        columns.timestamp.set(sink, report, index, parseTimeText(timestamp, this.timeFormat), where);
       }
       if (attrs.has("start") || attrs.has("startopen")) {
         columns.start.set(sink, report, index, bounds.start, where);
@@ -1878,10 +2189,20 @@ class GexfReader {
           line: where.line ?? null
         });
       }
-      pairs.push([
+      const pair = [
         parseTimeText(items[0], this.timeFormat).value,
         parseTimeText(items[1], this.timeFormat).value
-      ]);
+      ];
+      if (pair[0] > pair[1]) {
+        this.report.error(
+          "validation-error",
+          BAD_VALUE_CODE,
+          `interval "${part.trim()}" starts after it ends; it is not kept`,
+          where
+        );
+        continue;
+      }
+      pairs.push(pair);
     }
     return pairs;
   }
@@ -1901,9 +2222,13 @@ class GexfReader {
       14
       /* Skip */
     );
+    this.checkAttributes("spell", attrs, line);
     const where = this.spellsWhere ?? { line };
     try {
       const bounds = this.readBounds(attrs, where);
+      if (bounds === null) {
+        return;
+      }
       this.spellPairs?.push([bounds.start.value, bounds.end.value]);
       this.spellOpen.push(bounds.open);
     } catch (err) {
@@ -2024,28 +2349,52 @@ class GexfReader {
     );
   }
   /**
-   * Report XML attributes the importer does not read (once per attribute name and domain).
+   * Report XML attributes the importer does not read (once per attribute name and element kind;
+   * beyond MAX_UNKNOWN_ATTRIBUTE_NAMES distinct names per kind the rest are counted and reported
+   * once at the end). Namespace declarations and `xml:` / `xsi:` attributes are not data.
    * @param attrs - the element's attributes
    * @param known - the attribute names read
-   * @param domain - node or edge
+   * @param kind - the element name
    * @param where - the element's location
    */
-  checkAttributeNames(attrs, known, domain, where) {
+  checkAttributeNames(attrs, known, kind, where) {
+    if (attrs.size === 0) {
+      return;
+    }
     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 }
-          );
-        }
+      if (known.has(key) || key === "xmlns" || /^(xmlns|xml|xsi):/.test(key)) {
+        continue;
+      }
+      let names = this.unknownNames.get(kind);
+      if (names === void 0) {
+        names = /* @__PURE__ */ new Set();
+        this.unknownNames.set(kind, names);
       }
+      if (names.has(key)) {
+        continue;
+      }
+      names.add(key);
+      if (names.size > MAX_UNKNOWN_ATTRIBUTE_NAMES) {
+        this.unknownOverflow.set(kind, (this.unknownOverflow.get(kind) ?? 0) + 1);
+        continue;
+      }
+      this.report.warning(
+        "unsupported",
+        UNKNOWN_XML_ATTRIBUTE_CODE,
+        `attribute ${key} of <${kind}> is not GEXF and was ignored`,
+        { ...where, element: key }
+      );
     }
   }
+  /**
+   * Report the XML attributes the importer does not read on an element other than node / edge.
+   * @param kind - the element's local name (a key of ELEMENT_ATTRIBUTES)
+   * @param attrs - its attributes
+   * @param line - the line
+   */
+  checkAttributes(kind, attrs, line) {
+    this.checkAttributeNames(attrs, ELEMENT_ATTRIBUTES[kind] ?? /* @__PURE__ */ new Set(), kind, { line });
+  }
   /**
    * Write one cell of a domain.
    * @param domain - node or edge
@@ -2087,6 +2436,9 @@ class GexfReader {
     }
   }
 }
+function isViz(name, ns) {
+  return isVizNamespace(ns) || ns === null && name.startsWith("viz:");
+}
 function edgeElement(source, target) {
   return `${source ?? "?"}->${target ?? "?"}`;
 }
@@ -2122,7 +2474,7 @@ function parseColor(attrs) {
   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`, {
+      throw new GraphFormatError("E_COLUMN_TYPE", `viz hex="${hex}" is not a #RRGGBB color`, {
         attribute: "hex"
       });
     }
@@ -2139,7 +2491,7 @@ function parseColor(attrs) {
 }
 const XML_START = /^\uFEFF?\s*</;
 function sniffGexf(head) {
-  const text = new TextDecoder("utf-8", { fatal: false }).decode(head);
+  const text = sniffXmlText(head);
   if (!XML_START.test(text)) {
     return 0;
   }
@@ -2163,6 +2515,7 @@ function resolveGexfOptions(options) {
 }
 const gexfImporter = Object.freeze({
   format: GEXF_FORMAT,
+  options: Object.freeze(["viz"]),
   extensions: Object.freeze([".gexf"]),
   mimeTypes: Object.freeze(["application/gexf+xml", "application/xml", "text/xml"]),
   sniff: sniffGexf,
@@ -2187,10 +2540,13 @@ const gexfImporter = Object.freeze({
     const reader = new GexfReader(sink, report, resolved, viz);
     try {
       await tokenizeXml(
-        textChunks(input, report, { ...resolved, declaredEncoding: xmlDeclaredEncoding }),
+        textChunks(input, report, { ...resolved, declaredEncoding: xmlDeclaredEncoding, xml: true }),
         reader
       );
     } catch (err) {
+      if (err instanceof XmlEmptyInputError) {
+        report.fail(EMPTY_INPUT_CODE, "the input is empty (no markup at all)", { line: err.line });
+      }
       if (err instanceof XmlSyntaxError) {
         report.fail(XML_SYNTAX_CODE, err.message, { line: err.line });
       }
@@ -2210,25 +2566,41 @@ const GEXF_LOSS = Object.freeze({
   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. */
+  /** A temporal extension table without the element / start / end / value columns. */
   TEMPORAL_TABLE_SHAPE: "W_TEMPORAL_TABLE_SHAPE",
-  /** An attribute whose title the importer would rename on re-import (a reserved name). */
+  /** An attribute's name is one GEXF reserves, so a GEXF import would give it another 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. */
+  /**
+   * An attribute type that this GEXF version does not have (GEXF 1.2 has no date, dateTime or typed lists) is
+   * written as the nearest type it has.
+   */
   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. */
+  /**
+   * A node id that reads back as a different type: a number that is not an integer comes back as text, and text that
+   * looks like an integer ("42") comes back as a number, unless you read the file with `ids: "string"` or `ids:
+   * "keep"`.
+   */
   ID_TEXT_TYPE: LOSS.ID_TEXT_TYPE,
   /** A numeric edge id column: GEXF edge ids read back as strings. */
   EDGE_ID_TEXT: "W_GEXF_EDGE_ID_TEXT",
-  /** A viz role column (position, color, size, thickness) that is not f32; the importer reads viz values as f32. */
+  /**
+   * A visual attribute (position, color, size, thickness) is stored at more precision than GEXF keeps; it reads back
+   * as a 32-bit float.
+   */
   VIZ_DTYPE: "W_GEXF_VIZ_DTYPE",
-  /** A plain `weight` edge column reads back as THE weight (the importer's weightFrom default). */
+  /**
+   * An attribute named `weight` without the weight role reads back as the edge weight, because GEXF reads weights
+   * from `weight` by default.
+   */
   WEIGHT_KEY_CLASH: LOSS.WEIGHT_KEY_CLASH,
-  /** A dict column without declared options gains one from its dictionary on re-import. */
+  /**
+   * A text attribute stored as a dictionary, without a declared list of allowed values, reads back with its distinct
+   * values as that list.
+   */
   OPTIONS_GAINED: LOSS.OPTIONS_GAINED,
-  /** A string cell holding a character XML 1.0 forbids; export() throws E_COLUMN_TYPE. */
+  /** A text value holds a character XML 1.0 forbids (most control characters); the save fails with E_COLUMN_TYPE. */
   XML_ILLEGAL_CHAR: LOSS.XML_ILLEGAL_CHAR
 });
 const DTYPES_KEPT = ["f32", "f64", "i32", "bool", "dict", "string"];
@@ -2284,7 +2656,8 @@ function planExport(snapshot, options) {
       temporalText: true,
       positionDtype: "f32",
       roles: MAPPED_ROLES,
-      roleNames: ROLE_NAMES
+      // GEXF 1.2 has no edge kind: the kind column is dropped (W_GEXF_KIND_DROPPED), not renamed
+      roleNames: version === "1.2" ? ROLE_NAMES_1_2 : ROLE_NAMES
     })
   ];
   const note = (code, message, column = null, count = null) => {
@@ -2301,7 +2674,7 @@ function planExport(snapshot, options) {
   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`,
+      `${typeChanges} node id${plural(typeChanges)} ${agree(typeChanges, "changes", "change")} type when read back under ids: "canonical" (string ids that are integer text, non-integer numbers); the file's idtype is not honored by the importer`,
       null,
       typeChanges
     );
@@ -2461,6 +2834,9 @@ const ROLE_NAMES = Object.freeze({
   parent: NODE_COLUMNS.parent,
   parents: NODE_COLUMNS.parents
 });
+const ROLE_NAMES_1_2 = Object.freeze(
+  Object.fromEntries(Object.entries(ROLE_NAMES).filter(([role]) => role !== "kind"))
+);
 function collectRoles(table, domain, note) {
   const companions = /* @__PURE__ */ new Map();
   const roles = {
@@ -2792,7 +3168,7 @@ function collectAttributes(snapshot, domain, roles, tables, version, note) {
     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`,
+        `edge column "${name}" is written as an attribute titled "${title}", which the importer reads as the edge weight (weightFrom); it reads back as the weight, not as a column`,
         name,
         column.length - column.nullCount
       );
@@ -2929,7 +3305,7 @@ function declaredTexts(column, domain, typed, version, note) {
     if (count > 0) {
       note(
         GEXF_LOSS.LIST_SEPARATOR,
-        `${domain} column "${name}": ${count} row(s) hold an item containing "|", the 1.2 list separator`,
+        `${domain} column "${name}": ${count} row${plural(count)} ${agree(count, "holds", "hold")} an item containing "|", the 1.2 list separator`,
         name,
         count
       );
@@ -3426,6 +3802,7 @@ function graphExtraText(snapshot, key) {
 }
 const gexfExporter = Object.freeze({
   format: GEXF_FORMAT,
+  options: Object.freeze(["version"]),
   capabilities: CAPABILITIES_1_3,
   /**
    * Pre-flight: what export() would lose.
@@ -3457,38 +3834,71 @@ const gexfExporter = Object.freeze({
 });
 const GEXF_1_2_CAPABILITIES = CAPABILITIES_1_2;
 const GEXF_ISSUE = Object.freeze({
-  /** The XML is not well-formed (fatal). */
+  ...INPUT_ISSUE,
+  ...ELEMENT_ISSUE,
+  /**
+   * A value that does not parse as the type its attribute declares ("x" in an integer attribute). The value is
+   * left unset; the node or edge is kept.
+   */
+  COLUMN_TYPE: COLUMN_TYPE_CODE,
+  /** The XML is not well-formed. The import stops. */
   XML_SYNTAX: XML_SYNTAX_CODE,
-  /** The input holds invalid UTF-8 (fatal). */
+  /** The input is not valid UTF-8. The import stops. */
   INVALID_UTF8: INVALID_UTF8_CODE,
-  /** Invalid bytes in the encoding a BOM, a declaration or the encoding option chose (fatal). */
+  /**
+   * Some bytes are not valid in the encoding that was chosen (by a byte order mark, the file's declaration or the
+   * `encoding` option). The import stops.
+   */
   INVALID_ENCODING: INVALID_ENCODING_CODE,
   /** Bytes that are not UTF-8 and declare no encoding were read as windows-1252. */
   ENCODING_FALLBACK: ENCODING_FALLBACK_CODE,
   /** A declared encoding the platform cannot decode was ignored. */
   UNKNOWN_ENCODING: UNKNOWN_ENCODING_CODE,
-  /** The root element is not `<gexf>` (fatal). */
+  /** A declared encoding the byte order mark contradicts (the mark wins). */
+  ENCODING_CONFLICT: ENCODING_CONFLICT_CODE,
+  /** The input holds no XML at all: it is empty, whitespace or a byte order mark only. The import stops. */
+  EMPTY_INPUT: EMPTY_INPUT_CODE,
+  /** The root element is not `<gexf>`. The import stops. */
   NOT_GEXF: NOT_GEXF_CODE,
-  /** The document has no `<graph>` (fatal). */
+  /** The document has no `<graph>`. The import stops. */
   NO_GRAPH: NO_GRAPH_CODE,
+  /**
+   * The file holds more than one `<graph>` element; their nodes and edges are merged into one graph.
+   * `importAllGraphs()` reads every one.
+   */
+  MULTIPLE_GRAPHS: MULTIPLE_GRAPHS_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 endpoint that names no declared node (addMissingNodes false, the GEXF default). */
+  UNKNOWN_NODE: "E_UNKNOWN_NODE",
   /** An edge `type` outside directed / undirected / mutual. */
   EDGE_TYPE: EDGE_TYPE_CODE,
-  /** A `pid` / `<parent for>` naming an unknown node. */
+  /** A `pid` / `<parent for>` naming an unknown node, a `<parent>` without for, or the children of a skipped node. */
   UNKNOWN_PARENT: UNKNOWN_PARENT_CODE,
+  /** A `pid` / nested containment that would close a parent cycle; that link is dropped. */
+  PARENT_CYCLE: PARENT_CYCLE_CODE,
+  /** An inverted interval (start after end) of an element, a spell or a value; it is not kept. */
+  BAD_VALUE: BAD_VALUE_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). */
+  /**
+   * A node or edge count the file announces is too large to reserve room for; it is ignored and the elements are
+   * read as they come.
+   */
   COUNT_HINT: COUNT_HINT_CODE,
+  /**
+   * A `count` attribute disagrees with the number of nodes or edges actually in its section. The elements are read
+   * as they are.
+   */
+  COUNT_MISMATCH: COUNT_MISMATCH_CODE,
   /** A node id declared twice. */
   DUPLICATE_NODE: DUPLICATE_NODE_CODE,
   /** An edge id declared twice (the second edge is skipped). */
@@ -3503,9 +3913,15 @@ const GEXF_ISSUE = Object.freeze({
   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). */
+  /**
+   * An attribute was renamed `<name>#<suffix>` because another attribute already has its name, for example
+   * two attributes declared with the same name.
+   */
   COLUMN_RENAMED: COLUMN_RENAMED_CODE,
-  /** A column declared without its role because the table already holds it. */
+  /**
+   * You read into a graph builder that already has an id, label or position attribute, so this file's one is kept as
+   * a plain attribute.
+   */
   ROLE_TAKEN: ROLE_TAKEN_CODE,
   /** An `<attvalue for>` naming an undeclared attribute. */
   UNKNOWN_ATTRIBUTE: UNKNOWN_ATTRIBUTE_CODE,
@@ -3513,13 +3929,13 @@ const GEXF_ISSUE = Object.freeze({
   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. */
+  /** An integer beyond 2^53 was stored as the nearest 64-bit float; pass `long: "string"` to keep every digit. */
   PRECISION: PRECISION_CODE,
-  /** Two id texts merged into one number under ids "number". */
+  /** Two different id texts became the same number because `ids` is "number", so their nodes were merged. */
   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 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,
@@ -3529,19 +3945,35 @@ const GEXF_ISSUE = Object.freeze({
   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. */
+  /** Both `timestamp` and `start` / `end` on one element or value. */
+  TIMESTAMP_CONFLICT: TIMESTAMP_CONFLICT_CODE,
+  /** A value outside the declared `<options>` (kept). */
+  VALUE_OUTSIDE_OPTIONS: VALUE_OUTSIDE_OPTIONS_CODE,
+  /** An element GEXF does not define at that place was skipped. */
   UNKNOWN_ELEMENT: UNKNOWN_ELEMENT_CODE,
+  /** An XML attribute GEXF does not define on that element was ignored. */
+  UNKNOWN_XML_ATTRIBUTE: UNKNOWN_XML_ATTRIBUTE_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. */
+  /** You set an option this format does not use; it had no effect. The message names the option. */
   OPTION_IGNORED: OPTION_IGNORED_CODE,
-  /** A builder-policy option the sink does not honour. */
+  /**
+   * You read into your own graph builder, which was created with a different `addMissingNodes`, `duplicateEdges`,
+   * `selfLoops` or `weightDtype` than the option you passed; the builder's setting applies.
+   */
   SINK_OPTION: SINK_OPTION_CODE,
-  /** The sink refused the file's direction. */
+  /**
+   * You read into a graph builder whose direction is already set, or which already holds edges, so the file is read
+   * with the builder's direction instead of its own.
+   */
   DIRECTION_REFUSED: DIRECTION_REFUSED_CODE,
-  /** Edges forced to the policy's direction. */
+  /** Edges of the other direction were read with the direction `onMixedDirection` chose. */
   DIRECTION_FORCED: DIRECTION_FORCED_CODE,
-  /** A mixed file under onMixedDirection "error" (fatal). */
+  /**
+   * The graph has both directed and undirected edges and `onMixedDirection` is "error". An import stops; a save to a
+   * format that holds one direction per file fails with E_DIRECTED. Pass "directed" or "undirected" to read or write
+   * it anyway.
+   */
   MIXED_DIRECTION: MIXED_DIRECTION_CODE
 });
 export {