@graphty/graph-io 0.3.43 → 0.3.44

package/dist/gexf.js

@@ -1,274 +1,10 @@
-import { bF as TIME_TEXT_ROLE, bG as TIME_TEXT_SUFFIX, al as resolveImportOptions, a8 as ImportReportBuilder, ao as reportSinkOptions, an as reportUnusedOptions, a4 as textChunks, E as EMPTY_INPUT_CODE, X as XML_SYNTAX_CODE, am as throwIfAborted, ar as IdCoercer, aq as DirectionResolver, f as STRAY_TEXT_CODE, N as NO_GRAPH_CODE, h as UNKNOWN_XML_ATTRIBUTE_CODE, l as MULTIPLE_GRAPHS_CODE, j as COUNT_MISMATCH_CODE, k as COUNT_HINT_CODE, o as DUPLICATE_ATTRIBUTE_CODE, aJ as isWeightField, bH as declareAttribute, a1 as declareResolved, t as MISSING_ID_CODE, n as DUPLICATE_NODE_CODE, q as UNKNOWN_PARENT_CODE, ai as PARENT_CYCLE_CODE, s as MISSING_ENDPOINT_CODE, m as DUPLICATE_EDGE_ID_CODE, aK as parseWeightText, bI as overflowsToInfinity, P as PRECISION_CODE, bJ as parseDeclaredTemporal, br as declareCompanion, bK as parseDeclaredValue, bL as losesPrecision, bM as parseTimeText, a3 as BAD_VALUE_CODE, bN as splitListText, g as UNKNOWN_ELEMENT_CODE, I as ID_MERGED_CODE, bO as timeTextCompanion, bP as parseDecimalText, c as capabilities, L as LOSS, aE as sanitizeIds, p as pairFolding, e as explicitWeights, r as resolveExportOptions, a as checkCapabilities, aa as formatF32, ab as formatF64, bQ as formatTimeValue, bR as mapDeclaredType, bS as joinListText, bT as formatTemporal, aG as formatInteger, b as plural, $ as agree, bx as isCanonicalIntegerText, M as MIXED_DIRECTION_CODE, D as DIRECTION_FORCED_CODE, d as DIRECTION_REFUSED_CODE, S as SINK_OPTION_CODE, O as OPTION_IGNORED_CODE, R as ROLE_TAKEN_CODE, C as COLUMN_RENAMED_CODE, aZ as BAD_OPTIONS_CODE, B as BAD_DEFAULT_CODE, U as UNKNOWN_ATTR_TYPE_CODE, v as ENCODING_CONFLICT_CODE, w as UNKNOWN_ENCODING_CODE, x as ENCODING_FALLBACK_CODE, y as INVALID_ENCODING_CODE, z as INVALID_UTF8_CODE, A as COLUMN_TYPE_CODE, F as ELEMENT_ISSUE, G as INPUT_ISSUE } from "./chunks/export-rKLeGQMo.js";
+import { Z as ImportReportBuilder, E as EMPTY_INPUT_CODE, X as XML_NESTING_CODE, v as XML_SYNTAX_CODE, b as STRAY_TEXT_CODE, N as NO_GRAPH_CODE, d as UNKNOWN_XML_ATTRIBUTE_CODE, h as MULTIPLE_GRAPHS_CODE, f as COUNT_MISMATCH_CODE, g as COUNT_HINT_CODE, k as DUPLICATE_ATTRIBUTE_CODE, n as MISSING_ID_CODE, j as DUPLICATE_NODE_CODE, l as UNKNOWN_PARENT_CODE, a6 as PARENT_CYCLE_CODE, m as MISSING_ENDPOINT_CODE, i as DUPLICATE_EDGE_ID_CODE, P as PRECISION_CODE, Y as BAD_VALUE_CODE, c as UNKNOWN_ELEMENT_CODE, I as ID_MERGED_CODE, $ as formatF32, a0 as formatF64, ad as formatInteger, p as plural, V as agree, M as MIXED_DIRECTION_CODE, D as DIRECTION_FORCED_CODE, a as DIRECTION_REFUSED_CODE, S as SINK_OPTION_CODE, O as OPTION_IGNORED_CODE, R as ROLE_TAKEN_CODE, C as COLUMN_RENAMED_CODE, ae as BAD_OPTIONS_CODE, B as BAD_DEFAULT_CODE, U as UNKNOWN_ATTR_TYPE_CODE, q as ENCODING_CONFLICT_CODE, r as UNKNOWN_ENCODING_CODE, s as ENCODING_FALLBACK_CODE, t as INVALID_ENCODING_CODE, u as INVALID_UTF8_CODE, w as COLUMN_TYPE_CODE, x as ELEMENT_ISSUE, y as INPUT_ISSUE } from "./chunks/format-GDmO6m6Q.js";
 import { GraphFormatError, INVALID_INDEX, MAX_COUNT } from "@graphty/graph-format";
