@graphty/graph-io 0.3.43 → 0.3.45

package/dist/graph-io.js

@@ -1,42 +1,49 @@
 import { INVALID_INDEX, GraphFormatError, GraphBuilder } from "@graphty/graph-format";
 import { GraphBuilder as GraphBuilder2, GraphFormatError as GraphFormatError2, INVALID_INDEX as INVALID_INDEX2 } from "@graphty/graph-format";
-import { al as resolveImportOptions, a8 as ImportReportBuilder, ao as reportSinkOptions, an as reportUnusedOptions, ar as IdCoercer, aq as DirectionResolver, az as LineReader, am as throwIfAborted, aK as parseWeightText, aL as isAbortError, aM as BAD_LINE_CODE, aN as messageOf, aO as describe, b as plural, aP as UNKNOWN_OPTION_CODE, a7 as chooseGraph, aQ as normalizeInput, aR as foreignKind, E as EMPTY_INPUT_CODE, aS as ImportError, aT as FETCH_CODE, $ as agree, aU as EDGES_MERGED_CODE, aV as SELF_LOOPS_DROPPED_CODE, O as OPTION_IGNORED_CODE, aW as WEIGHT_NOT_FOUND_CODE, aX as lockReader, aY as abortable } from "./chunks/export-rKLeGQMo.js";
-import { ae, Y, V, B, aZ, a3, at, a_, C, a$, A, b0, k, j, i, b1, b2, b3, D, d, o, b4, m, u, n, F, b5, v, x, b6, b7, aB, af, H, I, b8, J, G, b9, y, z, ba, a2, L, s, t, M, l, W, T, bb, bc, aA, bd, be, N, bf, bg, Q, ai, bh, P, aD, ay, au, K, R, bi, ag, S, Z, _, bj, f, ah, ak, bk, bl, bm, ad, aC, U, g, w, q, bn, h, bo, bp, aj, ax, X, aH, c, a, bq, aI, br, a1, bs, bt, e, bu, aF, aa, ab, bv, aG, ap, bw, bx, by, bz, aJ, bA, p, bB, bC, r, aE, a4 } from "./chunks/export-rKLeGQMo.js";
-import { T as TextCellWriter } from "./chunks/text-DHOJXnED.js";
-import { W as W2, i as i2, a as a5, p as p2 } from "./chunks/text-DHOJXnED.js";
-import { C as C2, c as c2, a as a6 } from "./chunks/children-CA4coBi0.js";
+import { Z as ImportReportBuilder, aj as isAbortError, ak as BAD_LINE_CODE, al as messageOf, p as plural, am as UNKNOWN_OPTION_CODE, E as EMPTY_INPUT_CODE, an as ImportError, ao as FETCH_CODE, a5 as STYLES_NOT_IMPORTED_CODE, a as agree, ap as EDGES_MERGED_CODE, aq as SELF_LOOPS_DROPPED_CODE, O as OPTION_IGNORED_CODE, ar as WEIGHT_NOT_FOUND_CODE } from "./chunks/format-BpQBx8MZ.js";
+import { a2, Q, K, B, ae, Y, a9, as, C, at, x, au, h, g, f, av, D, b, l, aw, j, q, k, y, ax, r, t, ay, az, ag, a3, H, I, aA, A, z, aB, u, v, aC, W, n, o, M, i, L, J, aD, af, aE, N, aF, G, a6, aG, P, ai, aa, F, R, aH, a4, S, T, V, aI, c, a8, aJ, aK, aL, a1, ah, U, d, s, m, e, aM, aN, a7, ac, X, w, aO, $, a0, aP, ad, aQ } from "./chunks/format-BpQBx8MZ.js";
+import { g as resolveImportOptions, j as reportSinkOptions, i as reportUnusedOptions, I as IdCoercer, l as DirectionResolver, P as LineReader, h as throwIfAborted, s as parseWeightText, Q as describe, f as chooseGraph, S as normalizeInput, U as foreignKind, V as lockReader, W as abortable } from "./chunks/export-BvqAXCKh.js";
+import { X as X2, Y as Y2, L as L2, Z, _, $ as $2, R as R2, a0 as a02, a1 as a12, c as c2, a, a2 as a22, a3 as a32, y as y2, d as d2, a4 as a42, a5, e as e2, a6 as a62, k as k2, a7 as a72, O, a8 as a82, a9 as a92, o as o2, aa as aa2, p, ab, ac as ac2, r as r2, G as G2, t as t2 } from "./chunks/export-BvqAXCKh.js";
+import { T as TextCellWriter } from "./chunks/text-CzJNFOS9.js";
+import { W as W2, i as i2, a as a10, p as p2 } from "./chunks/text-CzJNFOS9.js";
+import { C as C2, c as c3, a as a11 } from "./chunks/children-CA4coBi0.js";
 import { c as collectBytes } from "./chunks/writer-DxjgHwSe.js";
-import { D as D2, d as d2, e as e2, j as j2, t as t2 } from "./chunks/writer-DxjgHwSe.js";
+import { D as D2, d as d3, e as e3, j as j2, t as t3 } from "./chunks/writer-DxjgHwSe.js";
 import { csvImporter, csvExporter } from "./csv.js";
 import { CSV_CAPABILITIES, CSV_ISSUE, CSV_LOSS } from "./csv.js";
