@graphty/graph-io 0.3.26 → 0.3.28

package/src/formats/cx2/exporter.ts

@@ -229,7 +229,7 @@ function nonFiniteCount(column: Column): number {
             if ((value as readonly number[]).some((v) => !Number.isFinite(v))) {
                 count++;
             }
-        } else if (!Number.isFinite(value as number)) {
+        } else if (!Number.isFinite(value)) {
             count++;
         }
     }
@@ -270,18 +270,26 @@ function planAttributes(
     return plans;
 }
 
+/** A note-recording callback. */
+type Note = (code: string, message: string, column?: string | null, count?: number | null) => void;
+
 /**
- * Plan an export: the notes, the fatal condition and what is written.
+ * The generic notes of checkCapabilities(), adapted to CX2: bypass columns hold any JSON value,
+ * ids are counted by planNodeIds(), nested values are written as JSON text, and only the node
+ * label is written into the "n" slot (an edge label keeps its own name but loses its role).
  * @param snapshot - the snapshot
  * @param common - the resolved common options
- * @returns the plan
+ * @param notes - the notes so far, appended to
+ * @param note - the recorder
+ * @returns the fatal condition, or null
  */
-function plan(snapshot: GraphSnapshot, common: ResolvedExportOptions): Plan {
-    const notes: LossNote[] = [];
+function capabilityNotes(
+    snapshot: GraphSnapshot,
+    common: ResolvedExportOptions,
+    notes: LossNote[],
+    note: Note,
+): GraphFormatError | null {
     let fatal: GraphFormatError | null = null;
-    const note = (code: string, message: string, column: string | null = null, count: number | null = null): void => {
-        notes.push(Object.freeze({ code, message, column, count }));
-    };
     // bypass columns are written as bypasses, which hold any JSON value
     const bypassNames = new Set(
         [...snapshot.nodes, ...snapshot.edges].filter((c) => isBypass(c) || isZ(c)).map((c) => c.meta.name),
@@ -290,11 +298,7 @@ function plan(snapshot: GraphSnapshot, common: ResolvedExportOptions): Plan {
         roles: SLOT_ROLES,
         roleNames: ROLE_NAMES,
     })) {
-        if (gen.column !== null && bypassNames.has(gen.column) && (gen.code === LOSS.JSON || gen.code === LOSS.DTYPE)) {
-            continue;
-        }
-        if (gen.code === LOSS.ID_CHARSET || gen.code === LOSS.ID_MANGLED) {
-            // counted below: CX2 also keeps integer ids beyond 2^53, which the generic rule refuses
+        if (!keepGenericNote(gen, bypassNames)) {
             continue;
         }
         if (gen.code === LOSS.JSON) {
@@ -311,27 +315,83 @@ function plan(snapshot: GraphSnapshot, common: ResolvedExportOptions): Plan {
         }
         notes.push(gen);
     }
+    const edgeLabel = snapshot.edges.byRole("label");
+    if (edgeLabel !== null) {
+        note(
+            LOSS.ROLE,
+            `edge column "${edgeLabel.meta.name}" (label) is written as a plain attribute; CX2 edges have no label slot and the role is lost`,
+            edgeLabel.meta.name,
+            edgeLabel.length - edgeLabel.nullCount,
+        );
+    }
+    return fatal;
+}
 
-    const folding = pairFolding(snapshot);
-    directionNotes(snapshot, folding, common, CX2_LOSS.UNDIRECTED_AS_DIRECTED, note);
+/**
+ * Whether a generic note applies to CX2 as it stands.
+ * @param gen - the generic note
+ * @param bypassNames - the names of the columns written as bypasses
+ * @returns false for a note CX2 drops or replaces
+ */
+function keepGenericNote(gen: LossNote, bypassNames: ReadonlySet<string>): boolean {
+    if (gen.column !== null && bypassNames.has(gen.column) && (gen.code === LOSS.JSON || gen.code === LOSS.DTYPE)) {
+        return false;
+    }
+    if (gen.code === LOSS.COLUMN_NAME_CHANGED && gen.message.startsWith("edge column")) {
+        // only the node label is written into the "n" slot; an edge label keeps its own name
+        return false;
+    }
+    // ids are counted by planNodeIds(): CX2 also keeps integer ids beyond 2^53, which the generic rule refuses
+    return gen.code !== LOSS.ID_CHARSET && gen.code !== LOSS.ID_MANGLED;
+}
 
-    const planned = planNodeIds(snapshot, common, "CX2", ORIGINAL_ID_ATTRIBUTE, note);
-    const ids = planned instanceof GraphFormatError ? null : planned;
-    if (planned instanceof GraphFormatError) {
-        fatal ??= planned;
+/**
+ * Note the NaN and infinite values written as null: attribute cells, explicit weights, positions.
+ * @param snapshot - the snapshot
+ * @param attrs - every planned attribute
+ * @param weights - the explicit weights
+ * @param position - the position column, or null
+ * @param note - the recorder
+ */
+function nonFiniteNote(
+    snapshot: GraphSnapshot,
+    attrs: readonly AttributePlan[],
+    weights: ExplicitWeights,
+    position: Column | null,
+    note: Note,
+): void {
+    let nonfinite = 0;
+    for (const p of attrs) {
+        nonfinite += nonFiniteCount(p.column);
+    }
+    for (let e = 0; e < snapshot.edgeCount; e++) {
+        if (weights.isExplicit(e) && !Number.isFinite(weights.value(e))) {
+            nonfinite++;
+        }
     }
+    if (position !== null) {
+        nonfinite += nonFinitePositions(position);
+    }
+    if (nonfinite > 0) {
+        note(
+            CX2_LOSS.NONFINITE_AS_NULL,
+            `${nonfinite} NaN or infinite value${plural(nonfinite)} cannot be written in CX2; written as null, they read back unset`,
+            null,
+            nonfinite,
+        );
+    }
+}
 
-    const weights = explicitWeights(snapshot);
-    const label = snapshot.nodes.byRole("label");
-    const nodeAttrs = planAttributes(
-        snapshot.nodes,
-        (c) => (c.meta.role !== null && SKIPPED_ROLES.has(c.meta.role)) || isBypass(c) || isZ(c),
-        (c) => (c === label && !snapshot.nodes.has("name") ? "name" : c.meta.name),
-        ids !== null && ids.changed > 0 ? new Set([ORIGINAL_ID_ATTRIBUTE]) : new Set(),
-    );
+/**
+ * Plan the edge attributes, noting a plain `weight` column that clashes with the weight key.
+ * @param snapshot - the snapshot
+ * @param weights - the explicit weights
+ * @param note - the recorder
+ * @returns the edge attribute plans
+ */
+function planEdgeAttributes(snapshot: GraphSnapshot, weights: ExplicitWeights, note: Note): AttributePlan[] {
     const plainWeight = snapshot.edges.get(WEIGHT_ATTRIBUTE);
-    const weightColumnClash = plainWeight !== null && plainWeight.meta.role === null;
-    if (weightColumnClash) {
+    if (plainWeight !== null && plainWeight.meta.role === null) {
         note(
             LOSS.WEIGHT_KEY_CLASH,
             weights.weighted
@@ -341,7 +401,7 @@ function plan(snapshot: GraphSnapshot, common: ResolvedExportOptions): Plan {
             null,
         );
     }
-    const edgeAttrs = planAttributes(
+    return planAttributes(
         snapshot.edges,
         (c) =>
             (c.meta.role !== null && (SKIPPED_ROLES.has(c.meta.role) || c.meta.role === "id")) ||
@@ -350,33 +410,47 @@ function plan(snapshot: GraphSnapshot, common: ResolvedExportOptions): Plan {
         (c) => c.meta.name,
         weights.weighted ? new Set([WEIGHT_ATTRIBUTE]) : new Set(),
     );
+}
+
+/**
+ * Plan an export: the notes, the fatal condition and what is written.
+ * @param snapshot - the snapshot
+ * @param common - the resolved common options
+ * @returns the plan
+ */
+function plan(snapshot: GraphSnapshot, common: ResolvedExportOptions): Plan {
+    const notes: LossNote[] = [];
+    const note: Note = (code, message, column = null, count = null) => {
+        notes.push(Object.freeze({ code, message, column, count }));
+    };
+    let fatal = capabilityNotes(snapshot, common, notes, note);
+
+    const folding = pairFolding(snapshot);
+    directionNotes(snapshot, folding, common, CX2_LOSS.UNDIRECTED_AS_DIRECTED, note);
+
+    const planned = planNodeIds(snapshot, common, "CX2", ORIGINAL_ID_ATTRIBUTE, note);
+    const ids = planned instanceof GraphFormatError ? null : planned;
+    if (planned instanceof GraphFormatError) {
+        fatal ??= planned;
+    }
+
+    const weights = explicitWeights(snapshot);
+    const label = snapshot.nodes.byRole("label");
+    const nodeAttrs = planAttributes(
+        snapshot.nodes,
+        (c) => (c.meta.role !== null && SKIPPED_ROLES.has(c.meta.role)) || isBypass(c) || isZ(c),
+        (c) => (c === label && !snapshot.nodes.has("name") ? "name" : c.meta.name),
+        ids !== null && ids.changed > 0 ? new Set([ORIGINAL_ID_ATTRIBUTE]) : new Set(),
+    );
+    const edgeAttrs = planEdgeAttributes(snapshot, weights, note);
     const graphAttrs = planAttributes(
         snapshot.graph,
         () => false,
         (c) => c.meta.name,
     ).map((p) => ({ ...p, key: p.name }));
 
-    let nonfinite = 0;
-    for (const p of [...nodeAttrs, ...edgeAttrs, ...graphAttrs]) {
-        nonfinite += nonFiniteCount(p.column);
-    }
-    for (let e = 0; e < snapshot.edgeCount; e++) {
-        if (weights.isExplicit(e) && !Number.isFinite(weights.value(e))) {
-            nonfinite++;
-        }
-    }
     const position = snapshot.nodes.byRole("position");
-    if (position !== null) {
-        nonfinite += nonFinitePositions(position);
-    }
-    if (nonfinite > 0) {
-        note(
-            CX2_LOSS.NONFINITE_AS_NULL,
-            `${nonfinite} NaN or infinite value${plural(nonfinite)} cannot be written in CX2; written as null, they read back unset`,
-            null,
-            nonfinite,
-        );
-    }
+    nonFiniteNote(snapshot, [...nodeAttrs, ...edgeAttrs, ...graphAttrs], weights, position, note);
 
     const edgeIds = planEdgeIds(snapshot, note);
     const z = [...snapshot.nodes].find(isZ) ?? null;

package/src/formats/cx2/importer.ts

@@ -709,7 +709,7 @@ function readDescriptor(value: unknown, line: number, doc: Cx2Document, report:
     const text = typeof raw === "string" || typeof raw === "number" ? String(raw) : "";
     // the major version: "2.0", "2.1", "2.0.1", "2.1-beta", " 2.0" are all CX2
     const match = /^\s*(\d+)(?=$|[.\s-])/.exec(text);
-    const major = match === null ? NaN : Number(match[1]);
+    const major = match === null ? Number.NaN : Number(match[1]);
     if (major === 1) {
         report.fail(
             CX2_ISSUE.VERSION,

package/src/formats/cys/session.ts

@@ -113,7 +113,7 @@ export interface Session {
  * @category Plugin helpers
  */
 export function urlDecode(text: string): string {
-    const plus = text.replace(/\+/g, " ");
+    const plus = text.replaceAll("+", " ");
     try {
         return decodeURIComponent(plus);
     } catch {
@@ -282,13 +282,13 @@ function layoutOf(zipEntries: readonly ZipEntry[], report: ImportReportBuilder):
             `the session has ${markers.length} version markers (${listed(markers)}); ${markers[0]} is used and the others are not read`,
         );
     }
-    if (marker === undefined && cysession === undefined) {
+    const anchor = marker ?? cysession;
+    if (anchor === undefined) {
         report.fail(
             CYS_ISSUE.NOT_SESSION,
             "the zip holds neither a session version marker (<x.y.z>.version) nor cysession.xml: it is not a Cytoscape session",
         );
     }
-    const anchor = marker ?? (cysession as string);
     const root = anchor.slice(0, anchor.lastIndexOf("/") + 1);
     let era: "2" | "3" = "2";
     let version = "2.0.0";

package/src/formats/dot/exporter.ts

@@ -377,6 +377,11 @@ class ExportPlan {
 
     private readonly targetPort: Column | null;
 
+    /** The node and edge label role columns, written under `label` whatever their name. */
+    private readonly nodeLabel: Column | null;
+
+    private readonly edgeLabel: Column | null;
+
     private readonly children: ChildrenCsr;
 
     private readonly extraNotes: LossNote[] = [];
@@ -417,6 +422,8 @@ class ExportPlan {
         this.folding = pairFolding(snapshot);
         this.sourcePort = edges.byRole("sourcePort");
         this.targetPort = edges.byRole("targetPort");
+        this.nodeLabel = nodes.byRole("label");
+        this.edgeLabel = edges.byRole("label");
         this.nodeColumns = [...nodes].filter((c) => this.writesNodeColumn(c));
         this.edgeColumns = [...edges].filter((c) => this.writesEdgeColumn(c));
         this.graphColumns = [...graph].filter(
@@ -444,7 +451,7 @@ class ExportPlan {
             this.clash("node", name, "the position role is written as pos");
             return false;
         }
-        return true;
+        return this.labelFree("node", column, this.nodeLabel);
     }
 
     /**
@@ -468,7 +475,23 @@ class ExportPlan {
             this.clash("edge", name, "the weight is written as weight");
             return false;
         }
-        return true;
+        return this.labelFree("edge", column, this.edgeLabel);
+    }
+
+    /**
+     * Whether a column may be written: false (reported) for a plain `label` column when the label
+     * role column is named otherwise, since that one is written as `label`.
+     * @param domain - the table
+     * @param column - the column
+     * @param labelRole - the table's label role column, or null
+     * @returns true when written
+     */
+    private labelFree(domain: string, column: Column, labelRole: Column | null): boolean {
+        if (column.meta.name !== LABEL_ATTRIBUTE || labelRole === null || labelRole === column) {
+            return true;
+        }
+        this.clash(domain, column.meta.name, "the label role is written as label");
+        return false;
     }
 
     /**
@@ -703,7 +726,7 @@ class ExportPlan {
         }
         for (const columns of [this.nodeColumns, this.edgeColumns, this.graphColumns]) {
             for (const column of columns) {
-                visit(column.meta.name, "attribute name");
+                visit(this.attributeName(column), "attribute name");
                 if (column.dtype === "string" || column.dtype === "dict") {
                     for (let r = 0; r < column.length; r++) {
                         if (column.isSet(r)) {
@@ -844,6 +867,16 @@ class ExportPlan {
         return parts.join(",");
     }
 
+    /**
+     * The attribute a column is written as: `label` for a node or edge label role column (the
+     * importer gives that attribute the role back), the column name otherwise.
+     * @param column - the column
+     * @returns the attribute name
+     */
+    private attributeName(column: Column): string {
+        return column === this.nodeLabel || column === this.edgeLabel ? LABEL_ATTRIBUTE : column.meta.name;
+    }
+
     /**
      * The `name=value` attributes of one row over a column list (set cells only).
      * @param columns - the columns
@@ -858,7 +891,7 @@ class ExportPlan {
             }
             const text = cellText(column, row);
             if (text !== null) {
-                out.push(`${quoteDotId(column.meta.name)}=${writeId(text)}`);
+                out.push(`${quoteDotId(this.attributeName(column))}=${writeId(text)}`);
             }
         }
         return out;

package/src/formats/dot/importer.ts

@@ -514,7 +514,7 @@ function countGraphs(lexer: DotTokenizer, first: DotToken): number {
         if (!isPunct(token, "{")) {
             throw new DotSyntaxError(`expected "{" after the graph header, found ${describeToken(token)}`, token.line);
         }
-        for (let depth = 1; depth > 0; ) {
+        for (let depth = 1; depth > 0;) {
             token = lexer.next();
             if (token.kind === "eof") {
                 throw new DotSyntaxError('missing "}" at the end of a graph', token.line);

package/src/formats/gml/exporter.ts

@@ -305,6 +305,25 @@ function versionText(text: string): string {
     return NUMBER_TEXT.test(text) ? text : quoteGmlString(text);
 }
 
+/**
+ * A node or edge table's label role column, which is written under "label" (the key the importer
+ * gives the role back to): the key is marked used so a plain column of that name cannot have it.
+ * @param columns - the written columns
+ * @param label - the table name
+ * @param used - the keys already taken, gaining "label" when there is a label role column
+ * @returns the label role column, or undefined
+ */
+function labelRoleColumn(columns: readonly Column[], label: string, used: Set<string>): Column | undefined {
+    if (label !== "node" && label !== "edge") {
+        return undefined;
+    }
+    const column = columns.find((c) => c.meta.role === "label");
+    if (column !== undefined) {
+        used.add("label");
+    }
+    return column;
+}
+
 /**
  * Select the written columns of a table and assign their keys, recording invalid and reserved
  * keys as notes (or rewriting them under mangle).
@@ -326,14 +345,13 @@ function selectColumns(
 ): WrittenColumn[] {
     const used = new Set<string>(reserved);
     const out: WrittenColumn[] = [];
-    for (const column of table) {
-        if (!isWritten(column) || !filter(column)) {
-            continue;
-        }
-        const preferred = preferredKey(column.meta);
+    const columns = [...table].filter((c) => isWritten(c) && filter(c));
+    const labelRole = labelRoleColumn(columns, label, used);
+    for (const column of columns) {
+        const preferred = column === labelRole ? "label" : preferredKey(column.meta);
         let key = preferred;
         const valid = isGmlKey(preferred);
-        const taken = used.has(preferred);
+        const taken = column !== labelRole && used.has(preferred);
         if (!valid || taken) {
             const code = valid ? RESERVED_KEY_CODE : INVALID_KEY_CODE;
             let why = "is not a GML key";

package/src/formats/gml/syntax.ts

@@ -499,7 +499,7 @@ export function numberOfText(text: string): number {
     if (NON_FINITE_TEXT.test(text)) {
         const lower = text.toLowerCase();
         if (lower.endsWith("nan")) {
-            return NaN;
+            return Number.NaN;
         }
         return lower.startsWith("-") ? -Infinity : Infinity;
     }
@@ -536,7 +536,7 @@ export function isGmlKey(text: string): boolean {
  * @category Plugin helpers
  */
 export function mangleGmlKey(text: string): string {
-    const body = text.replace(/[^0-9A-Za-z_]/g, "_");
+    const body = text.replaceAll(/\W/g, "_");
     return /^[A-Za-z]/.test(body) ? body : `x${body}`;
 }
 

package/src/formats/json/dialect.ts

@@ -102,7 +102,7 @@ export interface JsonShapeMeta {
  */
 export function jsonShapeOf(snapshot: GraphSnapshot): JsonShapeMeta | null {
     const shape = snapshot.meta.extra[META_KEY];
-    return isJsonObject(shape) ? (shape as JsonShapeMeta) : null;
+    return isJsonObject(shape) ? shape : null;
 }
 
 /**

package/src/formats/neo4j/exporter.ts

@@ -1374,7 +1374,7 @@ function formatPoint(value: unknown): string {
         if (typeof item === "number") {
             parts.push(`${key}:${formatF64(item)}`);
         } else if (typeof item === "string") {
-            parts.push(`${key}:'${item.replace(/'/g, "")}'`);
+            parts.push(`${key}:'${item.replaceAll("'", "")}'`);
         } else {
             return JSON.stringify(value) ?? "";
         }
@@ -1514,7 +1514,7 @@ export function exportNeo4jFiles(
     try {
         return Promise.resolve(plan(snapshot, options).files());
     } catch (err) {
-        return Promise.reject(err as Error);
+        return Promise.reject(err);
     }
 }
 

package/src/formats/pajek/exporter.ts

@@ -528,7 +528,7 @@ function firstModeOf(snapshot: GraphSnapshot): number | null {
     if (typeof value === "number" && Number.isInteger(value) && value >= 0 && value <= snapshot.nodeCount) {
         return value;
     }
-    return NaN;
+    return Number.NaN;
 }
 
 /**

package/src/formats/pajek/importer.ts

@@ -1607,7 +1607,7 @@ class PajekParser {
     private extras(tokens: readonly string[], start: number, domain: "node" | "edge", line: number): RowExtras {
         const extras: RowExtras = { keys: [], values: [], spells: null };
         const seen = new Set<string>();
-        for (let i = start; i < tokens.length; ) {
+        for (let i = start; i < tokens.length;) {
             const token = tokens[i];
             if (token.startsWith("[")) {
                 extras.spells = this.intervals(token, domain);

package/src/formats/pajek/syntax.ts

@@ -438,7 +438,7 @@ export function parseIntervals(token: string): [number, number][] {
     }
     const spells: [number, number][] = [];
     for (const part of body.split(",")) {
-        const match = TIME_POINT.exec(part.replace(/\s+/g, ""));
+        const match = TIME_POINT.exec(part.replaceAll(/\s+/g, ""));
         if (match === null) {
             throw new Error(`malformed time interval ${token}: "${part}" is not a-b, a-* or a`);
         }
@@ -485,7 +485,7 @@ export function decodeCharacterReferences(text: string, onUnknown?: (reference:
     if (!text.includes("&#")) {
         return text;
     }
-    return text.replace(CHARACTER_REFERENCE, (whole, hex: string | undefined, dec: string | undefined) => {
+    return text.replaceAll(CHARACTER_REFERENCE, (whole, hex: string | undefined, dec: string | undefined) => {
         const code = hex === undefined ? Number(dec) : Number.parseInt(hex, 16);
         if (code <= 0x10ffff) {
             return String.fromCodePoint(code);
@@ -506,7 +506,7 @@ export function encodeCharacterReferences(text: string): string {
     if (!text.includes("&#")) {
         return text;
     }
-    return text.replace(CHARACTER_REFERENCE, (whole) => `&#38;${whole.slice(1)}`);
+    return text.replaceAll(CHARACTER_REFERENCE, (whole) => `&#38;${whole.slice(1)}`);
 }
 
 /**

package/src/formats/xgmml/exporter.ts

@@ -772,7 +772,7 @@ function valueText(value: unknown, dtype: string | null, escapes: boolean): stri
     } else if (typeof value === "number") {
         text = dtype === "f32" ? formatF32(value) : formatF64(value);
     } else if (typeof value === "string") {
-        text = escapes ? value.replace(/\n/g, "\\n").replace(/\t/g, "\\t") : value;
+        text = escapes ? value.replaceAll("\n", String.raw`\n`).replaceAll("\t", String.raw`\t`) : value;
     } else if (ArrayBuffer.isView(value)) {
         text = JSON.stringify(Array.from(value as unknown as ArrayLike<number>));
     } else {

package/src/formats/xgmml/values.ts

@@ -187,5 +187,5 @@ export function parseScalar(text: string, kind: ScalarKind, unescape: boolean):
  * @returns the text with `\n` and `\t` decoded
  */
 function unescapeCytoscape(text: string): string {
-    return text.includes("\\") ? text.replace(/\\t/g, "\t").replace(/\\n/g, "\n") : text;
+    return text.includes("\\") ? text.replaceAll(String.raw`\t`, "\t").replaceAll(String.raw`\n`, "\n") : text;
 }

package/src/registry.ts

@@ -421,16 +421,15 @@ export class FormatRegistry {
     ): Promise<ImportGraphResult> {
         const opts = options as ImportGraphOptions;
         const picked = await this.choose(input, opts);
-        const unknown = this.unknownOptions(opts).map(
-            (name): ImportIssue =>
-                Object.freeze({
-                    category: "unsupported",
-                    severity: "warning",
-                    code: UNKNOWN_OPTION_CODE,
-                    message: unknownOptionText(name),
-                    line: null,
-                    element: name,
-                }),
+        const unknown = this.unknownOptions(opts).map((name): ImportIssue =>
+            Object.freeze({
+                category: "unsupported",
+                severity: "warning",
+                code: UNKNOWN_OPTION_CODE,
+                message: unknownOptionText(name),
+                line: null,
+                element: name,
+            }),
         );
         const chosen = unknown.length === 0 ? picked : { ...picked, warnings: [...picked.warnings, ...unknown] };
         const { importer } = chosen;

package/src/sniff.ts

@@ -32,19 +32,7 @@ import { type GraphImporter } from "./types.js";
  * @category Formats and detection
  */
 export type GraphFormatName =
-    | "gexf"
-    | "graphml"
-    | "gml"
-    | "dot"
-    | "pajek"
-    | "csv"
-    | "json"
-    | "neo4j"
-    | "xgmml"
-    | "cx2"
-    | "cx"
-    | "obo"
-    | "cys";
+    "gexf" | "graphml" | "gml" | "dot" | "pajek" | "csv" | "json" | "neo4j" | "xgmml" | "cx2" | "cx" | "obo" | "cys";
 
 /**
  * A format name: one of the built-in names (with editor autocomplete) or the name of a format you
@@ -345,14 +333,7 @@ export function sniffJsonDialectHead(head: Uint8Array | string): JsonImportDiale
 
 /** Where a key was seen while scanning a truncated head. */
 type KeyPath =
-    | ""
-    | "graph"
-    | "options"
-    | "nodes[0]"
-    | "edges[0]"
-    | "links[0]"
-    | "graphs[0].nodes[]"
-    | "graphs[0].edges[]";
+    "" | "graph" | "options" | "nodes[0]" | "edges[0]" | "links[0]" | "graphs[0].nodes[]" | "graphs[0].edges[]";
 
 /**
  * A partial document rebuilt from the keys a truncated head reveals: every key gets a placeholder

package/src/types.ts

@@ -458,13 +458,7 @@ export interface GraphExporter<Opts = unknown> {
  * @category Reports and errors
  */
 export type IssueCategory =
-    | "parse-error"
-    | "missing-value"
-    | "validation-error"
-    | "unsupported"
-    | "precision"
-    | "coercion"
-    | "merged";
+    "parse-error" | "missing-value" | "validation-error" | "unsupported" | "precision" | "coercion" | "merged";
 
 /**
  * One problem found while importing.