@graphty/graph-io 0.3.25 → 0.3.27

package/dist/chunks/{importer-DIrbbnAf.js → importer-DpEW5zeG.js}

@@ -1,152 +1,9 @@
 import { GraphFormatError, INVALID_INDEX, MAX_COUNT } from "@graphty/graph-format";
 import { c as childrenCsr } from "./children-CL3Cy0ez.js";
-import { af as MIXED_DIRECTION_CODE, D as DIRECTION_FORCED_CODE, a as DIRECTION_REFUSED_CODE, S as SINK_OPTION_CODE, P as PRECISION_CODE, Z as BAD_DEFAULT_CODE, k as UNKNOWN_ATTR_TYPE_CODE, R as ROLE_TAKEN_CODE, C as COLUMN_RENAMED_CODE, O as OPTION_IGNORED_CODE, I as ID_MERGED_CODE, au as STRAY_TEXT_CODE, Y as UNKNOWN_ELEMENT_CODE, an as HYPEREDGE_CODE, ai as COUNT_HINT_CODE, M as MULTIPLE_GRAPHS_CODE, c as DUPLICATE_EDGE_ID_CODE, d as DUPLICATE_NODE_CODE, e as MISSING_ENDPOINT_CODE, f as MISSING_ID_CODE, al as DUPLICATE_KEY_CODE, N as NO_GRAPH_CODE, q as UNKNOWN_ENCODING_CODE, E as ENCODING_FALLBACK_CODE, r as INVALID_ENCODING_CODE, s as INVALID_UTF8_CODE, aw as XML_SYNTAX_CODE, b as ID_TEXT_TYPE_CODE, ac as ROLE_DROPPED_CODE, ab as PARENTS_DROPPED_CODE, a9 as MUTUAL_AS_UNDIRECTED_CODE, V as resolveExportOptions, X as pairFolding, aE as isCanonicalIntegerText, v as resolveImportOptions, w as ImportReportBuilder, F as reportSinkOptions, z as reportUnusedOptions, x as textChunks, y as throwIfAborted, K as IdCoercer, J as DirectionResolver, aK as declareAttribute, Q as uniqueColumnName, L as declareResolved, aX as takenIn, aM as parseDeclaredValue, aN as losesPrecision } from "./report-B1z4WT9e.js";
-import { a as escapeXmlText, g as isWhitespace, n as isXmlName, e as escapeXmlAttribute, l as localName, x as xmlIllegalTextNotes, t as tokenizeXml, f as xmlDeclaredEncoding, X as XmlSyntaxError } from "./escape-B-tkk_Cl.js";
-import { c as capabilities, a as checkCapabilities, L as LOSS, s as sanitizeIds, i as isNmtoken, m as mangleNmtoken } from "./export-Bh60Dv-n.js";
-import { e as explicitWeights, d as formatInteger, a as formatF64, f as formatF32, i as isWeightField, p as parseWeightText } from "./weights-Dzba96G3.js";
-import { j as joinText, e as encodeChunks } from "./writer-C7flM-Ih.js";
-const GRAPHML_NAMESPACE = "http://graphml.graphdrawing.org/xmlns";
-const YFILES_NAMESPACE = "http://www.yworks.com/xml/graphml";
-const XSI_NAMESPACE = "http://www.w3.org/2001/XMLSchema-instance";
-const SCHEMA_LOCATION = "http://graphml.graphdrawing.org/xmlns http://graphml.graphdrawing.org/xmlns/1.0/graphml.xsd";
-const FORMAT = "graphml";
-const EXTENSIONS = Object.freeze([".graphml", ".xml"]);
-const MIME_TYPES = Object.freeze(["application/graphml+xml", "application/xml", "text/xml"]);
-const ORIGINAL_ID_ATTRIBUTE = "graphty:originalId";
-const ORIGINAL_ID_COLUMN = "graphty.originalId";
-const EDGE_ID_COLUMN = "id";
-const SOURCE_PORT_COLUMN = "sourceport";
-const TARGET_PORT_COLUMN = "targetport";
-const PARENT_COLUMN = "parent";
-const HYPEREDGE_HUB_COLUMN = "graphty.hyperedge";
-const LABEL_COLUMN = "label";
-const RESERVED_EDGE_NAMES = /* @__PURE__ */ new Set([
-  EDGE_ID_COLUMN,
-  SOURCE_PORT_COLUMN,
-  TARGET_PORT_COLUMN
-]);
-const RESERVED_NODE_NAMES = /* @__PURE__ */ new Set([PARENT_COLUMN]);
-const META_KEY = "graphml";
-const GRAPHML_ISSUE = Object.freeze({
-  /** Fatal: the input is not well-formed XML. */
-  XML_SYNTAX: XML_SYNTAX_CODE,
-  /** Fatal: the input holds invalid UTF-8. */
-  INVALID_UTF8: INVALID_UTF8_CODE,
-  /** Invalid bytes in the encoding a BOM, a declaration or the encoding option chose (fatal). */
-  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,
-  /** Fatal: the root element is not `<graphml>`. */
-  NOT_GRAPHML: "E_NOT_GRAPHML",
-  /** Fatal: the document has no `<graph>`. */
-  NO_GRAPH: NO_GRAPH_CODE,
-  /** A `<key>` without an id. */
-  KEY_MISSING_ID: "E_GRAPHML_KEY_MISSING_ID",
-  /** Two `<key>` elements with the same id. */
-  DUPLICATE_KEY: DUPLICATE_KEY_CODE,
-  /** A key declared for hyperedges, ports or endpoints (never used). */
-  KEY_DOMAIN_UNSUPPORTED: "W_GRAPHML_KEY_DOMAIN_UNSUPPORTED",
-  /** A `<node>` without an id. */
-  MISSING_ID: MISSING_ID_CODE,
-  /** An `<edge>` without a source or a target. */
-  MISSING_ENDPOINT: MISSING_ENDPOINT_CODE,
-  /** A `<data>` whose key was never declared. */
-  UNKNOWN_KEY: "E_GRAPHML_UNKNOWN_KEY",
-  /** A `<data>` whose key is declared for another domain. */
-  KEY_DOMAIN: "W_GRAPHML_KEY_DOMAIN",
-  /** A `<data>` without a key attribute. */
-  DATA_MISSING_KEY: "E_GRAPHML_DATA_MISSING_KEY",
-  /** A `<key>` whose `for` is not a GraphML domain. */
-  KEY_FOR_INVALID: "E_GRAPHML_KEY_FOR_INVALID",
-  /** Data of a nested `<graph>`; only the top-level graph has attributes. */
-  NESTED_GRAPH_DATA: "W_GRAPHML_NESTED_GRAPH_DATA",
-  /** Data of a hyperedge expanded to a star or clique. */
-  HYPEREDGE_DATA_DROPPED: "W_GRAPHML_HYPEREDGE_DATA_DROPPED",
-  /** Nested elements in the `<data>` of a typed (non-yfiles) key. */
-  DATA_NESTED: "E_GRAPHML_DATA_NESTED",
-  /** A `<node>` declared twice. */
-  DUPLICATE_NODE: DUPLICATE_NODE_CODE,
-  /** An edge id already used by another edge. */
-  DUPLICATE_EDGE_ID: DUPLICATE_EDGE_ID_CODE,
-  /** A `directed` attribute that is neither true nor false. */
-  INVALID_DIRECTED: "E_GRAPHML_INVALID_DIRECTED",
-  /** An `edgedefault` that is neither directed nor undirected. */
-  INVALID_EDGEDEFAULT: "E_GRAPHML_INVALID_EDGEDEFAULT",
-  /** A `<graph>` without edgedefault; the `defaultDirected` option applies. */
-  EDGEDEFAULT_MISSING: "W_GRAPHML_EDGEDEFAULT_MISSING",
-  /** A second top-level `<graph>`; its nodes and edges are merged into the first. */
-  MULTIPLE_GRAPHS: MULTIPLE_GRAPHS_CODE,
-  /** A `parse.nodes` / `parse.edges` hint the sink cannot reserve (ignored). */
-  COUNT_HINT: COUNT_HINT_CODE,
-  /** A hyperedge under `hyperedges: "error"`. */
-  HYPEREDGE: HYPEREDGE_CODE,
-  /** Hyperedges skipped under `hyperedges: "skip"`. */
-  HYPEREDGE_SKIPPED: "W_GRAPHML_HYPEREDGE_SKIPPED",
-  /** An endpoint of a hyperedge without a node, or with an unknown type. */
-  HYPEREDGE_ENDPOINT: "E_GRAPHML_HYPEREDGE_ENDPOINT",
-  /** `<port>` declarations (and their data) are not kept; sourceport / targetport edge attributes are. */
-  PORT_DECLARATION: "W_GRAPHML_PORT_DECLARATION",
-  /** A GraphML `parse.*` hint on `<graph>`, `<node>` or `<edge>` the importer does not act on (parse.nodeids, parse.order, ...). */
-  PARSE_HINT_IGNORED: "W_GRAPHML_PARSE_HINT_IGNORED",
-  /** An XML attribute GraphML does not define on `<graph>`, `<node>` or `<edge>`; it is not kept. */
-  UNKNOWN_XML_ATTRIBUTE: "W_GRAPHML_UNKNOWN_XML_ATTRIBUTE",
-  /** A `<locator>` element. */
-  LOCATOR_DROPPED: "W_GRAPHML_LOCATOR_DROPPED",
-  /** A `<desc>` of a node, an edge or a hyperedge. */
-  DESC_DROPPED: "W_GRAPHML_DESC_DROPPED",
-  /** An element the GraphML schema does not define at that place. */
-  UNKNOWN_ELEMENT: UNKNOWN_ELEMENT_CODE,
-  /** Non-whitespace text where the schema allows only elements. */
-  STRAY_TEXT: STRAY_TEXT_CODE,
-  /** Two distinct id texts merged into one number under `ids: "number"`. */
-  ID_MERGED: ID_MERGED_CODE,
-  /** An option GraphML has no use for (`nodeIdFrom`: nodes are identified by their id attribute). */
-  OPTION_IGNORED: OPTION_IGNORED_CODE,
-  /** A yFiles key under `yfiles: "skip"`. */
-  YFILES_SKIPPED: "W_GRAPHML_YFILES_SKIPPED",
-  /** A key renamed `<name>#<id>` because the name was taken (design section 5.6). */
-  COLUMN_RENAMED: COLUMN_RENAMED_CODE,
-  /** A key declared without its role because the table already holds it. */
-  ROLE_TAKEN: ROLE_TAKEN_CODE,
-  /** A declared type the format does not define (kept as string). */
-  UNKNOWN_ATTR_TYPE: UNKNOWN_ATTR_TYPE_CODE,
-  /** A default that does not parse as the declared type. */
-  BAD_DEFAULT: BAD_DEFAULT_CODE,
-  /** A long value beyond 2^53 rounded. */
-  PRECISION: PRECISION_CODE,
-  /** A builder-policy option the sink does not honour. */
-  SINK_OPTION: SINK_OPTION_CODE,
-  /** The sink refused the file's direction. */
-  DIRECTION_REFUSED: DIRECTION_REFUSED_CODE,
-  /** Edges forced to the policy's direction. */
-  DIRECTION_FORCED: DIRECTION_FORCED_CODE,
-  /** A mixed file under onMixedDirection "error" (fatal). */
-  MIXED_DIRECTION: MIXED_DIRECTION_CODE
-});
-const GRAPHML_LOSS = Object.freeze({
-  /** yFiles nested XML kept as a JSON tree: structure preserved, not byte-exact. */
-  YFILES_JSON: "W_GRAPHML_YFILES_JSON",
-  /** A mutual pair written as one undirected edge; the mark is lost. */
-  MUTUAL_AS_UNDIRECTED: MUTUAL_AS_UNDIRECTED_CODE,
-  /** A `parents` (multi-parent) column cannot be written as nested graphs. */
-  PARENTS_DROPPED: PARENTS_DROPPED_CODE,
-  /** A role column GraphML has no slot for (kind, node ids, ...) written as a plain attribute. */
-  ROLE_DROPPED: ROLE_DROPPED_CODE,
-  /** Containment order differs from index order; node indices change after a round trip. */
-  HIERARCHY_REORDERED: "W_GRAPHML_HIERARCHY_REORDERED",
-  /** Nodes whose parent chain never reaches a root are written at the top level. */
-  PARENT_CYCLE: "W_GRAPHML_PARENT_CYCLE",
-  /** Node ids that change type after a round trip under the canonical rule (design section 4.1). */
-  ID_TEXT_TYPE: ID_TEXT_TYPE_CODE,
-  /** A numeric edge id column reads back as string. */
-  EDGE_ID_TEXT: "W_GRAPHML_EDGE_ID_TEXT",
-  /** A `yfiles.*` graphics column that no longer matches its yFiles tree: only the tree is written. */
-  YFILES_GRAPHICS_STALE: "W_GRAPHML_YFILES_GRAPHICS_STALE",
-  /** A yfiles json value that is not a serialisable tree: export() will throw E_COLUMN_TYPE. */
-  YFILES_TREE: "E_GRAPHML_YFILES_TREE"
-});
+import { r as resolveExportOptions, c as capabilities, a as checkCapabilities, L as LOSS, p as pairFolding, b as plural, $ as agree, aE as sanitizeIds, e as explicitWeights, bA as isNmtoken, by as isCanonicalIntegerText, bB as mangleNmtoken, aG as formatInteger, ab as formatF64, aa as formatF32, al as resolveImportOptions, a8 as ImportReportBuilder, ao as reportSinkOptions, an as reportUnusedOptions, a4 as textChunks, am as throwIfAborted, ar as IdCoercer, aq as DirectionResolver, aK as isWeightField, bI as declareAttribute, a0 as uniqueColumnName, a1 as declareResolved, bX as takenIn, aL as parseWeightText, bL as parseDeclaredValue, bM as losesPrecision, P as PRECISION_CODE, bJ as overflowsToInfinity } from "./export-CHd4tQE2.js";
+import { a as escapeXmlText, j as isWhitespace, n as isXmlName, e as escapeXmlAttribute, l as localName, x as xmlIllegalTextNotes, t as tokenizeXml, f as xmlDeclaredEncoding, g as XmlEmptyInputError, X as XmlSyntaxError, s as sniffXmlText } from "./escape-D1HPTUrP.js";
+import { j as joinText, e as encodeChunks } from "./writer-DxjgHwSe.js";
+import { F as FORMAT, a as GRAPHML_LOSS, Y as YFILES_NAMESPACE, X as XSI_NAMESPACE, S as SCHEMA_LOCATION, b as GRAPHML_NAMESPACE, O as ORIGINAL_ID_ATTRIBUTE, M as META_KEY, L as LABEL_COLUMN, R as RESERVED_NODE_NAMES, c as RESERVED_EDGE_NAMES, P as PARENT_COLUMN, T as TARGET_PORT_COLUMN, d as SOURCE_PORT_COLUMN, E as EDGE_ID_COLUMN, e as MIME_TYPES, f as EXTENSIONS, G as GRAPHML_ISSUE, g as ORIGINAL_ID_COLUMN, H as HYPEREDGE_HUB_COLUMN } from "./constants-ikG85dT8.js";
 const ATTRIBUTE_PREFIX = "@_";
 const TEXT_KEY = "#text";
 class XmlTreeBuilder {
@@ -431,44 +288,44 @@ function staleGraphicsRows(column, table, domain) {
   }
   return stale;
 }