-import { d as cxImporter, c as cxExporter } from "./chunks/importer-C98dpSH4.js";
-import { C as C3, a as a7, b } from "./chunks/importer-C98dpSH4.js";
-import { c as cx2Exporter } from "./chunks/exporter-8hLNemFk.js";
-import { C as C4, a as a8 } from "./chunks/exporter-8hLNemFk.js";
-import { c as cx2Importer } from "./chunks/importer-D794XUTe.js";
-import { C as C5 } from "./chunks/importer-D794XUTe.js";
-import { d as cysImporter, c as cysExporter } from "./chunks/importer-WrGRZb0N.js";
-import { C as C6, a as a9, b as b10 } from "./chunks/importer-WrGRZb0N.js";
-import { b as dotImporter, d as dotExporter } from "./chunks/importer-BbNb7eNg.js";
-import { D as D3, a as a10 } from "./chunks/importer-BbNb7eNg.js";
+import { d as cxImporter, c as cxExporter } from "./chunks/importer-B-9Rc1zO.js";
+import { C as C3, a as a13, b as b2 } from "./chunks/importer-B-9Rc1zO.js";
+import { c as cx2Exporter } from "./chunks/exporter-DFqJhBnj.js";
+import { C as C4, a as a14 } from "./chunks/exporter-DFqJhBnj.js";
+import { c as cx2Importer } from "./chunks/importer-BVVR740x.js";
+import { C as C5 } from "./chunks/importer-BVVR740x.js";
+import { d as cysImporter, c as cysExporter } from "./chunks/importer-C0AjA3Ax.js";
+import { C as C6, a as a15, b as b3 } from "./chunks/importer-C0AjA3Ax.js";
+import { c as dotImporter, d as dotExporter } from "./chunks/importer-C7pvJe1L.js";
+import { D as D3, a as a16, b as b4 } from "./chunks/importer-C7pvJe1L.js";
 import { gexfImporter, gexfExporter } from "./gexf.js";
 import { GEXF_1_2_CAPABILITIES, GEXF_ISSUE, GEXF_LOSS } from "./gexf.js";
 import { gmlImporter, gmlExporter } from "./gml.js";
-import { GML_ISSUE, GML_LOSS } from "./gml.js";
-import { a as graphmlImporter, g as graphmlExporter } from "./chunks/importer-xZ-3suY1.js";
-import { r as rankFormats, S as SNIFF_HEAD_BYTES, e as jsonImporter, c as jsonExporter } from "./chunks/exporter-RVtXVetw.js";
-import { G as G2, J as J2, a as a11, b as b11, d as d3, g as g2, h as h2, j as j3, f as f2, n as n2, s as s2, i as i3 } from "./chunks/exporter-RVtXVetw.js";
+import { GML_ISSUE, GML_LOSS, GML_STYLE_BLOCK_KEY, GML_STYLE_CAPABILITIES } from "./gml.js";
+import { a as graphmlImporter, g as graphmlExporter } from "./chunks/importer-ClwoVx3O.js";
+import { r as rankFormats, S as SNIFF_HEAD_BYTES, e as jsonImporter, c as jsonExporter } from "./chunks/exporter-C-9cgZKa.js";
+import { G as G3, J as J2, a as a17, b as b5, d as d4, g as g2, h as h2, j as j3, f as f2, n as n2, s as s2, i as i3 } from "./chunks/exporter-C-9cgZKa.js";
 import { neo4jImporter, neo4jExporter } from "./neo4j.js";
 import { ID_SPACE_COLUMN, LABELS_COLUMN, NEO4J_CAPABILITIES, NEO4J_ISSUE, NEO4J_LOSS, ORIGINAL_ID_COLUMN, TYPE_COLUMN, exportNeo4jFiles } from "./neo4j.js";