-import { t as tokenizeXml, f as xmlDeclaredEncoding, g as XmlEmptyInputError, X as XmlSyntaxError, s as sniffXmlText, l as localName, j as isWhitespace, x as xmlIllegalTextNotes, a as escapeXmlText, e as escapeXmlAttribute } from "./chunks/escape-B62ZGM_a.js";
+import { g as resolveImportOptions, j as reportSinkOptions, i as reportUnusedOptions, t as textChunks, h as throwIfAborted, I as IdCoercer, l as DirectionResolver, o as isWeightField, q as declareAttribute, d as declareResolved, s as parseWeightText, v as overflowsToInfinity, x as parseDeclaredTemporal, y as declareCompanion, z as parseDeclaredValue, A as losesPrecision, B as parseTimeText, C as splitListText, E as timeTextCompanion, F as parseDecimalText, c as capabilities, L as LOSS, G as sanitizeIds, p as pairFolding, e as explicitWeights, r as resolveExportOptions, a as checkCapabilities, H as formatTimeValue, J as mapDeclaredType, K as joinListText, N as formatTemporal, O as isCanonicalIntegerText } from "./chunks/export-D7IGzTG4.js";
+import { t as tokenizeXml, b as xmlDeclaredEncoding, X as XmlEmptyInputError, c as XmlSyntaxError, d as XmlNestingError, s as sniffXmlText, l as localName, i as isWhitespace, x as xmlIllegalTextNotes, a as escapeXmlText, e as escapeXmlAttribute } from "./chunks/escape-B1rMftd9.js";
+import { t as MAX_STYLE_BLOCK_LENGTH } from "./chunks/block-JQiwViEt.js";
+import { g as gexfStyles, G as GEXF_FORMAT, N as NODE_DECLS, E as EDGE_DECLS, a as GRAPHTY_XML_NAMESPACE, b as GRAPH_MODES, T as TIME_FORMATS, c as TIME_REPRESENTATIONS, t as temporalTableName, d as temporalTableDecls, e as canonVizColor, O as OPEN_START, f as OPEN_END, R as RESERVED_NODE_NAMES, h as RESERVED_EDGE_NAMES, i as gexfStyledExport, j as GEXF_STYLE_CAPABILITIES, k as GEXF_NAMESPACES, p as parseTemporalTableName, l as TEMPORAL_COLUMNS, m as NODE_COLUMNS, V as VIZ_NAMESPACE, n as isListType, o as canonicalScalarType, q as isScalarType } from "./chunks/styles-Brt9JMfs.js";
 import { j as joinText, e as encodeChunks } from "./chunks/writer-DxjgHwSe.js";
