@graphty/graph-io 0.3.24 → 0.3.26

package/dist/src/formats/graphml/importer.js

@@ -19,19 +19,39 @@
  */
 import { GraphFormatError, INVALID_INDEX, MAX_COUNT, } from "@graphty/graph-format";
 import { declareAttribute, declareResolved, losesPrecision, parseDeclaredValue, PRECISION_CODE, takenIn, uniqueColumnName, } from "../../common/attributes.js";
+import { overflowsToInfinity } from "../../common/declared-types.js";
 import { DirectionResolver } from "../../common/direction.js";
 import { IdCoercer } from "../../common/ids.js";
 import { textChunks, throwIfAborted } from "../../common/input.js";
 import { reportSinkOptions, reportUnusedOptions, resolveImportOptions, } from "../../common/options.js";
+import { agree, plural } from "../../common/plural.js";
 import { ImportReportBuilder } from "../../common/report.js";
 import { isWeightField, parseWeightText } from "../../common/weights.js";
-import { isWhitespace, localName, tokenizeXml, xmlDeclaredEncoding, XmlSyntaxError, } from "../../common/xml.js";
+import { isWhitespace, localName, sniffXmlText, tokenizeXml, xmlDeclaredEncoding, XmlEmptyInputError, XmlSyntaxError, } from "../../common/xml.js";
 import { EDGE_ID_COLUMN, EXTENSIONS, FORMAT, GRAPHML_ISSUE, GRAPHML_LOSS, GRAPHML_NAMESPACE, HYPEREDGE_HUB_COLUMN, LABEL_COLUMN, META_KEY, MIME_TYPES, ORIGINAL_ID_ATTRIBUTE, ORIGINAL_ID_COLUMN, PARENT_COLUMN, RESERVED_EDGE_NAMES, RESERVED_NODE_NAMES, SOURCE_PORT_COLUMN, TARGET_PORT_COLUMN, XSI_NAMESPACE, } from "./constants.js";
 import { XmlTreeBuilder } from "./tree.js";
 import { graphicsDecl, graphicsValues } from "./yfiles.js";
-/** The XML attributes the importer reads on `<graph>`, `<node>` and `<edge>`; any other is reported. */
+/** The XML attributes the importer reads on each element; any other is reported (once per element and name). */
 const GRAPH_ATTRIBUTES = new Set(["id", "edgedefault", "parse.nodes", "parse.edges"]);
 const NODE_ATTRIBUTES = new Set(["id"]);
+const KEY_ATTRIBUTES = new Set([
+    "id",
+    "for",
+    "attr.name",
+    "attr.type",
+    "name",
+    "type",
+    "yfiles.type",
+]);
+const DATA_ATTRIBUTES = new Set(["key"]);
+const HYPEREDGE_ATTRIBUTES = new Set(["id"]);
+const ENDPOINT_ATTRIBUTES = new Set(["node", "type"]);
+const PORT_ATTRIBUTES = new Set(["name"]);
+const NO_ATTRIBUTES = new Set();
+/** Attributes the GraphML schema defines that the importer does not keep: reported as not kept, not as foreign. */
+const SCHEMA_ATTRIBUTES = new Set(["id", "port", "parse.order", "parse.nodeids", "parse.edgeids"]);
+/** Distinct unknown attribute names reported one by one per element kind; the rest are counted in one issue. */
+const MAX_UNKNOWN_ATTRIBUTE_NAMES = 16;
 const EDGE_ATTRIBUTES = new Set([
     "id",
     "source",
@@ -78,6 +98,10 @@ var Ctx;
     Ctx[Ctx["Data"] = 8] = "Data";
     Ctx[Ctx["Capture"] = 9] = "Capture";
     Ctx[Ctx["Skip"] = 10] = "Skip";
+    /** A `<port>` (ports nest; their names are collected for the edge port check). */
+    Ctx[Ctx["Port"] = 11] = "Port";
+    /** Inside a `<graph>` held by an `<edge>`: dropped, its nodes and edges counted as skipped. */
+    Ctx[Ctx["Dropped"] = 12] = "Dropped";
 })(Ctx || (Ctx = {}));
 /**
  * A growable bit set over node indices, marking the indices declared by a `<node>` element so a
@@ -133,6 +157,10 @@ class GraphmlReader {
         this.nodes = [];
         this.declared = new IndexFlags();
         this.edgeIds = new Set();
+        /** The keys `<data>` referenced before any `<key>` declared them (E_GRAPHML_UNKNOWN_KEY). */
+        this.unknownKeyIds = new Set();
+        /** The ids of the edges waiting in {@link deferred}. */
+        this.deferredEdgeIds = new Set();
         this.elementsSinceCheck = 0;
         /** Mangled id text -> the original id restored from `graphty:originalId`, for edge endpoints. */
         this.restored = new Map();
@@ -150,6 +178,9 @@ class GraphmlReader {
         };
         this.descTarget = null;
         this.descText = "";
+        this.descLine = 0;
+        /** The keys of the graph-level `<data>` read so far, for the duplicate check. */
+        this.graphKeys = { keys: null };
         this.description = null;
         this.graphSeen = false;
         this.graphId = null;