-import { c as oboImporter, o as oboExporter } from "./chunks/exporter-yLxKBvLE.js";
-import { O, a as a12, b as b12 } from "./chunks/exporter-yLxKBvLE.js";
-import { b as pajekImporter, p as pajekExporter } from "./chunks/importer-Dz7tI8Sa.js";
-import { P as P2, a as a13 } from "./chunks/importer-Dz7tI8Sa.js";
-import { x as xgmmlExporter } from "./chunks/exporter-BWwEuOPT.js";
-import { x as xgmmlImporter } from "./chunks/importer-Ht7LNg8L.js";
-import { X as X2, a as a14 } from "./chunks/importer-Ht7LNg8L.js";
-import { G as G3, a as a15 } from "./chunks/constants-fT3E8JYY.js";
-import { X as X3, b as b13, h as h3, t as t3, x as x2 } from "./chunks/escape-B62ZGM_a.js";
+import { c as oboImporter, o as oboExporter } from "./chunks/exporter--Mk9gXCJ.js";
+import { O as O2, a as a18, b as b6 } from "./chunks/exporter--Mk9gXCJ.js";
+import { d as pajekImporter, p as pajekExporter } from "./chunks/importer-EHQk1jbM.js";
+import { P as P2, a as a19, b as b7, c as c4 } from "./chunks/importer-EHQk1jbM.js";
+import { x as xgmmlExporter } from "./chunks/exporter-DteVeJki.js";
+import { x as xgmmlImporter } from "./chunks/importer-D0sC_6bO.js";
+import { e as extractStyles } from "./chunks/generic-BGO71QBv.js";
+import { p as prepareStyleExport, i as isKeptGraphtyProperty } from "./chunks/writer-gQ8kx99H.js";
+import { G as G4, a as a20 } from "./chunks/constants-BKwqelYD.js";
+import { G as G5 } from "./chunks/styles-yed-Cz9rLBCP.js";
+import { X as X3, a as a21 } from "./chunks/styles-zNTmz5R7.js";
+import { M as M2, d as d5, c as c5, f as f3, h as h3, t as t4, x as x2 } from "./chunks/escape-CgzxiYPg.js";
+import { S as S2 } from "./chunks/block-CPCHkX42.js";
+import { j as j4, a as a23 } from "./chunks/styles-DvoFBKCK.js";
 const USED = /* @__PURE__ */ new Set(["ids", "defaultDirected", "weightFrom", "addMissingNodes"]);
 function defineLineFormat(definition) {
   const { format, extensions, mimeTypes = [], directed = false, comment = "#", sniff: sniff2, parseLine } = definition;
@@ -77,9 +84,9 @@ function defineLineFormat(definition) {
         edge: (source, target, attributes2) => {
           const raw = opts.weightFrom === null ? void 0 : attributes2?.[opts.weightFrom];
           const weight = raw === null || raw === void 0 ? void 0 : parseWeightText(String(raw), report);
-          const [s3, t4] = [ids.text(source), ids.text(target)];
-          const added = new Set([s3, t4].filter((id) => sink.indexOf(id) === INVALID_INDEX)).size;
-          const edge = edges.addEdge(s3, t4, kind, weight, { line });
+          const [s3, t5] = [ids.text(source), ids.text(target)];
+          const added = new Set([s3, t5].filter((id) => sink.indexOf(id) === INVALID_INDEX)).size;
+          const edge = edges.addEdge(s3, t5, kind, weight, { line });
           report.counts.nodes += added;
           report.counts.edges++;
           write("edge", edge, attributes2);
@@ -174,18 +181,18 @@ function compareSnapshots(expected, actual, options = {}) {
   const tolerance = options.tolerance ?? 0;
   const ctx = {
     options,
-    diff: (path, e3, a16, message) => {
+    diff: (path, e4, a24, message) => {
       diffs.push({
         path,
-        expected: e3,
-        actual: a16,
-        message: message ?? `${path}: expected ${show(e3)}, got ${show(a16)}`
+        expected: e4,
+        actual: a24,
+        message: message ?? `${path}: expected ${show(e4)}, got ${show(a24)}`
       });
       if (diffs.length >= limit) {
         throw new LimitReached();
       }
     },
-    same: (e3, a16) => valuesEqual(e3, a16, tolerance)
+    same: (e4, a24) => valuesEqual(e4, a24, tolerance)
   };
   try {
     compareGraphs(expected, actual, ctx);
@@ -241,9 +248,9 @@ function compareTopology(expected, actual, diff) {
   }
   const el = expected.edgeList();
   const al = actual.edgeList();
-  for (let e3 = 0; e3 < expected.edgeCount; e3++) {
-    if (el.src[e3] !== al.src[e3] || el.dst[e3] !== al.dst[e3]) {
-      diff(`edge[${e3}]`, `${el.src[e3]}->${el.dst[e3]}`, `${al.src[e3]}->${al.dst[e3]}`);
+  for (let e4 = 0; e4 < expected.edgeCount; e4++) {
+    if (el.src[e4] !== al.src[e4] || el.dst[e4] !== al.dst[e4]) {
+      diff(`edge[${e4}]`, `${el.src[e4]}->${el.dst[e4]}`, `${al.src[e4]}->${al.dst[e4]}`);
     }
   }
 }
@@ -270,23 +277,23 @@ function compareWeights(expected, actual, ctx) {
     );
   }
   const ew = expected.edgeList().weights;
-  const aw = actual.edgeList().weights;
-  for (let e3 = 0; e3 < expected.edgeCount; e3++) {
-    const ev = ew === null ? 1 : ew[e3];
-    const av = aw === null ? 1 : aw[e3];
-    if (!ctx.same(ev, av)) {
-      ctx.diff(`weight[${e3}]`, ev, av);
+  const aw2 = actual.edgeList().weights;
+  for (let e4 = 0; e4 < expected.edgeCount; e4++) {
+    const ev = ew === null ? 1 : ew[e4];
+    const av2 = aw2 === null ? 1 : aw2[e4];
+    if (!ctx.same(ev, av2)) {
+      ctx.diff(`weight[${e4}]`, ev, av2);
     }
   }
 }
 function compareExactWeights(edgeCount, expected, actual, ctx) {
-  for (let e3 = 0; e3 < edgeCount; e3++) {
-    const eSet = expected.isSet(e3);
-    const aSet = actual.isSet(e3);
+  for (let e4 = 0; e4 < edgeCount; e4++) {
+    const eSet = expected.isSet(e4);
+    const aSet = actual.isSet(e4);
     if (ctx.options.weightExplicitness !== false && eSet !== aSet) {
-      ctx.diff(`weightExplicit[${e3}]`, eSet, aSet);
-    } else if (eSet && aSet && !ctx.same(expected.value(e3), actual.value(e3))) {
-      ctx.diff(`weight[${e3}]`, expected.value(e3), actual.value(e3));
+      ctx.diff(`weightExplicit[${e4}]`, eSet, aSet);
+    } else if (eSet && aSet && !ctx.same(expected.value(e4), actual.value(e4))) {
+      ctx.diff(`weight[${e4}]`, expected.value(e4), actual.value(e4));
     }
   }
 }
@@ -343,36 +350,36 @@ function compareColumn(path, column, other, ctx) {
     ctx.diff(`${path}.length`, column.length, other.length);
     return;
   }
-  for (let r2 = 0; r2 < column.length; r2++) {
-    const eSet = column.isSet(r2);
-    const aSet = other.isSet(r2);
+  for (let r3 = 0; r3 < column.length; r3++) {
+    const eSet = column.isSet(r3);
+    const aSet = other.isSet(r3);
     if (eSet !== aSet) {
-      ctx.diff(`${path}[${r2}]`, eSet ? column.value(r2) : void 0, aSet ? other.value(r2) : void 0);
+      ctx.diff(`${path}[${r3}]`, eSet ? column.value(r3) : void 0, aSet ? other.value(r3) : void 0);
     } else if (eSet) {
-      const ev = cellValue(column, r2);
-      const av = cellValue(other, r2);
-      if (!ctx.same(ev, av)) {
-        ctx.diff(`${path}[${r2}]`, ev, av);
+      const ev = cellValue(column, r3);
+      const av2 = cellValue(other, r3);
+      if (!ctx.same(ev, av2)) {
+        ctx.diff(`${path}[${r3}]`, ev, av2);
       }
     }
   }
 }
 function compareDeclaration(path, column, other, ctx) {
   const { options, diff } = ctx;
-  const e3 = column.meta;
-  const a16 = other.meta;
+  const e4 = column.meta;
+  const a24 = other.meta;
   if (options.dtypes !== false) {
     for (const key of ["dtype", "itemDtype", "components"]) {
-      if (e3[key] !== a16[key]) {
-        diff(`${path}.${key}`, e3[key], a16[key]);
+      if (e4[key] !== a24[key]) {
+        diff(`${path}.${key}`, e4[key], a24[key]);
       }
     }
   }
-  if (options.roles !== false && e3.role !== a16.role) {
-    diff(`${path}.role`, e3.role, a16.role);
+  if (options.roles !== false && e4.role !== a24.role) {
+    diff(`${path}.role`, e4.role, a24.role);
   }
-  const eType = e3.origin?.type ?? null;
-  const aType = a16.origin?.type ?? null;
+  const eType = e4.origin?.type ?? null;
+  const aType = a24.origin?.type ?? null;
   if (options.originType === true && eType !== aType) {
     diff(`${path}.origin.type`, eType, aType);
   }
@@ -389,38 +396,38 @@ function cellValue(column, row) {
     }
   }
 }
-function valuesEqual(e3, a16, tolerance) {
-  if (typeof e3 === "number" && typeof a16 === "number") {
-    if (Object.is(e3, a16)) {
+function valuesEqual(e4, a24, tolerance) {
+  if (typeof e4 === "number" && typeof a24 === "number") {
+    if (Object.is(e4, a24)) {
       return true;
     }
-    return Number.isFinite(e3) && Number.isFinite(a16) && Math.abs(e3 - a16) <= tolerance;
+    return Number.isFinite(e4) && Number.isFinite(a24) && Math.abs(e4 - a24) <= tolerance;
   }
-  if (Array.isArray(e3) || ArrayBuffer.isView(e3)) {
-    const ea = Array.from(e3);
-    if (!(Array.isArray(a16) || ArrayBuffer.isView(a16))) {
+  if (Array.isArray(e4) || ArrayBuffer.isView(e4)) {
+    const ea = Array.from(e4);
+    if (!(Array.isArray(a24) || ArrayBuffer.isView(a24))) {
       return false;
     }
-    const aa2 = Array.from(a16);
-    return ea.length === aa2.length && ea.every((v2, i4) => valuesEqual(v2, aa2[i4], tolerance));
+    const aa3 = Array.from(a24);
+    return ea.length === aa3.length && ea.every((v2, i4) => valuesEqual(v2, aa3[i4], tolerance));
   }
-  if (typeof e3 === "object" && e3 !== null && typeof a16 === "object" && a16 !== null) {
-    const eo = e3;
-    const ao = a16;
+  if (typeof e4 === "object" && e4 !== null && typeof a24 === "object" && a24 !== null) {
+    const eo = e4;
+    const ao = a24;
     const keys = Object.keys(eo);
     if (keys.length !== Object.keys(ao).length) {
       return false;
     }
-    return keys.every((k2) => Object.hasOwn(ao, k2) && valuesEqual(eo[k2], ao[k2], tolerance));
+    return keys.every((k3) => Object.hasOwn(ao, k3) && valuesEqual(eo[k3], ao[k3], tolerance));
   }
-  return Object.is(e3, a16);
+  return Object.is(e4, a24);
 }
-function typedEqual(a16, b14) {
-  if (a16.length !== b14.length) {
+function typedEqual(a24, b8) {
+  if (a24.length !== b8.length) {
     return false;
   }
-  for (let i4 = 0; i4 < a16.length; i4++) {
-    if (a16[i4] !== b14[i4]) {
+  for (let i4 = 0; i4 < a24.length; i4++) {
+    if (a24[i4] !== b8[i4]) {
       return false;
     }
   }
@@ -439,7 +446,7 @@ function show(v2) {
   }
 }
 function describeDiffs(diffs) {
-  return diffs.length === 0 ? "no differences" : diffs.map((d4) => `  - ${d4.message}`).join("\n");
+  return diffs.length === 0 ? "no differences" : diffs.map((d6) => `  - ${d6.message}`).join("\n");
 }
 const TOO_MANY_EMPTY_CELLS_CODE = "E_TOO_MANY_EMPTY_CELLS";
 const DEFAULT_MAX_EMPTY_CELLS = 2 ** 24;
@@ -591,6 +598,7 @@ const FUNCTION_OPTIONS = /* @__PURE__ */ new Set([
   "sanitizeIds",
   "selfLoops",
   "signal",
+  "styles",
   "weightDtype",
   "weightFrom"
 ]);
@@ -600,7 +608,8 @@ const REGISTRY_KEYS = /* @__PURE__ */ new Set([
   "mimeType",
   "builder",
   "freeze",
-  "maxEmptyCells"
+  "maxEmptyCells",
+  "styles"
 ]);
 class FormatRegistry {
   constructor() {
@@ -731,7 +740,7 @@ class FormatRegistry {
     const { importer } = chosen;
     if ((opts.graphIndex !== void 0 || opts.graphName !== void 0) && importer.importAll !== void 0 && importer.listGraphs === void 0) {
       const all = await this.readAll(chosen, opts);
-      const names = all.map((r2) => r2.snapshot.meta.name);
+      const names = all.map((r3) => r3.snapshot.meta.name);
       return all[chooseGraph(names, opts, new ImportReportBuilder(importer.format, 0))];
     }
     let builder;
@@ -939,7 +948,38 @@ class FormatRegistry {
    * @returns the encoded chunks
    */
   exportGraph(snapshot, format, options) {
-    return this.exporter(format).export(snapshot, options);
+    const styled = this.styled(snapshot, format, options);
+    if (styled === null) {
+      return this.exporter(format).export(snapshot, options);
+    }
+    if (styled.refusal !== null) {
+      return refuse(styled.refusal);
+    }
+    return styled.exporter.export(styled.snapshot, styled.options);
+  }
+  /**
+   * An export with styles worked out, or null when no styles were given (the export is then exactly as before).
+   * @param snapshot - the graph
+   * @param format - the format name
+   * @param options - the caller's options
+   * @returns the exporter, the snapshot and options to hand it, the style losses and any refusal
+   */
+  styled(snapshot, format, options) {
+    const styles = options?.styles;
+    if (styles === void 0 || styles === null) {
+      return null;
+    }
+    const exporter = this.exporter(format);
+    const { styles: _given, ...rest } = options;
+    const prepared = prepareStyleExport(snapshot, exporter, styles, rest);
+    return {
+      exporter,
+      snapshot: prepared.snapshot,
+      options: prepared.input === null ? rest : { ...rest, styles: prepared.input },
+      plain: rest,
+      notes: prepared.notes,
+      refusal: prepared.refusal
+    };
   }
   /**
    * Write a snapshot in a format, as one string.
@@ -949,7 +989,14 @@ class FormatRegistry {
    * @returns the whole document
    */
   async exportGraphToString(snapshot, format, options) {
-    return this.exporter(format).exportToString(snapshot, options);
+    const styled = this.styled(snapshot, format, options);
+    if (styled === null) {
+      return this.exporter(format).exportToString(snapshot, options);
+    }
+    if (styled.refusal !== null) {
+      throw refusalError(styled.refusal);
+    }
+    return styled.exporter.exportToString(styled.snapshot, styled.options);
   }
   /**
    * Write a snapshot in a format as one buffer of UTF-8 bytes; see the top-level
@@ -975,7 +1022,7 @@ class FormatRegistry {
     for await (const chunk of this.exportGraph(snapshot, format, options)) {
       parts.push(chunk);
     }
-    const info = this.listFormats().find((f3) => f3.format === format);
+    const info = this.listFormats().find((f4) => f4.format === format);
     return new Blob(parts, { type: info?.mimeTypes[0] ?? "application/octet-stream" });
   }
   /**
@@ -986,7 +1033,22 @@ class FormatRegistry {
    * @returns the loss notes, empty when the export is exact
    */
   checkExport(snapshot, format, options) {
-    const notes = this.exporter(format).check(snapshot, options);
+    const styled = this.styled(snapshot, format, options);
+    let notes;
+    if (styled === null) {
+      notes = this.exporter(format).check(snapshot, options);
+    } else if (styled.refusal === null) {
+      const key = (n3) => `${n3.code}\0${n3.style?.target ?? ""}\0${n3.style?.property ?? ""}`;
+      const reported = new Set(styled.notes.filter((n3) => n3.style !== void 0).map(key));
+      notes = [
+        ...styled.exporter.check(styled.snapshot, styled.options).filter(
+          (n3) => n3.style === void 0 || !reported.has(key(n3)) && !isKeptGraphtyProperty(n3, styled.exporter)
+        ),
+        ...styled.notes
+      ];
+    } else {
+      notes = [...styled.exporter.check(snapshot, styled.plain), styled.refusal];
+    }
     const unknown = this.unknownOptions(options);
     if (unknown.length === 0) {
       return notes;
@@ -1042,7 +1104,7 @@ class FormatRegistry {
     }
     const { filename, ...rest } = options;
     const blob = await this.exportGraphToBlob(snapshot, format, rest);
-    const extension = this.listFormats().find((f3) => f3.format === format)?.extensions[0] ?? `.${format}`;
+    const extension = this.listFormats().find((f4) => f4.format === format)?.extensions[0] ?? `.${format}`;
     const href = URL.createObjectURL(blob);
     const anchor = document.createElement("a");
     anchor.href = href;
@@ -1067,7 +1129,7 @@ class FormatRegistry {
         mimeTypes: importer?.mimeTypes ?? exporter?.mimeTypes ?? [],
         canImport: importer !== void 0,
         canExport: exporter !== void 0,
-        capabilities: exporter?.capabilities ?? null
+        capabilities: capabilitiesOf(exporter)
       });
     });
   }
@@ -1200,16 +1262,25 @@ function result(chosen, builder, report, options) {
     throw freezeFailure(err, report);
   }
   const { warnings } = chosen;
+  const wanted = options.styles;
+  let styles;
+  if (wanted !== void 0 && wanted !== false) {
+    styles = extractStyles(chosen.importer, frozen.snapshot, report, {
+      signal: options.signal,
+      toolDefaults: typeof wanted === "object" ? wanted.toolDefaults : void 0
+    });
+  }
+  const read = styles !== void 0 && chosen.importer.styles !== void 0 ? withoutStylesNotImported(report) : report;
   const result2 = {
     format: chosen.importer.format,
     sniff: chosen.sniff,
     snapshot: frozen.snapshot,
     report: withFreezeWarnings(
       weightNotFound(
-        warnings.length === 0 ? report : Object.freeze({
-          ...report,
-          issues: Object.freeze([...warnings, ...report.issues]),
-          warningCount: report.warningCount + warnings.length
+        warnings.length === 0 ? read : Object.freeze({
+          ...read,
+          issues: Object.freeze([...warnings, ...read.issues]),
+          warningCount: read.warningCount + warnings.length
         }),
         frozen.snapshot,
         options.weightFrom
@@ -1217,9 +1288,40 @@ function result(chosen, builder, report, options) {
       frozen.report
     )
   };
+  if (styles !== void 0) {
+    Object.assign(result2, { styles });
+  }
   Object.defineProperty(result2, "freeze", { value: frozen.report, enumerable: false });
   return Object.freeze(result2);
 }
+function withoutStylesNotImported(report) {
+  const issues = report.issues.filter((i4) => i4.code !== STYLES_NOT_IMPORTED_CODE);
+  if (issues.length === report.issues.length) {
+    return report;
+  }
+  return Object.freeze({
+    ...report,
+    issues: Object.freeze(issues),
+    warningCount: report.warningCount - (report.issues.length - issues.length)
+  });
+}
+function refusalError(note) {
+  return new GraphFormatError("E_UNSUPPORTED", note.message, { code: note.code });
+}
+function refuse(note) {
+  return {
+    [Symbol.asyncIterator]: () => ({ next: () => Promise.reject(refusalError(note)) })
+  };
+}
+function capabilitiesOf(exporter) {
+  if (exporter === void 0) {
+    return null;
+  }
+  if (exporter.styles === void 0) {
+    return exporter.capabilities;
+  }
+  return Object.freeze({ ...exporter.capabilities, styles: exporter.styles.capabilities });
+}
 function unknownOptionText(name) {
   return `option ${JSON.stringify(name)} is not an option of any format or of the load and save functions, so it has no effect; check its spelling`;
 }
@@ -1339,10 +1441,10 @@ async function peekHead(input, bytes, signal) {
   return { head: joinHead(buffered, bytes), input: replayed, close: () => replayed.close() };
 }
 function joinHead(chunks, bytes) {
-  if (chunks.every((c3) => c3 instanceof Uint8Array)) {
+  if (chunks.every((c6) => c6 instanceof Uint8Array)) {
     const total = Math.min(
       bytes,
-      chunks.reduce((sum, c3) => sum + c3.byteLength, 0)
+      chunks.reduce((sum, c6) => sum + c6.byteLength, 0)
     );
     const head = new Uint8Array(total);
     let offset = 0;
@@ -1436,172 +1538,184 @@ function readerIterator(stream, signal) {
   };
 }
 export {
-  ae as AMBIGUOUS_GRAPH_NAME_CODE,
-  Y as ASPECT_ORDER_CODE,
-  V as BAD_ASPECT_BLOCK_CODE,
+  a2 as AMBIGUOUS_GRAPH_NAME_CODE,
+  Q as ASPECT_ORDER_CODE,
+  K as BAD_ASPECT_BLOCK_CODE,
   B as BAD_DEFAULT_CODE,
   BAD_LINE_CODE,
-  aZ as BAD_OPTIONS_CODE,
-  a3 as BAD_VALUE_CODE,
-  at as COLUMN_AS_PROPERTY_VALUE_CODE,
-  a_ as COLUMN_DROPPED_CODE,
+  ae as BAD_OPTIONS_CODE,
+  Y as BAD_VALUE_CODE,
+  a9 as COLUMN_AS_PROPERTY_VALUE_CODE,
+  as as COLUMN_DROPPED_CODE,
   C as COLUMN_RENAMED_CODE,
-  a$ as COLUMN_RENAMED_LOSS_CODE,
-  A as COLUMN_TYPE_CODE,
-  b0 as CONTROL_CHARACTER_CODE,
-  k as COUNT_HINT_CODE,
-  j as COUNT_MISMATCH_CODE,
+  at as COLUMN_RENAMED_LOSS_CODE,
+  x as COLUMN_TYPE_CODE,
+  au as CONTROL_CHARACTER_CODE,
+  h as COUNT_HINT_CODE,
+  g as COUNT_MISMATCH_CODE,
   CSV_CAPABILITIES,
   CSV_ISSUE,
   CSV_LOSS,
   C4 as CX2_CAPABILITIES,
   C5 as CX2_ISSUE,
-  a8 as CX2_LOSS,
+  a14 as CX2_LOSS,
   C3 as CX_CAPABILITIES,
-  a7 as CX_ISSUE,
-  b as CX_LOSS,
+  a13 as CX_ISSUE,
+  b2 as CX_LOSS,
   C6 as CYS_CAPABILITIES,
-  a9 as CYS_ISSUE,
-  b10 as CYS_LOSS,
+  a15 as CYS_ISSUE,
+  b3 as CYS_LOSS,
   C2 as ChildrenCsr,
-  i as DANGLING_REFERENCE_CODE,
+  f as DANGLING_REFERENCE_CODE,
   D2 as DEFAULT_CHUNK_BYTES,
-  b1 as DEFAULT_ERROR_LIMIT,
-  b2 as DIRECTED_COLUMN,
-  b3 as DIRECTION_DROPPED_CODE,
+  X2 as DEFAULT_ERROR_LIMIT,
+  Y2 as DIRECTED_COLUMN,
+  av as DIRECTION_DROPPED_CODE,
   D as DIRECTION_FORCED_CODE,
-  d as DIRECTION_REFUSED_CODE,
+  b as DIRECTION_REFUSED_CODE,
   D3 as DOT_ISSUE,
-  a10 as DOT_LOSS,
-  o as DUPLICATE_ATTRIBUTE_CODE,
-  b4 as DUPLICATE_EDGE_CODE,
-  m as DUPLICATE_EDGE_ID_CODE,
-  u as DUPLICATE_KEY_CODE,
-  n as DUPLICATE_NODE_CODE,
+  a16 as DOT_LOSS,
+  S2 as DOT_STYLE_BLOCK_ATTRIBUTE,
+  b4 as DOT_STYLE_CAPABILITIES,
+  l as DUPLICATE_ATTRIBUTE_CODE,
+  aw as DUPLICATE_EDGE_CODE,
+  j as DUPLICATE_EDGE_ID_CODE,
+  q as DUPLICATE_KEY_CODE,
+  k as DUPLICATE_NODE_CODE,
   DirectionResolver,
   EDGES_MERGED_CODE,
-  F as ELEMENT_ISSUE,
-  b5 as EMPTY_COLUMN_DROPPED_CODE,
+  y as ELEMENT_ISSUE,
+  ax as EMPTY_COLUMN_DROPPED_CODE,
   EMPTY_INPUT_CODE,
-  v as ENCODING_CONFLICT_CODE,
-  x as ENCODING_FALLBACK_CODE,
-  b6 as EQUATION_AS_TEXT_CODE,
+  r as ENCODING_CONFLICT_CODE,
+  t as ENCODING_FALLBACK_CODE,
+  ay as EQUATION_AS_TEXT_CODE,
   FETCH_CODE,
-  b7 as FOREIGN_FORMAT_CODE,
+  az as FOREIGN_FORMAT_CODE,
   FormatRegistry,
   GEXF_1_2_CAPABILITIES,
   GEXF_ISSUE,
   GEXF_LOSS,
+  j4 as GEXF_STYLE_CAPABILITIES,
   GML_ISSUE,
   GML_LOSS,
-  G3 as GRAPHML_ISSUE,
-  a15 as GRAPHML_LOSS,
-  aB as GRAPH_COLUMN_AS_METADATA_CODE,
-  G2 as GRAPH_FORMATS,
-  af as GRAPH_NOT_FOUND_CODE,
+  GML_STYLE_BLOCK_KEY,
+  GML_STYLE_CAPABILITIES,
+  G4 as GRAPHML_ISSUE,
+  a20 as GRAPHML_LOSS,
+  G5 as GRAPHML_STYLE_CAPABILITIES,
+  a23 as GRAPHTY_XML_NAMESPACE,
+  ag as GRAPH_COLUMN_AS_METADATA_CODE,
+  G3 as GRAPH_FORMATS,
+  a3 as GRAPH_NOT_FOUND_CODE,
   GraphBuilder2 as GraphBuilder,
   GraphFormatError2 as GraphFormatError,
   H as HYPEREDGE_CODE,
   I as ID_MERGED_CODE,
   ID_SPACE_COLUMN,
-  b8 as ID_TEXT_COLLISION_CODE,
-  J as ID_TEXT_TYPE_CODE,
-  G as INPUT_ISSUE,
-  b9 as INTEGRAL_F64_CODE,
-  y as INVALID_ENCODING_CODE,
+  aA as ID_TEXT_COLLISION_CODE,
+  A as ID_TEXT_TYPE_CODE,
+  z as INPUT_ISSUE,
+  aB as INTEGRAL_F64_CODE,
+  u as INVALID_ENCODING_CODE,
   INVALID_INDEX2 as INVALID_INDEX,
-  z as INVALID_UTF8_CODE,
-  ba as ISSUES_SUPPRESSED_CODE,
+  v as INVALID_UTF8_CODE,
+  aC as ISSUES_SUPPRESSED_CODE,
   IdCoercer,
   ImportError,
   ImportReportBuilder,
   J2 as JSON_DIALECTS,
-  a11 as JSON_ISSUE,
-  b11 as JSON_LOSS,
-  a2 as JSON_NONSTANDARD_NUMBER_CODE,
+  a17 as JSON_ISSUE,
+  b5 as JSON_LOSS,
+  W as JSON_NONSTANDARD_NUMBER_CODE,
   LABELS_COLUMN,
-  L as LOSS,
+  L2 as LOSS,
   LineReader,
-  s as MISSING_ENDPOINT_CODE,
-  t as MISSING_ID_CODE,
+  M2 as MAX_XML_DEPTH,
+  n as MISSING_ENDPOINT_CODE,
+  o as MISSING_ID_CODE,
   M as MIXED_DIRECTION_CODE,
-  l as MULTIPLE_GRAPHS_CODE,
-  W as MULTI_ASPECT_FRAGMENT_CODE,
-  T as MUTUAL_AS_UNDIRECTED_CODE,
-  bb as MUTUAL_COLUMN,
-  bc as MUTUAL_EXPANDED_CODE,
+  i as MULTIPLE_GRAPHS_CODE,
+  L as MULTI_ASPECT_FRAGMENT_CODE,
+  J as MUTUAL_AS_UNDIRECTED_CODE,
+  Z as MUTUAL_COLUMN,
+  aD as MUTUAL_EXPANDED_CODE,
   NEO4J_CAPABILITIES,
   NEO4J_ISSUE,
   NEO4J_LOSS,
-  aA as NODE_ORDER_CODE,
-  bd as NONFINITE_AS_NULL_CODE,
-  be as NO_CAPABILITIES,
+  af as NODE_ORDER_CODE,
+  aE as NONFINITE_AS_NULL_CODE,
+  _ as NO_CAPABILITIES,
   N as NO_GRAPH_CODE,
-  O as OBO_CAPABILITIES,
-  a12 as OBO_ISSUE,
-  b12 as OBO_LOSS,
-  bf as OPTIONS_GAINED_CODE,
+  O2 as OBO_CAPABILITIES,
+  a18 as OBO_ISSUE,
+  b6 as OBO_LOSS,
+  aF as OPTIONS_GAINED_CODE,
   OPTION_IGNORED_CODE,
   ORIGINAL_ID_COLUMN,
-  bg as PAIR_COLUMN,
+  $2 as PAIR_COLUMN,
   P2 as PAJEK_ISSUE,
-  a13 as PAJEK_LOSS,
-  Q as PARENTS_DROPPED_CODE,
-  ai as PARENT_CYCLE_CODE,
-  bh as PARSE_ERROR_CODE,
+  a19 as PAJEK_LOSS,
+  b7 as PAJEK_STYLE_CAPABILITIES,
+  c4 as PAJEK_STYLE_COMMENT,
+  G as PARENTS_DROPPED_CODE,
+  a6 as PARENT_CYCLE_CODE,
+  aG as PARSE_ERROR_CODE,
   P as PRECISION_CODE,
-  aD as RELATION_ASSUMED_CODE,
-  ay as RENAMED_CODE,
-  au as ROLE_ASSUMED_CODE,
-  K as ROLE_DROPPED_CODE,
+  ai as RELATION_ASSUMED_CODE,
+  R2 as RENAMED_CODE,
+  aa as ROLE_ASSUMED_CODE,
+  F as ROLE_DROPPED_CODE,
   R as ROLE_TAKEN_CODE,
   SELF_LOOPS_DROPPED_CODE,
-  bi as SELF_LOOP_CODE,
-  ag as SINGLE_OBJECT_ASPECT_CODE,
+  aH as SELF_LOOP_CODE,
+  a4 as SINGLE_OBJECT_ASPECT_CODE,
   S as SINK_OPTION_CODE,
   SNIFF_FAILED_CODE,
   SNIFF_HEAD_BYTES,
-  Z as STATUS_FAILED_CODE,
-  _ as STATUS_WARNING_CODE,
-  bj as STORAGE_CLASS_CODE,
-  f as STRAY_TEXT_CODE,
-  ah as STYLES_NOT_IMPORTED_CODE,
-  ak as SYNTAX_CODE,
-  bk as TEMPORAL_DROPPED_CODE,
-  bl as TEMPORAL_TEXT_DROPPED_CODE,
-  bm as TEXT_INFERRED_CODE,
-  ad as TOO_LARGE_CODE,
-  aC as TYPEDEF_NODES_CODE,
+  T as STATUS_FAILED_CODE,
+  V as STATUS_WARNING_CODE,
+  aI as STORAGE_CLASS_CODE,
+  c as STRAY_TEXT_CODE,
+  STYLES_NOT_IMPORTED_CODE,
+  a8 as SYNTAX_CODE,
+  aJ as TEMPORAL_DROPPED_CODE,
+  aK as TEMPORAL_TEXT_DROPPED_CODE,
+  aL as TEXT_INFERRED_CODE,
+  a1 as TOO_LARGE_CODE,
+  ah as TYPEDEF_NODES_CODE,
   TYPE_COLUMN,
   TextCellWriter,
   U as UNKNOWN_ATTR_TYPE_CODE,
-  g as UNKNOWN_ELEMENT_CODE,
-  w as UNKNOWN_ENCODING_CODE,
+  d as UNKNOWN_ELEMENT_CODE,
+  s as UNKNOWN_ENCODING_CODE,
   UNKNOWN_FORMAT_CODE,
   UNKNOWN_OPTION_CODE,
-  q as UNKNOWN_PARENT_CODE,
-  bn as UNKNOWN_TYPE_CODE,
-  h as UNKNOWN_XML_ATTRIBUTE_CODE,
-  bo as WEIGHTS_DROPPED_CODE,
-  bp as WEIGHT_KEY_CLASH_CODE,
+  m as UNKNOWN_PARENT_CODE,
+  a02 as UNKNOWN_TYPE_CODE,
+  e as UNKNOWN_XML_ATTRIBUTE_CODE,
+  aM as WEIGHTS_DROPPED_CODE,
+  aN as WEIGHT_KEY_CLASH_CODE,
   WEIGHT_NOT_FOUND_CODE,
-  aj as WIDENED_CODE,
+  a7 as WIDENED_CODE,
   W2 as WIDENING_UNSUPPORTED_CODE,
-  X2 as XGMML_ISSUE,
-  a14 as XGMML_LOSS,
-  ax as XML_ILLEGAL_CHAR_CODE,
-  X as XML_SYNTAX_CODE,
-  X3 as XmlSyntaxError,
-  b13 as XmlTokenizer,
-  aH as canonicalId,
-  c as capabilities,
+  X3 as XGMML_ISSUE,
+  a21 as XGMML_LOSS,
+  ac as XML_ILLEGAL_CHAR_CODE,
+  X as XML_NESTING_CODE,
+  w as XML_SYNTAX_CODE,
+  d5 as XmlNestingError,
+  c5 as XmlSyntaxError,
+  f3 as XmlTokenizer,
+  a12 as canonicalId,
+  c2 as capabilities,
   a as checkCapabilities,
   checkExport,
-  c2 as childrenCsr,
-  a6 as childrenFromColumn,
+  c3 as childrenCsr,
+  a11 as childrenFromColumn,
   chooseGraph,
-  bq as coerceId,
-  aI as coerceIdText,
+  a22 as coerceId,
+  a32 as coerceIdText,
   collectBytes,
   compareSnapshots,
   createRegistry,
@@ -1613,36 +1727,36 @@ export {
   cxImporter,
   cysExporter,
   cysImporter,
-  br as declareCompanion,
-  a1 as declareResolved,
-  d2 as decodeChunks,
-  bs as decodeEntryName,
+  y2 as declareCompanion,
+  d2 as declareResolved,
+  d3 as decodeChunks,
+  a42 as decodeEntryName,
   defineLineFormat,
   describeDiffs,
-  d3 as dialectCapabilities,
+  d4 as dialectCapabilities,
   dotExporter,
   dotImporter,
   downloadGraph,
-  bt as edgeWeights,
-  e2 as encodeChunks,
-  e as explicitWeights,
+  a5 as edgeWeights,
+  e3 as encodeChunks,
+  e2 as explicitWeights,
   exportGraph,
   exportGraphToBlob,
   exportGraphToBytes,
   exportGraphToString,
   exportNeo4jFiles,
   g2 as extensionOf,
-  bu as forDecodedText,
-  aF as formatDecimal,
-  aa as formatF32,
-  ab as formatF64,
-  bv as formatGmlReal,
-  aG as formatInteger,
+  a62 as forDecodedText,
+  aO as formatDecimal,
+  $ as formatF32,
+  a0 as formatF64,
+  aP as formatGmlReal,
+  ad as formatInteger,
   gexfExporter,
   gexfImporter,
   gmlExporter,
   gmlImporter,
-  ap as graphChosen,
+  k2 as graphChosen,
   graphmlExporter,
   graphmlImporter,
   h3 as hasIllegalXmlChar,
@@ -1650,23 +1764,24 @@ export {
   importAllGraphs,
   importGraph,
   i2 as inferTextDtype,
-  bw as inputLength,
+  a72 as inputLength,
   isAbortError,
-  bx as isCanonicalIntegerText,
-  by as isImportInput,
-  bz as isNmtoken,
-  a5 as isNumericText,
-  aJ as isWeightField,
+  O as isCanonicalIntegerText,
+  a82 as isImportInput,
+  a92 as isNmtoken,
+  a10 as isNumericText,
+  o2 as isWeightField,
   j2 as joinText,
   j3 as jsonCapabilities,
   jsonExporter,
   jsonImporter,
   f2 as jsonShapeOf,
+  aQ as keptForStyles,
   listFormats,
   listGraphs,
   loadFromFile,
   loadFromUrl,
-  bA as mangleNmtoken,
+  aa2 as mangleNmtoken,
   neo4jExporter,
   neo4jImporter,
   n2 as normalizeMimeType,
@@ -1678,21 +1793,21 @@ export {
   p2 as parseTextCell,
   parseWeightText,
   rankFormats,
-  bB as readText,
-  bC as refusedSave,
+  ab as readText,
+  ac2 as refusedSave,
   registry,
   reportSinkOptions,
   reportUnusedOptions,
-  r as resolveExportOptions,
+  r2 as resolveExportOptions,
   resolveImportOptions,
-  aE as sanitizeIds,
+  G2 as sanitizeIds,
   sniff,
   s2 as sniffFormat,
   i3 as sniffJsonDialectHead,
-  a4 as textChunks,
+  t2 as textChunks,
   throwIfAborted,
-  t2 as toReadableStream,
-  t3 as tokenizeXml,
+  t3 as toReadableStream,
+  t4 as tokenizeXml,
   xgmmlExporter,
   xgmmlImporter,
   x2 as xmlIllegalTextNotes