-const GEXF_FORMAT = "gexf";
-const GEXF_NAMESPACES = {
-  "1.2": { gexf: "http://www.gexf.net/1.2draft", viz: "http://www.gexf.net/1.2draft/viz" },
-  "1.3": { gexf: "http://gexf.net/1.3", viz: "http://gexf.net/1.3/viz" }
-};
-const TIME_FORMATS = /* @__PURE__ */ new Set(["integer", "double", "date", "dateTime"]);
-const GRAPH_MODES = /* @__PURE__ */ new Set(["static", "dynamic", "slice"]);
-const TIME_REPRESENTATIONS = /* @__PURE__ */ new Set(["interval", "timestamp"]);
-const VIZ_NAMESPACE = "viz";
-const XML_ORIGIN = { format: GEXF_FORMAT };
-const VIZ_ORIGIN = { format: GEXF_FORMAT, namespace: VIZ_NAMESPACE };
-const NODE_COLUMNS = Object.freeze({
-  label: "label",
-  parent: "parent",
-  parents: "parents",
-  start: "start",
-  end: "end",
-  timestamp: "timestamp",
-  spells: "spells",
-  spellsOpen: "spells.open",
-  timestamps: "timestamps",
-  open: "open",
-  position: "position",
-  color: "color",
-  size: "size",
-  shape: "shape",
-  shapeUri: "shape.uri"
-});
-const EDGE_COLUMNS = Object.freeze({
-  id: "id",
-  label: "label",
-  kind: "kind",
-  start: "start",
-  end: "end",
-  timestamp: "timestamp",
-  spells: "spells",
-  spellsOpen: "spells.open",
-  timestamps: "timestamps",
-  open: "open",
-  color: "color",
-  thickness: "thickness",
-  shape: "shape"
-});
-const RESERVED_NODE_NAMES = /* @__PURE__ */ new Set([
-  ...Object.values(NODE_COLUMNS),
-  NODE_COLUMNS.start + TIME_TEXT_SUFFIX,
-  NODE_COLUMNS.end + TIME_TEXT_SUFFIX,
-  NODE_COLUMNS.timestamp + TIME_TEXT_SUFFIX
-]);
-const RESERVED_EDGE_NAMES = /* @__PURE__ */ new Set([
-  ...Object.values(EDGE_COLUMNS),
-  EDGE_COLUMNS.start + TIME_TEXT_SUFFIX,
-  EDGE_COLUMNS.end + TIME_TEXT_SUFFIX,
-  EDGE_COLUMNS.timestamp + TIME_TEXT_SUFFIX
-]);
-const NODE_DECLS = {
-  label: { name: NODE_COLUMNS.label, dtype: "string", role: "label", nullable: true, origin: XML_ORIGIN },
-  parent: {
-    name: NODE_COLUMNS.parent,
-    dtype: "u32",
-    role: "parent",
-    refersTo: "node",
-    nullable: true,
-    origin: XML_ORIGIN
-  },
-  parents: {
-    name: NODE_COLUMNS.parents,
-    dtype: "list",
-    itemDtype: "u32",
-    role: "parents",
-    refersTo: "node",
-    nullable: true,
-    origin: XML_ORIGIN
-  },
-  start: { name: NODE_COLUMNS.start, dtype: "f64", role: "start", nullable: true, origin: XML_ORIGIN },
-  end: { name: NODE_COLUMNS.end, dtype: "f64", role: "end", nullable: true, origin: XML_ORIGIN },
-  timestamp: { name: NODE_COLUMNS.timestamp, dtype: "f64", role: "timestamp", nullable: true, origin: XML_ORIGIN },
-  spells: {
-    name: NODE_COLUMNS.spells,
-    dtype: "list",
-    itemDtype: "f64",
-    itemComponents: 2,
-    role: "spells",
-    nullable: true,
-    origin: XML_ORIGIN
-  },
-  timestamps: {
-    name: NODE_COLUMNS.timestamps,
-    dtype: "list",
-    itemDtype: "f64",
-    role: "timestamps",
-    nullable: true,
-    origin: XML_ORIGIN
-  },
-  open: { name: NODE_COLUMNS.open, dtype: "u8", role: "open", nullable: true, origin: XML_ORIGIN },
-  spellsOpen: {
-    name: NODE_COLUMNS.spellsOpen,
-    dtype: "list",
-    itemDtype: "u8",
-    role: "spellsOpen",
-    nullable: true,
-    origin: XML_ORIGIN
-  },
-  position: {
-    name: NODE_COLUMNS.position,
-    dtype: "f64",
-    components: 3,
-    role: "position",
-    mutable: true,
-    nullable: true,
-    origin: VIZ_ORIGIN,
-    extra: { units: "file" }
-  },
-  color: {
-    name: NODE_COLUMNS.color,
-    dtype: "f32",
-    components: 4,
-    role: "color",
-    nullable: true,
-    origin: VIZ_ORIGIN
-  },
-  size: { name: NODE_COLUMNS.size, dtype: "f32", role: "size", nullable: true, origin: VIZ_ORIGIN },
-  shape: { name: NODE_COLUMNS.shape, dtype: "dict", role: "shape", nullable: true, origin: VIZ_ORIGIN },
-  shapeUri: { name: NODE_COLUMNS.shapeUri, dtype: "string", nullable: true, origin: VIZ_ORIGIN }
-};
-const EDGE_DECLS = {
-  id: { name: EDGE_COLUMNS.id, dtype: "string", role: "id", unique: true, nullable: true, origin: XML_ORIGIN },
-  label: { name: EDGE_COLUMNS.label, dtype: "string", role: "label", nullable: true, origin: XML_ORIGIN },
-  kind: { name: EDGE_COLUMNS.kind, dtype: "dict", role: "kind", nullable: true, origin: XML_ORIGIN },
-  start: { name: EDGE_COLUMNS.start, dtype: "f64", role: "start", nullable: true, origin: XML_ORIGIN },
-  end: { name: EDGE_COLUMNS.end, dtype: "f64", role: "end", nullable: true, origin: XML_ORIGIN },
-  timestamp: { name: EDGE_COLUMNS.timestamp, dtype: "f64", role: "timestamp", nullable: true, origin: XML_ORIGIN },
-  spells: {
-    name: EDGE_COLUMNS.spells,
-    dtype: "list",
-    itemDtype: "f64",
-    itemComponents: 2,
-    role: "spells",
-    nullable: true,
-    origin: XML_ORIGIN
-  },
-  timestamps: {
-    name: EDGE_COLUMNS.timestamps,
-    dtype: "list",
-    itemDtype: "f64",
-    role: "timestamps",
-    nullable: true,
-    origin: XML_ORIGIN
-  },
-  open: { name: EDGE_COLUMNS.open, dtype: "u8", role: "open", nullable: true, origin: XML_ORIGIN },
-  spellsOpen: {
-    name: EDGE_COLUMNS.spellsOpen,
-    dtype: "list",
-    itemDtype: "u8",
-    role: "spellsOpen",
-    nullable: true,
-    origin: XML_ORIGIN
-  },
-  color: {
-    name: EDGE_COLUMNS.color,
-    dtype: "f32",
-    components: 4,
-    role: "color",
-    nullable: true,
-    origin: VIZ_ORIGIN
-  },
-  thickness: { name: EDGE_COLUMNS.thickness, dtype: "f32", role: "thickness", nullable: true, origin: VIZ_ORIGIN },
-  shape: { name: EDGE_COLUMNS.shape, dtype: "dict", role: "shape", nullable: true, origin: VIZ_ORIGIN }
-};
-const OPEN_START = 1;
-const OPEN_END = 2;
-const TEMPORAL_TABLE_PREFIX = "temporal:";
-const TEMPORAL_COLUMNS = Object.freeze({
-  element: "element",
-  start: "start",
-  end: "end",
-  value: "value",
-  open: "open",
-  startText: `start${TIME_TEXT_SUFFIX}`,
-  endText: `end${TIME_TEXT_SUFFIX}`,
-  valueText: `value${TIME_TEXT_SUFFIX}`
-});
-function temporalTableName(domain, column) {
-  return `${TEMPORAL_TABLE_PREFIX}${domain}:${column}`;
-}
-function parseTemporalTableName(name) {
-  if (!name.startsWith(TEMPORAL_TABLE_PREFIX)) {
-    return null;
-  }
-  const rest = name.slice(TEMPORAL_TABLE_PREFIX.length);
-  const colon = rest.indexOf(":");
-  if (colon < 0) {
-    return null;
-  }
-  const domain = rest.slice(0, colon);
-  if (domain !== "node" && domain !== "edge") {
-    return null;
-  }
-  return { domain, column: rest.slice(colon + 1) };
-}
-function temporalTableDecls(domain, value, temporalValue) {
-  const decls = [
-    { name: TEMPORAL_COLUMNS.element, dtype: "u32", refersTo: domain, nullable: false },
-    { name: TEMPORAL_COLUMNS.start, dtype: "f64", role: "start", nullable: true },
-    { name: TEMPORAL_COLUMNS.end, dtype: "f64", role: "end", nullable: true },
-    { name: TEMPORAL_COLUMNS.value, ...value, nullable: true },
-    {
-      name: TEMPORAL_COLUMNS.startText,
-      dtype: "string",
-      role: TIME_TEXT_ROLE,
-      nullable: true,
-      extra: { for: TEMPORAL_COLUMNS.start }
-    },
-    { name: TEMPORAL_COLUMNS.endText, dtype: "string", nullable: true, extra: { for: TEMPORAL_COLUMNS.end } },
-    { name: TEMPORAL_COLUMNS.open, dtype: "u8", role: "open", nullable: true }
-  ];
-  if (temporalValue) {
-    decls.push({
-      name: TEMPORAL_COLUMNS.valueText,
-      dtype: "string",
-      nullable: true,
-      extra: { for: TEMPORAL_COLUMNS.value }
-    });
-  }
-  return decls;
-}
-const TYPES_1_2 = /* @__PURE__ */ new Set(["integer", "long", "double", "float", "boolean", "string", "anyURI"]);
-const TYPES_1_3 = /* @__PURE__ */ new Set([
-  ...TYPES_1_2,
-  "bigdecimal",
-  "biginteger",
-  "byte",
-  "char",
-  "short",
-  "date",
-  "dateTime"
-]);
-function isScalarType(type, version) {
-  return (version === "1.2" ? TYPES_1_2 : TYPES_1_3).has(type);
-}
-function isListType(type, version) {
-  return type.startsWith("list") && type.length > 4 && isScalarType(type.slice(4), "1.3");
-}
-function canonicalScalarType(dtype) {
-  switch (dtype) {
-    case "bool":
-      return "boolean";
-    case "i32":
-    case "u8":
-      return "integer";
-    case "u32":
-      return "long";
-    case "f32":
-      return "float";
-    case "f64":
-      return "double";
-    case "dict":
-    case "string":
-    case "json":
-    case "list":
-      return "string";
-    default: {
-      const name = dtype;
-      return name;
-    }
-  }
-}
 const NOT_GEXF_CODE = "E_NOT_GEXF";
 const MISSING_NODES_CODE = "E_GEXF_MISSING_NODES";
 const EDGE_TYPE_CODE = "E_GEXF_EDGE_TYPE";
