@graphty/graph-io 0.3.43 → 0.3.45

package/dist/chunks/{importer-xZ-3suY1.js → importer-ClwoVx3O.js}

@@ -1,9 +1,13 @@
 import { GraphFormatError, INVALID_INDEX, MAX_COUNT } from "@graphty/graph-format";
 import { c as childrenCsr } from "./children-CA4coBi0.js";
-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, bz as isNmtoken, bx as isCanonicalIntegerText, bA 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, aJ as isWeightField, bH as declareAttribute, a0 as uniqueColumnName, a1 as declareResolved, bW as takenIn, aK as parseWeightText, bK as parseDeclaredValue, bL as losesPrecision, P as PRECISION_CODE, bI as overflowsToInfinity } from "./export-rKLeGQMo.js";
-import { j as isWhitespace, n as isXmlName, a as escapeXmlText, 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-B62ZGM_a.js";
+import { c as capabilities, r as resolveExportOptions, L as LOSS, G as sanitizeIds, a as checkCapabilities, p as pairFolding, a9 as isNmtoken, aa as mangleNmtoken, e as explicitWeights, O as isCanonicalIntegerText, 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, u as uniqueColumnName, d as declareResolved, ae as takenIn, s as parseWeightText, z as parseDeclaredValue, A as losesPrecision, v as overflowsToInfinity } from "./export-BvqAXCKh.js";
+import { i as isWhitespace, a as escapeXmlText, p as isXmlName, e as escapeXmlAttribute, l as localName, x as xmlIllegalTextNotes, t as tokenizeXml, b as xmlDeclaredEncoding, X as XmlEmptyInputError, c as XmlSyntaxError, d as XmlNestingError, s as sniffXmlText } from "./escape-CgzxiYPg.js";
+import { p as plural, a as agree, ad as formatInteger, a0 as formatF64, $ as formatF32, Z as ImportReportBuilder, P as PRECISION_CODE } from "./format-BpQBx8MZ.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-fT3E8JYY.js";
+import { F as FORMAT, O as ORIGINAL_ID_ATTRIBUTE, a as GRAPHML_LOSS, Y as YFILES_NAMESPACE, X as XSI_NAMESPACE, b as GRAPHML_NAMESPACE, S as SCHEMA_LOCATION, 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-BKwqelYD.js";
+import { G as GRAPHML_STYLE_CAPABILITIES, h as graphmlStyledExport, t as treeChildren, i as isTree, l as localOf, j as treeAttr, k as treeChild, m as treeText, v as valueColumns, n as yfilesColumns, r as readYedStyles, o as exactFromBlock } from "./styles-yed-Cz9rLBCP.js";
+import { p as plainCell, a as STYLE_ISSUE, M as MAX_STYLE_VALUE_LENGTH, h as canonNumber, o as canonText, l as canonEnum, n as noteAt, g as canonColor, x as colorOpacity, t as StyleNotes, S as STYLE_BLOCK_NAME, u as parseStyleBlock, s as styleFingerprint, v as blockStyles, r as resolveStyles } from "./block-CPCHkX42.js";
+import { r as gephiRules } from "./styles-DvoFBKCK.js";
 const ATTRIBUTE_PREFIX = "@_";
 const TEXT_KEY = "#text";
 class XmlTreeBuilder {
@@ -84,9 +88,9 @@ function valueOf(frame) {
 }
 function attachChild(parent, name, value) {
   parent.hasChildren = true;
-  const existing = parent.node[name];
+  const existing = Object.hasOwn(parent.node, name) ? parent.node[name] : void 0;
   if (existing === void 0) {
-    parent.node[name] = value;
+    Object.defineProperty(parent.node, name, { value, writable: true, enumerable: true, configurable: true });
   } else if (Array.isArray(existing)) {
     existing.push(value);
   } else {
@@ -170,38 +174,38 @@ function writeElements(name, value, indent, out) {
     }
     return;
   }
+  const brk = indent === null ? "" : `
+${indent}`;
   if (value === null || typeof value !== "object") {
-    const text22 = scalarText(value);
-    out.push(text22.length === 0 ? `
-${indent}<${name}/>` : `
-${indent}<${name}>${escapeXmlText(text22)}</${name}>`);
+    const text2 = scalarText(value);
+    out.push(text2.length === 0 ? `${brk}<${name}/>` : `${brk}<${name}>${escapeXmlText(text2)}</${name}>`);
     return;
   }
-  const object = value;
-  const { attrs, text: text2, hasChildren } = scanElement(object);
+  writeObjectElement(name, value, indent, out);
+}
+function writeObjectElement(name, object, indent, out) {
+  const brk = indent === null ? "" : `
+${indent}`;
+  const { attrs, text: text2, hasChildren } = elementParts(object);
   if (!hasChildren) {
     out.push(
-      text2 === null || text2.length === 0 ? `
-${indent}<${name}${attrs}/>` : `
-${indent}<${name}${attrs}>${escapeXmlText(text2)}</${name}>`
+      text2 === null || text2.length === 0 ? `${brk}<${name}${attrs}/>` : `${brk}<${name}${attrs}>${escapeXmlText(text2)}</${name}>`
     );
     return;
   }
-  out.push(`
-${indent}<${name}${attrs}>`);
-  const inner = `${indent}  `;
+  const inner = indent === null || text2 !== null ? null : `${indent}  `;
+  out.push(`${brk}<${name}${attrs}>`);
+  if (text2 !== null) {
+    out.push(escapeXmlText(text2));
+  }
   for (const [key, child2] of Object.entries(object)) {
     if (key !== TEXT_KEY && !key.startsWith(ATTRIBUTE_PREFIX)) {
       writeElements(key, child2, inner, out);
     }
   }
-  if (text2 !== null) {
-    out.push(escapeXmlText(text2));
-  }
-  out.push(`
-${indent}</${name}>`);
+  out.push(inner === null ? `</${name}>` : `${brk}</${name}>`);
 }
-function scanElement(object) {
+function elementParts(object) {
   let attrs = "";
   let text2 = null;
   let hasChildren = false;
@@ -230,7 +234,20 @@ function scalarText(value) {
 }
 const YFILES_COLUMN_PREFIX = "yfiles.";
 const NODE_FIELDS = {
-  position: { dtype: "f64", components: 3, role: "position", mutable: true },
+  // yEd writes the top-left corner of the node's box, y growing downward, in pixels
+  position: {
+    dtype: "f64",
+    components: 3,
+    role: "position",
+    mutable: true,
+    extra: {
+      units: "px",
+      yAxis: "down",
+      anchor: "top-left",
+      width: `${YFILES_COLUMN_PREFIX}width`,
+      height: `${YFILES_COLUMN_PREFIX}height`
+    }
+  },
   width: { dtype: "f64" },
   height: { dtype: "f64" },
   color: { dtype: "string" },
@@ -261,6 +278,9 @@ function graphicsDecl(domain, field, keyId) {
     }
   };
 }
+function yfilesPositions(snapshot) {
+  return snapshot.nodes.byRole("position")?.meta.origin?.namespace === "yfiles" ? { tool: "yed" } : null;
+}
 function isGraphicsColumn(meta) {
   return meta.dtype !== "json" && meta.origin?.namespace === "yfiles" && meta.name.startsWith(YFILES_COLUMN_PREFIX);
 }
@@ -300,7 +320,9 @@ function graphicsValues(domain, tree, unmapped = []) {
   const out = [];
   if (domain === "node") {
     const shape = child(tree, "ShapeNode");
-    if (shape !== void 0) {
+    if (shape === void 0) {
+      geometryValues(child(geometryNode(tree), "Geometry"), out, unmapped);
+    } else {
       shapeNodeValues(shape, out, unmapped);
     }
   } else {
@@ -312,14 +334,7 @@ function graphicsValues(domain, tree, unmapped = []) {
   return out;
 }
 function shapeNodeValues(shape, out, unmapped) {
-  const geometry = child(shape, "Geometry");
-  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", checked(attr(geometry, "width"), "width", unmapped));
-  push(out, "height", checked(attr(geometry, "height"), "height", unmapped));
+  geometryValues(child(shape, "Geometry"), out, unmapped);
   push(out, "color", color(attr(child(shape, "Fill"), "color")));
   const border = child(shape, "BorderStyle");
   push(out, "borderColor", color(attr(border, "color")));
@@ -330,6 +345,33 @@ function shapeNodeValues(shape, out, unmapped) {
   }
   push(out, "shape", nonEmpty(attr(child(shape, "Shape"), "type")));
 }
+function geometryValues(geometry, out, unmapped) {
+  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", checked(attr(geometry, "width"), "width", unmapped));
+  push(out, "height", checked(attr(geometry, "height"), "height", unmapped));
+}
+const GEOMETRY_NODES = ["GenericNode", "ImageNode", "SVGNode"];
+function geometryNode(tree) {
+  for (const local of GEOMETRY_NODES) {
+    const node = child(tree, local);
+    if (node !== void 0) {
+      return node;
+    }
+  }
+  const realizers = child(child(tree, "ProxyAutoBoundsNode"), "Realizers");
+  const active = Number.parseInt(attr(realizers, "active") ?? "0", 10);
+  return elements(realizers)[Number.isNaN(active) ? 0 : active];
+}
+function elements(node) {
+  if (typeof node !== "object" || node === null) {
+    return [];
+  }
+  return Object.entries(node).filter(([key]) => !key.startsWith("@_") && key !== "#text").flatMap(([, value]) => Array.isArray(value) ? value : [value]);
+}
 function polyLineEdgeValues(edge, out, unmapped) {
   const line = child(edge, "LineStyle");
   push(out, "color", color(attr(line, "color")));
@@ -504,7 +546,7 @@ function graphmlMetaOf(snapshot) {
   }
   return { graphId, edgedefault, namespaces };
 }
-function planExport(snapshot, options, format) {
+function planExport(snapshot, options, format, keyOrdered = false) {
   const graphics = new Set(
     [...snapshot.nodes, ...snapshot.edges].filter((c) => isGraphicsColumn(c.meta)).map((c) => c.meta.name)
   );
@@ -522,6 +564,12 @@ function planExport(snapshot, options, format) {
   const nodeColumns = planTable(snapshot.nodes, "node", notes, note);
   const edgeColumns = planTable(snapshot.edges, "edge", notes, note);
   const keys = planKeys([...graphColumns, ...nodeColumns, ...edgeColumns], keyIds);
+  if (keyOrdered) {
+    const keyOrder = new Map(keys.map((k, i) => [k.id, i]));
+    const byKey = (a, b) => (keyOrder.get(a.keyId) ?? 0) - (keyOrder.get(b.keyId) ?? 0);
+    nodeColumns.sort(byKey);
+    edgeColumns.sort(byKey);
+  }
   reservedNameNotes(nodeColumns, RESERVED_NODE_NAMES, note);
   reservedNameNotes(edgeColumns, RESERVED_EDGE_NAMES, note);
   const weight = planWeight(snapshot, edgeColumns, keyIds, keys, note);
@@ -1133,7 +1181,8 @@ function keyElement(key, indent) {
     text2 += ` attr.type="${escapeXmlAttribute(key.attrType)}"`;
   }
   if (key.yfilesType !== null) {
-    text2 += ` yfiles.type="${escapeXmlAttribute(key.yfilesType)}"`;
+    const uri = key.yfilesType.includes("://");
+    text2 += ` ${uri ? "y:attr.uri" : "yfiles.type"}="${escapeXmlAttribute(key.yfilesType)}"`;
   }
   const { column } = key;
   const desc = column?.meta.extra.desc;
@@ -1201,21 +1250,7 @@ function* writeGraphml(snapshot, plan) {
   const i3 = plan.pretty ? "      " : "";
   const step = plan.pretty ? "  " : "";
   yield '<?xml version="1.0" encoding="UTF-8"?>\n';
-  let root = `<graphml xmlns="${GRAPHML_NAMESPACE}"`;
-  const namespaces = { ...plan.meta?.namespaces };
-  if ((plan.nodeColumns.some((c) => c.yfiles) || plan.edgeColumns.some((c) => c.yfiles) || plan.graphColumns.some((c) => c.yfiles)) && !Object.values(namespaces).includes(YFILES_NAMESPACE)) {
-    namespaces.y = YFILES_NAMESPACE;
-  }
-  if (!Object.values(namespaces).includes(XSI_NAMESPACE)) {
-    namespaces.xsi = XSI_NAMESPACE;
-  }
-  for (const [prefix, uri] of Object.entries(namespaces)) {
-    root += ` xmlns:${prefix}="${escapeXmlAttribute(uri)}"`;
-  }
-  const xsiPrefix = Object.entries(namespaces).find(([, uri]) => uri === XSI_NAMESPACE)?.[0] ?? "xsi";
-  root += ` ${xsiPrefix}:schemaLocation="${SCHEMA_LOCATION}">
-`;
-  yield root;
+  yield rootElement(plan);
   for (const key of plan.keys) {
     yield keyElement(key, i1);
   }
@@ -1248,58 +1283,80 @@ ${i2}<desc>${escapeXmlText(description)}</desc>`;
     yield* writeNodeSubtree(rootNode, plan, ids, i2, step, walk);
   }
   const list = snapshot.edgeList();
-  const { folding } = plan;
   for (let e = 0; e < snapshot.edgeCount; e++) {
-    if (folding.folded(e)) {
-      continue;
-    }
-    const parts = [`
-${i2}<edge`];
-    const id = edgeIds[e];
-    if (id !== null) {
-      parts.push(` id="${escapeXmlAttribute(id)}"`);
-    }
-    parts.push(
-      ` source="${escapeXmlAttribute(String(ids.idAt(list.src[e])))}" target="${escapeXmlAttribute(String(ids.idAt(list.dst[e])))}"`
-    );
-    const directed = snapshot.directed && isDirectedEdge(folding, e);
-    if (directed !== (plan.edgedefault === "directed")) {
-      parts.push(` directed="${directed ? "true" : "false"}"`);
+    if (!plan.folding.folded(e)) {
+      const start = edgeStartTag(snapshot, plan, e, String(ids.idAt(list.src[e])), String(ids.idAt(list.dst[e])));
+      yield edgeElement(plan, e, edgeIds[e], start, [i2, i3]);
     }
-    const sourcePort = portText(plan.sourcePortColumn, e);
-    if (sourcePort !== null) {
-      parts.push(` sourceport="${escapeXmlAttribute(sourcePort)}"`);
-    }
-    const targetPort = portText(plan.targetPortColumn, e);
-    if (targetPort !== null) {
-      parts.push(` targetport="${escapeXmlAttribute(targetPort)}"`);
-    }
-    const open = parts.length;
-    if (plan.weight !== null) {
-      const { keyId, attrType } = plan.weight;
-      const weight = plan.weight.weights.text(e, attrType === "int" || attrType === "long");
-      if (weight !== null) {
-        parts.push(`
-${i3}<data key="${keyId}">${escapeXmlText(weight)}</data>`);
-      }
-    }
-    for (const column of plan.edgeColumns) {
-      writeData(column, e, i3, parts);
-    }
-    if (parts.length === open) {
-      parts.push("/>");
-    } else {
-      parts.splice(open, 0, ">");
-      parts.push(`
-${i2}</edge>`);
-    }
-    yield parts.join("");
   }
   yield `
 ${i1}</graph>
 </graphml>
 `;
 }
+function rootElement(plan) {
+  const namespaces = { ...plan.meta?.namespaces };
+  const yfilesColumns2 = plan.nodeColumns.some((c) => c.yfiles) || plan.edgeColumns.some((c) => c.yfiles) || plan.graphColumns.some((c) => c.yfiles);
+  if (plan.yedGraphics === true || yfilesColumns2 && !Object.values(namespaces).includes(YFILES_NAMESPACE) && // a yFiles 3 file binds `y` to its own namespace, which its kept trees are written in
+  namespaces.y === void 0) {
+    namespaces.y = YFILES_NAMESPACE;
+  }
+  if (!Object.values(namespaces).includes(XSI_NAMESPACE)) {
+    namespaces.xsi = XSI_NAMESPACE;
+  }
+  let root = `<graphml xmlns="${GRAPHML_NAMESPACE}"`;
+  for (const [prefix, uri] of Object.entries(namespaces)) {
+    root += ` xmlns:${prefix}="${escapeXmlAttribute(uri)}"`;
+  }
+  const xsiPrefix = Object.entries(namespaces).find(([, uri]) => uri === XSI_NAMESPACE)?.[0] ?? "xsi";
+  return `${root} ${xsiPrefix}:schemaLocation="${SCHEMA_LOCATION}">
+`;
+}
+function edgeStartTag(snapshot, plan, e, source, target) {
+  let text2 = ` source="${escapeXmlAttribute(source)}" target="${escapeXmlAttribute(target)}"`;
+  const directed = snapshot.directed && isDirectedEdge(plan.folding, e);
+  if (directed !== (plan.edgedefault === "directed")) {
+    text2 += ` directed="${directed ? "true" : "false"}"`;
+  }
+  const sourcePort = portText(plan.sourcePortColumn, e);
+  if (sourcePort !== null) {
+    text2 += ` sourceport="${escapeXmlAttribute(sourcePort)}"`;
+  }
+  const targetPort = portText(plan.targetPortColumn, e);
+  if (targetPort !== null) {
+    text2 += ` targetport="${escapeXmlAttribute(targetPort)}"`;
+  }
+  return text2;
+}
+function edgeElement(plan, e, id, start, indents) {
+  const [i2, i3] = indents;
+  const parts = [`
+${i2}<edge`];
+  if (id !== null) {
+    parts.push(` id="${escapeXmlAttribute(id)}"`);
+  }
+  parts.push(start);
+  const open = parts.length;
+  if (plan.weight !== null) {
+    const { keyId, attrType } = plan.weight;
+    const weight = plan.weight.weights.text(e, attrType === "int" || attrType === "long");
+    if (weight !== null) {
+      parts.push(`
+${i3}<data key="${keyId}">${escapeXmlText(weight)}</data>`);
+    }
+  }
+  for (const column of plan.edgeColumns) {
+    writeData(column, e, i3, parts);
+  }
+  if (parts.length === open) {
+    parts.push("/>");
+  } else {
+    parts.splice(open, 0, ">");
+    parts.push(`
+${i2}</edge>`);
+  }
+  return parts.join("");
+}
 function portText(column, e) {
   if (!column?.isSet(e)) {
     return null;
@@ -1385,6 +1442,7 @@ const graphmlExporter = Object.freeze({
   format: FORMAT,
   options: Object.freeze(["edgedefault", "pretty"]),
   capabilities: CAPABILITIES,
+  styles: Object.freeze({ capabilities: GRAPHML_STYLE_CAPABILITIES }),
   /**
    * Pre-flight: every loss the export would incur.
    * @param snapshot - the snapshot
@@ -1392,8 +1450,8 @@ const graphmlExporter = Object.freeze({
    * @returns the notes
    */
   check(snapshot, options) {
-    const plan = planExport(snapshot, resolveExportOptions(options), resolveFormatOptions(options));
-    return Object.freeze(plan.notes);
+    const { plan, styled } = prepare(snapshot, options);
+    return Object.freeze([...plan.notes, ...styled?.notes ?? []]);
   },
   /**
    * Write the document as UTF-8 chunks.
@@ -1402,8 +1460,8 @@ const graphmlExporter = Object.freeze({
    * @returns the chunks
    */
   export(snapshot, options) {
-    const plan = planExport(snapshot, resolveExportOptions(options), resolveFormatOptions(options));
-    return encodeChunks(writeGraphml(snapshot, plan));
+    const { plan, written } = prepare(snapshot, options);
+    return encodeChunks(writeGraphml(written, plan));
   },
   /**
    * Write the document as one string.
@@ -1412,10 +1470,576 @@ const graphmlExporter = Object.freeze({
    * @returns the document
    */
   exportToString(snapshot, options) {
-    const plan = planExport(snapshot, resolveExportOptions(options), resolveFormatOptions(options));
-    return joinText(writeGraphml(snapshot, plan));
+    const { plan, written } = prepare(snapshot, options);
+    return joinText(writeGraphml(written, plan));
   }
 });
+function prepare(snapshot, options) {
+  const styled = graphmlStyledExport(snapshot, options?.styles);
+  const written = styled?.snapshot ?? snapshot;
+  const plan = planExport(written, resolveExportOptions(options), resolveFormatOptions(options), styled !== null);
+  if (styled === null) {
+    return { plan, written, styled };
+  }
+  const position = written.nodes.byRole("position")?.meta.name;
+  const notes = plan.notes.filter((n) => n.code !== LOSS.POSITIONS || n.column !== position);
+  return { plan: { ...plan, notes, yedGraphics: true }, written, styled };
+}
+const MAX_REFERENCE_DEPTH = 16;
+const NULL = /* @__PURE__ */ Symbol("x:Null");
+const REFERENCE = /^\{\s*[\w.-]*:?GraphMLReference\s+([^\s}]+)\s*\}$/;
+const NULL_MARKUP = /^\{\s*[\w.-]*:?Null\s*\}$/;
+const KINDS = /* @__PURE__ */ new Set(["NodeStyle", "EdgeStyle", "NodeLabels", "EdgeLabels", "NodeGeometry"]);
+function keyKind(type) {
+  if (typeof type !== "string" || !type.includes("://")) {
+    return null;
+  }
+  const last = type.slice(type.lastIndexOf("/") + 1);
+  return KINDS.has(last) || last === "SharedData" ? last : null;
+}
+function columnsByKind(table) {
+  const out = /* @__PURE__ */ new Map();
+  for (const col of table) {
+    const kind = col.dtype === "json" && col.meta.origin?.namespace === "yfiles" ? keyKind(col.meta.origin.type) : null;
+    if (kind !== null && !out.has(kind)) {
+      out.set(kind, col.meta.name);
+    }
+  }
+  return out;
+}
+class References {
+  /**
+   * Collects the shared objects of the graph's `SharedData` value.
+   * @param data - the `<data>` content of the SharedData key
+   */
+  constructor(data) {
+    this.shared = /* @__PURE__ */ new Map();
+    this.cycles = 0;
+    for (const sd of treeChildren(data, "SharedData")) {
+      if (isTree(sd)) {
+        this.collect(sd);
+      }
+    }
+  }
+  /**
+   * Collects the shared objects of one SharedData element: the first of each key wins.
+   * @param sd - the element
+   */
+  collect(sd) {
+    for (const key of Object.keys(sd).filter((k) => !k.startsWith("@_") && k !== "#text")) {
+      for (const e of treeChildren(sd, localOf(key))) {
+        const name = sharedKey(e);
+        if (name !== null && !this.shared.has(name)) {
+          this.shared.set(name, { tag: localOf(key), e });
+        }
+      }
+    }
+  }
+  /**
+   * Whether a walk has gone too deep; counts it once when it has.
+   * @param depth - the walk's depth
+   * @returns true past the limit
+   */
+  tooDeep(depth) {
+    if (depth > MAX_REFERENCE_DEPTH) {
+      this.cycles++;
+      return true;
+    }
+    return false;
+  }
+  /**
+   * A style object, following a `<y:GraphMLReference ResourceKey>` element to what it names.
+   * @param tag - the element's local name
+   * @param e - the element
+   * @returns the object, or null when the reference names nothing
+   */
+  object(tag, e) {
+    if (tag === "GraphMLReference") {
+      return this.shared.get(treeAttr(e, "ResourceKey") ?? "") ?? null;
+    }
+    return { tag, e };
+  }
+  /**
+   * The first child element of a property element, as a style object.
+   * @param d - the property element (or a `<data>` content)
+   * @returns the object, or null
+   */
+  first(d) {
+    if (!isTree(d)) {
+      return null;
+    }
+    for (const key of Object.keys(d)) {
+      if (!key.startsWith("@_") && key !== "#text") {
+        return this.object(localOf(key), treeChildren(d, localOf(key))[0]);
+      }
+    }
+    return null;
+  }
+  /**
+   * A property value resolved through references: a style object, text, `{x:Null}` or nothing.
+   * @param v - an attribute's text or a property element
+   * @param depth - the walk's depth
+   * @returns the resolved value
+   */
+  deref(v, depth = 0) {
+    if (v === void 0 || v === null || this.tooDeep(depth)) {
+      return null;
+    }
+    if (typeof v === "object") {
+      return this.first(v);
+    }
+    if (typeof v !== "string") {
+      return null;
+    }
+    const t = v.trim();
+    if (t.length > MAX_STYLE_VALUE_LENGTH) {
+      return t;
+    }
+    if (NULL_MARKUP.test(t)) {
+      return NULL;
+    }
+    const m = REFERENCE.exec(t);
+    if (m !== null) {
+      return this.shared.get(m[1]) ?? null;
+    }
+    return t;
+  }
+}
+function sharedKey(e) {
+  if (!isTree(e)) {
+    return null;
+  }
+  for (const key of Object.keys(e)) {
+    if (key.startsWith("@_") && localOf(key.slice(2)) === "Key") {
+      const value = e[key];
+      return typeof value === "string" ? value : null;
+    }
+  }
+  return null;
+}
+function prop(st, name) {
+  const attr2 = treeAttr(st.e, name);
+  if (attr2 !== void 0) {
+    return attr2;
+  }
+  return treeChild(st.e, `${st.tag}.${name}`);
+}
+function paintOf(refs, v, gradient, depth = 0) {
+  if (refs.tooDeep(depth)) {
+    return null;
+  }
+  const x = refs.deref(v, depth);
+  if (x === null || x === NULL) {
+    return x;
+  }
+  if (typeof x === "string") {
+    return { raw: x, dialect: "yfiles3" };
+  }
+  const { tag } = x;
+  if (tag === "SolidColorFill") {
+    return paintOf(refs, prop(x, "color"), gradient, depth + 1);
+  }
+  if (tag === "Color") {
+    return paintOf(refs, treeAttr(x.e, "value"), gradient, depth + 1);
+  }
+  if (tag === "CssFill") {
+    const css = treeAttr(x.e, "cssString");
+    return css === void 0 ? null : { raw: css, dialect: "css" };
+  }
+  if (tag.endsWith("Gradient")) {
+    gradient?.();
+    const stop = treeChildren(x.e, "GradientStop")[0] ?? treeChildren(treeChild(x.e, `${tag}.GradientStops`), "GradientStop")[0];
+    return stop === void 0 ? null : paintOf(refs, treeAttr(stop, "color"), null, depth + 1);
+  }
+  if (tag === "Stroke") {
+    return paintOf(refs, prop(x, "fill"), gradient, depth + 1);
+  }
+  return null;
+}
+const DASHES = /* @__PURE__ */ new Map([
+  ["solid", "solid"],
+  ["dash", "dashed"],
+  ["dot", "dotted"],
+  ["dashdot", "dash-dot"],
+  ["dashdotdot", "dash-dot"]
+]);
+function strokeOf(refs, v) {
+  const x = refs.deref(v);
+  if (x === null || x === NULL) {
+    return x;
+  }
+  if (typeof x === "string" || x.tag !== "Stroke") {
+    return { color: paintOf(refs, v, null), width: 1, line: "solid" };
+  }
+  let line = "solid";
+  const d = refs.deref(prop(x, "dashStyle"), 1);
+  if (typeof d === "string") {
+    const lower = d.slice(0, MAX_STYLE_VALUE_LENGTH).toLowerCase().replaceAll("_", "");
+    line = DASHES.get(lower) ?? `other:${lower}`;
+  } else if (d !== null && d !== NULL) {
+    const dashes = (treeAttr(d.e, "dashes") ?? "").slice(0, MAX_STYLE_VALUE_LENGTH).trim().split(/[\s,]+/).map(Number).filter(Number.isFinite);
+    if (dashes.length === 2) {
+      line = dashes[0] <= 1 ? "dotted" : "dashed";
+    } else if (dashes.length === 4) {
+      line = "dash-dot";
+    } else if (dashes.length > 0) {
+      line = `other:dashes ${dashes.slice(0, 8).join(" ")}`;
+    }
+  }
+  const w = prop(x, "thickness");
+  return { color: paintOf(refs, prop(x, "fill"), null), width: typeof w === "string" ? w : 1, line };
+}
+function putPaint(pt, property, opacity, put, at) {
+  if (pt === null || pt === NULL) {
+    return;
+  }
+  const c = canonColor(pt.raw, pt.dialect, at(property));
+  if (c === null) {
+    return;
+  }
+  put(property, c.color);
+  const alpha = colorOpacity(c, null, at(property), opacity !== null);
+  if (opacity !== null) {
+    put(opacity, alpha);
+  }
+}
+function readNodeStyle(refs, data, put, at) {
+  const st = unwrapped(refs, refs.first(data));
+  if (st === null || typeof st !== "object") {
+    if (data !== null && data !== void 0 && data !== "") {
+      noteAt(at("fill"), STYLE_ISSUE.UNRESOLVED, "NodeStyle");
+    }
+    return;
+  }
+  const style = st;
+  putPaint(
+    paintOf(refs, prop(style, "fill"), () => {
+      noteAt(at("fill"), STYLE_ISSUE.GRADIENT, style.tag);
+    }),
+    "fill",
+    "fillOpacity",
+    put,
+    at
+  );
+  const stroke = strokeOf(refs, prop(style, "stroke"));
+  if (stroke === NULL) {
+    put("borderWidth", 0);
+  } else if (stroke !== null) {
+    putPaint(stroke.color, "borderColor", null, put, at);
+    put("borderWidth", canonNumber(stroke.width, at("borderWidth")));
+    put("borderStyle", canonEnum("borderStyle", stroke.line, "yfiles3", at("borderStyle")));
+  }
+  put("shape", nodeShapeOf(style, at));
+  const cornerSize = style.tag === "RectangleNodeStyle" ? treeAttr(style.e, "cornerSize") : void 0;
+  if (cornerSize !== void 0) {
+    put("cornerRadius", canonNumber(cornerSize, at("cornerRadius")));
+  }
+}
+function unwrapped(refs, first) {
+  let st = first;
+  const seen = /* @__PURE__ */ new Set();
+  while (st !== null && typeof st === "object" && st.tag === "CollapsibleNodeStyleDecorator") {
+    if (seen.has(st.e) || refs.tooDeep(seen.size)) {
+      refs.cycles++;
+      return null;
+    }
+    seen.add(st.e);
+    st = refs.deref(prop(st, "wrappedStyle"));
+  }
+  return st;
+}
+function nodeShapeOf(style, at) {
+  const shape = treeAttr(style.e, "shape");
+  if (shape !== void 0) {
+    return canonEnum("shape", shape, "yfiles3", at("shape"));
+  }
+  if (style.tag === "RectangleNodeStyle") {
+    return treeAttr(style.e, "cornerSize") === void 0 ? "rectangle" : "round-rectangle";
+  }
+  if (style.tag === "ShapeNodeStyle") {
+    return "rectangle";
+  }
+  noteAt(at("shape"), STYLE_ISSUE.UNKNOWN_VALUE, style.tag);
+  return `other:${style.tag}`;
+}
+function readEdgeStyle(refs, data, put, at) {
+  const st = refs.first(data);
+  if (st === null) {
+    return;
+  }
+  const stroke = strokeOf(refs, prop(st, "stroke"));
+  if (stroke === NULL) {
+    noteAt(at("color"), STYLE_ISSUE.NO_STROKE, "{x:Null}");
+  } else if (stroke !== null) {
+    putPaint(stroke.color, "color", "opacity", put, at);
+    put("width", canonNumber(stroke.width, at("width")));
+    put("lineStyle", canonEnum("lineStyle", stroke.line, "yfiles3", at("lineStyle")));
+  }
+  for (const end of ["source", "target"]) {
+    const a = refs.deref(prop(st, `${end}Arrow`));
+    const property = `${end}Arrow`;
+    let type = null;
+    if (a !== null && a !== NULL && typeof a === "object") {
+      type = treeAttr(a.e, "type") ?? "DEFAULT";
+      putPaint(paintOf(refs, prop(a, "fill"), null), `${end}ArrowColor`, null, put, at);
+    } else if (typeof a === "string") {
+      type = a;
+    }
+    if (type !== null) {
+      put(property, canonEnum("arrow", /^default$/i.test(type) ? "triangle" : type, "yfiles3", at(property)));
+    }
+  }
+}
+function readLabels(refs, data, put, at) {
+  let label = void 0;
+  let text2 = "";
+  let extra = 0;
+  for (const l of treeChildren(treeChild(data, "List"), "Label")) {
+    const raw = treeAttr(l, "Text") ?? treeText(treeChild(l, "Label.Text")) ?? "";
+    if (raw.trim().length === 0) {
+      continue;
+    }
+    if (label === void 0) {
+      label = l;
+      text2 = raw;
+    } else {
+      extra++;
+    }
+  }
+  if (label === void 0) {
+    return;
+  }
+  if (extra > 0) {
+    noteAt(at("label"), STYLE_ISSUE.EXTRA_LABELS, `${String(extra + 1)} labels`);
+  }
+  put("label", canonText(text2, at("label")));
+  const ls = refs.deref(treeAttr(label, "Style") ?? treeChild(label, "Label.Style"));
+  if (ls === null || ls === NULL || typeof ls !== "object" || !ls.tag.endsWith("LabelStyle")) {
+    return;
+  }
+  putPaint(paintOf(refs, prop(ls, "textFill"), null), "labelColor", null, put, at);
+  const f = refs.deref(prop(ls, "font"));
+  if (f !== null && f !== NULL && typeof f === "object" && f.tag === "Font") {
+    put("labelSize", canonNumber(treeAttr(f.e, "fontSize"), at("labelSize")));
+    const family = treeAttr(f.e, "fontFamily");
+    if (family !== void 0) {
+      put("labelFont", canonText(family.replaceAll(/(^['"])|(['"]$)/g, ""), at("labelFont")));
+    }
+    const weight = treeAttr(f.e, "fontWeight");
+    if (weight !== void 0) {
+      put("labelWeight", canonEnum("weight", weight, "yfiles3", at("labelWeight")));
+    }
+  }
+}
+function readYfiles3Styles(snapshot, notes, budget) {
+  const nodeKinds = columnsByKind(snapshot.nodes);
+  const edgeKinds = columnsByKind(snapshot.edges);
+  const styled = [...nodeKinds.keys(), ...edgeKinds.keys()].some((k) => k !== "SharedData");
+  if (!styled) {
+    return null;
+  }
+  const graphKinds = columnsByKind(snapshot.graph);
+  const sharedName = graphKinds.get("SharedData");
+  const refs = new References(sharedName === void 0 ? null : plainCell(snapshot.graph.value(sharedName, 0)));
+  const read = (target, kinds) => {
+    const table = target === "node" ? snapshot.nodes : snapshot.edges;
+    const n = target === "node" ? snapshot.nodeCount : snapshot.edgeCount;
+    const out = valueColumns(n);
+    const style = kinds.get(target === "node" ? "NodeStyle" : "EdgeStyle");
+    const labels = kinds.get(target === "node" ? "NodeLabels" : "EdgeLabels");
+    const geometry = target === "node" ? kinds.get("NodeGeometry") : void 0;
+    const readStyle = target === "node" ? readNodeStyle : readEdgeStyle;
+    const cell = (name, i) => name === void 0 ? void 0 : plainCell(table.value(name, i));
+    for (let i = 0; i < n; i++) {
+      budget.spend(target, 1);
+      const at = (property) => ({ notes, target, property, element: i, budget });
+      const put = (property, value) => {
+        out.put(i, property, value);
+      };
+      if (style !== void 0) {
+        readStyle(refs, cell(style, i), put, at);
+      }
+      if (labels !== void 0) {
+        readLabels(refs, cell(labels, i), put, at);
+      }
+      if (geometry !== void 0) {
+        const rect = treeChild(cell(geometry, i), "RectD");
+        put("width", canonNumber(treeAttr(rect, "Width"), at("width")));
+        put("height", canonNumber(treeAttr(rect, "Height"), at("height")));
+      }
+    }
+    return out.values;
+  };
+  const node = read("node", nodeKinds);
+  const edge = read("edge", edgeKinds);
+  if (refs.cycles > 0) {
+    notes.add(STYLE_ISSUE.REFERENCE_CYCLE, null, null, {
+      sample: `references deeper than ${String(MAX_REFERENCE_DEPTH)} or circular (${String(refs.cycles)})`
+    });
+  }
+  return { node, edge };
+}
+const GEPHI_COLUMNS = ["r", "g", "b", "size"];
+function hasRgb(table) {
+  return table.has("r") && table.has("g") && table.has("b");
+}
+function readGephi(snapshot, notes, context) {
+  const read = (target) => {
+    const table = target === "node" ? snapshot.nodes : snapshot.edges;
+    const n = target === "node" ? snapshot.nodeCount : snapshot.edgeCount;
+    const out = valueColumns(n);
+    const has = { rgb: hasRgb(table), size: target === "node" && table.has("size"), label: table.has("label") };
+    for (let i = 0; i < n; i++) {
+      context.budget.spend(target, 1);
+      const at = (property) => ({
+        notes,
+        target,
+        property,
+        element: i,
+        budget: context.budget
+      });
+      readGephiRow(
+        table,
+        target,
+        i,
+        has,
+        (property, value) => {
+          out.put(i, property, value);
+        },
+        at
+      );
+    }
+    return out.values;
+  };
+  return { node: read("node"), edge: read("edge") };
+}
+function readGephiRow(table, target, i, has, put, at) {
+  if (has.rgb) {
+    const [r, g, b] = ["r", "g", "b"].map((c) => plainCell(table.value(c, i)));
+    if (r !== null && g !== null && b !== null) {
+      const property = target === "node" ? "fill" : "color";
+      put(property, canonColor({ r, g, b }, "gephi", at(property))?.color ?? null);
+    }
+  }
+  if (has.size) {
+    const v = canonNumber(plainCell(table.value("size", i)), at("width"));
+    put("width", v);
+    put("height", v);
+  }
+  if (has.label) {
+    put("label", canonText(plainCell(table.value("label", i)), at("label")));
+  }
+}
+function exactFromGraphtyBlock(snapshot, yed) {
+  const text2 = snapshot.graph.has(STYLE_BLOCK_NAME) ? plainCell(snapshot.graph.value(STYLE_BLOCK_NAME, 0)) : null;
+  if (typeof text2 !== "string") {
+    return;
+  }
+  const parsed = parseStyleBlock(text2, styleFingerprint(snapshot));
+  const ex = parsed.ok ? blockStyles(parsed.block, snapshot, "graphml") : null;
+  if (ex === null) {
+    return;
+  }
+  exactFromBlock(
+    yed,
+    (target, property) => resolveStyles(ex, target, property, snapshot),
+    { node: snapshot.nodeCount, edge: snapshot.edgeCount },
+    new StyleNotes()
+  );
+}
+function graphmlStyles(snapshot, context) {
+  const notes = new StyleNotes();
+  const readFrom = { node: yfilesColumns(snapshot.nodes), edge: yfilesColumns(snapshot.edges) };
+  const yfiles3 = readYfiles3Styles(snapshot, notes, context.budget);
+  if (yfiles3 !== null) {
+    return {
+      canonical: true,
+      dialect: "yfiles3",
+      tool: "yfiles3",
+      units: "px",
+      node: { values: yfiles3.node },
+      edge: { values: yfiles3.edge },
+      notes: notes.list(),
+      readFrom
+    };
+  }
+  const yed = readYedStyles(snapshot, notes, context.budget);
+  if (yed !== null) {
+    exactFromGraphtyBlock(snapshot, yed);
+    return {
+      canonical: true,
+      dialect: "yed",
+      tool: "yed",
+      units: "px",
+      node: { values: yed.node },
+      edge: { values: yed.edge },
+      notes: notes.list(),
+      opacityInColor: true,
+      readFrom
+    };
+  }
+  if (hasRgb(snapshot.nodes)) {
+    const gephi = readGephi(snapshot, notes, context);
+    const { rules, columns } = gephiRules(
+      snapshot,
+      gephi.node.fill,
+      gephi.edge.color,
+      context.budget,
+      gephi.edge.width
+    );
+    const used = (table) => GEPHI_COLUMNS.filter((c) => table.has(c));
+    return {
+      canonical: true,
+      dialect: "gephi",
+      tool: "gephi",
+      units: "relative",
+      node: { values: gephi.node },
+      edge: { values: gephi.edge, rules, columns },
+      notes: notes.list(),
+      readFrom: { node: used(snapshot.nodes), edge: used(snapshot.edges) }
+    };
+  }
+  if (snapshot.nodes.has("SUID") && snapshot.nodes.has("shared name")) {
+    const label = valueColumns(snapshot.nodeCount);
+    if (snapshot.nodes.has("name")) {
+      for (let i = 0; i < snapshot.nodeCount; i++) {
+        label.put(
+          i,
+          "label",
+          canonText(plainCell(snapshot.nodes.value("name", i)), {
+            notes,
+            target: "node",
+            property: "label",
+            element: i,
+            budget: context.budget
+          })
+        );
+      }
+    }
+    return {
+      canonical: true,
+      dialect: "cytoscape",
+      tool: "cytoscape",
+      units: "px",
+      node: { values: label.values },
+      edge: { values: {} },
+      notes: notes.list()
+    };
+  }
+  return null;
+}
+function isPassedAttribute(kind, name) {
+  return name === "xmlns" || /^(xmlns|xml|xsi):/.test(name) || isAttributeUri(kind, name);
+}
+function unreadAttributeMessage(kind, name, hint2) {
+  if (hint2) {
+    return `the <${kind}> parse hint ${name} is ignored`;
+  }
+  if (SCHEMA_ATTRIBUTES.has(name)) {
+    return `the <${kind}> attribute ${name} is not kept`;
+  }
+  return `the <${kind}> attribute ${name} is not a GraphML attribute; it is not kept`;
+}
 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([
@@ -1432,6 +2056,17 @@ 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();
+function isAttributeUri(kind, name) {
+  return kind === "key" && name.endsWith(":attr.uri");
+}
+function attributeUri(attrs) {
+  for (const [name, value] of attrs) {
+    if (isAttributeUri("key", name) && value.length > 0) {
+      return value;
+    }
+  }
+  return null;
+}
 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([
@@ -2200,30 +2835,38 @@ class GraphmlReader {
    */
   reportUnreadAttributes(kind, attrs, known, line) {
     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;
-      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 (!known.has(name) && !isPassedAttribute(kind, name)) {
+        this.reportUnreadAttribute(kind, name, line);
       }
-      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;
-      }
-      const message = unreadAttributeMessage(kind, name, hint2);
-      this.report.warning("unsupported", code, message, { line, element: name });
     }
   }
+  /**
+   * Report one attribute reportUnreadAttributes() found, unless its name was reported for this
+   * element kind already or the kind is past MAX_UNKNOWN_ATTRIBUTE_NAMES names (then it is counted).
+   * @param kind - the element name
+   * @param name - the attribute's name
+   * @param line - the line
+   */
+  reportUnreadAttribute(kind, name, line) {
+    const hint2 = name.startsWith("parse.");
+    let names = this.unknownNames.get(kind);
+    if (names === void 0) {
+      names = /* @__PURE__ */ new Set();
+      this.unknownNames.set(kind, names);
+    }
+    if (names.has(name)) {
+      return;
+    }
+    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) {
+      return;
+    }
+    const code = hint2 ? GRAPHML_ISSUE.PARSE_HINT_IGNORED : GRAPHML_ISSUE.UNKNOWN_XML_ATTRIBUTE;
+    this.report.warning("unsupported", code, unreadAttributeMessage(kind, name, hint2), { line, element: name });
+  }
   /**
    * Open a `<graph>`: the top-level one sets the sink's direction (rule 1 of design section
    * 8.4); a nested one records its container as the parent of its nodes.
@@ -2381,6 +3024,9 @@ class GraphmlReader {
       case "all":
         domains = ["graph", "node", "edge"];
         break;
+      case "graphml":
+        domains = ["graph"];
+        break;
       case "graph":
       case "node":
       case "edge":
@@ -2406,12 +3052,13 @@ class GraphmlReader {
         );
         domains = [];
     }
+    const attrType = attrs.get("attr.type") ?? attrs.get("type") ?? null;
     this.pendingKey = {
       id,
-      // `name` / `type` without the `attr.` prefix are written by some tools; the spec's spelling wins
       attrName: attrs.get("attr.name") ?? attrs.get("name") ?? null,
-      attrType: attrs.get("attr.type") ?? attrs.get("type") ?? null,
-      yfilesType: attrs.get("yfiles.type") ?? null,
+      attrType,
+      // yFiles 3 declares its untyped keys with `y:attr.uri` instead of `yfiles.type`: their data is nested XML
+      yfilesType: attrs.get("yfiles.type") ?? (attrType === null ? attributeUri(attrs) : null),
       domains,
       line,
       desc: "",
@@ -2929,6 +3576,18 @@ class GraphmlReader {
       }
       return value;
     }
+    if (typeof value !== "string" && target.spec.declared === "") {
+      this.report.warnOnce(
+        "validation-error",
+        GRAPHML_ISSUE.DATA_STRUCTURED,
+        `<data> of the untyped attribute "${target.name}" holds elements; they are kept as XML text`,
+        { line: where.line, element: target.name },
+        `${GRAPHML_ISSUE.DATA_STRUCTURED}:${target.name}`
+      );
+      const parts = [];
+      writeXmlTree(value, "", parts);
+      return parts.join("").trim();
+    }
     if (typeof value !== "string") {
       this.report.error(
         "validation-error",
@@ -3659,7 +4318,11 @@ async function importGraphml(input, sink, options) {
       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 });
+      report.fail(
+        err instanceof XmlNestingError ? GRAPHML_ISSUE.XML_NESTING : GRAPHML_ISSUE.XML_SYNTAX,
+        err.message,
+        { line: err.line }
+      );
     }
     throw err;
   }
@@ -3673,6 +4336,8 @@ const graphmlImporter = Object.freeze({
   extensions: EXTENSIONS,
   mimeTypes: MIME_TYPES,
   sniff: sniffGraphml,
+  styles: graphmlStyles,
+  positions: yfilesPositions,
   import: importGraphml
 });
 const GRAPHML_ELEMENTS = /* @__PURE__ */ new Set([
@@ -3695,17 +4360,8 @@ function unknownElementMessage(name) {
   }
   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`;
 }
-function unreadAttributeMessage(kind, name, hint2) {
-  if (hint2) {
-    return `the <${kind}> parse hint ${name} is ignored`;
-  }
-  if (SCHEMA_ATTRIBUTES.has(name)) {
-    return `the <${kind}> attribute ${name} is not kept`;
-  }
-  return `the <${kind}> attribute ${name} is not a GraphML attribute; it is not kept`;
-}
 export {
   graphmlImporter as a,
   graphmlExporter as g
 };
-//# sourceMappingURL=importer-xZ-3suY1.js.map
+//# sourceMappingURL=importer-ClwoVx3O.js.map