@@ -165,6 +196,24 @@ class GraphmlReader {
         this.targetPortHandle = INVALID_INDEX;
         this.parentHandle = INVALID_INDEX;
         this.hubHandle = INVALID_INDEX;
+        /** The hub nodes of star-expanded hyperedges, so a later `<node>` of the same id is reported as a clash. */
+        this.hubs = new IndexFlags();
+        /** Edges and hyperedges whose endpoints were not declared yet under addMissingNodes: false, added at the end. */
+        this.deferred = [];
+        /** The ids of the `<graph>` elements read so far, for the endpoint-names-a-graph check. */
+        this.graphIds = new Set();
+        /** How many top-level `<graph>` elements were opened. */
+        this.topGraphs = 0;
+        /** The namespace of the `<graphml>` root (children in it are GraphML even when it is not GraphML's). */
+        this.rootNs = GRAPHML_NAMESPACE;
+        /** Whether a graph-level `<desc>` was kept, so a second one is reported. */
+        this.graphDescSeen = false;
+        /** Unknown attribute names reported per element kind, and how many more were not listed. */
+        this.unknownNames = new Map();
+        this.unknownOverflow = new Map();
+        /** The port names each node declares, and the ports edges reference, checked at the end. */
+        this.ports = new Map();
+        this.portRefs = [];
         this.sink = sink;
         this.report = report;
         this.options = options;
@@ -178,8 +227,9 @@ class GraphmlReader {
      * @param name - the element name
      * @param attrs - its attributes
      * @param line - the line
+     * @param ns - the element's namespace (null: an undeclared prefix)
      */
-    start(name, attrs, line) {
+    start(name, attrs, line, ns = "") {
         const parent = this.ctx.length === 0 ? null : this.ctx[this.ctx.length - 1];
         switch (parent) {
             case Ctx.Capture:
@@ -193,10 +243,18 @@ class GraphmlReader {
             case Ctx.Default:
                 this.captureStart(name, attrs);
                 return;
+            case Ctx.Dropped:
+                this.dropStart(localName(name));
+                return;
             default:
                 break;
         }
         const local = localName(name);
+        if (parent !== null && ns !== GRAPHML_NAMESPACE && ns !== "" && ns !== this.rootNs) {
+            // a vendor element whose local name happens to be node, edge or data is not GraphML
+            this.unknownElement(name, line);
+            return;
+        }
         switch (parent) {
             case null:
                 if (local !== "graphml") {
@@ -204,6 +262,13 @@ class GraphmlReader {
                         line,
                     });
                 }
+                if (ns !== GRAPHML_NAMESPACE && ns !== "") {
+                    this.report.warning("validation-error", GRAPHML_ISSUE.NAMESPACE, ns === null
+                        ? `the root <${name}> uses an undeclared prefix; read as GraphML`
+                        : `the root <${name}> is in the namespace ${JSON.stringify(ns)}, not ${GRAPHML_NAMESPACE}; read as GraphML`, { line, element: ns });
+                }
+                this.rootNs = ns;
+                this.reportUnreadAttributes("graphml", attrs, NO_ATTRIBUTES, line);
                 this.readRoot(attrs);
                 this.ctx.push(Ctx.Graphml);
                 return;
@@ -211,7 +276,7 @@ class GraphmlReader {
                 this.startInGraphml(name, local, attrs, line);
                 return;
             case Ctx.Key:
-                this.startInKey(name, local, line);
+                this.startInKey(name, local, attrs, line);
                 return;
             case Ctx.Graph:
                 this.startInGraph(name, local, attrs, line);
@@ -225,6 +290,9 @@ class GraphmlReader {
             case Ctx.Hyperedge:
                 this.startInHyperedge(name, local, attrs, line);
                 return;
+            case Ctx.Port:
+                this.startInPort(name, local, attrs, line);
+                return;
             default:
                 this.unknownElement(name, line);
         }
@@ -242,6 +310,8 @@ class GraphmlReader {
                 return;
             case Ctx.Skip:
             case Ctx.Graphml:
+            case Ctx.Port:
+            case Ctx.Dropped:
             case undefined:
                 return;
             case Ctx.Desc:
@@ -266,7 +336,7 @@ class GraphmlReader {
                 this.finishHyperedge();
                 return;
             case Ctx.Graph:
-                this.graphs.pop();
+                this.finishGraph();
                 return;
             default: {
                 const value = ctx;
@@ -298,6 +368,7 @@ class GraphmlReader {
                 this.descText += text;
                 return;
             case Ctx.Skip:
+            case Ctx.Dropped:
                 return;
             default:
                 if (!isWhitespace(text)) {
@@ -312,6 +383,20 @@ class GraphmlReader {
         if (!this.graphSeen) {
             this.report.fail(GRAPHML_ISSUE.NO_GRAPH, "the document has no <graph> element");
         }
+        // GraphML allows an edge before the nodes it joins: what waited for them is added now
+        for (const edge of this.deferred) {
+            if ("endpoints" in edge) {
+                this.expandHyperedge(edge);
+            }
+            else {
+                this.addEdge(edge);
+            }
+        }
+        this.deferred.length = 0;
+        this.checkPorts();
+        for (const [kind, more] of this.unknownOverflow) {
+            this.report.warning("unsupported", GRAPHML_ISSUE.UNKNOWN_XML_ATTRIBUTE, `${more} more distinct attribute names on <${kind}> are not GraphML attributes and are not kept (not listed one by one)`, { element: kind });
+        }
         const meta = { graphId: this.graphId, edgedefault: this.edgedefault, namespaces: this.namespaces };
         this.sink.setMeta({
             sourceFormat: FORMAT,
@@ -350,7 +435,7 @@ class GraphmlReader {
     startInGraphml(name, local, attrs, line) {
         switch (local) {
             case "desc":
-                this.beginDesc("graph");
+                this.beginDesc("graph", line);
                 return;
             case "key":
                 this.beginKey(attrs, line);
@@ -369,14 +454,20 @@ class GraphmlReader {
      * A child of `<key>`.
      * @param name - the element name
      * @param local - its local name
+     * @param attrs - its attributes
      * @param line - the line
      */
-    startInKey(name, local, line) {
+    startInKey(name, local, attrs, line) {
         switch (local) {
             case "desc":
-                this.beginDesc("key");
+                this.beginDesc("key", line);
                 return;
             case "default":
+                this.reportUnreadAttributes("default", attrs, NO_ATTRIBUTES, line);
+                if (this.pendingKey !== null &&
+                    (this.pendingKey.defaultText !== null || this.pendingKey.defaultTree !== undefined)) {
+                    this.report.warning("validation-error", GRAPHML_ISSUE.DUPLICATE_ATTRIBUTE, `key "${this.pendingKey.id ?? ""}" has a second <default>; the later one is kept`, { line, element: this.pendingKey.id });
+                }
                 this.content.key = null;
                 this.content.pendingKey = this.pendingKey;
                 this.content.text = "";
@@ -396,21 +487,25 @@ class GraphmlReader {
      * @param line - the line
      */
     startInGraph(name, local, attrs, line) {
+        const first = this.graphs.length === 1 && this.topGraphs === 1;
         switch (local) {
             case "desc":
-                if (this.graphs.length === 1) {
-                    this.beginDesc("graph");
+                if (first) {
+                    this.beginDesc("graph", line);
                 }
                 else {
+                    this.report.warnOnce("unsupported", GRAPHML_ISSUE.DESC_DROPPED, `the <desc> of a ${this.graphs.length === 1 ? "second top-level" : "nested"} <graph> is not kept`, { line }, `${GRAPHML_ISSUE.DESC_DROPPED}:graph`);
                     this.ctx.push(Ctx.Skip);
                 }
                 return;
             case "data":
-                if (this.graphs.length === 1) {
+                if (first) {
                     this.beginData(attrs, line, "graph");
                 }
                 else {
-                    this.report.warnOnce("unsupported", GRAPHML_ISSUE.NESTED_GRAPH_DATA, "data of a nested <graph> cannot be kept; only the top-level graph has attributes", { line });
+                    this.report.warnOnce("unsupported", GRAPHML_ISSUE.NESTED_GRAPH_DATA, this.graphs.length === 1
+                        ? "data of a second top-level <graph> cannot be kept; the graphs are merged and only the first one's attributes are kept"
+                        : "data of a nested <graph> cannot be kept; only the top-level graph has attributes", { line });
                     this.ctx.push(Ctx.Skip);
                 }
                 return;
@@ -451,11 +546,14 @@ class GraphmlReader {
                 return;
             case "port":
                 this.report.warnOnce("unsupported", GRAPHML_ISSUE.PORT_DECLARATION, "<port> declarations are not kept; sourceport / targetport edge attributes are", { line });
-                this.ctx.push(Ctx.Skip);
+                this.beginPort(attrs, line);
                 return;
             case "graph": {
                 const node = this.nodes[this.nodes.length - 1];
                 this.materializeNode(node);
+                if (node.index === INVALID_INDEX) {
+                    this.report.error("missing-value", GRAPHML_ISSUE.UNKNOWN_PARENT, "the nodes of this nested <graph> lose their parent: the node holding it was skipped; they are read as top-level nodes", { line });
+                }
                 this.beginGraph(attrs, line, node.index);
                 return;
             }
@@ -485,10 +583,84 @@ class GraphmlReader {
             case "data":
                 this.beginData(attrs, line, "edge");
                 return;
+            case "graph":
+                this.report.warnOnce("unsupported", GRAPHML_ISSUE.EDGE_GRAPH_DROPPED, "a <graph> inside an <edge> is not supported; it is dropped with the nodes and edges it holds (counted as skipped)", { line, element: attrs.get("id") ?? null });
+                this.ctx.push(Ctx.Dropped);
+                return;
+            default:
+                this.unknownElement(name, line);
+        }
+    }
+    /**
+     * An element inside a dropped `<graph>` (one held by an edge): counted as skipped.
+     * @param local - its local name
+     */
+    dropStart(local) {
+        if (local === "node") {
+            this.report.counts.skippedNodes++;
+        }
+        else if (local === "edge" || local === "hyperedge") {
+            this.report.counts.skippedEdges++;
+        }
+        this.ctx.push(local === "data" || local === "desc" ? Ctx.Skip : Ctx.Dropped);
+    }
+    /**
+     * Open a `<port>`: its name is kept for the edge port check, its content is skipped.
+     * @param attrs - its attributes
+     * @param line - the line
+     */
+    beginPort(attrs, line) {
+        this.reportUnreadAttributes("port", attrs, PORT_ATTRIBUTES, line);
+        const node = this.nodes[this.nodes.length - 1];
+        const name = attrs.get("name");
+        if (node.id !== null && name !== undefined) {
+            const id = node.restoredId ?? node.id;
+            let names = this.ports.get(id);
+            if (names === undefined) {
+                names = new Set();
+                this.ports.set(id, names);
+            }
+            names.add(name);
+        }
+        this.ctx.push(Ctx.Port);
+    }
+    /**
+     * A child of `<port>`: a nested port declares a name too; data and desc are skipped.
+     * @param name - the element name
+     * @param local - its local name
+     * @param attrs - its attributes
+     * @param line - the line
+     */
+    startInPort(name, local, attrs, line) {
+        switch (local) {
+            case "port":
+                this.beginPort(attrs, line);
+                return;
+            case "data":
+            case "desc":
+                this.ctx.push(Ctx.Skip);
+                return;
             default:
                 this.unknownElement(name, line);
         }
     }
+    /**
+     * Report the `sourceport` / `targetport` values that name a port their node never declares
+     * (once, with the count), now that every node has been read.
+     */
+    checkPorts() {
+        let dangling = 0;
+        let first = null;
+        for (const [node, port] of this.portRefs) {
+            if (this.ports.get(node)?.has(port) !== true) {
+                dangling++;
+                first ?? (first = `${String(node)}:${port}`);
+            }
+        }
+        if (dangling > 0) {
+            this.report.warning("missing-value", GRAPHML_ISSUE.DANGLING_REFERENCE, `${dangling} edge port reference${plural(dangling)} ${agree(dangling, "names", "name")} a port their node does not declare (first: ${first ?? ""}); the values are kept`, { element: first });
+        }
+    }
     /**
      * A child of `<hyperedge>` (under the star / clique policies).
      * @param name - the element name
@@ -499,6 +671,7 @@ class GraphmlReader {
     startInHyperedge(name, local, attrs, line) {
         switch (local) {
             case "endpoint":
+                this.reportUnreadAttributes("endpoint", attrs, ENDPOINT_ATTRIBUTES, line);
                 this.readEndpoint(attrs, line);
                 this.ctx.push(Ctx.Skip);
                 return;
@@ -507,6 +680,7 @@ class GraphmlReader {
                 this.ctx.push(Ctx.Skip);
                 return;
             case "desc":
+                this.report.warnOnce("unsupported", GRAPHML_ISSUE.DESC_DROPPED, "the <desc> of a hyperedge is not kept by the star / clique expansions", { line }, `${GRAPHML_ISSUE.DESC_DROPPED}:hyperedge`);
                 this.ctx.push(Ctx.Skip);
                 return;
             default:
@@ -519,7 +693,7 @@ class GraphmlReader {
      * @param line - the line
      */
     unknownElement(name, line) {
-        this.report.warnOnce("unsupported", GRAPHML_ISSUE.UNKNOWN_ELEMENT, `element <${name}> is not GraphML and was skipped`, {
+        this.report.warnOnce("unsupported", GRAPHML_ISSUE.UNKNOWN_ELEMENT, unknownElementMessage(name), {
             line,
             element: name,
         });
@@ -528,10 +702,12 @@ class GraphmlReader {
     /**
      * Open a `<desc>`.
      * @param target - what the text describes
+     * @param line - the line
      */
-    beginDesc(target) {
+    beginDesc(target, line) {
         this.descTarget = target;
         this.descText = "";
+        this.descLine = line;
         this.ctx.push(Ctx.Desc);
     }
     /** Close a `<desc>`. */
@@ -541,6 +717,11 @@ class GraphmlReader {
             this.pendingKey.desc = text;
         }
         else if (this.descTarget === "graph" && text.length > 0) {
+            if (this.graphDescSeen) {
+                // a <graphml> and a <graph> description: the graph has one description field
+                this.report.warning("unsupported", GRAPHML_ISSUE.DESC_DROPPED, "a second graph-level <desc> replaces the first; the earlier text is not kept", { line: this.descLine });
+            }
+            this.graphDescSeen = true;
             this.description = text;
         }
         this.descTarget = null;
@@ -549,23 +730,51 @@ class GraphmlReader {
     // ------------------------------------------------------------------ graphs
     /**
      * Report, once per element kind and attribute name, an XML attribute the importer does not read:
-     * a GraphML `parse.*` hint as ignored, anything else as unknown. Namespace declarations and
-     * `xml:` / `xsi:` attributes are not data and pass silently.
+     * a GraphML `parse.*` hint as ignored, anything else as not kept. Namespace declarations and
+     * `xml:` / `xsi:` attributes are not data and pass silently. Beyond MAX_UNKNOWN_ATTRIBUTE_NAMES
+     * distinct names per element kind the rest are counted and reported once at the end, so a file
+     * with thousands of vendor attributes does not grow the report without bound.
      * @param kind - the element name
      * @param attrs - the element's attributes
      * @param known - the attributes the importer reads on that element
      * @param line - the line
      */
     reportUnreadAttributes(kind, attrs, known, line) {
+        if (attrs.size === 0) {
+            return;
+        }
         for (const name of attrs.keys()) {
             if (known.has(name) || name === "xmlns" || /^(xmlns|xml|xsi):/.test(name)) {
                 continue;
             }
             const hint = name.startsWith("parse.");
             const code = hint ? GRAPHML_ISSUE.PARSE_HINT_IGNORED : GRAPHML_ISSUE.UNKNOWN_XML_ATTRIBUTE;
-            this.report.warnOnce("unsupported", code, hint
-                ? `the <${kind}> parse hint ${name} is ignored`
-                : `the <${kind}> attribute ${name} is not a GraphML attribute; it is not kept`, { line, element: name }, `${code}:${kind}:${name}`);
+            let names = this.unknownNames.get(kind);
+            if (names === undefined) {
+                names = new Set();
+                this.unknownNames.set(kind, names);
+            }
+            if (names.has(name)) {
+                continue;
+            }
+            if (names.size >= MAX_UNKNOWN_ATTRIBUTE_NAMES && !hint) {
+                this.unknownOverflow.set(kind, (this.unknownOverflow.get(kind) ?? 0) + 1);
+            }
+            names.add(name);
+            if (names.size > MAX_UNKNOWN_ATTRIBUTE_NAMES && !hint) {
+                continue;
+            }
+            let message;
+            if (hint) {
+                message = `the <${kind}> parse hint ${name} is ignored`;
+            }
+            else if (SCHEMA_ATTRIBUTES.has(name)) {
+                message = `the <${kind}> attribute ${name} is not kept`;
+            }
+            else {
+                message = `the <${kind}> attribute ${name} is not a GraphML attribute; it is not kept`;
+            }
+            this.report.warning("unsupported", code, message, { line, element: name });
         }
     }
     /**
@@ -578,6 +787,13 @@ class GraphmlReader {
     beginGraph(attrs, line, parent) {
         this.reportUnreadAttributes("graph", attrs, GRAPH_ATTRIBUTES, line);
         const top = this.graphs.length === 0;
+        if (top) {
+            this.topGraphs++;
+        }
+        const graphId = attrs.get("id");
+        if (graphId !== undefined && graphId.length > 0) {
+            this.graphIds.add(graphId);
+        }
         const edgedefault = attrs.get("edgedefault");
         let directed;
         if (edgedefault === "directed" || edgedefault === "undirected") {
@@ -585,14 +801,24 @@ class GraphmlReader {
         }
         else if (edgedefault === undefined) {
             directed = top ? this.options.defaultDirected : this.graphs[this.graphs.length - 1].directed;
-            this.report.warning("validation-error", GRAPHML_ISSUE.EDGEDEFAULT_MISSING, `<graph> has no edgedefault; read as ${directed ? "directed" : "undirected"}`, { line });
+            // once per kind: a file of thousands of nested graphs without edgedefault is one finding
+            const direction = directed ? "directed" : "undirected";
+            this.report.warnOnce("validation-error", GRAPHML_ISSUE.EDGEDEFAULT_MISSING, top
+                ? `<graph> has no edgedefault; read as ${direction}`
+                : `a nested <graph> has no edgedefault; it takes its container's (${direction})`, { line }, `${GRAPHML_ISSUE.EDGEDEFAULT_MISSING}:${top ? "top" : "nested"}`);
         }
         else {
             directed = top ? this.options.defaultDirected : this.graphs[this.graphs.length - 1].directed;
             this.report.error("validation-error", GRAPHML_ISSUE.INVALID_EDGEDEFAULT, `edgedefault "${edgedefault}" is neither directed nor undirected; read as ${directed ? "directed" : "undirected"}`, { line });
         }
+        let hints = null;
         if (top && this.graphSeen) {
             this.report.warnOnce("unsupported", GRAPHML_ISSUE.MULTIPLE_GRAPHS, "the document holds more than one top-level <graph>; their nodes and edges are merged into one graph", { line, element: attrs.get("id") ?? null });
+            for (const name of ["parse.nodes", "parse.edges"]) {
+                if (attrs.has(name)) {
+                    this.report.warnOnce("unsupported", GRAPHML_ISSUE.PARSE_HINT_IGNORED, `the ${name} hint of a second top-level <graph> is ignored`, { line, element: name }, `${GRAPHML_ISSUE.PARSE_HINT_IGNORED}:second:${name}`);
+                }
+            }
         }
         else if (top) {
             this.graphSeen = true;
@@ -601,6 +827,7 @@ class GraphmlReader {
             this.direction.setHeader(directed, { line });
             const nodes = this.hint(attrs.get("parse.nodes"), "parse.nodes", line);
             const edges = this.hint(attrs.get("parse.edges"), "parse.edges", line);
+            hints = nodes === null && edges === null ? null : { nodes, edges };
             if (nodes !== null || edges !== null) {
                 try {
                     this.sink.reserve(nodes ?? undefined, edges ?? undefined);
@@ -615,9 +842,24 @@ class GraphmlReader {
                 }
             }
         }
-        this.graphs.push({ directed, parent });
+        this.graphs.push({ directed, parent, hints, nodes: 0, edges: 0, line });
         this.ctx.push(Ctx.Graph);
     }
+    /** Close a `<graph>`: a top-level graph's count hints are checked against what it held. */
+    finishGraph() {
+        const graph = this.graphs.pop();
+        if (graph?.hints === null || graph === undefined) {
+            return;
+        }
+        for (const [name, hint, found] of [
+            ["parse.nodes", graph.hints.nodes, graph.nodes],
+            ["parse.edges", graph.hints.edges, graph.edges],
+        ]) {
+            if (hint !== null && hint !== found) {
+                this.report.warning("validation-error", GRAPHML_ISSUE.COUNT_MISMATCH, `<graph ${name}="${hint}"> but the graph holds ${found} ${name === "parse.nodes" ? "<node>" : "<edge>"} elements`, { line: graph.line, element: name });
+            }
+        }
+    }
     /**
      * A `parse.nodes` / `parse.edges` hint the sink can reserve; anything else is reported and ignored.
      * @param text - the attribute text, or undefined
@@ -643,7 +885,12 @@ class GraphmlReader {
      * @param line - the line
      */
     beginKey(attrs, line) {
+        // attr.list (a list extension of some writers) and yEd's yfiles.foldertype are reported here
+        this.reportUnreadAttributes("key", attrs, KEY_ATTRIBUTES, line);
         const id = attrs.get("id") ?? null;
+        if (id !== null && this.unknownKeyIds.delete(id)) {
+            this.report.warning("missing-value", GRAPHML_ISSUE.KEY_DECLARED_LATE, `key "${id}" is declared after data that uses it; those values were dropped (declare <key> before <graph>)`, { line, element: id });
+        }
         const forText = attrs.get("for") ?? "all";
         let domains;
         switch (forText) {
@@ -712,6 +959,8 @@ class GraphmlReader {
                 continue;
             }
             if (domain === "edge" && !yfiles && isWeightField(name, this.options.weightFrom)) {
+                // networkx writes one weight key per value type (long and double): every key of
+                // that name is the weight; two of them on one edge are reported in finishData
                 weight = true;
                 this.weightOrigin ?? (this.weightOrigin = { id: key.id, title: key.attrName, type: key.attrType });
                 continue;
@@ -877,8 +1126,12 @@ class GraphmlReader {
      * @param domain - the domain of the element holding it
      */
     beginData(attrs, line, domain) {
+        this.reportUnreadAttributes("data", attrs, DATA_ATTRIBUTES, line);
         const keyId = attrs.get("key");
         const { content } = this;
+        if (keyId !== undefined) {
+            this.checkDuplicateData(keyId, domain, line);
+        }
         content.key = null;
         content.pendingKey = null;
         content.domain = domain;
@@ -894,6 +1147,7 @@ class GraphmlReader {
             const entries = this.keys.get(keyId);
             const key = entries?.find((entry) => entry.domains.includes(domain)) ?? entries?.[0];
             if (key === undefined) {
+                this.unknownKeyIds.add(keyId);
                 this.report.error("validation-error", GRAPHML_ISSUE.UNKNOWN_KEY, `<data> references undeclared key "${keyId}"`, { line, element: keyId });
             }
             else if (!key.skipped && !key.domains.includes(domain)) {
@@ -905,6 +1159,32 @@ class GraphmlReader {
         }
         this.ctx.push(Ctx.Data);
     }
+    /**
+     * Report a second `<data>` of one key on one element; the later value is kept (it overwrites).
+     * @param keyId - the key
+     * @param domain - the domain of the element holding it
+     * @param line - the line
+     */
+    checkDuplicateData(keyId, domain, line) {
+        let holder = null;
+        if (domain === "node") {
+            holder = this.nodes.at(-1) ?? null;
+        }
+        else if (domain === "edge") {
+            holder = this.edge;
+        }
+        else {
+            holder = this.graphKeys;
+        }
+        if (holder === null) {
+            return;
+        }
+        holder.keys ?? (holder.keys = new Set());
+        if (holder.keys.has(keyId)) {
+            this.report.warning("validation-error", GRAPHML_ISSUE.DUPLICATE_ATTRIBUTE, `a second <data key="${keyId}"> on one ${domain}; the later value is kept`, { line, element: keyId });
+        }
+        holder.keys.add(keyId);
+    }
     /**
      * A child element inside `<data>` / `<default>`: the content becomes a tree.
      * @param name - the element name
@@ -959,9 +1239,13 @@ class GraphmlReader {
             case "node": {
                 const node = this.nodes[this.nodes.length - 1];
                 if (key.originalId) {
-                    if (typeof value === "string") {
-                        node.restoredId = value;
+                    if (typeof value !== "string" || node.index !== INVALID_INDEX) {
+                        this.report.warning("validation-error", GRAPHML_ISSUE.ORIGINAL_ID_IGNORED, typeof value === "string"
+                            ? `the ${ORIGINAL_ID_ATTRIBUTE} value comes after the node's nested <graph>, which added the node under its written id; it is not restored`
+                            : `the ${ORIGINAL_ID_ATTRIBUTE} value holds elements, not text; it is not restored`, where);
+                        return;
                     }
+                    node.restoredId = value;
                     return;
                 }
                 if (key.yfiles) {
@@ -988,8 +1272,13 @@ class GraphmlReader {
                         this.report.error("validation-error", GRAPHML_ISSUE.DATA_NESTED, "a weight value must be text", where);
                         return;
                     }
+                    if (edge.weightKey !== null && edge.weightKey !== key.id) {
+                        this.report.warning("validation-error", GRAPHML_ISSUE.DUPLICATE_ATTRIBUTE, `the edge has values of two weight keys ("${edge.weightKey}" and "${key.id}"); the later one is kept`, where);
+                    }
+                    edge.weightKey = key.id;
                     try {
-                        edge.weight = parseWeightText(value);
+                        edge.weight = parseWeightText(value, this.report);
+                        this.checkOverflow(value, edge.weight, key.name, where);
                     }
                     catch (err) {
                         this.skipEdge(edge);
@@ -1057,7 +1346,12 @@ class GraphmlReader {
      */
     graphics(domain, key, tree, where) {
         const out = [];
-        for (const [field, value] of graphicsValues(domain, tree)) {
+        const unmapped = [];
+        const values = graphicsValues(domain, tree, unmapped);
+        for (const field of unmapped) {
+            this.report.warnOnce("validation-error", GRAPHML_ISSUE.YFILES_VALUE, `a yFiles ${domain} ${field} that is not a number is not mapped to its yfiles column (the graphics tree is kept)`, where, `${GRAPHML_ISSUE.YFILES_VALUE}:${domain}:${field}`);
+        }
+        for (const [field, value] of values) {
             const id = `${domain}:${field}`;
             let handle = this.graphicsColumns.get(id);
             if (handle === undefined) {
@@ -1102,6 +1396,7 @@ class GraphmlReader {
             if (spec.precision && losesPrecision(spec, value)) {
                 this.report.warnOnce("precision", PRECISION_CODE, `long values of "${target.name}" beyond 2^53 are stored as the nearest double`, { line: where.line, element: target.name });
             }
+            this.checkOverflow(value, parsed, target.name, where);
             return parsed;
         }
         catch (err) {
@@ -1109,6 +1404,18 @@ class GraphmlReader {
             return undefined;
         }
     }
+    /**
+     * Report (once per column) a finite number text too large for a double, stored as Infinity.
+     * @param text - the value text
+     * @param value - the parsed value
+     * @param column - the column name
+     * @param where - the location
+     */
+    checkOverflow(text, value, column, where) {
+        if (typeof value === "number" && overflowsToInfinity(text)) {
+            this.report.warnOnce("precision", PRECISION_CODE, `values of "${column}" beyond the double range (${text.trim()}) are stored as Infinity`, { line: where.line, element: column }, `${PRECISION_CODE}:overflow:${column}`);
+        }
+    }
     // ------------------------------------------------------------------ nodes
     /**
      * Open a `<node>`; it is added to the sink when its data is complete (or a nested graph
@@ -1119,6 +1426,7 @@ class GraphmlReader {
     beginNode(attrs, line) {
         this.reportUnreadAttributes("node", attrs, NODE_ATTRIBUTES, line);
         const graph = this.graphs[this.graphs.length - 1];
+        graph.nodes++;
         const state = {
             id: null,
             idText: null,
@@ -1128,6 +1436,7 @@ class GraphmlReader {
             restoredId: null,
             failed: false,
             line,
+            keys: null,
         };
         const idText = attrs.get("id");
         if (idText === undefined || idText.length === 0) {
@@ -1167,7 +1476,10 @@ class GraphmlReader {
         try {
             const existing = this.sink.indexOf(id);
             const index = this.sink.addNode(id);
-            if (existing !== INVALID_INDEX && this.declared.has(index)) {
+            if (existing !== INVALID_INDEX && this.hubs.has(index)) {
+                this.report.warning("validation-error", GRAPHML_ISSUE.HUB_ID_CLASH, `node "${String(id)}" has the id of the hub a star-expanded hyperedge created earlier; the node is merged into the hub`, { line: node.line, element: String(id) });
+            }
+            else if (existing !== INVALID_INDEX && this.declared.has(index)) {
                 this.report.warning("validation-error", GRAPHML_ISSUE.DUPLICATE_NODE, `node "${String(id)}" is declared twice; the declarations are merged`, { line: node.line, element: String(id) });
             }
             else {
@@ -1234,10 +1546,15 @@ class GraphmlReader {
     beginEdge(attrs, line) {
         this.reportUnreadAttributes("edge", attrs, EDGE_ATTRIBUTES, line);
         const graph = this.graphs[this.graphs.length - 1];
+        graph.edges++;
+        const idText = attrs.get("id");
+        const sourceText = attrs.get("source");
+        const targetText = attrs.get("target");
         const edge = {
             source: null,
             target: null,
-            id: attrs.get("id") ?? null,
+            // an exporter that writes id="" for an edge without one: the same as no id
+            id: idText === undefined || idText.length === 0 ? null : idText,
             kind: graph.directed ? "directed" : "undirected",
             sourcePort: attrs.get("sourceport") ?? null,
             targetPort: attrs.get("targetport") ?? null,
@@ -1245,10 +1562,12 @@ class GraphmlReader {
             pending: [],
             failed: false,
             line,
+            keys: null,
+            weightKey: null,
+            sourceText: sourceText ?? null,
+            targetText: targetText ?? null,
         };
         const where = { line, element: edge.id };
-        const sourceText = attrs.get("source");
-        const targetText = attrs.get("target");
         if (sourceText === undefined || sourceText.length === 0) {
             this.skipEdge(edge);
             this.report.error("missing-value", GRAPHML_ISSUE.MISSING_ENDPOINT, "<edge> without a source", where);
@@ -1269,15 +1588,16 @@ class GraphmlReader {
         }
         const directedText = attrs.get("directed");
         if (directedText !== undefined) {
-            if (directedText === "true") {
+            // the schema types directed as xs:boolean: true, false, 1 or 0
+            if (directedText === "true" || directedText === "1") {
                 edge.kind = "directed";
             }
-            else if (directedText === "false") {
+            else if (directedText === "false" || directedText === "0") {
                 edge.kind = "undirected";
             }
             else {
                 this.skipEdge(edge);
-                this.report.error("validation-error", GRAPHML_ISSUE.INVALID_DIRECTED, `directed="${directedText}" is neither true nor false`, where);
+                this.report.error("validation-error", GRAPHML_ISSUE.INVALID_DIRECTED, `directed="${directedText}" is neither true nor false (nor 1 or 0)`, where);
             }
         }
         this.edge = edge;
@@ -1296,6 +1616,28 @@ class GraphmlReader {
             this.skipEdge(edge);
             return;
         }
+        if ((!this.options.addMissingNodes &&
+            (this.sink.indexOf(edge.source) === INVALID_INDEX ||
+                this.sink.indexOf(edge.target) === INVALID_INDEX)) ||
+            (edge.id !== null && this.deferredEdgeIds.has(edge.id))) {
+            // GraphML allows nodes and edges in any order: wait for the end of the document. An
+            // edge reusing a waiting edge's id waits behind it, so the first one keeps the id.
+            if (edge.id !== null) {
+                this.deferredEdgeIds.add(edge.id);
+            }
+            this.deferred.push(edge);
+            return;
+        }
+        this.addEdge(edge);
+    }
+    /**
+     * Push an edge through the direction resolver and write its values.
+     * @param edge - the edge, its endpoints known
+     */
+    addEdge(edge) {
+        if (edge.source === null || edge.target === null) {
+            return;
+        }
         const element = edge.id ?? `${String(edge.source)} -> ${String(edge.target)}`;
         const where = { line: edge.line, element };
         try {
@@ -1303,6 +1645,8 @@ class GraphmlReader {
                 this.requireNode(edge.source);
                 this.requireNode(edge.target);
             }
+            this.checkGraphEndpoint(edge.source, edge.sourceText, where);
+            this.checkGraphEndpoint(edge.target, edge.targetText, where);
             if (edge.id !== null && this.edgeIds.has(edge.id)) {
                 throw new GraphFormatError("E_DUPLICATE_EDGE_ID", `edge id "${edge.id}" is used twice`, {
                     id: edge.id,
@@ -1319,9 +1663,11 @@ class GraphmlReader {
             }
             if (edge.sourcePort !== null) {
                 this.sink.setEdgeValue(this.portColumn("source"), e, edge.sourcePort);
+                this.portRefs.push([edge.source, edge.sourcePort]);
             }
             if (edge.targetPort !== null) {
                 this.sink.setEdgeValue(this.portColumn("target"), e, edge.targetPort);
+                this.portRefs.push([edge.target, edge.targetPort]);
             }
             const { pending } = edge;
             for (let i = 0; i < pending.length; i += 2) {
@@ -1343,6 +1689,18 @@ class GraphmlReader {
             this.report.counts.skippedEdges++;
         }
     }
+    /**
+     * Report an endpoint that names a nested `<graph>` rather than a node (a node of that id is
+     * then created under addMissingNodes).
+     * @param id - the endpoint id
+     * @param text - the endpoint as written, or null
+     * @param where - the edge's location
+     */
+    checkGraphEndpoint(id, text, where) {
+        if (text !== null && this.graphIds.has(text) && this.sink.indexOf(id) === INVALID_INDEX) {
+            this.report.warning("validation-error", GRAPHML_ISSUE.GRAPH_ENDPOINT, `edge endpoint "${text}" names a <graph>, not a node; a node "${text}" is created`, where);
+        }
+    }
     /**
      * E_UNKNOWN_NODE when an endpoint was never declared (addMissingNodes false enforced by the
      * importer, whatever the sink allows).
@@ -1408,6 +1766,7 @@ class GraphmlReader {
      * @param line - the line
      */
     beginHyperedge(attrs, line) {
+        this.reportUnreadAttributes("hyperedge", attrs, HYPEREDGE_ATTRIBUTES, line);
         const id = attrs.get("id") ?? null;
         const where = { line, element: id };
         switch (this.options.hyperedges) {
@@ -1474,13 +1833,40 @@ class GraphmlReader {
         if (hyperedge.failed) {
             return;
         }
+        if (hyperedge.endpoints.length === 0) {
+            this.skipEdge(hyperedge);
+            this.report.error("missing-value", GRAPHML_ISSUE.HYPEREDGE_ENDPOINT, "<hyperedge> without endpoints yields no edge", { line: hyperedge.line, element: hyperedge.id });
+            return;
+        }
+        if (!this.options.addMissingNodes &&
+            hyperedge.endpoints.some((endpoint) => this.sink.indexOf(endpoint.node) === INVALID_INDEX)) {
+            this.deferred.push(hyperedge);
+            return;
+        }
+        this.expandHyperedge(hyperedge);
+    }
+    /**
+     * Expand a hyperedge to a star or a clique; under addMissingNodes false every endpoint must be
+     * a declared node.
+     * @param hyperedge - the hyperedge, its endpoints read
+     */
+    expandHyperedge(hyperedge) {
         const where = { line: hyperedge.line, element: hyperedge.id };
         try {
+            for (const endpoint of hyperedge.endpoints) {
+                if (!this.options.addMissingNodes) {
+                    this.requireNode(endpoint.node);
+                }
+            }
+            for (const node of new Set(hyperedge.endpoints.map((endpoint) => endpoint.node))) {
+                this.countEndpoints(node, node);
+            }
             if (this.options.hyperedges === "star") {
                 this.expandStar(hyperedge, where);
             }
-            else {
-                this.expandClique(hyperedge, where);
+            else if (this.expandClique(hyperedge, where) === 0) {
+                this.skipEdge(hyperedge);
+                this.report.error("validation-error", GRAPHML_ISSUE.HYPEREDGE_ENDPOINT, "no two endpoints of this hyperedge can be joined (all in, all out, or only one); it yields no edge", where);
             }
         }
         catch (err) {
@@ -1503,6 +1889,7 @@ class GraphmlReader {
         }
         const hub = this.sink.addNode(hubId);
         this.declared.add(hub);
+        this.hubs.add(hub);
         this.report.counts.nodes++;
         if (this.hubHandle === INVALID_INDEX) {
             this.hubHandle = this.sink.declareNodeColumn({
@@ -1538,9 +1925,11 @@ class GraphmlReader {
      * joined undirected to every other endpoint; two endpoints of the same direction are not joined.
      * @param hyperedge - the hyperedge
      * @param where - the location for issues
+     * @returns the number of edge elements added
      */
     expandClique(hyperedge, where) {
         const { endpoints } = hyperedge;
+        let added = 0;
         for (let i = 0; i < endpoints.length; i++) {
             for (let j = i + 1; j < endpoints.length; j++) {
                 const a = endpoints[i];
@@ -1558,9 +1947,11 @@ class GraphmlReader {
                 else {
                     continue;
                 }
+                added++;
                 this.report.counts.edges += this.sink.edgeCount - before;
             }
         }
+        return added;
     }
     // ------------------------------------------------------------------ options and ids
     /**
@@ -1655,12 +2046,13 @@ function resolveYfiles(options) {
  *     or when the head does not start with markup
  */
 function sniffGraphml(head) {
-    const text = new TextDecoder("utf-8", { fatal: false }).decode(head.subarray(0, SNIFF_BYTES));
+    const text = sniffXmlText(head.subarray(0, SNIFF_BYTES));
     // Only a document that starts as markup: a JSON or CSV value may mention a `<graphml>` tag.
     if (!/^\uFEFF?\s*</.test(text)) {
         return 0;
     }
-    const root = text.indexOf("<graphml");
+    // the root may carry a namespace prefix (<g:graphml xmlns:g="...">)
+    const root = text.search(/<([\w.-]+:)?graphml[\s>/]/);
     if (root >= 0) {
         return text.includes(GRAPHML_NAMESPACE, root) ? 1 : 0.9;
     }
@@ -1681,9 +2073,12 @@ async function importGraphml(input, sink, options) {
     reportUnusedOptions(options, report, USED_OPTIONS);
     const reader = new GraphmlReader(sink, report, common, yfilesMode);
     try {
-        await tokenizeXml(textChunks(input, report, { ...common, declaredEncoding: xmlDeclaredEncoding }), reader);
+        await tokenizeXml(textChunks(input, report, { ...common, declaredEncoding: xmlDeclaredEncoding, xml: true }), reader);
     }
     catch (err) {
+        if (err instanceof XmlEmptyInputError) {
+            report.fail(GRAPHML_ISSUE.EMPTY_INPUT, "the input is empty (no markup at all)", { line: err.line });
+        }
         if (err instanceof XmlSyntaxError) {
             report.fail(GRAPHML_ISSUE.XML_SYNTAX, err.message, { line: err.line });
         }
@@ -1693,12 +2088,44 @@ async function importGraphml(input, sink, options) {
     throwIfAborted(common.signal);
     return report.finish();
 }
-/** The GraphML importer (design section 8.4). */
+/**
+ * The GraphML importer.
+ * @category Built-in formats
+ */
 export const graphmlImporter = Object.freeze({
     format: FORMAT,
+    options: Object.freeze(["yfiles"]),
     extensions: EXTENSIONS,
     mimeTypes: MIME_TYPES,
     sniff: sniffGraphml,
     import: importGraphml,
 });
+/** The elements GraphML defines, for telling a misplaced one from a foreign one. */
+const GRAPHML_ELEMENTS = new Set([
+    "graphml",
+    "key",
+    "default",
+    "graph",
+    "node",
+    "edge",
+    "hyperedge",
+    "endpoint",
+    "port",
+    "data",
+    "desc",
+    "locator",
+]);
+/**
+ * The message of an element skipped where it stands.
+ * @param name - the element name
+ * @returns a message that says where a GraphML element belongs, or that a foreign one is not GraphML
+ */
+function unknownElementMessage(name) {
+    if (name === "key") {
+        return "element <key> is only allowed as a child of <graphml>, before the first <graph>; it was skipped";
+    }
+    return GRAPHML_ELEMENTS.has(name)
+        ? `element <${name}> is not allowed at this place in a GraphML file and was skipped`
+        : `element <${name}> is not GraphML and was skipped`;
+}
 //# sourceMappingURL=importer.js.map