@graphty/graph-io 0.3.42 → 0.3.44

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

@@ -36,14 +36,17 @@ import { AMBIGUOUS_GRAPH_NAME_CODE, BAD_VALUE_CODE, COLUMN_RENAMED_CODE, DANGLIN
 import { DirectionResolver } from "../../common/direction.js";
 import { ID_MERGED_CODE, IdCoercer } from "../../common/ids.js";
 import { readText, throwIfAborted } from "../../common/input.js";
-import { findDuplicateKeys, flipY, MAYBE_INEXACT_EXPONENT, MAYBE_UNSAFE_INTEGER, rewriteNumbers, } from "../../common/json-elements.js";
+import { findDuplicateKeys, flipY, keysInTextOrder, MAYBE_INEXACT_EXPONENT, MAYBE_UNSAFE_INTEGER, rewriteNumbers, } from "../../common/json-elements.js";
 import { chooseGraph, graphChosen, reportSinkOptions, reportUnusedOptions, resolveImportOptions, SINK_OPTION_CODE, } from "../../common/options.js";
 import { agree, plural } from "../../common/plural.js";
 import { ImportReportBuilder } from "../../common/report.js";
 import { weightFromValue } from "../../common/weights.js";
 import { headBytes, sniffJsonDialectHead } from "../../sniff.js";
+import { STYLE_BLOCK_NAME } from "../../styles/io/block.js";
 import { CLASSES_COLUMN, CYTOSCAPE_ELEMENT_KEYS, CYTOSCAPE_STRUCTURAL_KEYS, DIALECT_DEFAULT_DIRECTED, hasKey, isJsonImportDialect, isJsonObject, JSON_IMPORT_DIALECTS, META_KEY, NODE_LINK_SOURCE_KEYS, NODE_LINK_TARGET_KEYS, PARENT_COLUMN, POSITION_COLUMN, sniffJsonDialect, SUFFIX, } from "./dialect.js";
 import { importObographs } from "./obographs.js";
+import { jsonPositions } from "./positions.js";
+import { jsonStyles } from "./styles.js";
 /**
  * The issue codes the JSON importer records, by name: the codes shared with
  * the other importers and the JSON-specific ones. A key is the code without
@@ -218,12 +221,18 @@ const JGF_EDGE_KEYS = new Set([
 ]);
 /** The JGF hyperedge keys that are not metadata. */
 const JGF_HYPEREDGE_KEYS = new Set([...JGF_EDGE_KEYS, "nodes"]);
+/** A key JavaScript orders as an array index: digits with no leading zero, below 2^32 - 1. */
+const ARRAY_INDEX = /^(?:0|[1-9]\d{0,9})$/;
 /** The JGF node keys that are not metadata. */
 const JGF_NODE_KEYS = new Set(["label", "metadata"]);
 /** The graphology node keys that are not attributes. */
 const GRAPHOLOGY_NODE_KEYS = new Set(["key", "attributes"]);
 /** The graphology edge keys that are not attributes. */
 const GRAPHOLOGY_EDGE_KEYS = new Set(["key", "source", "target", "attributes", "undirected"]);
+/** The structural keys of a node in Gephi's JSON export. */
+const GEPHI_NODE_KEYS = new Set(["id", "attributes"]);
+/** The structural keys of an edge in Gephi's JSON export. */
+const GEPHI_EDGE_KEYS = new Set([...GRAPHOLOGY_EDGE_KEYS, "id"]);
 /** The vis.js endpoint keys. */
 const VIS_SOURCE_KEYS = Object.freeze(["from"]);
 const VIS_TARGET_KEYS = Object.freeze(["to"]);
@@ -634,6 +643,8 @@ export class ImportContext {
      * @param explicitDefaultDirected - whether the caller passed defaultDirected
      */
     constructor(sink, report, options, json, explicitDefaultDirected) {
+        /** The document's text, for an order JSON.parse does not keep (a JGF nodes object's integer-like keys). */
+        this.text = "";
         /** Nodes and edges pushed since the signal was last checked. */
         this.elementsSinceCheck = 0;
         /** The direction the file declares (or the default), set by setHeader(). */
@@ -643,6 +654,8 @@ export class ImportContext {
         this.danglingCount = 0;
         /** Set when the document has no node section: every node comes from an edge (E_MISSING_SECTION says so). */
         this.nodesFromEdges = false;
+        /** What the dialect's reader keeps for the style reader (`report.keepForStyles()`), or null. */
+        this.styleSource = null;
         /** Dangling endpoints whose id, as the other JSON type, is a node (`"1"` next to the node 1). */
         this.nearMatches = [];
         this.sink = sink;
@@ -790,6 +803,31 @@ export class ImportContext {
         }
         return edge;
     }
+    /**
+     * A Cytoscape.js endpoint or parent id: Cytoscape.js holds every id as text, so an endpoint `0` names the node
+     * `"0"` and an endpoint `"0"` the node `0` when the file has no node of the endpoint's own type.
+     * @param raw - the JSON value
+     * @param element - the element name for issues
+     * @returns the id, or null when the value was reported
+     */
+    textualId(raw, element) {
+        const id = this.coerceId(raw, element);
+        if (id === null || this.sink.indexOf(id) !== INVALID_INDEX) {
+            return id;
+        }
+        let other = null;
+        if (typeof raw === "number" && Number.isFinite(raw)) {
+            other = String(raw);
+        }
+        else if (typeof raw === "string" && /^-?\d+(?:\.\d+)?$/.test(raw)) {
+            other = Number(raw);
+        }
+        if (other === null) {
+            return id;
+        }
+        const alt = this.ids.value(other);
+        return this.sink.indexOf(alt) === INVALID_INDEX ? id : alt;
+    }
     /**
      * Count a placeholder node an edge endpoint created.
      * @param id - the endpoint
@@ -953,10 +991,14 @@ export class ImportContext {
      * @param record - the element record
      * @param dict - the nested attribute dict
      * @param structural - the element keys that are not attributes
-     * @param weightFrom - the weight key to skip in the dict, or null
      * @param element - the element name for issues
+     * @param how - `weightFrom`: the weight key to skip in the dict; `plain`: write the element-level keys under their
+     * own names, not with the `#element` suffix
+     * @param how.weightFrom - the weight key to skip in the dict, or null (the default)
+     * @param how.plain - write the element-level keys under their own names (default false)
      */
-    writeNested(writer, row, record, dict, structural, weightFrom, element) {
+    writeNested(writer, row, record, dict, structural, element, how = {}) {
+        const { weightFrom = null, plain = false } = how;
         for (const key of Object.keys(dict)) {
             if (key !== weightFrom) {
                 writer.write(row, key, dict[key], SUFFIX.data, element);
@@ -964,7 +1006,7 @@ export class ImportContext {
         }
         for (const key of Object.keys(record)) {
             if (!structural.has(key)) {
-                writer.write(row, `${key}${SUFFIX.element}`, record[key], SUFFIX.data, element);
+                writer.write(row, plain ? key : `${key}${SUFFIX.element}`, record[key], SUFFIX.data, element);
             }
         }
     }
@@ -1284,7 +1326,8 @@ function arraySection(value, what, report) {
     if (!Array.isArray(value)) {
         return report.fail(JSON_ISSUE.SHAPE, `${what} must be an array, found ${describe(value)}`, { element: what });
     }
-    return value;
+    const items = value;
+    return items;
 }
 /**
  * A boolean flag with a default and a warning when it has another type.
@@ -1351,9 +1394,15 @@ function reportUnreadKeys(ctx, record, known, prefix) {
     }
 }
 /** The keys of a vis.js document the reader reads. */
-const VIS_DOCUMENT_KEYS = new Set(["nodes", "edges"]);
+const VIS_DOCUMENT_KEYS = new Set(["nodes", "edges", STYLE_BLOCK_NAME]);
 /** The keys of a graphology serialization the reader reads. */
-const GRAPHOLOGY_DOCUMENT_KEYS = new Set(["nodes", "edges", "options", "attributes"]);
+const GRAPHOLOGY_DOCUMENT_KEYS = new Set([
+    "nodes",
+    "edges",
+    "options",
+    "attributes",
+    STYLE_BLOCK_NAME,
+]);
 /** The keys of a JGF graph object the reader reads. */
 const JGF_GRAPH_KEYS = new Set([
     "id",
@@ -1392,94 +1441,33 @@ function isIndexBelow(value, bound) {
  */
 function importNodeLink(ctx, root, dialect) {
     const { report, json } = ctx;
-    let { edgesKey } = json;
-    if (edgesKey === null) {
-        edgesKey = hasKey(root, "edges") || !hasKey(root, "links") ? "edges" : "links";
-    }
-    const nodes = arraySection(root.nodes, "nodes", report);
-    const edges = arraySection(root[edgesKey], edgesKey, report);
-    if (nodes === null) {
-        report.warning("missing-value", JSON_ISSUE.MISSING_SECTION, "the document has no nodes array; nodes come from the edges", { element: "nodes" });
-        ctx.nodesFromEdges = true;
-    }
-    if (edges === null) {
-        report.warning("missing-value", JSON_ISSUE.MISSING_SECTION, `the document has no ${edgesKey} array; the graph has no edges`, { element: edgesKey });
-    }
+    const edgesKey = json.edgesKey ?? (hasKey(root, "edges") || !hasKey(root, "links") ? "edges" : "links");
+    const { nodeList, edgeList } = nodeLinkSections(ctx, root, edgesKey);
     const directed = flagOf(root.directed, "directed", ctx.defaultDirected(dialect), report);
     const multigraph = hasKey(root, "multigraph") ? flagOf(root.multigraph, "multigraph", false, report) : null;
     ctx.setHeader(directed);
     ctx.writeGraphDict(root.graph, "graph");
-    reportUnreadKeys(ctx, root, new Set(["nodes", edgesKey, "directed", "multigraph", "graph"]), "");
-    const nodeList = nodes ?? [];
-    const edgeList = edges ?? [];
+    reportUnreadKeys(ctx, root, new Set(["nodes", edgesKey, "directed", "multigraph", "graph", STYLE_BLOCK_NAME]), "");
+    // NetworkX's node_link_data writes all three keys; its drawing defaults then apply
+    const networkx = hasKey(root, "directed") && hasKey(root, "multigraph") && hasKey(root, "graph");
+    ctx.styleSource = { dialect, block: blockOf(root), networkx };
     ctx.sink.reserve(nodeList.length, edgeList.length);
-    // the id key: the caller's, else "id" when any node has it, else "name" (d3); nodes without any
-    // id key are positional (nodeIdFrom "index", or a d3 v3 file whose nodes carry no id at all)
-    let { nodeIdKey } = json;
-    let positional = ctx.options.nodeIdFrom === "index";
-    if (!positional && nodeIdKey === null) {
-        const candidates = ctx.options.nodeIdFrom === "label" ? ["label", "name", "id"] : ["id", "name"];
-        nodeIdKey = candidates.find((key) => anyHas(nodeList, key)) ?? null;
-        if (ctx.options.nodeIdFrom === "label" && (nodeIdKey === "id" || nodeIdKey === "name")) {
-            report.warning("unsupported", JSON_ISSUE.OPTION_IGNORED, nodeIdKey === "id"
-                ? 'nodeIdFrom "label": no node has a label or name key; ids are read from "id"'
-                : 'nodeIdFrom "label": no node has a "label" key; ids are read from "name"', { element: "nodeIdFrom" });
-        }
-        if (nodeIdKey === null) {
-            if (nodeList.length > 0) {
-                positional = true;
-                report.warning("missing-value", JSON_ISSUE.POSITIONAL_NODES, "no node has an id or name key; array positions are the node ids", { element: "nodes" });
-            }
-            else {
-                nodeIdKey = "id";
-            }
-        }
-    }
-    if (positional) {
-        nodeIdKey = null;
-    }
+    const nodeIdKey = nodeLinkIdKey(ctx, nodeList);
+    const positional = nodeIdKey === null;
     let indexLinks;
     if (positional) {
         indexLinks = true;
     }
     else if (json.indexLinks === "auto") {
-        indexLinks = nodeIdKey !== null && looksIndexLinked(nodeList, edgeList, nodeIdKey, json);
+        indexLinks = looksIndexLinked(nodeList, edgeList, nodeIdKey, json);
     }
     else {
         ({ indexLinks } = json);
     }
-    const positionIds = indexLinks ? [] : null;
-    if (indexLinks && !positional && json.indexLinks === "auto" && nodeIdKey !== null) {
+    if (indexLinks && !positional && json.indexLinks === "auto") {
         reportAmbiguousIndexLinks(ctx, nodeList, edgeList, nodeIdKey);
     }
-    for (let i = 0; i < nodeList.length; i++) {
-        const element = `nodes[${i}]`;
-        const record = nodeList[i];
-        let pushed = null;
-        if (!isJsonObject(record)) {
-            ctx.badElement("node", element);
-        }
-        else {
-            let id;
-            if (nodeIdKey === null) {
-                id = i;
-            }
-            else {
-                id = ctx.coerceId(hasKey(record, nodeIdKey) ? record[nodeIdKey] : undefined, element);
-            }
-            if (id === null) {
-                ctx.countSkipped("node");
-            }
-            else {
-                const index = ctx.pushNode(id, element);
-                if (index >= 0) {
-                    pushed = id;
-                    writeFlat(ctx.nodes, index, record, id, (key) => key !== nodeIdKey);
-                }
-            }
-        }
-        positionIds?.push(pushed);
-    }
+    const positionIds = importNodeLinkNodes(ctx, nodeList, nodeIdKey, indexLinks);
     throwIfAborted(ctx.options.signal);
     const endpointKeys = importNodeLinkEdges(ctx, edgeList, edgesKey, positionIds, multigraph);
     ctx.setMeta({
@@ -1491,6 +1479,103 @@ function importNodeLink(ctx, root, dialect) {
         targetKey: endpointKeys.target ?? undefined,
     }, { declaredMultigraph: multigraph, ...ctx.weightOriginPatch() });
 }
+/**
+ * The node and edge arrays of a node-link or d3 document; a missing one is reported (without nodes, nodes come from
+ * the edges).
+ * @param ctx - the context
+ * @param root - the document
+ * @param edgesKey - the key of the edges
+ * @returns the arrays, empty when missing
+ */
+function nodeLinkSections(ctx, root, edgesKey) {
+    const { report } = ctx;
+    const nodes = arraySection(root.nodes, "nodes", report);
+    const edges = arraySection(root[edgesKey], edgesKey, report);
+    if (nodes === null) {
+        report.warning("missing-value", JSON_ISSUE.MISSING_SECTION, "the document has no nodes array; nodes come from the edges", { element: "nodes" });
+        ctx.nodesFromEdges = true;
+    }
+    if (edges === null) {
+        report.warning("missing-value", JSON_ISSUE.MISSING_SECTION, `the document has no ${edgesKey} array; the graph has no edges`, { element: edgesKey });
+    }
+    return { nodeList: nodes ?? [], edgeList: edges ?? [] };
+}
+/**
+ * The key node ids are read from: the caller's, else "id" when any node has it, else "name" (d3); null when the nodes
+ * are positional (nodeIdFrom "index", or a d3 v3 file whose nodes carry no id at all).
+ * @param ctx - the context
+ * @param nodeList - the node records
+ * @returns the key, or null for positional nodes
+ */
+function nodeLinkIdKey(ctx, nodeList) {
+    const { report, json } = ctx;
+    if (ctx.options.nodeIdFrom === "index") {
+        return null;
+    }
+    if (json.nodeIdKey !== null) {
+        return json.nodeIdKey;
+    }
+    const byLabel = ctx.options.nodeIdFrom === "label";
+    const candidates = byLabel ? ["label", "name", "id"] : ["id", "name"];
+    const found = candidates.find((key) => anyHas(nodeList, key)) ?? null;
+    if (byLabel && (found === "id" || found === "name")) {
+        report.warning("unsupported", JSON_ISSUE.OPTION_IGNORED, found === "id"
+            ? 'nodeIdFrom "label": no node has a label or name key; ids are read from "id"'
+            : 'nodeIdFrom "label": no node has a "label" key; ids are read from "name"', { element: "nodeIdFrom" });
+    }
+    if (found !== null || nodeList.length === 0) {
+        return found ?? "id";
+    }
+    report.warning("missing-value", JSON_ISSUE.POSITIONAL_NODES, "no node has an id or name key; array positions are the node ids", { element: "nodes" });
+    return null;
+}
+/**
+ * Read the node-link / d3 node records.
+ * @param ctx - the context
+ * @param nodeList - the node records
+ * @param nodeIdKey - the key ids are read from, or null for positional nodes
+ * @param indexLinks - whether edges name their endpoints by array position
+ * @returns the ids by array position under index links (null where a node was not added), else null
+ */
+function importNodeLinkNodes(ctx, nodeList, nodeIdKey, indexLinks) {
+    const positionIds = indexLinks ? [] : null;
+    for (let i = 0; i < nodeList.length; i++) {
+        const element = `nodes[${i}]`;
+        const record = nodeList[i];
+        let pushed = null;
+        if (isJsonObject(record)) {
+            pushed = pushNodeLinkNode(ctx, record, i, nodeIdKey);
+        }
+        else {
+            ctx.badElement("node", element);
+        }
+        positionIds?.push(pushed);
+    }
+    return positionIds;
+}
+/**
+ * Add one node-link / d3 node and its other keys as attributes.
+ * @param ctx - the context
+ * @param record - the node record
+ * @param i - its array position
+ * @param nodeIdKey - the key its id is read from, or null for positional nodes
+ * @returns its id, or null when it was not added
+ */
+function pushNodeLinkNode(ctx, record, i, nodeIdKey) {
+    const element = `nodes[${i}]`;
+    const raw = nodeIdKey !== null && hasKey(record, nodeIdKey) ? record[nodeIdKey] : undefined;
+    const id = nodeIdKey === null ? i : ctx.coerceId(raw, element);
+    if (id === null) {
+        ctx.countSkipped("node");
+        return null;
+    }
+    const index = ctx.pushNode(id, element);
+    if (index < 0) {
+        return null;
+    }
+    writeFlat(ctx.nodes, index, record, id, (key) => key !== nodeIdKey);
+    return id;
+}
 /**
  * Read the node-link / d3 edge records: endpoints by id or array position, the weight, the other
  * keys as attributes.
@@ -1769,6 +1854,7 @@ function importVis(ctx, root) {
     if (arrows > 0) {
         report.warning("validation-error", JSON_ISSUE.INCONSISTENT, `${arrows} edge${plural(arrows)} ${agree(arrows, "carries", "carry")} vis.js arrows but the graph is read undirected; the arrows are kept as an attribute (pass defaultDirected: true to read the edges as directed)`, { element: "arrows" });
     }
+    ctx.styleSource = { dialect: "vis", block: blockOf(root), options: root.options, groups: root.groups };
     ctx.setMeta({ dialect: "vis", nodeIdKey, sourceKey: sourceKey ?? undefined, targetKey: targetKey ?? undefined }, ctx.weightOriginPatch());
 }
 // ============================================================ NetworkX adjacency_data / tree_data
@@ -2082,36 +2168,29 @@ function importGraphology(ctx, root) {
         });
     }
     const type = graphologyType(ctx, options);
-    ctx.setHeader(graphologyDirected(ctx, type, edges));
+    ctx.setHeader(type === "mixed" ? mostlyDirected(ctx, edges) : type === "directed");
     const multi = hasKey(options, "multi") ? flagOf(options.multi, "options.multi", false, report) : null;
     const allowSelfLoops = hasKey(options, "allowSelfLoops")
         ? flagOf(options.allowSelfLoops, "options.allowSelfLoops", true, report)
         : undefined;
     ctx.writeGraphDict(root.attributes, "attributes");
+    // Gephi's JSON export (for sigma.js) names nodes and edges by `id` and puts sigma's display keys (`label`, `x`,
+    // `y`, `color`, `size`) beside `attributes`; they are read as attributes, not as unknown element keys
+    const firstNode = nodes.find((n) => isJsonObject(n));
+    const gephi = isJsonObject(firstNode) && !hasKey(firstNode, "key") && hasKey(firstNode, "id");
+    ctx.styleSource = { dialect: "graphology", block: blockOf(root), gephi };
     ctx.reportNodeIdFrom("graphology", "the node key");
     ctx.sink.reserve(nodes.length, edges.length);
-    for (let i = 0; i < nodes.length; i++) {
-        pushGraphologyNode(ctx, nodes[i], `nodes[${i}]`);
-    }
+    importGraphologyNodes(ctx, nodes, gephi);
     throwIfAborted(ctx.options.signal);
-    const reading = {
-        ids: ctx.declareEdgeIds(edges, (edge) => edge.key, "key", true),
-        type,
-        allowSelfLoops,
-        // what the edges do against the declared options: graphology itself refuses such a document
-        violations: { selfLoops: 0, parallels: 0, flags: 0 },
-        pairs: multi === false ? new Set() : null,
-    };
-    for (let i = 0; i < edges.length; i++) {
-        readGraphologyEdge(ctx, reading, edges[i], `edges[${i}]`);
-    }
-    reportGraphologyViolations(ctx, reading.violations, type);
+    const violations = importGraphologyEdges(ctx, edges, { type, gephi, multi, allowSelfLoops });
+    reportGraphologyViolations(ctx, violations, type);
     ctx.setMeta({ dialect: "graphology", allowSelfLoops }, { declaredMultigraph: multi, ...ctx.weightOriginPatch() });
 }
 /**
- * A graphology document's `options.type`; anything else is reported and read as "mixed".
+ * A graphology document's `options.type`: "mixed" when absent or not one of the three (reported).
  * @param ctx - the context
- * @param options - the options object
+ * @param options - the document's options
  * @returns the type
  */
 function graphologyType(ctx, options) {
@@ -2124,114 +2203,133 @@ function graphologyType(ctx, options) {
     return "mixed";
 }
 /**
- * The header direction of a graphology document: its type, or for "mixed" directed unless every
- * edge object says undirected (the dialect default when there is none).
+ * The header direction of a mixed graphology graph: directed unless every edge is flagged undirected.
  * @param ctx - the context
- * @param type - options.type
  * @param edges - the edge records
- * @returns whether the header is directed
+ * @returns true for directed
  */
-function graphologyDirected(ctx, type, edges) {
-    if (type !== "mixed") {
-        return type === "directed";
-    }
+function mostlyDirected(ctx, edges) {
     const objects = edges.filter((edge) => isJsonObject(edge));
     const undirectedEdges = objects.filter((edge) => edge.undirected === true).length;
     return objects.length === 0 ? ctx.defaultDirected("graphology") : undirectedEdges < objects.length;
 }
 /**
- * Push one graphology node record: `key` the id, `attributes` the columns.
+ * Read the graphology node records.
  * @param ctx - the context
- * @param record - the node record
- * @param element - the element name
+ * @param nodes - the node records
+ * @param gephi - whether Gephi wrote them (ids under `id`, display keys beside the attributes)
  */
-function pushGraphologyNode(ctx, record, element) {
-    if (!isJsonObject(record)) {
-        ctx.badElement("node", element);
-        return;
-    }
-    const id = ctx.coerceId(hasKey(record, "key") ? record.key : undefined, element);
-    if (id === null) {
-        ctx.countSkipped("node");
-        return;
+function importGraphologyNodes(ctx, nodes, gephi) {
+    const nodeKey = gephi ? "id" : "key";
+    for (let i = 0; i < nodes.length; i++) {
+        const element = `nodes[${i}]`;
+        const record = nodes[i];
+        if (!isJsonObject(record)) {
+            ctx.badElement("node", element);
+            continue;
+        }
+        const id = ctx.coerceId(hasKey(record, nodeKey) ? record[nodeKey] : undefined, element);
+        if (id === null) {
+            ctx.countSkipped("node");
+            continue;
+        }
+        pushNestedNode(ctx, id, record, "attributes", gephi ? GEPHI_NODE_KEYS : GRAPHOLOGY_NODE_KEYS, element, gephi);
     }
-    pushNestedNode(ctx, id, record, "attributes", GRAPHOLOGY_NODE_KEYS, element);
 }
 /**
- * Read one graphology edge record, counting what it does against the declared options.
+ * Read the graphology edge records.
  * @param ctx - the context
- * @param reading - the read's state
- * @param record - the edge record
- * @param element - the element name
- */
-function readGraphologyEdge(ctx, reading, record, element) {
-    if (!isJsonObject(record)) {
-        ctx.badElement("edge", element);
-        return;
-    }
-    if (!present(record, "source") || !present(record, "target")) {
-        ctx.missingEndpoint(element, present(record, "source") ? "target" : "source");
-        return;
-    }
-    try {
-        const u = ctx.coerceId(record.source, `${element}.source`);
-        const v = ctx.coerceId(record.target, `${element}.target`);
-        if (u === null || v === null) {
-            ctx.countSkipped("edge");
-            return;
+ * @param edges - the edge records
+ * @param declared - what the document declares
+ * @returns the edges that contradict the declared options: graphology itself refuses such a document
+ */
+function importGraphologyEdges(ctx, edges, declared) {
+    const { gephi } = declared;
+    const ids = ctx.declareEdgeIds(edges, (edge) => (gephi && !hasKey(edge, "key") ? edge.id : edge.key), "key", true);
+    const violations = { selfLoops: 0, parallels: 0, flags: 0 };
+    const pairs = declared.multi === false ? new Set() : null;
+    for (let i = 0; i < edges.length; i++) {
+        const element = `edges[${i}]`;
+        const record = graphologyEdgeRecord(ctx, edges[i], element);
+        if (record === null) {
+            continue;
         }
-        const kind = graphologyEdgeKind(ctx, reading, record, element);
-        const attributes = graphologyEdgeAttributes(ctx, record, element);
-        const idValue = ctx.edgeIdValue(reading.ids, record.key);
-        const edge = ctx.pushEdge(u, v, kind, ctx.weightOf(attributes), element);
-        ctx.setEdgeId(reading.ids, edge, idValue);
-        ctx.writeNested(ctx.edges, edge, record, attributes, GRAPHOLOGY_EDGE_KEYS, ctx.options.weightFrom, element);
-        if (reading.allowSelfLoops === false && u === v) {
-            reading.violations.selfLoops++;
+        try {
+            const pushed = pushGraphologyEdge(ctx, record, element, ids, declared, violations);
+            if (pushed !== null && pairs !== null) {
+                violations.parallels += pairs.has(pushed) ? 1 : 0;
+                pairs.add(pushed);
+            }
         }
-        if (reading.pairs !== null) {
-            const pair = `${kind} ${pairKey(u, v, kind === "directed")}`;
-            reading.violations.parallels += reading.pairs.has(pair) ? 1 : 0;
-            reading.pairs.add(pair);
+        catch (err) {
+            ctx.skip(err, "edge", element);
         }
     }
-    catch (err) {
-        ctx.skip(err, "edge", element);
-    }
+    return violations;
 }
 /**
- * The direction of one graphology edge: its `undirected` flag under type "mixed", else the type
- * (a contrary flag is counted as a violation).
+ * One graphology edge record, when it is an object with both endpoints.
  * @param ctx - the context
- * @param reading - the read's state
  * @param record - the edge record
  * @param element - the element name
- * @returns the edge's kind
+ * @returns the record, or null when it was reported and is skipped
  */
-function graphologyEdgeKind(ctx, reading, record, element) {
-    const { type } = reading;
-    if (type === "mixed") {
-        return flagOf(record.undirected, `${element}.undirected`, false, ctx.report) ? "undirected" : "directed";
+function graphologyEdgeRecord(ctx, record, element) {
+    if (!isJsonObject(record)) {
+        ctx.badElement("edge", element);
+        return null;
     }
-    if (typeof record.undirected === "boolean" && record.undirected !== (type === "undirected")) {
-        reading.violations.flags++;
+    if (!present(record, "source") || !present(record, "target")) {
+        ctx.missingEndpoint(element, present(record, "source") ? "target" : "source");
+        return null;
     }
-    return type;
+    return record;
 }
 /**
- * The `attributes` object of a graphology edge; any other non-null value is reported and read as
- * no attributes.
+ * Add one graphology edge with its id and attributes.
  * @param ctx - the context
  * @param record - the edge record
  * @param element - the element name
- * @returns the attributes
+ * @param ids - the edge id column
+ * @param declared - what the document declares
+ * @param violations - counts the edges that contradict the declared options
+ * @returns the edge's kind and endpoint pair, or null when it was skipped
  */
-function graphologyEdgeAttributes(ctx, record, element) {
-    const { attributes } = record;
-    if (attributes !== undefined && attributes !== null && !isJsonObject(attributes)) {
-        ctx.report.error("validation-error", JSON_ISSUE.BAD_VALUE, `${element}: attributes must be an object, found ${describe(attributes)}`, { element });
+function pushGraphologyEdge(ctx, record, element, ids, declared, violations) {
+    const { report } = ctx;
+    const { type, gephi } = declared;
+    const u = ctx.coerceId(record.source, `${element}.source`);
+    const v = ctx.coerceId(record.target, `${element}.target`);
+    if (u === null || v === null) {
+        ctx.countSkipped("edge");
+        return null;
+    }
+    let kind;
+    if (type === "mixed") {
+        kind = flagOf(record.undirected, `${element}.undirected`, false, report) ? "undirected" : "directed";
     }
-    return isJsonObject(attributes) ? attributes : {};
+    else {
+        kind = type;
+        if (typeof record.undirected === "boolean" && record.undirected !== (type === "undirected")) {
+            violations.flags++;
+        }
+    }
+    const { attributes: rawAttributes } = record;
+    if (rawAttributes !== undefined && rawAttributes !== null && !isJsonObject(rawAttributes)) {
+        report.error("validation-error", JSON_ISSUE.BAD_VALUE, `${element}: attributes must be an object, found ${describe(rawAttributes)}`, { element });
+    }
+    const attributes = isJsonObject(rawAttributes) ? rawAttributes : {};
+    const idValue = ctx.edgeIdValue(ids, record.key);
+    const edge = ctx.pushEdge(u, v, kind, ctx.weightOf(attributes), element);
+    ctx.setEdgeId(ids, edge, idValue);
+    ctx.writeNested(ctx.edges, edge, record, attributes, gephi ? GEPHI_EDGE_KEYS : GRAPHOLOGY_EDGE_KEYS, element, {
+        weightFrom: ctx.options.weightFrom,
+        plain: gephi,
+    });
+    if (declared.allowSelfLoops === false && u === v) {
+        violations.selfLoops++;
+    }
+    return `${kind} ${pairKey(u, v, kind === "directed")}`;
 }
 /**
  * Report the edges that contradict a graphology document's declared options (W_JSON_INCONSISTENT,
@@ -2269,9 +2367,10 @@ function reportGraphologyViolations(ctx, violations, type) {
  * @param dictKey - the key of the nested dict
  * @param structural - the element keys that are not attributes
  * @param element - the element name
+ * @param plain - write the element-level keys under their own names
  * @returns the node index, or -1 when skipped
  */
-function pushNestedNode(ctx, id, record, dictKey, structural, element) {
+function pushNestedNode(ctx, id, record, dictKey, structural, element, plain = false) {
     const index = ctx.pushNode(id, element);
     if (index < 0) {
         return index;
@@ -2281,7 +2380,7 @@ function pushNestedNode(ctx, id, record, dictKey, structural, element) {
         if (dict !== undefined && dict !== null && !isJsonObject(dict)) {
             ctx.report.error("validation-error", JSON_ISSUE.BAD_VALUE, `${element}: ${dictKey} must be an object, found ${describe(dict)}`, { element });
         }
-        ctx.writeNested(ctx.nodes, index, record, isJsonObject(dict) ? dict : {}, structural, null, element);
+        ctx.writeNested(ctx.nodes, index, record, isJsonObject(dict) ? dict : {}, structural, element, { plain });
     }
     catch (err) {
         ctx.report.recordError(err, { element: String(id) });
@@ -2319,7 +2418,7 @@ function importJgf(ctx, root) {
     ctx.sink.reserve(nodeRecords.length, edges.length);
     const labelColumn = ctx.nodes.declareIf({ name: "label", dtype: "string", role: "label", nullable: true }, anyHas(nodeRecords, "label"));
     if (isJsonObject(nodesRaw)) {
-        for (const key of Object.keys(nodesRaw)) {
+        for (const key of jgfNodeKeys(ctx, root, graph, nodesRaw)) {
             pushJgfKeyedNode(ctx, key, nodesRaw[key], labelColumn);
         }
     }
@@ -2425,7 +2524,7 @@ function jgfEdgeWriter(ctx, edges, hyperedges) {
                 element,
             });
         }
-        ctx.writeNested(ctx.edges, edge, record, dict, structural, ctx.options.weightFrom, element);
+        ctx.writeNested(ctx.edges, edge, record, dict, structural, element, { weightFrom: ctx.options.weightFrom });
     };
 }
 /**
@@ -2459,6 +2558,25 @@ function readJgfEdge(ctx, record, element, directed, writeJgfEdge) {
         ctx.skip(err, "edge", element);
     }
 }
+/**
+ * The keys of a JGF nodes object in the file's order, which is the nodes' order: JSON.parse puts integer-like keys
+ * first, so then they are read from the text.
+ * @param ctx - the context, holding the text
+ * @param root - the document
+ * @param graph - the graph object read
+ * @param nodes - its nodes object
+ * @returns the keys
+ */
+function jgfNodeKeys(ctx, root, graph, nodes) {
+    const keys = Object.keys(nodes);
+    if (!keys.some((k) => ARRAY_INDEX.test(k))) {
+        return keys;
+    }
+    const path = isJsonObject(root.graph)
+        ? ["graph", "nodes"]
+        : ["graphs", root.graphs.indexOf(graph), "nodes"];
+    return keysInTextOrder(ctx.text, path) ?? keys;
+}
 /**
  * The graph object of a JGF document: `graph`, or the graph of `graphs` that graphIndex /
  * graphName choose (chooseGraph()).
@@ -2612,7 +2730,7 @@ function pushJgfNode(ctx, id, record, labelColumn, element) {
                 element,
             });
         }
-        ctx.writeNested(ctx.nodes, index, record, isJsonObject(metadata) ? metadata : {}, JGF_NODE_KEYS, null, element);
+        ctx.writeNested(ctx.nodes, index, record, isJsonObject(metadata) ? metadata : {}, JGF_NODE_KEYS, element);
     }
     catch (err) {
         ctx.report.recordError(err, { element: String(id) });
@@ -2767,42 +2885,44 @@ function distinctMembers(ctx, members, element) {
 function importCytoscape(ctx, root) {
     const { elements, extra } = cytoscapeRoot(ctx, root);
     const { nodes, edges } = cytoscapeSections(ctx, elements);
+    const generatedIds = cytoscapeGeneratedIds(nodes);
+    ctx.styleSource = {
+        dialect: "cytoscape",
+        block: blockOf(root),
+        elements: elements ?? [],
+        style: isJsonObject(root) ? root.style : undefined,
+        generatedBy: isJsonObject(root) && typeof root.generated_by === "string" ? root.generated_by : null,
+        generatedIds,
+    };
     ctx.setHeader(ctx.defaultDirected("cytoscape"));
     ctx.reportNodeIdFrom("cytoscape", "data.id");
     ctx.sink.reserve(nodes.length, edges.length);
-    const dataHas = (items, key) => items.some((item) => isJsonObject(item) && isJsonObject(item.data) && item.data[key] !== undefined);
-    const reading = {
-        positionColumn: ctx.nodes.declareIf({
-            name: POSITION_COLUMN,
-            dtype: "f64",
-            components: 3,
-            role: "position",
-            mutable: true,
-            nullable: true,
-            // 3D layouts written by Cytoscape-compatible tools carry a z
-            extra: { sourceDims: nodes.some(hasPositionZ) ? 3 : 2, units: "file" },
-            origin: { format: "json", namespace: "cytoscape" },
-        }, anyHas(nodes, "position")),
-        classesColumn: ctx.nodes.declareIf({ name: CLASSES_COLUMN, dtype: "list", itemDtype: "string", role: "classes", nullable: true }, anyHas(nodes, "classes")),
-        parents: [],
-        point: [0, 0, 0],
-    };
-    const parentColumn = ctx.nodes.declareIf({ name: PARENT_COLUMN, dtype: "u32", role: "parent", refersTo: "node", nullable: true }, dataHas(nodes, "parent"));
+    const columns = cytoscapeNodeColumns(ctx, nodes);
     const edgeClassesColumn = ctx.edges.declareIf({ name: CLASSES_COLUMN, dtype: "list", itemDtype: "string", role: "classes", nullable: true }, anyHas(edges, "classes"));
+    const parents = [];
     for (let i = 0; i < nodes.length; i++) {
-        readCytoscapeNode(ctx, reading, nodes[i], `nodes[${i}]`);
+        const element = `nodes[${i}]`;
+        const record = nodes[i];
+        if (isJsonObject(record) && isJsonObject(record.data)) {
+            // Cytoscape.js gives a node without data.id an id of its own
+            const raw = record.data.id === undefined ? generatedIds.get(record) : record.data.id;
+            importCytoscapeNode(ctx, record, record.data, raw, element, columns, parents);
+        }
+        else {
+            ctx.badElement("node", element, "an element with a data object");
+        }
     }
-    resolveCytoscapeParents(ctx, reading.parents, parentColumn);
+    resolveCytoscapeParents(ctx, parents, columns.parent);
     throwIfAborted(ctx.options.signal);
     importCytoscapeEdges(ctx, edges, edgeClassesColumn);
     ctx.setMeta({ dialect: "cytoscape", cytoscape: extra }, ctx.weightOriginPatch());
 }
 /**
- * The elements of a Cytoscape document (the document itself when it is an array) and, for an
- * object, its graph `data` written and its other top-level keys kept.
+ * A Cytoscape document's elements, and its other top-level keys (kept in meta); its `data` is written as graph
+ * attributes.
  * @param ctx - the context
- * @param root - the document
- * @returns the elements and the other top-level keys, if any
+ * @param root - the document: an object, or an array of elements
+ * @returns the elements and the other keys (undefined when there are none)
  */
 function cytoscapeRoot(ctx, root) {
     if (Array.isArray(root)) {
@@ -2811,31 +2931,53 @@ function cytoscapeRoot(ctx, root) {
     if (!isJsonObject(root)) {
         ctx.report.fail(JSON_ISSUE.SHAPE, `a Cytoscape document must be an object or an array, found ${describe(root)}`);
     }
-    ctx.writeGraphDict(root.data, "data");
+    const object = root;
+    ctx.writeGraphDict(object.data, "data");
     const rest = {};
-    for (const key of Object.keys(root)) {
-        if (key !== "elements" && key !== "data") {
-            rest[key] = root[key];
+    for (const key of Object.keys(object)) {
+        if (key !== "elements" && key !== "data" && key !== STYLE_BLOCK_NAME) {
+            rest[key] = object[key];
         }
     }
-    return Object.keys(rest).length > 0 ? { elements: root.elements, extra: rest } : { elements: root.elements };
+    return Object.keys(rest).length > 0 ? { elements: object.elements, extra: rest } : { elements: object.elements };
 }
 /**
- * Read one Cytoscape node element: `data.id` the id, the other `data` keys attributes (`parent`
- * kept for later), `position`, `classes` and the element-level keys.
+ * Declare the position, classes and parent columns the node records use.
+ * @param ctx - the context
+ * @param nodes - the node records
+ * @returns the columns
+ */
+function cytoscapeNodeColumns(ctx, nodes) {
+    const dataHas = (items, key) => items.some((item) => isJsonObject(item) && isJsonObject(item.data) && item.data[key] !== undefined);
+    return {
+        position: ctx.nodes.declareIf({
+            name: POSITION_COLUMN,
+            dtype: "f64",
+            components: 3,
+            role: "position",
+            mutable: true,
+            nullable: true,
+            // 3D layouts written by Cytoscape-compatible tools carry a z
+            extra: { sourceDims: nodes.some(hasPositionZ) ? 3 : 2, units: "file" },
+            origin: { format: "json", namespace: "cytoscape" },
+        }, anyHas(nodes, "position")),
+        classes: ctx.nodes.declareIf({ name: CLASSES_COLUMN, dtype: "list", itemDtype: "string", role: "classes", nullable: true }, anyHas(nodes, "classes")),
+        parent: ctx.nodes.declareIf({ name: PARENT_COLUMN, dtype: "u32", role: "parent", refersTo: "node", nullable: true }, dataHas(nodes, "parent")),
+    };
+}
+/**
+ * Add one Cytoscape node: its data as attributes (its parent kept for later), its position, classes and element keys.
  * @param ctx - the context
- * @param reading - the read's state
  * @param record - the element
+ * @param data - its data object
+ * @param raw - its raw id
  * @param element - the element name
+ * @param columns - the node columns
+ * @param parents - receives its parent link
  */
-function readCytoscapeNode(ctx, reading, record, element) {
+function importCytoscapeNode(ctx, record, data, raw, element, columns, parents) {
     const { report } = ctx;
-    if (!isJsonObject(record) || !isJsonObject(record.data)) {
-        ctx.badElement("node", element, "an element with a data object");
-        return;
-    }
-    const { data } = record;
-    const id = ctx.coerceId(hasKey(data, "id") ? data.id : undefined, element);
+    const id = ctx.coerceId(raw, element);
     if (id === null) {
         ctx.countSkipped("node");
         return;
@@ -2848,9 +2990,18 @@ function readCytoscapeNode(ctx, reading, record, element) {
         report.warning("validation-error", JSON_ISSUE.INCONSISTENT, `${element} has data.source and data.target, the shape of an edge, but its section or group says node; read as a node`, { element });
     }
     try {
-        writeCytoscapeData(ctx, reading, index, data, element);
-        writeCytoscapePosition(ctx, reading, index, record.position, element);
-        writeClasses(ctx, ctx.nodes, reading.classesColumn, index, record.classes, element);
+        for (const key of Object.keys(data).filter((k) => k !== "id")) {
+            if (key !== "parent") {
+                ctx.nodes.write(index, key, data[key], SUFFIX.data, element);
+                continue;
+            }
+            const parent = data.parent === null ? null : ctx.coerceId(data.parent, `${element}.data.parent`);
+            if (parent !== null) {
+                parents.push({ index, parent, element });
+            }
+        }
+        writeCytoscapePosition(ctx, columns.position, index, record.position, element);
+        writeClasses(ctx, ctx.nodes, columns.classes, index, record.classes, element);
         writeElementKeys(ctx.nodes, index, record, element);
     }
     catch (err) {
@@ -2858,53 +3009,21 @@ function readCytoscapeNode(ctx, reading, record, element) {
     }
 }
 /**
- * Write a Cytoscape node's `data` keys as attributes; `parent` is kept as a link to resolve later.
- * @param ctx - the context
- * @param reading - the read's state
- * @param index - the node index
- * @param data - the element's data object
- * @param element - the element name
- */
-function writeCytoscapeData(ctx, reading, index, data, element) {
-    for (const key of Object.keys(data)) {
-        if (key === "id") {
-            continue;
-        }
-        if (key !== "parent") {
-            ctx.nodes.write(index, key, data[key], SUFFIX.data, element);
-            continue;
-        }
-        const raw = data.parent;
-        if (raw === undefined || raw === null) {
-            continue;
-        }
-        const parent = ctx.coerceId(raw, `${element}.data.parent`);
-        if (parent !== null) {
-            reading.parents.push({ index, parent, element });
-        }
-    }
-}
-/**
- * Write a Cytoscape node's `position` ({ x, y, z? }, y flipped to grow upward); any other value is
- * reported.
+ * Write a Cytoscape node's position, y flipped (Cytoscape's y grows downward; positions are stored y-up and the
+ * exporter flips back).
  * @param ctx - the context
- * @param reading - the read's state
- * @param index - the node index
+ * @param column - the position column
+ * @param index - the node
  * @param position - the element's position
  * @param element - the element name
  */
-function writeCytoscapePosition(ctx, reading, index, position, element) {
+function writeCytoscapePosition(ctx, column, index, position, element) {
     if (position === undefined || position === null) {
         return;
     }
     const z = isJsonObject(position) ? (position.z ?? 0) : 0;
     if (isJsonObject(position) && isCoordinate(position.x) && isCoordinate(position.y) && isCoordinate(z)) {
-        const { point } = reading;
-        point[0] = position.x;
-        // Cytoscape's y grows downward; positions are stored y-up (the exporter flips back)
-        point[1] = flipY(position.y);
-        point[2] = z;
-        ctx.nodes.set(reading.positionColumn, index, point);
+        ctx.nodes.set(column, index, [position.x, flipY(position.y), z]);
     }
     else {
         ctx.report.error("validation-error", JSON_ISSUE.BAD_VALUE, `${element}: position must be an object with numeric x and y (and z) that are finite numbers`, { element });
@@ -2923,7 +3042,11 @@ function resolveCytoscapeParents(ctx, parents, parentColumn) {
     // the last link per child (a duplicate node's later parent wins), child -> its link
     const linkOf = new Map();
     for (let order = 0; order < parents.length; order++) {
-        const { index, parent, element } = parents[order];
+        const { index, element } = parents[order];
+        let { parent } = parents[order];
+        if (ctx.sink.indexOf(parent) === INVALID_INDEX) {
+            parent = ctx.textualId(parent, element) ?? parent;
+        }
         const parentIndex = ctx.sink.indexOf(parent);
         if (parentIndex === INVALID_INDEX) {
             report.error("missing-value", JSON_ISSUE.UNKNOWN_PARENT, `${element}: parent ${JSON.stringify(parent)} is not a node`, { element });
@@ -3014,8 +3137,8 @@ function importCytoscapeEdges(ctx, edges, edgeClassesColumn) {
 function importCytoscapeEdge(ctx, shared, record, data, element) {
     const { ids, kind, edgeClassesColumn } = shared;
     try {
-        const u = ctx.coerceId(data.source, `${element}.data.source`);
-        const v = ctx.coerceId(data.target, `${element}.data.target`);
+        const u = ctx.textualId(data.source, `${element}.data.source`);
+        const v = ctx.textualId(data.target, `${element}.data.target`);
         if (u === null || v === null) {
             ctx.countSkipped("edge");
             return;
@@ -3071,6 +3194,45 @@ function cytoscapeSections(ctx, elements) {
     }
     return report.fail(JSON_ISSUE.SHAPE, `elements must be an object or an array, found ${describe(elements)}`);
 }
+/**
+ * The ids Cytoscape.js would give the nodes without a `data.id`: `n<k>` by their place among the nodes, made unique
+ * against every id the file states.
+ * @param nodes - the node elements
+ * @returns the generated id of each node element without one
+ */
+function cytoscapeGeneratedIds(nodes) {
+    const out = new Map();
+    const missing = nodes.filter((n) => isJsonObject(n) && isJsonObject(n.data) && n.data.id === undefined);
+    if (missing.length === 0) {
+        return out;
+    }
+    const taken = new Set();
+    for (const n of nodes) {
+        const id = isJsonObject(n) && isJsonObject(n.data) ? n.data.id : undefined;
+        if (typeof id === "string" || typeof id === "number") {
+            taken.add(String(id));
+        }
+    }
+    for (let k = 0; k < missing.length; k++) {
+        let id = `n${String(k)}`;
+        let j = 2;
+        while (taken.has(id)) {
+            id = `n${String(k)}_${String(j)}`;
+            j++;
+        }
+        taken.add(id);
+        out.set(missing[k], id);
+    }
+    return out;
+}
+/**
+ * A `graphty.styles` block a document holds as a top-level key, or null.
+ * @param root - the document
+ * @returns the block's text
+ */
+function blockOf(root) {
+    return isJsonObject(root) && typeof root[STYLE_BLOCK_NAME] === "string" ? root[STYLE_BLOCK_NAME] : null;
+}
 /**
  * Whether a Cytoscape element's position has a numeric z.
  * @param element - the element
@@ -3165,6 +3327,7 @@ export const jsonImporter = Object.freeze({
         "typedefs",
     ]),
     extensions: Object.freeze([".json"]),
+    positions: jsonPositions,
     mimeTypes: Object.freeze(["application/json"]),
     /**
      * Confidence that the head is a JSON graph document: 0 unless it starts with `{` or `[`, 0.5
@@ -3198,7 +3361,7 @@ export const jsonImporter = Object.freeze({
         const report = new ImportReportBuilder("json", resolved.errorLimit);
         const text = await readText(input, report, { ...resolved, bomlessUtf16: true });
         const { root, dialect } = documentOf(parseDocument(text, report), json, report);
-        readGraph(root, dialect, sink, report, resolved, json, options);
+        readGraph({ root, dialect, text }, sink, report, resolved, json, options);
         return report.finish();
     },
     /**
@@ -3235,28 +3398,41 @@ export const jsonImporter = Object.freeze({
         const reports = [];
         for (let i = 0; i < Math.max(graphs, 1); i++) {
             const report = i === 0 ? first : new ImportReportBuilder("json", resolved.errorLimit);
-            readGraph(root, dialect, sinkFor(i), report, resolved, { ...json, graphIndex: i, all: true }, options);
+            readGraph({ root, dialect, text }, sinkFor(i), report, resolved, { ...json, graphIndex: i, all: true }, options);
             reports.push(report.finish());
         }
         return reports;
     },
+    /**
+     * The document's styles, read by its dialect's reader (Cytoscape.js stylesheets, graphology and vis.js keys,
+     * NetworkX's defaults); a `graphty.styles` block gives back the rules graphty wrote.
+     * @param snapshot - the graph the import built
+     * @param context - the work budget and what the import kept
+     * @returns the styles, or null when the dialect has none
+     */
+    styles: jsonStyles,
 });
 /**
  * Read one graph of a parsed document into a sink.
- * @param root - the parsed document
- * @param dialect - its dialect
+ * @param doc - the parsed document, its dialect and its text
+ * @param doc.root - the parsed document
+ * @param doc.dialect - its dialect
+ * @param doc.text - the document's text
  * @param sink - the sink
  * @param report - the graph's report
  * @param resolved - the resolved common options
  * @param json - the resolved JSON options (graphIndex picks the JGF graph)
  * @param options - the caller's options, for the sink and unused-option checks
  */
-function readGraph(root, dialect, sink, report, resolved, json, options) {
+function readGraph(doc, sink, report, resolved, json, options) {
+    const { root, dialect, text } = doc;
     const ctx = new ImportContext(sink, report, resolved, json, options?.defaultDirected !== undefined);
+    ctx.text = text;
     // the obographs reader refuses missing endpoints itself, so addMissingNodes false holds on any sink
     reportSinkOptions(sink, options, report, dialect === "obographs");
     reportUnusedOptions(options, report, USED_OPTIONS);
     readDialect(ctx, root, dialect);
+    report.keepForStyles(ctx.styleSource ?? { dialect, block: blockOf(root) });
     ctx.reportDangling();
     ctx.nodes.reportNullOnly();
     ctx.edges.reportNullOnly();