@@ -281,6 +17,7 @@ const ATTVALUE_SHAPE_CODE = "W_GEXF_ATTVALUE_SHAPE";
 const TIMED_STATIC_CODE = "W_GEXF_TIMED_VALUE_ON_STATIC";
 const WEIGHT_IGNORED_CODE = "W_GEXF_WEIGHT_IGNORED";
 const VIZ_SKIPPED_CODE = "W_GEXF_VIZ_SKIPPED";
+const UNKNOWN_PID_CODE = "W_GEXF_UNKNOWN_PID";
 const VIZ_DYNAMIC_CODE = "W_GEXF_VIZ_DYNAMIC_DROPPED";
 const SPELL_OPEN_CODE = "W_GEXF_SPELL_OPEN_DROPPED";
 const VIZ_VALUE_CODE = "W_GEXF_VIZ_VALUE";
@@ -289,6 +26,9 @@ const TIMESTAMP_CONFLICT_CODE = "W_GEXF_TIMESTAMP_CONFLICT";
 const VALUE_OUTSIDE_OPTIONS_CODE = "W_GEXF_VALUE_OUTSIDE_OPTIONS";
 const VERSIONS = /* @__PURE__ */ new Set(["1.0", "1.1", "1.2", "1.3"]);
 function namespaceVersion(ns) {
+  if (ns !== null && /gephi\.org\/gexf\/?$/.test(ns)) {
+    return "1.0";
+  }
   const match = ns === null ? null : /gexf\.net\/(1\.[0-3])/.exec(ns);
   return match === null ? null : match[1];
 }
@@ -335,8 +75,14 @@ function isDateText(text) {
 }
 const EDGE_TYPES = /* @__PURE__ */ new Set(["directed", "undirected", "mutual"]);
 function edgeTypeKeyword(text) {
-  return text.trim().toLowerCase();
+  const keyword = text.trim().toLowerCase();
+  return EDGE_TYPE_ALIASES.get(keyword) ?? keyword;
 }