-function graphicsValues(domain, tree) {
+function graphicsValues(domain, tree, unmapped = []) {
   const out = [];
   if (domain === "node") {
     const shape = child(tree, "ShapeNode");
     if (shape !== void 0) {
-      shapeNodeValues(shape, out);
+      shapeNodeValues(shape, out, unmapped);
     }
   } else {
     const edge = child(tree, "PolyLineEdge");
     if (edge !== void 0) {
-      polyLineEdgeValues(edge, out);
+      polyLineEdgeValues(edge, out, unmapped);
     }
   }
   return out;
 }
-function shapeNodeValues(shape, out) {
+function shapeNodeValues(shape, out, unmapped) {
   const geometry = child(shape, "Geometry");
-  const x = number(attr(geometry, "x"));
-  const y = number(attr(geometry, "y"));
+  const x = checked(attr(geometry, "x"), "x", unmapped);
+  const y = checked(attr(geometry, "y"), "y", unmapped);
   if (x !== void 0 && y !== void 0) {
     out.push(["position", [x, y, 0]]);
   }
-  push(out, "width", number(attr(geometry, "width")));
-  push(out, "height", number(attr(geometry, "height")));
+  push(out, "width", checked(attr(geometry, "width"), "width", unmapped));
+  push(out, "height", checked(attr(geometry, "height"), "height", unmapped));
   push(out, "color", color(attr(child(shape, "Fill"), "color")));
   const border = child(shape, "BorderStyle");
   push(out, "borderColor", color(attr(border, "color")));
-  push(out, "borderWidth", number(attr(border, "width")));
+  push(out, "borderWidth", checked(attr(border, "width"), "borderWidth", unmapped));
   const label = child(shape, "NodeLabel");
   if (typeof label === "string" ? label.length > 0 : label !== void 0) {
     out.push(["label", (typeof label === "string" ? label : text(label) ?? "").trim()]);
   }
   push(out, "shape", nonEmpty(attr(child(shape, "Shape"), "type")));
 }
-function polyLineEdgeValues(edge, out) {
+function polyLineEdgeValues(edge, out, unmapped) {
   const line = child(edge, "LineStyle");
   push(out, "color", color(attr(line, "color")));
-  push(out, "width", number(attr(line, "width")));
+  push(out, "width", checked(attr(line, "width"), "width", unmapped));
   const arrows = child(edge, "Arrows");
   if (arrows !== void 0 && typeof arrows === "object") {
     const target = attr(arrows, "target");
@@ -515,6 +372,13 @@ function number(value) {
   const n = Number.parseFloat(value);
   return Number.isNaN(n) ? void 0 : n;
 }
+function checked(value, field, unmapped) {
+  const n = number(value);
+  if (n === void 0 && value !== void 0 && value.length > 0) {
+    unmapped.push(field);
+  }
+  return n;
+}
 function color(value) {
   if (value === void 0 || value.length === 0) {
     return void 0;
@@ -657,7 +521,7 @@ function planExport(snapshot, options, format) {
   if (idTypeChanges > 0) {
     note(
       GRAPHML_LOSS.ID_TEXT_TYPE,
-      `${idTypeChanges} node id(s) change type when read back under ids: "canonical" (string ids that are integer text, non-integer numbers)`,
+      `${idTypeChanges} node id${plural(idTypeChanges)} ${agree(idTypeChanges, "changes", "change")} type when read back under ids: "canonical" (string ids that are integer text, non-integer numbers)`,
       null,
       idTypeChanges
     );
@@ -673,7 +537,7 @@ function planExport(snapshot, options, format) {
   if (folding.mutualCount > 0) {
     note(
       GRAPHML_LOSS.MUTUAL_AS_UNDIRECTED,
-      `${folding.mutualCount} mutual pair(s) are written as undirected edges; the mutual mark is lost`,
+      `${folding.mutualCount} mutual pair${plural(folding.mutualCount)} ${agree(folding.mutualCount, "is", "are")} written as undirected edges; the mutual mark is lost`,
       null,
       folding.mutualCount
     );
@@ -690,7 +554,7 @@ function planExport(snapshot, options, format) {
   if (hierarchy.unreachable > 0) {
     note(
       GRAPHML_LOSS.PARENT_CYCLE,
-      `${hierarchy.unreachable} node(s) whose parent chain never reaches a root are written at the top level`,
+      `${hierarchy.unreachable} node${plural(hierarchy.unreachable)} whose parent chain never reaches a root ${agree(hierarchy.unreachable, "is", "are")} written at the top level`,
       hierarchy.parent?.meta.name ?? null,
       hierarchy.unreachable
     );
@@ -805,7 +669,7 @@ function planWeight(snapshot, edgeColumns, keyIds, keys, note) {
     if (plan.attrName === attrName) {
       note(
         LOSS.WEIGHT_KEY_CLASH,
-        `edge column "${plan.column.meta.name}" is written as a key titled "${attrName}", which the importer reads as THE weight (weightFrom); it reads back as the weight, not as a column`,
+        `edge column "${plan.column.meta.name}" is written as a key titled "${attrName}", which the importer reads as the edge weight (weightFrom); it reads back as the weight, not as a column`,
         plan.column.meta.name,
         plan.column.length - plan.column.nullCount
       );
@@ -842,11 +706,16 @@ function planEdgeIds(snapshot, column, options, note) {
     return;
   }
   if (options.sanitizeIds === "mangle") {
-    note(LOSS.ID_MANGLED, `${bad} edge id(s) outside the nmtoken charset are rewritten`, column.meta.name, bad);
+    note(
+      LOSS.ID_MANGLED,
+      `${bad} edge id${plural(bad)} outside the nmtoken charset ${agree(bad, "is", "are")} rewritten`,
+      column.meta.name,
+      bad
+    );
   } else {
     note(
       LOSS.ID_CHARSET,
-      `${bad} edge id(s) outside the nmtoken charset; export() will throw unless sanitizeIds is "mangle"`,
+      `${bad} edge id${plural(bad)} outside the nmtoken charset; the save fails unless sanitizeIds is "mangle"`,
       column.meta.name,
       bad
     );
@@ -895,7 +764,7 @@ function planTable(table, domain, notes, note) {
       if (stale > 0) {
         note(
           GRAPHML_LOSS.YFILES_GRAPHICS_STALE,
-          `${stale} value(s) of ${domain} column "${name}" differ from the yFiles tree it was read from; only the tree is written, so they are lost`,
+          `${stale} value${plural(stale)} of ${domain} column "${name}" differ from the yFiles tree it was read from; only the tree is written, so they are lost`,
           name,
           stale
         );
@@ -937,7 +806,7 @@ function planTable(table, domain, notes, note) {
       if (bad > 0) {
         note(
           GRAPHML_LOSS.YFILES_TREE,
-          `${bad} value(s) of yfiles column "${name}" are not XML trees; export() will throw E_COLUMN_TYPE`,
+          `${bad} value${plural(bad)} of yfiles column "${name}" ${agree(bad, "is", "are")} not XML trees; the save fails with E_COLUMN_TYPE`,
           name,
           bad
         );
@@ -1016,6 +885,9 @@ function attrTypeFor(column) {
     case "u32":
       return columnMax(column) <= I32_MAX ? "int" : "long";
     case "string":
+      if (declared !== null && declared.trim().toLowerCase() === "long" && columnIntegerText(column)) {
+        return "long";
+      }
       if (declared !== null && TYPE_DTYPES[declared.trim().toLowerCase()] === void 0) {
         return declared;
       }
@@ -1030,6 +902,14 @@ function attrTypeFor(column) {
     }
   }
 }
+function columnIntegerText(column) {
+  for (let r = 0; r < column.length; r++) {
+    if (column.isSet(r) && !/^[+-]?\d+$/.test(String(column.value(r)))) {
+      return false;
+    }
+  }
+  return true;
+}
 function columnIntegral(column) {
   if (column.dtype !== "f64") {
     return false;
@@ -1287,7 +1167,7 @@ function sanitizeEdgeIds(column, mode, edgeCount) {
   if (bad.length > 0 && mode === "error") {
     throw new GraphFormatError(
       "E_INVALID_ID",
-      `${bad.length} edge id(s) cannot be written as nmtoken (first: ${JSON.stringify(edgeIdText(column, bad[0]))} at edge ${bad[0]}); pass sanitizeIds: "mangle" to rewrite them`,
+      `${bad.length} edge id${plural(bad.length)} ${agree(bad.length, "is", "are")} not XML name tokens (first: ${JSON.stringify(edgeIdText(column, bad[0]))} at edge ${bad[0]}); pass sanitizeIds: "mangle" to rewrite them`,
       { reason: "charset", charset: "nmtoken", count: bad.length, edge: bad[0] }
     );
   }
@@ -1490,6 +1370,7 @@ ${pad}</node>`;
 }
 const graphmlExporter = Object.freeze({
   format: FORMAT,
+  options: Object.freeze(["edgedefault", "pretty"]),
   capabilities: CAPABILITIES,
   /**
    * Pre-flight: every loss the export would incur.
@@ -1524,6 +1405,22 @@ const graphmlExporter = Object.freeze({
 });
 const GRAPH_ATTRIBUTES = /* @__PURE__ */ new Set(["id", "edgedefault", "parse.nodes", "parse.edges"]);
 const NODE_ATTRIBUTES = /* @__PURE__ */ new Set(["id"]);
+const KEY_ATTRIBUTES = /* @__PURE__ */ new Set([
+  "id",
+  "for",
+  "attr.name",
+  "attr.type",
+  "name",
+  "type",
+  "yfiles.type"
+]);
+const DATA_ATTRIBUTES = /* @__PURE__ */ new Set(["key"]);
+const HYPEREDGE_ATTRIBUTES = /* @__PURE__ */ new Set(["id"]);
+const ENDPOINT_ATTRIBUTES = /* @__PURE__ */ new Set(["node", "type"]);
+const PORT_ATTRIBUTES = /* @__PURE__ */ new Set(["name"]);
+const NO_ATTRIBUTES = /* @__PURE__ */ new Set();
+const SCHEMA_ATTRIBUTES = /* @__PURE__ */ new Set(["id", "port", "parse.order", "parse.nodeids", "parse.edgeids"]);
+const MAX_UNKNOWN_ATTRIBUTE_NAMES = 16;
 const EDGE_ATTRIBUTES = /* @__PURE__ */ new Set([
   "id",
   "source",
@@ -1598,6 +1495,8 @@ class GraphmlReader {
     this.nodes = [];
     this.declared = new IndexFlags();
     this.edgeIds = /* @__PURE__ */ new Set();
+    this.unknownKeyIds = /* @__PURE__ */ new Set();
+    this.deferredEdgeIds = /* @__PURE__ */ new Set();
     this.elementsSinceCheck = 0;
     this.restored = /* @__PURE__ */ new Map();
     this.graphColumnNames = /* @__PURE__ */ new Set();
@@ -1614,6 +1513,8 @@ class GraphmlReader {
     };
     this.descTarget = null;
     this.descText = "";
+    this.descLine = 0;
+    this.graphKeys = { keys: null };
     this.description = null;
     this.graphSeen = false;
     this.graphId = null;
@@ -1628,6 +1529,16 @@ class GraphmlReader {
     this.targetPortHandle = INVALID_INDEX;
     this.parentHandle = INVALID_INDEX;
     this.hubHandle = INVALID_INDEX;
+    this.hubs = new IndexFlags();
+    this.deferred = [];
+    this.graphIds = /* @__PURE__ */ new Set();
+    this.topGraphs = 0;
+    this.rootNs = GRAPHML_NAMESPACE;
+    this.graphDescSeen = false;
+    this.unknownNames = /* @__PURE__ */ new Map();
+    this.unknownOverflow = /* @__PURE__ */ new Map();
+    this.ports = /* @__PURE__ */ new Map();
+    this.portRefs = [];
     this.sink = sink;
     this.report = report;
     this.options = options;
@@ -1641,8 +1552,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 9:
@@ -1659,8 +1571,15 @@ class GraphmlReader {
       case 3:
         this.captureStart(name, attrs);
         return;
+      case 12:
+        this.dropStart(localName(name));
+        return;
     }
     const local = localName(name);
+    if (parent !== null && ns !== GRAPHML_NAMESPACE && ns !== "" && ns !== this.rootNs) {
+      this.unknownElement(name, line);
+      return;
+    }
     switch (parent) {
       case null:
         if (local !== "graphml") {
@@ -1668,6 +1587,16 @@ 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(
           0
@@ -1678,7 +1607,7 @@ class GraphmlReader {
         this.startInGraphml(name, local, attrs, line);
         return;
       case 2:
-        this.startInKey(name, local, line);
+        this.startInKey(name, local, attrs, line);
         return;
       case 4:
         this.startInGraph(name, local, attrs, line);
@@ -1692,6 +1621,9 @@ class GraphmlReader {
       case 7:
         this.startInHyperedge(name, local, attrs, line);
         return;
+      case 11:
+        this.startInPort(name, local, attrs, line);
+        return;
       default:
         this.unknownElement(name, line);
     }
@@ -1709,6 +1641,8 @@ class GraphmlReader {
         return;
       case 10:
       case 0:
+      case 11:
+      case 12:
       case void 0:
         return;
       case 1:
@@ -1733,7 +1667,7 @@ class GraphmlReader {
         this.finishHyperedge();
         return;
       case 4:
-        this.graphs.pop();
+        this.finishGraph();
         return;
       default: {
         const value = ctx;
@@ -1764,6 +1698,7 @@ class GraphmlReader {
         this.descText += text2;
         return;
       case 10:
+      case 12:
         return;
       default:
         if (!isWhitespace(text2)) {
@@ -1783,6 +1718,23 @@ class GraphmlReader {
     if (!this.graphSeen) {
       this.report.fail(GRAPHML_ISSUE.NO_GRAPH, "the document has no <graph> element");
     }
+    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,
@@ -1819,7 +1771,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);
@@ -1838,14 +1790,24 @@ 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 !== void 0)) {
+          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 = "";
@@ -1868,11 +1830,19 @@ 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(
             10
             /* Skip */
@@ -1880,13 +1850,13 @@ class GraphmlReader {
         }
         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",
+            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(
@@ -1953,14 +1923,19 @@ class GraphmlReader {
           "<port> declarations are not kept; sourceport / targetport edge attributes are",
           { line }
         );
-        this.ctx.push(
-          10
-          /* 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;
       }
@@ -2006,10 +1981,105 @@ 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(
+          12
+          /* 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" ? 10 : 12
+      /* 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 !== void 0) {
+      const id = node.restoredId ?? node.id;
+      let names = this.ports.get(id);
+      if (names === void 0) {
+        names = /* @__PURE__ */ new Set();
+        this.ports.set(id, names);
+      }
+      names.add(name);
+    }
+    this.ctx.push(
+      11
+      /* 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(
+          10
+          /* 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 ??= `${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
@@ -2020,6 +2090,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(
           10
@@ -2039,6 +2110,13 @@ class GraphmlReader {
         );
         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(
           10
           /* Skip */
@@ -2054,15 +2132,10 @@ 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`,
-      {
-        line,
-        element: name
-      }
-    );
+    this.report.warnOnce("unsupported", GRAPHML_ISSUE.UNKNOWN_ELEMENT, unknownElementMessage(name), {
+      line,
+      element: name
+    });
     this.ctx.push(
       10
       /* Skip */
@@ -2071,10 +2144,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(
       1
       /* Desc */
@@ -2086,6 +2161,15 @@ class GraphmlReader {
     if (this.descTarget === "key" && this.pendingKey !== null) {
       this.pendingKey.desc = text2;
     } else if (this.descTarget === "graph" && text2.length > 0) {
+      if (this.graphDescSeen) {
+        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 = text2;
     }
     this.descTarget = null;
@@ -2094,27 +2178,49 @@ 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 hint2 = name.startsWith("parse.");
       const code = hint2 ? GRAPHML_ISSUE.PARSE_HINT_IGNORED : GRAPHML_ISSUE.UNKNOWN_XML_ATTRIBUTE;
-      this.report.warnOnce(
-        "unsupported",
-        code,
-        hint2 ? `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 === void 0) {
+        names = /* @__PURE__ */ new Set();
+        this.unknownNames.set(kind, names);
+      }
+      if (names.has(name)) {
+        continue;
+      }
+      if (names.size >= MAX_UNKNOWN_ATTRIBUTE_NAMES && !hint2) {
+        this.unknownOverflow.set(kind, (this.unknownOverflow.get(kind) ?? 0) + 1);
+      }
+      names.add(name);
+      if (names.size > MAX_UNKNOWN_ATTRIBUTE_NAMES && !hint2) {
+        continue;
+      }
+      let message;
+      if (hint2) {
+        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 });
     }
   }
   /**
@@ -2127,17 +2233,26 @@ 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 !== void 0 && graphId.length > 0) {
+      this.graphIds.add(graphId);
+    }
     const edgedefault = attrs.get("edgedefault");
     let directed;
     if (edgedefault === "directed" || edgedefault === "undirected") {
       directed = edgedefault === "directed";
     } else if (edgedefault === void 0) {
       directed = top ? this.options.defaultDirected : this.graphs[this.graphs.length - 1].directed;
-      this.report.warning(
+      const direction = directed ? "directed" : "undirected";
+      this.report.warnOnce(
         "validation-error",
         GRAPHML_ISSUE.EDGEDEFAULT_MISSING,
-        `<graph> has no edgedefault; read as ${directed ? "directed" : "undirected"}`,
-        { line }
+        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;
@@ -2148,6 +2263,7 @@ class GraphmlReader {
         { line }
       );
     }
+    let hints = null;
     if (top && this.graphSeen) {
       this.report.warnOnce(
         "unsupported",
@@ -2155,6 +2271,17 @@ class GraphmlReader {
         "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;
       this.graphId = attrs.get("id") ?? null;
@@ -2162,6 +2289,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 ?? void 0, edges ?? void 0);
@@ -2180,12 +2308,32 @@ class GraphmlReader {
         }
       }
     }
-    this.graphs.push({ directed, parent });
+    this.graphs.push({ directed, parent, hints, nodes: 0, edges: 0, line });
     this.ctx.push(
       4
       /* 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 === void 0) {
+      return;
+    }
+    for (const [name, hint2, found] of [
+      ["parse.nodes", graph.hints.nodes, graph.nodes],
+      ["parse.edges", graph.hints.edges, graph.edges]
+    ]) {
+      if (hint2 !== null && hint2 !== found) {
+        this.report.warning(
+          "validation-error",
+          GRAPHML_ISSUE.COUNT_MISMATCH,
+          `<graph ${name}="${hint2}"> 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
@@ -2216,7 +2364,16 @@ class GraphmlReader {
    * @param line - the line
    */
   beginKey(attrs, line) {
+    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) {
@@ -2474,8 +2631,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 !== void 0) {
+      this.checkDuplicateData(keyId, domain, line);
+    }
     content.key = null;
     content.pendingKey = null;
     content.domain = domain;
@@ -2490,6 +2651,7 @@ class GraphmlReader {
       const entries = this.keys.get(keyId);
       const key = entries?.find((entry) => entry.domains.includes(domain)) ?? entries?.[0];
       if (key === void 0) {
+        this.unknownKeyIds.add(keyId);
         this.report.error(
           "validation-error",
           GRAPHML_ISSUE.UNKNOWN_KEY,
@@ -2512,6 +2674,35 @@ class GraphmlReader {
       /* 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 ??= /* @__PURE__ */ 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
@@ -2568,9 +2759,16 @@ 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) {
@@ -2602,8 +2800,18 @@ class GraphmlReader {
             );
             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);
             this.report.recordError(err, where);
@@ -2668,7 +2876,18 @@ 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 === void 0) {
@@ -2732,12 +2951,31 @@ class GraphmlReader {
           { line: where.line, element: target.name }
         );
       }
+      this.checkOverflow(value, parsed, target.name, where);
       return parsed;
     } catch (err) {
       this.report.recordError(err, where);
       return void 0;
     }
   }
+  /**
+   * 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(text2, value, column, where) {
+    if (typeof value === "number" && overflowsToInfinity(text2)) {
+      this.report.warnOnce(
+        "precision",
+        PRECISION_CODE,
+        `values of "${column}" beyond the double range (${text2.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
@@ -2748,6 +2986,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,
@@ -2756,7 +2995,8 @@ class GraphmlReader {
       pending: [],
       restoredId: null,
       failed: false,
-      line
+      line,
+      keys: null
     };
     const idText = attrs.get("id");
     if (idText === void 0 || idText.length === 0) {
@@ -2797,7 +3037,14 @@ 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,
@@ -2867,21 +3114,28 @@ 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 === void 0 || idText.length === 0 ? null : idText,
       kind: graph.directed ? "directed" : "undirected",
       sourcePort: attrs.get("sourceport") ?? null,
       targetPort: attrs.get("targetport") ?? null,
       weight: void 0,
       pending: [],
       failed: false,
-      line
+      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 === void 0 || sourceText.length === 0) {
       this.skipEdge(edge);
       this.report.error("missing-value", GRAPHML_ISSUE.MISSING_ENDPOINT, "<edge> without a source", where);
@@ -2901,16 +3155,16 @@ class GraphmlReader {
     }
     const directedText = attrs.get("directed");
     if (directedText !== void 0) {
-      if (directedText === "true") {
+      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`,
+          `directed="${directedText}" is neither true nor false (nor 1 or 0)`,
           where
         );
       }
@@ -2934,6 +3188,23 @@ 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)) {
+      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 {
@@ -2941,6 +3212,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
@@ -2957,9 +3230,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) {
@@ -2980,6 +3255,23 @@ 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, text2, where) {
+    if (text2 !== null && this.graphIds.has(text2) && this.sink.indexOf(id) === INVALID_INDEX) {
+      this.report.warning(
+        "validation-error",
+        GRAPHML_ISSUE.GRAPH_ENDPOINT,
+        `edge endpoint "${text2}" names a <graph>, not a node; a node "${text2}" is created`,
+        where
+      );
+    }
+  }
   /**
    * E_UNKNOWN_NODE when an endpoint was never declared (addMissingNodes false enforced by the
    * importer, whatever the sink allows).
@@ -3045,6 +3337,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) {
@@ -3131,12 +3424,48 @@ 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) {
       this.skipEdge(hyperedge);
@@ -3158,6 +3487,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({
@@ -3193,9 +3523,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];
@@ -3210,9 +3542,11 @@ class GraphmlReader {
         } else {
           continue;
         }
+        added++;
         this.report.counts.edges += this.sink.edgeCount - before;
       }
     }
+    return added;
   }
   // ------------------------------------------------------------------ options and ids
   /**
@@ -3296,11 +3630,11 @@ function resolveYfiles(options) {
   return value;
 }
 function sniffGraphml(head) {
-  const text2 = new TextDecoder("utf-8", { fatal: false }).decode(head.subarray(0, SNIFF_BYTES));
+  const text2 = sniffXmlText(head.subarray(0, SNIFF_BYTES));
   if (!/^\uFEFF?\s*</.test(text2)) {
     return 0;
   }
-  const root = text2.indexOf("<graphml");
+  const root = text2.search(/<([\w.-]+:)?graphml[\s>/]/);
   if (root >= 0) {
     return text2.includes(GRAPHML_NAMESPACE, root) ? 1 : 0.9;
   }
@@ -3314,8 +3648,14 @@ 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 });
     }
@@ -3327,15 +3667,34 @@ async function importGraphml(input, sink, options) {
 }
 const graphmlImporter = Object.freeze({
   format: FORMAT,
+  options: Object.freeze(["yfiles"]),
   extensions: EXTENSIONS,
   mimeTypes: MIME_TYPES,
   sniff: sniffGraphml,
   import: importGraphml
 });
+const GRAPHML_ELEMENTS = /* @__PURE__ */ new Set([
+  "graphml",
+  "key",
+  "default",
+  "graph",
+  "node",
+  "edge",
+  "hyperedge",
+  "endpoint",
+  "port",
+  "data",
+  "desc",
+  "locator"
+]);
+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`;
+}
 export {
-  GRAPHML_ISSUE as G,
-  GRAPHML_LOSS as a,
-  graphmlImporter as b,
+  graphmlImporter as a,
   graphmlExporter as g
 };
-//# sourceMappingURL=importer-DIrbbnAf.js.map
+//# sourceMappingURL=importer-DpEW5zeG.js.map