@graphty/graph-io 0.3.38 → 0.3.40

package/src/formats/cx/importer.ts

@@ -773,12 +773,13 @@ function checkNumberVerification(value: unknown, count: number, report: ImportRe
     const raw = isRecord(value) ? value.longNumber : undefined;
     const digits = raw instanceof ExactInteger ? raw.digits : String(raw);
     if (count > 1 || !NUMBER_VERIFICATION_VALUES.has(digits)) {
+        const held = raw === undefined ? null : digits;
         report.warning(
             "validation-error",
             CX_ISSUE.NUMBER_VERIFICATION,
             count > 1
                 ? "a second numberVerification element; ignored"
-                : `numberVerification holds ${shown(raw === undefined ? null : digits)}, not 281474976710655`,
+                : `numberVerification holds ${shown(held)}, not 281474976710655`,
             { line, element: "numberVerification" },
         );
     }
@@ -993,10 +994,12 @@ async function readDocument(
                         break;
                     }
                     countMember(event.block, null);
+                    const what =
+                        keys.length > 1 ? `an object with ${keys.length} keys (${keys.join(", ")})` : shown(value);
                     report.error(
                         "parse-error",
                         BAD_ASPECT_BLOCK_CODE,
-                        `a member of the document is ${keys.length > 1 ? `an object with ${keys.length} keys (${keys.join(", ")})` : shown(value)}, not a one-key aspect fragment; skipped`,
+                        `a member of the document is ${what}, not a one-key aspect fragment; skipped`,
                         { line: event.line, element: keys[0] ?? null },
                     );
                     break;
@@ -1361,6 +1364,26 @@ function memberCount(members: ReadonlySet<NodeId> | null, total: number): number
 
 // ============================================================ the build
 
+/** The cyVisualProperties of a graph's view, gathered before they are written. */
+interface VisualCollection {
+    /** per domain, per property: the [row, text] cells */
+    columns: Record<"node" | "edge", Map<string, [number, string][]>>;
+    /** the network values by property */
+    network: Map<string, string>;
+    defaults: number;
+    mappings: number;
+    dependencies: number;
+}
+
+/**
+ * A visual property value as text: a string as it is, anything else as JSON.
+ * @param raw - the value
+ * @returns its text
+ */
+function visualText(raw: unknown): string {
+    return typeof raw === "string" ? raw : JSON.stringify(raw);
+}
+
 /** One attribute column of the graph being built. */
 interface AttributeColumn {
     readonly name: string;
@@ -2849,57 +2872,99 @@ class CxReader {
      * applied.
      */
     private readVisualProperties(): void {
-        const entries = aspect(this.doc, "cyVisualProperties");
         // Cytoscape's table-cell styles: a visual property aspect graph-io keeps but does not read
         const tableStyles = TABLE_STYLE_ASPECTS.reduce((n, name) => n + (this.doc.kept.get(name)?.length ?? 0), 0);
         // the graph's own view (its first): the one its positions come from; the others stay in meta.extra.cx
         const views = new Set(this.plan.views.slice(0, 1));
-        const columns = { node: new Map<string, [number, string][]>(), edge: new Map<string, [number, string][]>() };
-        const network = new Map<string, string>();
-        let defaults = 0;
-        let mappings = 0;
-        let dependencies = 0;
-        for (const { value } of entries) {
-            if (!isRecord(value)) {
-                continue;
-            }
-            const view = value.view === undefined || value.view === null ? null : refId(value.view);
-            if (view !== null && views.size > 0 && !views.has(view)) {
-                continue;
+        const visual: VisualCollection = {
+            columns: { node: new Map(), edge: new Map() },
+            network: new Map(),
+            defaults: 0,
+            mappings: 0,
+            dependencies: 0,
+        };
+        for (const { value } of aspect(this.doc, "cyVisualProperties")) {
+            if (isRecord(value)) {
+                this.collectVisualEntry(value, views, visual);
             }
-            const properties = isRecord(value.properties) ? value.properties : {};
-            mappings += isRecord(value.mappings) ? Object.keys(value.mappings).length : 0;
-            dependencies += isRecord(value.dependencies) ? Object.keys(value.dependencies).length : 0;
-            switch (value.properties_of) {
-                case "nodes":
-                case "edges": {
-                    const domain = value.properties_of === "nodes" ? "node" : "edge";
-                    const target = refId(value.applies_to);
-                    const rows = domain === "node" ? this.nodeRows : this.edgeRows;
-                    const row = target === null ? undefined : rows.get(target);
-                    if (row === undefined) {
-                        if (target === null || !(domain === "node" ? this.rootNodes : this.rootEdges).has(target)) {
-                            this.dangle(`${domain} visual property entry`);
-                        }
-                        continue;
-                    }
-                    for (const [property, raw] of Object.entries(properties)) {
-                        const list = columns[domain].get(property) ?? [];
-                        list.push([row, typeof raw === "string" ? raw : JSON.stringify(raw)]);
-                        columns[domain].set(property, list);
-                    }
-                    break;
+        }
+        this.writeBypassColumns(visual.columns);
+        this.writeBypassNetwork(visual.network);
+        this.reportStyleRules(visual, tableStyles);
+    }
+
+    /**
+     * File one cyVisualProperties element of this graph's view into the collection: per-element and
+     * network values by property, defaults, mappings and dependencies counted.
+     * @param value - the element
+     * @param views - the views read (empty: every view)
+     * @param visual - the collection to add to
+     */
+    private collectVisualEntry(
+        value: Record<string, unknown>,
+        views: ReadonlySet<NodeId>,
+        visual: VisualCollection,
+    ): void {
+        const view = value.view === undefined || value.view === null ? null : refId(value.view);
+        if (view !== null && views.size > 0 && !views.has(view)) {
+            return;
+        }
+        const properties = isRecord(value.properties) ? value.properties : {};
+        visual.mappings += isRecord(value.mappings) ? Object.keys(value.mappings).length : 0;
+        visual.dependencies += isRecord(value.dependencies) ? Object.keys(value.dependencies).length : 0;
+        switch (value.properties_of) {
+            case "nodes":
+                this.collectElementProperties("node", value.applies_to, properties, visual.columns);
+                break;
+            case "edges":
+                this.collectElementProperties("edge", value.applies_to, properties, visual.columns);
+                break;
+            case "network":
+                for (const [property, raw] of Object.entries(properties)) {
+                    visual.network.set(property, visualText(raw));
                 }
-                case "network":
-                    for (const [property, raw] of Object.entries(properties)) {
-                        network.set(property, typeof raw === "string" ? raw : JSON.stringify(raw));
-                    }
-                    break;
-                default:
-                    defaults += Object.keys(properties).length;
-                    break;
+                break;
+            default:
+                visual.defaults += Object.keys(properties).length;
+                break;
+        }
+    }
+
+    /**
+     * File the visual values of one node or edge under its row; an element not in this graph is
+     * skipped, and reported dangling when it is in no graph of the file.
+     * @param domain - node or edge
+     * @param appliesTo - the element's applies_to
+     * @param properties - its visual properties
+     * @param columns - the per-property cells to add to
+     */
+    private collectElementProperties(
+        domain: "node" | "edge",
+        appliesTo: unknown,
+        properties: Record<string, unknown>,
+        columns: VisualCollection["columns"],
+    ): void {
+        const target = refId(appliesTo);
+        const rows = domain === "node" ? this.nodeRows : this.edgeRows;
+        const row = target === null ? undefined : rows.get(target);
+        if (row === undefined) {
+            if (target === null || !(domain === "node" ? this.rootNodes : this.rootEdges).has(target)) {
+                this.dangle(`${domain} visual property entry`);
             }
+            return;
         }
+        for (const [property, raw] of Object.entries(properties)) {
+            const list = columns[domain].get(property) ?? [];
+            list.push([row, visualText(raw)]);
+            columns[domain].set(property, list);
+        }
+    }
+
+    /**
+     * Write the collected per-element visual values as string columns in the cx.bypass namespace.
+     * @param columns - the per-property cells of each domain
+     */
+    private writeBypassColumns(columns: VisualCollection["columns"]): void {
         for (const domain of ["node", "edge"] as const) {
             for (const [property, cells] of columns[domain]) {
                 const handle = declareFresh(
@@ -2922,6 +2987,13 @@ class CxReader {
                 }
             }
         }
+    }
+
+    /**
+     * Write the network visual values as graph values in the cx.bypass namespace.
+     * @param network - the value of each property
+     */
+    private writeBypassNetwork(network: ReadonlyMap<string, string>): void {
         for (const [property, text] of network) {
             try {
                 this.sink.setGraphValue(property, text, {
@@ -2932,20 +3004,30 @@ class CxReader {
                 this.report.recordError(err, { element: property });
             }
         }
-        if (defaults + mappings + dependencies + tableStyles > 0) {
-            const parts = [
-                `cyVisualProperties: ${defaults} default${plural(defaults)}, ${mappings} mapping${plural(mappings)}, ${dependencies} dependenc(ies)`,
-            ];
-            if (tableStyles > 0) {
-                parts.push(`${tableStyles} table style element${plural(tableStyles)}`);
-            }
-            this.report.warning(
-                "unsupported",
-                STYLES_NOT_IMPORTED_CODE,
-                `the file's style rules are not applied (${parts.join("; ")}); they are kept in meta.extra.cx`,
-                { element: "cyVisualProperties" },
-            );
+    }
+
+    /**
+     * Warn that the style rules (defaults, mappings, dependencies, table styles) are kept, not applied.
+     * @param visual - the counted rules
+     * @param tableStyles - the number of table style elements
+     */
+    private reportStyleRules(visual: VisualCollection, tableStyles: number): void {
+        const { defaults, mappings, dependencies } = visual;
+        if (defaults + mappings + dependencies + tableStyles === 0) {
+            return;
         }
+        const parts = [
+            `cyVisualProperties: ${defaults} default${plural(defaults)}, ${mappings} mapping${plural(mappings)}, ${dependencies} dependenc(ies)`,
+        ];
+        if (tableStyles > 0) {
+            parts.push(`${tableStyles} table style element${plural(tableStyles)}`);
+        }
+        this.report.warning(
+            "unsupported",
+            STYLES_NOT_IMPORTED_CODE,
+            `the file's style rules are not applied (${parts.join("; ")}); they are kept in meta.extra.cx`,
+            { element: "cyVisualProperties" },
+        );
     }
 
     /**

package/src/formats/cx2/exporter.ts

@@ -304,9 +304,10 @@ function capabilityNotes(
             continue;
         }
         if (gen.code === LOSS.JSON) {
+            const what = gen.column === null ? "a column" : `column "${gen.column}"`;
             note(
                 CX2_LOSS.JSON_AS_STRING,
-                `${gen.column === null ? "a column" : `column "${gen.column}"`} holds nested values; written as a string attribute holding their JSON text`,
+                `${what} holds nested values; written as a string attribute holding their JSON text`,
                 gen.column,
                 gen.count,
             );

package/src/formats/cx2/importer.ts

@@ -688,6 +688,25 @@ async function readDocument(
     return doc;
 }
 
+/**
+ * Fail the import: the first member of the array is not a descriptor.
+ * @param value - the member
+ * @param line - its line
+ * @param report - the report
+ * @returns never: the import fails
+ */
+function failNoDescriptor(value: unknown, line: number, report: ImportReportBuilder): never {
+    const keys = isRecord(value) ? Object.keys(value) : [];
+    const keyList = keys.length > 0 ? ` (keys: ${keys.join(", ")})` : "";
+    return report.fail(
+        CX2_ISSUE.NO_DESCRIPTOR,
+        `the first member of the array is not a descriptor with CXVersion${keyList}`,
+        {
+            line,
+        },
+    );
+}
+
 /**
  * Check the descriptor, the first member of the array.
  * @param value - the member
@@ -697,12 +716,7 @@ async function readDocument(
  */
 function readDescriptor(value: unknown, line: number, doc: Cx2Document, report: ImportReportBuilder): void {
     if (!isRecord(value) || !("CXVersion" in value)) {
-        const keys = isRecord(value) ? Object.keys(value) : [];
-        report.fail(
-            CX2_ISSUE.NO_DESCRIPTOR,
-            `the first member of the array is not a descriptor with CXVersion${keys.length > 0 ? ` (keys: ${keys.join(", ")})` : ""}`,
-            { line },
-        );
+        failNoDescriptor(value, line, report);
     }
     const raw = value.CXVersion;
     const text = typeof raw === "string" || typeof raw === "number" ? String(raw) : "";
@@ -779,10 +793,11 @@ function memberAspect(
         collect(keys[0], value[keys[0]]);
         return;
     }
+    const what = keys.length > 1 ? `an object with ${keys.length} keys (${keys.join(", ")})` : shown(value);
     report.error(
         "parse-error",
         BAD_ASPECT_BLOCK_CODE,
-        `a member of the document is ${keys.length > 1 ? `an object with ${keys.length} keys (${keys.join(", ")})` : shown(value)}, not a one-key aspect block; skipped`,
+        `a member of the document is ${what}, not a one-key aspect block; skipped`,
         { line, element: keys[0] ?? null },
     );
 }
@@ -1325,10 +1340,11 @@ class Cx2Reader {
             }
             const other = table.byName.get(alias) ?? table.byAlias.get(alias);
             if (other !== undefined) {
+                const clash = other.name === alias ? "an attribute's name" : `the alias of "${other.name}"`;
                 this.report.error(
                     "validation-error",
                     CX2_ISSUE.ALIAS_CONFLICT,
-                    `the alias "${alias}" of the ${domain} attribute "${decl.name}" is also ${other.name === alias ? "an attribute's name" : `the alias of "${other.name}"`}; the alias is ignored`,
+                    `the alias "${alias}" of the ${domain} attribute "${decl.name}" is also ${clash}; the alias is ignored`,
                     { element: decl.name },
                 );
                 decl.alias = null;
@@ -2259,6 +2275,14 @@ class Cx2Reader {
                 }
             }
         }
+        this.checkStatus();
+        structure.checkCounts();
+    }
+
+    /** The status block: present, and exactly one well-formed element. */
+    private checkStatus(): void {
+        const { report } = this;
+        const { structure } = this.doc;
         if (!structure.hasStatus) {
             report.error("validation-error", CX2_ISSUE.NO_STATUS, "the document ends without a status block", {
                 element: "status",
@@ -2266,14 +2290,14 @@ class Cx2Reader {
         } else if (!structure.statusWellFormed() || structure.counts.get("status") !== 1) {
             // the specification: exactly one status aspect holding exactly one element
             const count = structure.counts.get("status") ?? 0;
+            const found = count === 1 ? shown(structure.status) : `${count} elements`;
             report.error(
                 "validation-error",
                 CX2_ISSUE.NO_STATUS,
-                `the status is malformed (${count === 1 ? shown(structure.status) : `${count} elements`}): a document ends with one status block holding one object with a boolean success`,
+                `the status is malformed (${found}): a document ends with one status block holding one object with a boolean success`,
                 { element: "status" },
             );
         }
-        structure.checkCounts();
     }
 
     /** Record the metadata: source format and version, name, description, id type, the kept aspects. */

package/src/formats/dot/importer.ts

@@ -97,6 +97,7 @@ import {
     PARENT_COLUMN,
     PIN_ATTRIBUTE,
     POS_ATTRIBUTE,
+    POSITION_COLUMN,
     SOURCE_PORT_COLUMN,
     TARGET_PORT_COLUMN,
 } from "./names.js";
@@ -122,6 +123,12 @@ export interface DotImportOptions extends GraphChoiceOptions, CommonImportOption
      * @defaultValue true
      */
     positions?: boolean | undefined;
+    /**
+     * With `positions`, also keep `pos` as the text the file wrote; the position column is then
+     * named `graphty.position`, so a reader gets both.
+     * @defaultValue false
+     */
+    keepPositionSource?: boolean | undefined;
 }
 
 /**
@@ -323,7 +330,7 @@ interface Scope {
  */
 export const dotImporter: GraphImporter<DotImportOptions> = Object.freeze({
     format: DOT_FORMAT,
-    options: Object.freeze(["mismatchedEdgeOperator", "positions"]),
+    options: Object.freeze(["keepPositionSource", "mismatchedEdgeOperator", "positions"]),
     extensions: EXTENSIONS,
     mimeTypes: MIME_TYPES,
 
@@ -376,7 +383,15 @@ export const dotImporter: GraphImporter<DotImportOptions> = Object.freeze({
         const reports = { current: report };
         const lexer = dotLexer(text, reports);
         const first = guard(report, () => lexer.next());
-        const parser = new DotParser(lexer, sink, report, resolved, mismatch, options?.positions !== false);
+        const parser = new DotParser(
+            lexer,
+            sink,
+            report,
+            resolved,
+            mismatch,
+            options?.positions !== false,
+            options?.keepPositionSource === true,
+        );
         parser.headCharset = head.charset;
         const trailing = parseGraph(parser, report, first);
         if (trailing.kind !== "eof") {
@@ -429,7 +444,15 @@ export const dotImporter: GraphImporter<DotImportOptions> = Object.freeze({
             reports.current = report;
             const sink = sinkFor(done.length);
             reportSinkOptions(sink, options, report);
-            const parser = new DotParser(lexer, sink, report, resolved, mismatch, options?.positions !== false);
+            const parser = new DotParser(
+                lexer,
+                sink,
+                report,
+                resolved,
+                mismatch,
+                options?.positions !== false,
+                options?.keepPositionSource === true,
+            );
             parser.headCharset = head.charset;
             token = parseGraph(parser, report, token);
             throwIfAborted(resolved.signal);
@@ -686,6 +709,8 @@ class DotParser {
     private readonly mismatch: "operator" | "header" | "error";
     private readonly positions: boolean;
 
+    private readonly keepPositionSource: boolean;
+
     private readonly ids: IdCoercer;
 
     private readonly resolver: DirectionResolver;
@@ -758,6 +783,7 @@ class DotParser {
      * @param options - the resolved common options
      * @param mismatch - the resolved mismatchedEdgeOperator option
      * @param positions - whether `pos` goes to the position column
+     * @param keepPositionSource - whether `pos` also stays as text
      */
     constructor(
         lexer: DotTokenizer,
@@ -766,6 +792,7 @@ class DotParser {
         options: ResolvedImportOptions,
         mismatch: "operator" | "header" | "error",
         positions: boolean,
+        keepPositionSource: boolean,
     ) {
         this.lexer = lexer;
         this.sink = sink;
@@ -773,6 +800,7 @@ class DotParser {
         this.options = options;
         this.mismatch = mismatch;
         this.positions = positions;
+        this.keepPositionSource = keepPositionSource;
         this.ids = new IdCoercer(options.ids);
         this.resolver = new DirectionResolver(sink, report, options.onMixedDirection);
     }
@@ -1586,6 +1614,9 @@ class DotParser {
                 this.sink.setNodeValue(this.nodeLabel(), index, value);
             } else if (name === POS_ATTRIBUTE && this.positions) {
                 this.setPosition(index, value, line, element);
+                if (this.keepPositionSource) {
+                    this.textWriter("node", name).write(index, value);
+                }
             } else {
                 this.textWriter("node", name).write(index, value);
             }
@@ -1766,7 +1797,7 @@ class DotParser {
     private positionColumn(dims: 2 | 3): ColumnHandle {
         if (this.positionHandle === INVALID_INDEX) {
             this.positionHandle = this.declare("node", {
-                name: POS_ATTRIBUTE,
+                name: this.keepPositionSource ? POSITION_COLUMN : POS_ATTRIBUTE,
                 dtype: "f64",
                 components: 3,
                 nullable: true,

package/src/formats/dot/names.ts

@@ -54,6 +54,12 @@ export const LABEL_ATTRIBUTE = "label";
  */
 export const POS_ATTRIBUTE = "pos";
 
+/**
+ * The node position column when the import keeps `pos` as text too (the `keepPositionSource` option).
+ * @category Plugin helpers
+ */
+export const POSITION_COLUMN = "graphty.position";
+
 /**
  * The edge attribute cgraph uses as an edge's identity within its endpoints, mapped to the edge id role.
  * @category Plugin helpers

package/src/formats/dot/tokenizer.ts

@@ -148,15 +148,15 @@ export class DotTokenizer {
         const { line } = this;
         const c = text.charCodeAt(start);
         switch (c) {
-            case 0x7b: // {
-            case 0x7d: // }
-            case 0x5b: // [
-            case 0x5d: // ]
-            case 0x3b: // ;
-            case 0x2c: // ,
-            case 0x3d: // =
-            case 0x3a: // :
-            case 0x2b: // +
+            case 0x7b: // "{"
+            case 0x7d: // "}"
+            case 0x5b: // "["
+            case 0x5d: // "]"
+            case 0x3b: // ";"
+            case 0x2c: // ","
+            case 0x3d: // "="
+            case 0x3a: // ":"
+            case 0x2b: // "+"
                 this.pos++;
                 return { kind: "punct", text: text[start], quoted: false, html: false, line };
             case 0x2d: {

package/src/formats/gexf/exporter.ts

@@ -1225,7 +1225,8 @@ function lifetimeAttrs(roles: RoleColumns, row: number, plan: ExportPlan): strin
         const text = timeText(column, roles.companions.get(column.meta.name) ?? null, row, timeFormat);
         // GEXF 1.2: `startopen` / `endopen` hold the time of a non-inclusive bound (dynamics.xsd
         // time-type) and replace `start` / `end`
-        out += ` ${open ? `${name}open` : name}="${escapeXmlAttribute(text)}"`;
+        const attribute = open ? `${name}open` : name;
+        out += ` ${attribute}="${escapeXmlAttribute(text)}"`;
     };
     if (roles.timestamp?.isSet(row)) {
         if (version === "1.3" && plan.timeRepresentation === "timestamp") {
@@ -1240,7 +1241,8 @@ function lifetimeAttrs(roles: RoleColumns, row: number, plan: ExportPlan): strin
     }
     if (version === "1.3" && roles.timestamps?.isSet(row)) {
         const items = listItems(roles.timestamps, row).map((t) => formatTimeValue(t as number, timeFormat));
-        out += ` timestamps="${escapeXmlAttribute(`<[${items.join(", ")}]>`)}"`;
+        const stamps = `<[${items.join(", ")}]>`;
+        out += ` timestamps="${escapeXmlAttribute(stamps)}"`;
     }
     return out;
 }

package/src/formats/gml/importer.ts

@@ -97,6 +97,12 @@ export interface GmlImportOptions extends GraphChoiceOptions, CommonImportOption
      * @defaultValue true
      */
     positions?: boolean | undefined;
+    /**
+     * With `positions`, also keep the whole `graphics` record, x / y / z included, as the JSON
+     * attribute named `graphics`, so a reader gets both the position and the record as written.
+     * @defaultValue false
+     */
+    keepPositionSource?: boolean | undefined;
     /**
      * Store a text attribute whose values repeat a lot (fewer distinct values than half the rows)
      * as a dictionary column, which uses less memory and reads the same. Such a column reports
@@ -378,6 +384,8 @@ class GmlImport {
 
     private readonly positions: boolean;
 
+    private readonly keepPositionSource: boolean;
+
     private readonly dictionaries: boolean;
 
     private readonly coercer: IdCoercer;
@@ -470,6 +478,7 @@ class GmlImport {
         this.report = report;
         this.options = options;
         this.positions = format?.positions ?? true;
+        this.keepPositionSource = format?.keepPositionSource ?? false;
         this.dictionaries = format?.dictionaries ?? true;
         this.coercer = new IdCoercer(options.ids);
     }
@@ -755,7 +764,8 @@ class GmlImport {
         }
         const positioned = x && y;
         entry.position ||= positioned;
-        entry.rest ||= positioned ? other : true;
+        // with keepPositionSource the whole record, x / y / z included, goes to the json column too
+        entry.rest ||= positioned ? other || this.keepPositionSource : true;
     }
 
     // ============================================================ pass 2: the push
@@ -1541,7 +1551,8 @@ class GmlImport {
         const positionPlan = plan.position;
         let rest: unknown = first;
         if (isRecord(first) && positionPlan !== null) {
-            rest = this.writePosition(positionPlan, index, first, where);
+            const left = this.writePosition(positionPlan, index, this.keepPositionSource ? { ...first } : first, where);
+            rest = this.keepPositionSource ? first : left;
         } else if (!isRecord(first)) {
             this.graphicsWarning("scalar", `node ${where.element}'s graphics is not a record`, where);
         }
@@ -1924,7 +1935,7 @@ function sniffGml(head: Uint8Array): number {
  */
 export const gmlImporter: GraphImporter<GmlImportOptions> = Object.freeze({
     format: "gml",
-    options: Object.freeze(["dictionaries", "positions"]),
+    options: Object.freeze(["dictionaries", "keepPositionSource", "positions"]),
     extensions: Object.freeze([".gml"]),
     mimeTypes: Object.freeze(["text/x-gml", "text/plain"]),
     sniff: sniffGml,

package/src/formats/graphml/exporter.ts

@@ -1418,9 +1418,8 @@ function* writeNodeSubtree(
         }
         if (hasChildren(u)) {
             parts.splice(open, 0, ">");
-            parts.push(
-                `\n${pad}${step}<graph id="${escapeXmlAttribute(`${String(ids.idAt(u))}:`)}" edgedefault="${plan.edgedefault}">`,
-            );
+            const graphId = `${String(ids.idAt(u))}:`;
+            parts.push(`\n${pad}${step}<graph id="${escapeXmlAttribute(graphId)}" edgedefault="${plan.edgedefault}">`);
             return parts.join("");
         }
         if (parts.length === open) {

package/src/formats/graphml/importer.ts

@@ -512,16 +512,14 @@ class GraphmlReader implements XmlHandler {
         const parent = this.ctx.at(-1) ?? null;
         switch (parent) {
             case Ctx.Capture:
+            case Ctx.Data:
+            case Ctx.Default:
                 this.captureStart(name, attrs);
                 return;
             case Ctx.Skip:
             case Ctx.Desc:
                 this.ctx.push(Ctx.Skip);
                 return;
-            case Ctx.Data:
-            case Ctx.Default:
-                this.captureStart(name, attrs);
-                return;
             case Ctx.Dropped:
                 this.dropStart(localName(name));
                 return;
@@ -2464,9 +2462,10 @@ class GraphmlReader implements XmlHandler {
      */
     private expandStar(hyperedge: HyperedgeState, where: Where): void {
         this.hyperedgeCount++;
-        let hubId = hyperedge.id ?? `hyperedge${this.hyperedgeCount}`;
+        const baseId = hyperedge.id ?? `hyperedge${this.hyperedgeCount}`;
+        let hubId = baseId;
         for (let n = 2; this.sink.indexOf(hubId) !== INVALID_INDEX; n++) {
-            hubId = `${hyperedge.id ?? `hyperedge${this.hyperedgeCount}`}#${n}`;
+            hubId = `${baseId}#${n}`;
         }
         const hub = this.sink.addNode(hubId);
         this.declared.add(hub);

package/src/formats/obo/importer.ts

@@ -1429,7 +1429,8 @@ class OboReader {
             return;
         }
         const map = (record.values.get("obo.qualifiers") as Record<string, unknown[]> | undefined) ?? {};
-        (map[tag] ??= []).push({ value, qualifiers });
+        map[tag] ??= [];
+        map[tag].push({ value, qualifiers });
         record.values.set("obo.qualifiers", map);
     }