+const EDGE_TYPE_ALIASES = /* @__PURE__ */ new Map([
+  ["dir", "directed"],
+  ["undir", "undirected"],
+  ["double", "mutual"]
+]);
 const ABORT_CHECK_INTERVAL = 64;
 const NODE_ATTRIBUTES = /* @__PURE__ */ new Set([
   "id",
@@ -472,6 +218,9 @@ class GexfReader {
     this.meta = { sourceFormat: GEXF_FORMAT };
     this.metaText = "";
     this.metaField = null;
+    this.styleBlock = "";
+    this.implicitNodes = /* @__PURE__ */ new Map();
+    this.edgesFirst = false;
     this.nodeAttrs = /* @__PURE__ */ new Map();
     this.edgeAttrs = /* @__PURE__ */ new Map();
     this.declaredNodeNames = /* @__PURE__ */ new Set();
@@ -548,7 +297,7 @@ class GexfReader {
   start(name, attrs, line, ns = "") {
     const parent = this.ctx.at(-1) ?? null;
     const local = localName(name);
-    if (ns === null && parent !== null && parent !== 14 && parent !== 2 && parent !== 6 && !name.startsWith("viz:")) {
+    if (ns === null && parent !== null && parent !== 14 && parent !== 2 && parent !== 6 && parent !== 15 && !name.startsWith("viz:")) {
       this.unknownElement(name, line);
       return;
     }
@@ -568,7 +317,7 @@ class GexfReader {
         this.startInGexf(name, local, attrs, line);
         return;
       case 1:
-        this.startInMeta(name, local, line);
+        this.startInMeta(name, local, line, ns);
         return;
       case 3:
         this.startInGraph(name, local, attrs, line);
@@ -602,6 +351,7 @@ class GexfReader {
         return;
       case 2:
       case 6:
+      case 15:
       case 14:
         this.ctx.push(
           14
@@ -626,8 +376,21 @@ class GexfReader {
       case 2:
         this.finishMetaText();
         return;
+      case 15:
+        this.report.keepForStyles(this.styleBlock);
+        this.styleBlock = "";
+        return;
       case 3:
         this.resolveParents();
+        if (!this.nodesSeen && this.implicitNodes.size > 0) {
+          this.report.error(
+            "validation-error",
+            MISSING_NODES_CODE,
+            "the graph declares <edges> but no <nodes>"
+          );
+        } else if (!this.options.addMissingNodes) {
+          this.dropUndeclaredNodes();
+        }
         return;
       case 4:
         this.attributeGroup = null;
@@ -680,6 +443,11 @@ class GexfReader {
       case 6:
         this.attributeTextValue += text;
         return;
+      case 15:
+        if (this.styleBlock.length <= MAX_STYLE_BLOCK_LENGTH) {
+          this.styleBlock += text.slice(0, MAX_STYLE_BLOCK_LENGTH + 1 - this.styleBlock.length);
+        }
+        return;
       case 14:
         return;
       default:
@@ -792,8 +560,17 @@ class GexfReader {
    * @param name - the element name
    * @param local - its local name
    * @param line - the line
+   * @param ns - its namespace
    */
-  startInMeta(name, local, line) {
+  startInMeta(name, local, line, ns) {
+    if (ns === GRAPHTY_XML_NAMESPACE && local === "styles") {
+      this.styleBlock = "";
+      this.ctx.push(
+        15
+        /* StyleBlock */
+      );
+      return;
+    }
     if (local === "creator" || local === "description" || local === "keywords") {
       this.metaField = local;
       this.metaText = "";
@@ -926,7 +703,9 @@ class GexfReader {
         this.beginSection(attrs, "node", line);
         return;
       case "edges":
-        if (!this.nodesSeen) {
+        if (!this.nodesSeen && this.meta.sourceVersion === "1.0") {
+          this.edgesFirst = true;
+        } else if (!this.nodesSeen) {
           this.report.error(
             "validation-error",
             MISSING_NODES_CODE,
@@ -1319,7 +1098,9 @@ class GexfReader {
     try {
       const id = this.coerceId(idText, where);
       const existing = sink.indexOf(id);
-      if (existing !== INVALID_INDEX) {
+      if (existing !== INVALID_INDEX && this.implicitNodes.delete(existing)) {
+        index = existing;
+      } else if (existing !== INVALID_INDEX) {
         report.warning(
           "validation-error",
           DUPLICATE_NODE_CODE,
@@ -1519,20 +1300,8 @@ class GexfReader {
       return false;
     };
     for (const ref of refs) {
-      let parent = ref.parentIndex;
-      if (ref.parentId !== null) {
-        parent = sink.indexOf(ref.parentId);
-        if (parent === INVALID_INDEX) {
-          report.error(
-            "missing-value",
-            UNKNOWN_PARENT_CODE,
-            `pid "${String(ref.parentId)}" names a node the document does not declare`,
-            ref.where
-          );
-          continue;
-        }
-      }
-      if (parentOf.get(ref.child) === parent) {
+      const parent = this.parentIndexOf(ref);
+      if (parent === null || parentOf.get(ref.child) === parent) {
         continue;
       }
       if (isAncestorOrSelf(ref.child, parent)) {
@@ -1558,27 +1327,64 @@ class GexfReader {
    * @param lists - the queued `<parents>` lists
    */
   resolveParentsLists(lists) {
-    const { sink, report } = this;
     for (const ref of lists) {
-      const indices = [];
-      for (const id of ref.ids) {
-        const parent = sink.indexOf(id);
-        if (parent === INVALID_INDEX) {
-          report.error(
-            "missing-value",
-            UNKNOWN_PARENT_CODE,
-            `<parent for="${String(id)}"> names a node the document does not declare`,
-            ref.where
-          );
-          continue;
-        }
-        indices.push(parent);
-      }
-      try {
-        this.parentsColumn.set(sink, report, ref.child, indices, ref.where);
-      } catch (err) {
-        report.recordError(err, ref.where);
+      this.resolveParentsList(ref);
+    }
+  }
+  /**
+   * The parent a `pid` or a nesting names.
+   * @param ref - the reference
+   * @returns its index, or null when the id names no node (reported)
+   */
+  parentIndexOf(ref) {
+    if (ref.parentId === null) {
+      return ref.parentIndex;
+    }
+    const parent = this.sink.indexOf(ref.parentId);
+    if (parent !== INVALID_INDEX) {
+      return parent;
+    }
+    if (this.meta.sourceVersion === "1.0") {
+      this.report.warnOnce(
+        "missing-value",
+        UNKNOWN_PID_CODE,
+        `pid "${String(ref.parentId)}" names no node; GEXF 1.0 files write it on top-level nodes, which stay top-level`,
+        ref.where
+      );
+    } else {
+      this.report.error(
+        "missing-value",
+        UNKNOWN_PARENT_CODE,
+        `pid "${String(ref.parentId)}" names a node the document does not declare`,
+        ref.where
+      );
+    }
+    return null;
+  }
+  /**
+   * Resolve one `<parents>` list; an id that names no node is reported and left out.
+   * @param ref - the list
+   */
+  resolveParentsList(ref) {
+    const { sink, report } = this;
+    const indices = [];
+    for (const id of ref.ids) {
+      const parent = sink.indexOf(id);
+      if (parent === INVALID_INDEX) {
+        report.error(
+          "missing-value",
+          UNKNOWN_PARENT_CODE,
+          `<parent for="${String(id)}"> names a node the document does not declare`,
+          ref.where
+        );
+        continue;
       }
+      indices.push(parent);
+    }
+    try {
+      this.parentsColumn.set(sink, report, ref.child, indices, ref.where);
+    } catch (err) {
+      report.recordError(err, ref.where);
     }
   }
   // ---------------------------------------------------------------- edges
@@ -1627,21 +1433,10 @@ class GexfReader {
       report.counts.skippedEdges++;
       return;
     }
-    let kind = this.defaultKind;
-    const typeText = attrs.get("type");
-    if (typeText !== void 0) {
-      const type = edgeTypeKeyword(typeText);
-      if (!EDGE_TYPES.has(type)) {
-        report.error(
-          "validation-error",
-          EDGE_TYPE_CODE,
-          `edge type "${typeText}" is not directed, undirected or mutual`,
-          where
-        );
-        report.counts.skippedEdges++;
-        return;
-      }
-      kind = type;
+    const kind = this.edgeKindOf(attrs, where);
+    if (kind === null) {
+      report.counts.skippedEdges++;
+      return;
     }
     if (idText !== void 0 && this.edgeIds.has(idText)) {
       report.error(
@@ -1655,9 +1450,7 @@ class GexfReader {
     }
     let index;
     try {
-      const source = this.coerceId(sourceText, where);
-      const target = this.coerceId(targetText, where);
-      this.requireDeclaredEndpoints(source, target, sourceText, targetText);
+      const [source, target] = this.endpoints(sourceText, targetText, where);
       const weight = this.xmlWeight(attrs, where);
       const before = sink.edgeCount;
       index = this.resolver.addEdge(source, target, kind, weight, where);
@@ -1675,40 +1468,68 @@ class GexfReader {
     frame.mirror = this.resolver.lastMirror;
     frame.xmlWeight = attrs.get("weight") ?? null;
     this.edge = frame;
-    this.writeEdgeColumns(attrs, index, idText, where);
+    this.writeEdgeAttributes(attrs, index, where);
   }
   /**
-   * Throw when addMissingNodes is off and an endpoint names an undeclared node.
-   * @param source - the coerced source id
-   * @param target - the coerced target id
-   * @param sourceText - the source as written
-   * @param targetText - the target as written
+   * The kind of an `<edge>`: its `type`, else the graph's default.
+   * @param attrs - its attributes
+   * @param where - where it was read
+   * @returns the kind, or null for a type GEXF does not have (reported)
    */
-  requireDeclaredEndpoints(source, target, sourceText, targetText) {
-    const { sink, options } = this;
-    if (options.addMissingNodes) {
-      return;
+  edgeKindOf(attrs, where) {
+    const typeText = attrs.get("type");
+    if (typeText === void 0) {
+      return this.defaultKind;
     }
-    if (sink.indexOf(source) === INVALID_INDEX) {
-      throw new GraphFormatError("E_UNKNOWN_NODE", `edge references undeclared node "${sourceText}"`, {
-        id: source
-      });
+    const type = edgeTypeKeyword(typeText);
+    if (!EDGE_TYPES.has(type)) {
+      this.report.error(
+        "validation-error",
+        EDGE_TYPE_CODE,
+        `edge type "${typeText}" is not directed, undirected or mutual`,
+        where
+      );
+      return null;
     }
-    if (sink.indexOf(target) === INVALID_INDEX) {
-      throw new GraphFormatError("E_UNKNOWN_NODE", `edge references undeclared node "${targetText}"`, {
-        id: target
+    return type;
+  }
+  /**
+   * An edge's endpoints: in GEXF 1.0 with its edges first, a node no `<node>` declared yet is added for now; without
+   * addMissingNodes, a node the document does not declare throws E_UNKNOWN_NODE.
+   * @param sourceText - the source's id text
+   * @param targetText - the target's id text
+   * @param where - where it was read
+   * @returns the ids
+   */
+  endpoints(sourceText, targetText, where) {
+    const { sink } = this;
+    const ends = [this.coerceId(sourceText, where), this.coerceId(targetText, where)];
+    if (this.edgesFirst && !this.nodesSeen) {
+      for (const end of ends) {
+        if (sink.indexOf(end) === INVALID_INDEX) {
+          this.implicitNodes.set(sink.addNode(end), end);
+          this.report.counts.nodes++;
+        }
+      }
+    }
+    const texts = [sourceText, targetText];
+    const unknown = this.options.addMissingNodes ? -1 : ends.findIndex((id) => sink.indexOf(id) === INVALID_INDEX);
+    if (unknown !== -1) {
+      throw new GraphFormatError("E_UNKNOWN_NODE", `edge references undeclared node "${texts[unknown]}"`, {
+        id: ends[unknown]
       });
     }
+    return ends;
   }
   /**
-   * Write the id, label, kind and lifetime columns of an added edge; a failure is reported.
-   * @param attrs - the edge's attributes
-   * @param index - the edge's index
-   * @param idText - the edge's id, or undefined
-   * @param where - the edge's location
+   * Write an added edge's id, label, kind and lifetime.
+   * @param attrs - its attributes
+   * @param index - its index
+   * @param where - where it was read
    */
-  writeEdgeColumns(attrs, index, idText, where) {
+  writeEdgeAttributes(attrs, index, where) {
     const { report, sink } = this;
+    const idText = attrs.get("id");
     try {
       if (idText !== void 0) {
         this.edgeIdColumn.set(sink, report, index, idText, where);
@@ -1726,6 +1547,25 @@ class GexfReader {
       report.recordError(err, where);
     }
   }
+  /**
+   * GEXF 1.0 with its edges first, addMissingNodes false: a node an edge named that no `<node>` declared is an
+   * unknown node, as it is when the nodes come first. It is reported, and it and its edges are removed when the
+   * sink can remove nodes.
+   */
+  dropUndeclaredNodes() {
+    const { sink, report } = this;
+    const removable = sink;
+    for (const [index, id] of this.implicitNodes) {
+      report.error("validation-error", "E_UNKNOWN_NODE", `edge references undeclared node "${String(id)}"`);
+      if (typeof removable.removeNodeByIndex === "function") {
+        const edges = removable.removeNodeByIndex(index);
+        report.counts.nodes--;
+        report.counts.edges -= edges.length;
+        report.counts.skippedEdges += edges.length;
+      }
+    }
+    this.implicitNodes.clear();
+  }
   /**
    * The weight argument of one edge from its `weight` XML attribute; undefined when absent (the
    * sink records a defaulted weight, design section 3.7).
@@ -1853,7 +1693,7 @@ class GexfReader {
     if (index === INVALID_INDEX) {
       return;
     }
-    const forId = attrs.get("for");
+    const forId = attrs.get("for") ?? attrs.get("id");
     const { valueWhere } = this;
     valueWhere.line = line;
     valueWhere.element = element;
@@ -2332,6 +2172,43 @@ class GexfReader {
     }
   }
   // ---------------------------------------------------------------- viz
+  /**
+   * Write a `<viz:position>` into the node position column, declared on first use with the
+   * dimensions the element writes.
+   * @param attrs - its attributes
+   * @param index - the node's index
+   * @param where - the element's location
+   */
+  writeVizPosition(attrs, index, where) {
+    const x = vizNumber(attrs, "x");
+    const y = vizNumber(attrs, "y");
+    const z = attrs.has("z") ? vizNumber(attrs, "z") : 0;
+    this.positionColumn ??= new LazyColumn("node", {
+      ...NODE_DECLS.position,
+      extra: { ...NODE_DECLS.position.extra, sourceDims: attrs.has("z") ? 3 : 2 }
+    });
+    this.positionColumn.set(this.sink, this.report, index, [x, y, z], where);
+  }
+  /**
+   * Write a `<viz:shape>` into the shape column, and a node's image `uri` beside it.
+   * @param name - the element name as written
+   * @param attrs - its attributes
+   * @param domain - node or edge
+   * @param index - the element's index
+   * @param where - the element's location
+   */
+  writeVizShape(name, attrs, domain, index, where) {
+    const value = attrs.get("value");
+    if (value === void 0) {
+      throw new GraphFormatError("E_COLUMN_TYPE", "<viz:shape> without a value", { element: name });
+    }
+    const columns = domain === "node" ? this.nodeColumns : this.edgeColumns;
+    columns.shape.set(this.sink, this.report, index, value, where);
+    const uri = attrs.get("uri");
+    if (domain === "node" && uri !== void 0) {
+      this.shapeUriColumn.set(this.sink, this.report, index, uri, where);
+    }
+  }
   /**
    * Write one viz element into its role column; a value that does not parse is a recorded
    * warning and the element is skipped.
@@ -2360,10 +2237,10 @@ class GexfReader {
     try {
       switch (local) {
         case "color":
-          columns.color.set(sink, report, index, parseColor(attrs), where);
+          columns.color.set(sink, report, index, this.vizColor(attrs, name, where), where);
           break;
         case "position":
-          this.writePosition(attrs, index, where);
+          this.writeVizPosition(attrs, index, where);
           break;
         case "size":
           this.sizeColumn.set(sink, report, index, vizNumber(attrs, "value"), where);
@@ -2372,7 +2249,7 @@ class GexfReader {
           this.thicknessColumn.set(sink, report, index, vizNumber(attrs, "value"), where);
           break;
         case "shape":
-          this.writeShape(name, attrs, domain, index, where);
+          this.writeVizShape(name, attrs, domain, index, where);
           break;
         default:
           break;
@@ -2385,41 +2262,45 @@ class GexfReader {
     }
   }
   /**
-   * Write a `<viz:position>`.
-   * @param attrs - its attributes
-   * @param index - the node's index
-   * @param where - the node's location
-   */
-  writePosition(attrs, index, where) {
-    const x = vizNumber(attrs, "x");
-    const y = vizNumber(attrs, "y");
-    const z = attrs.has("z") ? vizNumber(attrs, "z") : 0;
-    this.positionColumn ??= new LazyColumn("node", {
-      ...NODE_DECLS.position,
-      extra: { ...NODE_DECLS.position.extra, sourceDims: attrs.has("z") ? 3 : 2 }
-    });
-    this.positionColumn.set(this.sink, this.report, index, [x, y, z], where);
-  }
-  /**
-   * Write a `<viz:shape>` and, on a node, its `uri`.
+   * `<viz:color r g b a hex>` as rgba in 0..1 (design section 5.5: role color, f32 x4). `hex` is read as
+   * `#rgb`, `#rgba`, `#rrggbb` or `#rrggbbaa`; a channel outside 0..255 or an alpha outside 0..1 is clamped and
+   * reported, as Gephi clamps it.
+   * @param attrs - the element's attributes
    * @param name - the element name as written
-   * @param attrs - its attributes
-   * @param domain - node or edge
-   * @param index - the element's index
    * @param where - the element's location
-   */
-  writeShape(name, attrs, domain, index, where) {
-    const { sink, report } = this;
-    const columns = domain === "node" ? this.nodeColumns : this.edgeColumns;
-    const value = attrs.get("value");
-    if (value === void 0) {
-      throw new GraphFormatError("E_COLUMN_TYPE", "<viz:shape> without a value", { element: name });
+   * @returns [r, g, b, a]
+   */
+  vizColor(attrs, name, where) {
+    const hex = attrs.get("hex");
+    let rgba;
+    if (hex !== void 0 && !attrs.has("r")) {
+      const c = canonVizColor(hex);
+      if (c === null) {
+        throw new GraphFormatError(
+          "E_COLUMN_TYPE",
+          `viz hex="${hex}" is not a #RRGGBB, #RGB or #RRGGBBAA color`,
+          { attribute: "hex" }
+        );
+      }
+      rgba = [...c];
+      if (attrs.has("a")) {
+        rgba[3] = vizNumber(attrs, "a");
+      }
+    } else {
+      rgba = [vizNumber(attrs, "r"), vizNumber(attrs, "g"), vizNumber(attrs, "b")];
+      rgba.push(attrs.has("a") ? vizNumber(attrs, "a") : 1);
     }
-    columns.shape.set(sink, report, index, value, where);
-    const uri = attrs.get("uri");
-    if (domain === "node" && uri !== void 0) {
-      this.shapeUriColumn.set(sink, report, index, uri, where);
+    const max = [255, 255, 255, 1];
+    if (rgba.some((v, i) => v < 0 || v > max[i])) {
+      this.report.warning(
+        "validation-error",
+        VIZ_VALUE_CODE,
+        `<${name}> has a channel outside 0..255 or an alpha outside 0..1; clamped`,
+        where
+      );
+      rgba = rgba.map((v, i) => Math.max(0, Math.min(max[i], v)));
     }
+    return [rgba[0] / 255, rgba[1] / 255, rgba[2] / 255, rgba[3]];
   }
   // ---------------------------------------------------------------- helpers
   /**
@@ -2555,29 +2436,6 @@ function vizNumber(attrs, name) {
   }
   return value;
 }
-function parseColor(attrs) {
-  let r;
-  let g;
-  let b;
-  const hex = attrs.get("hex");
-  if (hex !== void 0 && !attrs.has("r")) {
-    const digits = hex.startsWith("#") ? hex.slice(1) : hex;
-    if (!/^[0-9a-fA-F]{6}$/.test(digits)) {
-      throw new GraphFormatError("E_COLUMN_TYPE", `viz hex="${hex}" is not a #RRGGBB color`, {
-        attribute: "hex"
-      });
-    }
-    r = Number.parseInt(digits.slice(0, 2), 16);
-    g = Number.parseInt(digits.slice(2, 4), 16);
-    b = Number.parseInt(digits.slice(4, 6), 16);
-  } else {
-    r = vizNumber(attrs, "r");
-    g = vizNumber(attrs, "g");
-    b = vizNumber(attrs, "b");
-  }
-  const a = attrs.has("a") ? vizNumber(attrs, "a") : 1;
-  return [r / 255, g / 255, b / 255, a];
-}
 const XML_START = /^\uFEFF?\s*</;
 function sniffGexf(head) {
   const text = sniffXmlText(head);
@@ -2608,6 +2466,7 @@ const gexfImporter = Object.freeze({
   extensions: Object.freeze([".gexf"]),
   mimeTypes: Object.freeze(["application/gexf+xml", "application/xml", "text/xml"]),
   sniff: sniffGexf,
+  styles: gexfStyles,
   /**
    * Read a GEXF document into the sink in one streaming pass.
    * @param input - the document as text, bytes, a stream or chunks
@@ -2637,7 +2496,9 @@ const gexfImporter = Object.freeze({
         report.fail(EMPTY_INPUT_CODE, "the input is empty (no markup at all)", { line: err.line });
       }
       if (err instanceof XmlSyntaxError) {
-        report.fail(XML_SYNTAX_CODE, err.message, { line: err.line });
+        report.fail(err instanceof XmlNestingError ? XML_NESTING_CODE : XML_SYNTAX_CODE, err.message, {
+          line: err.line
+        });
       }
       throw err;
     }
@@ -3711,7 +3572,9 @@ function edgeType(snapshot, e, folding) {
   }
   return "directed";
 }
-function* writeGexf(snapshot, options) {
+function* writeGexf(given, options) {
+  const styled = gexfStyledExport(given, options?.styles);
+  const snapshot = styled?.snapshot ?? given;
   const plan = planExport(snapshot, options);
   const { version } = plan;
   const ids = sanitizeIds(snapshot, "any", plan.options.sanitizeIds);
@@ -3721,7 +3584,7 @@ function* writeGexf(snapshot, options) {
   yield '<?xml version="1.0" encoding="UTF-8"?>\n';
   yield `<gexf xmlns="${ns.gexf}" xmlns:viz="${ns.viz}" version="${version}">
 `;
-  yield metaElement(meta);
+  yield metaElement(meta, styled);
   yield graphStart(snapshot, plan);
   yield attributesGroups("node", plan.nodeAttrs, "    ");
   yield attributesGroups("edge", plan.edgeAttrs, "    ");
@@ -3752,6 +3615,7 @@ function* writeGexf(snapshot, options) {
     }
     body += spellsElement(nodeRoles, i, plan, "        ");
     body += vizElements(nodeRoles, i, "        ", writeZ);
+    body += styled?.node(i, "        ") ?? "";
     yield body.length === 0 ? `      <node${attrs}/>
 ` : `      <node${attrs}>
 ${body}      </node>
@@ -3800,6 +3664,7 @@ ${body}      </node>
     let body = attvaluesElement(plan.edgeAttrs, e, plan, "        ");
     body += spellsElement(edgeRoles, e, plan, "        ");
     body += vizElements(edgeRoles, e, "        ", false);
+    body += styled?.edge(e, "        ") ?? "";
     yield body.length === 0 ? `      <edge${attrs}/>
 ` : `      <edge${attrs}>
 ${body}      </edge>
@@ -3809,7 +3674,7 @@ ${body}      </edge>
   yield "  </graph>\n";
   yield "</gexf>\n";
 }
-function metaElement(meta) {
+function metaElement(meta, styled) {
   let body = "";
   if (meta.creator !== null) {
     body += `    <creator>${escapeXmlText(meta.creator)}</creator>
@@ -3821,6 +3686,10 @@ function metaElement(meta) {
   }
   if (meta.keywords.length > 0) {
     body += `    <keywords>${escapeXmlText(meta.keywords.join(", "))}</keywords>
+`;
+  }
+  if (styled !== null) {
+    body += `    ${styled.blockElement}
 `;
   }
   const modified = meta.modified === null ? "" : ` lastmodifieddate="${escapeXmlAttribute(meta.modified)}"`;
@@ -3906,6 +3775,7 @@ const gexfExporter = Object.freeze({
   format: GEXF_FORMAT,
   options: Object.freeze(["version"]),
   capabilities: CAPABILITIES_1_3,
+  styles: Object.freeze({ capabilities: GEXF_STYLE_CAPABILITIES }),
   /**
    * Pre-flight: what export() would lose.
    * @param snapshot - the snapshot
@@ -3913,7 +3783,8 @@ const gexfExporter = Object.freeze({
    * @returns the loss notes, empty when the export is exact
    */
   check(snapshot, options) {
-    return Object.freeze(planExport(snapshot, options).notes);
+    const styled = gexfStyledExport(snapshot, options?.styles);
+    return Object.freeze([...planExport(styled?.snapshot ?? snapshot, options).notes, ...styled?.notes ?? []]);
   },
   /**
    * Write the snapshot as UTF-8 chunks.
@@ -3945,6 +3816,8 @@ const GEXF_ISSUE = Object.freeze({
   COLUMN_TYPE: COLUMN_TYPE_CODE,
   /** The XML is not well-formed. The import stops. */
   XML_SYNTAX: XML_SYNTAX_CODE,
+  /** Elements are nested more than 100,000 deep. The import stops. */
+  XML_NESTING: XML_NESTING_CODE,
   /** The input is not valid UTF-8. The import stops. */
   INVALID_UTF8: INVALID_UTF8_CODE,
   /**
@@ -3981,6 +3854,11 @@ const GEXF_ISSUE = Object.freeze({
   EDGE_TYPE: EDGE_TYPE_CODE,
   /** A `pid` / `<parent for>` naming an unknown node, a `<parent>` without for, or the children of a skipped node. */
   UNKNOWN_PARENT: UNKNOWN_PARENT_CODE,
+  /**
+   * GEXF 1.0 only: a `pid` naming no node. Gephi 0.6 wrote `pid="0"` on its top-level nodes; the node stays
+   * top-level.
+   */
+  UNKNOWN_PID: UNKNOWN_PID_CODE,
   /** A `pid` / nested containment that would close a parent cycle; that link is dropped. */
   PARENT_CYCLE: PARENT_CYCLE_CODE,
   /** An inverted interval (start after end) of an element, a spell or a value; it is not kept. */
@@ -4082,6 +3960,8 @@ export {
   GEXF_1_2_CAPABILITIES,
   GEXF_ISSUE,
   GEXF_LOSS,
+  GEXF_STYLE_CAPABILITIES,
+  GRAPHTY_XML_NAMESPACE,
   gexfExporter,
   gexfImporter
 };