@graphty/graph-io 0.3.42 → 0.3.44

package/src/formats/neo4j/exporter.ts

@@ -423,7 +423,8 @@ class ExportPlan {
                 this.fatalEdges = new GraphFormatError("E_DIRECTED", gen.message, { reason: "mixed direction" });
             }
             if ((gen.code === LOSS.POSITIONS || gen.code === LOSS.VIZ) && gen.column !== null) {
-                // written as a plain property (a point for a position); the role is what is lost
+                // written as a plain property (a point for a position); the role is what is lost. Deprecated for
+                // the style roles (next major): styles reach a file only through the style writer.
                 this.notes.push(
                     Object.freeze({
                         code: gen.code,

package/src/formats/pajek/exporter.ts

@@ -24,7 +24,9 @@ import { agree, plural } from "../../common/plural.js";
 import { inferTextDtype } from "../../common/text.js";
 import { explicitWeights } from "../../common/weights.js";
 import { encodeChunks, joinText } from "../../common/writer.js";
+import type { ExporterStyleOptions } from "../../styles/io/writer.js";
 import { type CommonExportOptions, type ExportCapabilities, type GraphExporter, type LossNote } from "../../types.js";
+import { PAJEK_STYLE_CAPABILITIES, pajekStyledExport } from "./styles.js";
 import {
     encodeCharacterReferences,
     formatIntervals,
@@ -37,6 +39,9 @@ import {
     SHAPES,
 } from "./syntax.js";
 
+/** What the writer takes: the format's options, the common ones and the styles. */
+type PajekWriteOptions = PajekExportOptions & CommonExportOptions & ExporterStyleOptions;
+
 /**
  * The format-specific options of the Pajek exporter.
  * @category Built-in formats
@@ -105,6 +110,8 @@ export const PAJEK_LOSS = Object.freeze({
      * reads back with that role.
      */
     ROLE_ASSUMED: LOSS.ROLE_ASSUMED,
+    /** The label column, when a role-less column named `label` is read over it on import. */
+    COLUMN_DROPPED: LOSS.COLUMN_DROPPED,
     /**
      * With `sanitizeIds: "mangle"`: an original id that reads back as a different type, such as the text "7" as the
      * number 7.
@@ -392,16 +399,19 @@ function labelNotes(snapshot: GraphSnapshot, nodePlan: readonly PlannedColumn[],
                 plain.length - plain.nullCount,
             ),
         );
-    }
-    if (carried === 0) {
-        return;
-    }
-    let gained = 0;
-    for (let i = 0; i < snapshot.nodeCount; i++) {
-        if (!labels?.isSet(i)) {
-            gained++;
+        // the labels written second on each vertex line are then read over by that parameter
+        if (labels !== null && labels !== plain) {
+            notes.push(
+                note(
+                    PAJEK_LOSS.COLUMN_DROPPED,
+                    `node column "${labels.meta.name}" (the labels) reads back replaced by the parameter "${LABEL_COLUMN}"`,
+                    labels.meta.name,
+                    labels.length - labels.nullCount,
+                ),
+            );
         }
     }
+    const gained = carried === 0 ? 0 : unlabeled(snapshot.nodeCount, labels);
     if (gained > 0) {
         notes.push(
             note(
@@ -414,6 +424,22 @@ function labelNotes(snapshot: GraphSnapshot, nodePlan: readonly PlannedColumn[],
     }
 }
 
+/**
+ * How many nodes have no label value.
+ * @param nodeCount - the node count
+ * @param labels - the label column, or null
+ * @returns the count
+ */
+function unlabeled(nodeCount: number, labels: Column | null): number {
+    let count = 0;
+    for (let i = 0; i < nodeCount; i++) {
+        if (!labels?.isSet(i)) {
+            count++;
+        }
+    }
+    return count;
+}
+
 /**
  * Whether every set value of a shape column is a Pajek shape keyword.
  * @param column - the shape column (string or dict)
@@ -689,12 +715,14 @@ function needsZ(column: Column): boolean {
  * @param options.networkHeader - whether the `*Network` line is written
  * @param options.name - the name on that line, or null for a bare line
  * @param options.mangle - whether the original ids are written as `graphty_originalId` parameters
+ * @param comment - a comment line written first (the `graphty.styles` block), or null
  * @yields lines with their terminator
  * @returns nothing
  */
 function* writeParts(
     snapshot: GraphSnapshot,
     options: { networkHeader: boolean; name: string | null; mangle: boolean },
+    comment: string | null = null,
 ): Generator<string, void, undefined> {
     const ids = sanitizeIds(snapshot, CAPABILITIES.idCharset, options.mangle ? "mangle" : "error");
     const nodePlan = withoutReservedKey(plan(snapshot.nodes, "node", null), options.mangle);
@@ -714,6 +742,9 @@ function* writeParts(
         }
     }
 
+    if (comment !== null) {
+        yield `${comment}\n`;
+    }
     if (options.networkHeader) {
         yield options.name === null ? "*Network\n" : `*Network ${options.name}\n`;
     }
@@ -1008,105 +1039,21 @@ export const pajekExporter: GraphExporter<PajekExportOptions> = Object.freeze({
     format: "pajek",
     options: Object.freeze(["name", "networkHeader"]),
     capabilities: CAPABILITIES,
+    styles: Object.freeze({ capabilities: PAJEK_STYLE_CAPABILITIES }),
 
     /**
-     * Pre-flight: the generic capability gaps plus the Pajek-specific ones.
+     * Pre-flight: the generic capability gaps plus the Pajek-specific ones; with styles, also the values written as
+     * the nearest ones Pajek has.
      * @param snapshot - the snapshot
      * @param options - export options
      * @returns the loss notes, empty when the export is exact
      */
-    check(snapshot: GraphSnapshot, options?: PajekExportOptions & CommonExportOptions): readonly LossNote[] {
-        const resolved = resolveExportOptions(options);
-        const { mangle } = resolvePajekOptions(snapshot, options);
-        const notes: LossNote[] = [];
-        const planned = plan(snapshot.nodes, "node", notes);
-        const nodePlan = withoutReservedKey(planned, mangle);
-        const edgePlan = plan(snapshot.edges, "edge", notes);
-        const ids = sanitizeIds(snapshot, CAPABILITIES.idCharset, mangle ? "mangle" : "error");
-        checkIdTexts(snapshot.nodeCount, ids, mangle, notes);
-        if (nodePlan.length !== planned.length) {
-            const reserved = planned.find((p) => p.slot === "param" && p.column.meta.name === ORIGINAL_ID_KEY);
-            if (reserved !== undefined) {
-                notes.push(
-                    note(
-                        PAJEK_LOSS.KEY_DROPPED,
-                        `node column "${ORIGINAL_ID_KEY}" is the parameter the exporter writes the original ids under (sanitizeIds "mangle"); it is not written`,
-                        ORIGINAL_ID_KEY,
-                        reserved.column.length - reserved.column.nullCount,
-                    ),
-                );
-            }
-        }
-        // columns this exporter handles itself although the generic table says otherwise: the spells
-        // list (written as an interval token, or reported above with the spells code), the shape
-        // keyword and the relation name (dict columns written as keywords)
-        const owned = new Set<string>();
-        for (const { column, slot } of [...nodePlan, ...edgePlan]) {
-            // a shape written as a parameter is owned too: its note already says the column reads back as string
-            if (
-                slot === "shape" ||
-                slot === "relation" ||
-                (slot === "param" && column.meta.domain === "node" && column.meta.name === SHAPE_COLUMN)
-            ) {
-                owned.add(`${column.meta.domain}:${column.meta.name}`);
-            }
-        }
-        for (const table of [snapshot.nodes, snapshot.edges]) {
-            for (const column of table) {
-                if (column.meta.role === "spells") {
-                    owned.add(`${column.meta.domain}:${column.meta.name}`);
-                }
-            }
-        }
-        for (const n of checkCapabilities(snapshot, CAPABILITIES, resolved, {
-            roles: SLOT_ROLES,
-            roleNames: ROLE_NAMES,
-            // the label slot is a vertex slot; an edge label is a parameter under its own name
-            edgeRoleNames: {},
-        })) {
-            if (n.column !== null && (n.code === LOSS.LIST || n.code === LOSS.DTYPE)) {
-                const domain = n.message.startsWith("node column") ? "node" : "edge";
-                if (owned.has(`${domain}:${n.column}`)) {
-                    continue;
-                }
-            }
-            notes.push(n);
-        }
-        labelNotes(snapshot, nodePlan, notes);
-        for (const column of snapshot.edges) {
-            if (column.meta.role === "label") {
-                notes.push(
-                    note(
-                        LOSS.ROLE,
-                        `edge column "${column.meta.name}" (label) is written as a plain parameter; Pajek labels vertices only and the role is lost`,
-                        column.meta.name,
-                        column.length - column.nullCount,
-                    ),
-                );
-            }
-        }
-        checkCells(nodePlan, "node", notes);
-        checkCells(edgePlan, "edge", notes);
-        const folding = pairFolding(snapshot, { foldMutual: true });
-        if (folding.mutualCount > 0) {
-            notes.push(
-                note(
-                    PAJEK_LOSS.MUTUAL_AS_UNDIRECTED,
-                    `${folding.mutualCount} mutual pair${plural(folding.mutualCount)} ${agree(folding.mutualCount, "is", "are")} written as undirected edges; the mutual mark is lost`,
-                    snapshot.edges.byRole("mutual")?.meta.name ?? null,
-                    folding.mutualCount,
-                ),
-            );
+    check(snapshot: GraphSnapshot, options?: PajekWriteOptions): readonly LossNote[] {
+        const styled = pajekStyledExport(snapshot, options?.styles);
+        if (styled === null) {
+            return checkPlain(snapshot, options);
         }
-        if (Number.isNaN(firstModeOf(snapshot))) {
-            notes.push(
-                note(
-                    PAJEK_LOSS.FIRST_MODE_DROPPED,
-                    "meta.extra.pajek.firstMode is not a count within 0..nodeCount; the two-mode header is not written",
-                ),
-            );
-        }
-        return notes;
+        return Object.freeze([...checkPlain(styled.snapshot, withOriginalIds(options)), ...styled.notes]);
     },
 
     /**
@@ -1115,9 +1062,8 @@ export const pajekExporter: GraphExporter<PajekExportOptions> = Object.freeze({
      * @param options - export options
      * @returns the chunks
      */
-    export(snapshot: GraphSnapshot, options?: PajekExportOptions & CommonExportOptions): AsyncIterable<Uint8Array> {
-        const resolved = resolvePajekOptions(snapshot, options);
-        return encodeChunks(writeParts(snapshot, resolved));
+    export(snapshot: GraphSnapshot, options?: PajekWriteOptions): AsyncIterable<Uint8Array> {
+        return encodeChunks(styledParts(snapshot, options));
     },
 
     /**
@@ -1126,8 +1072,151 @@ export const pajekExporter: GraphExporter<PajekExportOptions> = Object.freeze({
      * @param options - export options
      * @returns the document
      */
-    exportToString(snapshot: GraphSnapshot, options?: PajekExportOptions & CommonExportOptions): Promise<string> {
-        const resolved = resolvePajekOptions(snapshot, options);
-        return joinText(writeParts(snapshot, resolved));
+    exportToString(snapshot: GraphSnapshot, options?: PajekWriteOptions): Promise<string> {
+        return joinText(styledParts(snapshot, options));
     },
 });
+
+/**
+ * The text parts of a Pajek document, with its styles when they are given.
+ * @param snapshot - the snapshot
+ * @param options - export options
+ * @returns the parts
+ */
+function styledParts(snapshot: GraphSnapshot, options?: PajekWriteOptions): Generator<string, void, undefined> {
+    const styled = pajekStyledExport(snapshot, options?.styles);
+    if (styled === null) {
+        return writeParts(snapshot, resolvePajekOptions(snapshot, options));
+    }
+    return writeParts(styled.snapshot, resolvePajekOptions(styled.snapshot, withOriginalIds(options)), styled.comment);
+}
+
+/**
+ * The options of an export with styles: unless `sanitizeIds` is given, the original ids of renumbered vertices are
+ * written too (`"mangle"`), so the file reads back as the same graph and its `graphty.styles` block applies.
+ * @param options - export options
+ * @returns the options to write with
+ */
+function withOriginalIds(
+    options: (PajekExportOptions & CommonExportOptions) | undefined,
+): PajekExportOptions & CommonExportOptions {
+    return options?.sanitizeIds === undefined ? { ...options, sanitizeIds: "mangle" } : options;
+}
+
+/**
+ * The columns this exporter handles itself although the generic table says otherwise: the spells list (written as an
+ * interval token, or reported with the spells code), the shape keyword and the relation name (dict columns written as
+ * keywords), and a shape written as a parameter (its own note says the column reads back as string).
+ * @param snapshot - the snapshot
+ * @param planned - the node and edge column plans
+ * @returns the columns, as `<domain>:<name>`
+ */
+function ownedColumns(snapshot: GraphSnapshot, planned: readonly PlannedColumn[]): Set<string> {
+    const owned = new Set<string>();
+    const key = (column: Column): string => `${column.meta.domain}:${column.meta.name}`;
+    for (const { column, slot } of planned) {
+        const shapeParam = slot === "param" && column.meta.domain === "node" && column.meta.name === SHAPE_COLUMN;
+        if (slot === "shape" || slot === "relation" || shapeParam) {
+            owned.add(key(column));
+        }
+    }
+    for (const column of [...snapshot.nodes, ...snapshot.edges]) {
+        if (column.meta.role === "spells") {
+            owned.add(key(column));
+        }
+    }
+    return owned;
+}
+
+/**
+ * The generic capability gaps, without the list and dtype notes of a column Pajek writes in a slot of its own.
+ * @param snapshot - the snapshot
+ * @param resolved - the resolved export options
+ * @param owned - the columns written in a slot of their own, as `<domain>:<name>`
+ * @returns the loss notes
+ */
+function capabilityNotes(
+    snapshot: GraphSnapshot,
+    resolved: ReturnType<typeof resolveExportOptions>,
+    owned: ReadonlySet<string>,
+): LossNote[] {
+    const notes = checkCapabilities(snapshot, CAPABILITIES, resolved, {
+        roles: SLOT_ROLES,
+        roleNames: ROLE_NAMES,
+        // the label slot is a vertex slot; an edge label is a parameter under its own name
+        edgeRoleNames: {},
+    });
+    return notes.filter((n) => {
+        if (n.column === null || (n.code !== LOSS.LIST && n.code !== LOSS.DTYPE)) {
+            return true;
+        }
+        const domain = n.message.startsWith("node column") ? "node" : "edge";
+        return !owned.has(`${domain}:${n.column}`);
+    });
+}
+
+/**
+ * Every loss the Pajek text of a snapshot would incur: the generic capability gaps plus the Pajek-specific ones.
+ * @param snapshot - the snapshot
+ * @param options - export options
+ * @returns the loss notes
+ */
+function checkPlain(snapshot: GraphSnapshot, options?: PajekExportOptions & CommonExportOptions): LossNote[] {
+    const resolved = resolveExportOptions(options);
+    const { mangle } = resolvePajekOptions(snapshot, options);
+    const notes: LossNote[] = [];
+    const planned = plan(snapshot.nodes, "node", notes);
+    const nodePlan = withoutReservedKey(planned, mangle);
+    const edgePlan = plan(snapshot.edges, "edge", notes);
+    const ids = sanitizeIds(snapshot, CAPABILITIES.idCharset, mangle ? "mangle" : "error");
+    checkIdTexts(snapshot.nodeCount, ids, mangle, notes);
+    const reserved =
+        nodePlan.length === planned.length
+            ? undefined
+            : planned.find((p) => p.slot === "param" && p.column.meta.name === ORIGINAL_ID_KEY);
+    if (reserved !== undefined) {
+        notes.push(
+            note(
+                PAJEK_LOSS.KEY_DROPPED,
+                `node column "${ORIGINAL_ID_KEY}" is the parameter the exporter writes the original ids under (sanitizeIds "mangle"); it is not written`,
+                ORIGINAL_ID_KEY,
+                reserved.column.length - reserved.column.nullCount,
+            ),
+        );
+    }
+    const owned = ownedColumns(snapshot, [...nodePlan, ...edgePlan]);
+    notes.push(...capabilityNotes(snapshot, resolved, owned));
+    labelNotes(snapshot, nodePlan, notes);
+    for (const column of [...snapshot.edges].filter((c) => c.meta.role === "label")) {
+        notes.push(
+            note(
+                LOSS.ROLE,
+                `edge column "${column.meta.name}" (label) is written as a plain parameter; Pajek labels vertices only and the role is lost`,
+                column.meta.name,
+                column.length - column.nullCount,
+            ),
+        );
+    }
+    checkCells(nodePlan, "node", notes);
+    checkCells(edgePlan, "edge", notes);
+    const folding = pairFolding(snapshot, { foldMutual: true });
+    if (folding.mutualCount > 0) {
+        notes.push(
+            note(
+                PAJEK_LOSS.MUTUAL_AS_UNDIRECTED,
+                `${folding.mutualCount} mutual pair${plural(folding.mutualCount)} ${agree(folding.mutualCount, "is", "are")} written as undirected edges; the mutual mark is lost`,
+                snapshot.edges.byRole("mutual")?.meta.name ?? null,
+                folding.mutualCount,
+            ),
+        );
+    }
+    if (Number.isNaN(firstModeOf(snapshot))) {
+        notes.push(
+            note(
+                PAJEK_LOSS.FIRST_MODE_DROPPED,
+                "meta.extra.pajek.firstMode is not a count within 0..nodeCount; the two-mode header is not written",
+            ),
+        );
+    }
+    return notes;
+}

package/src/formats/pajek/importer.ts

@@ -68,6 +68,7 @@ import {
     type ImportInput,
     type ImportReport,
 } from "../../types.js";
+import { pajekStyles } from "./styles.js";
 import {
     decodeCharacterReferences,
     isCommentOrBlank,
@@ -78,6 +79,7 @@ import {
     isVertexNumber,
     LABEL_COLUMN,
     ORIGINAL_ID_KEY,
+    PAJEK_STYLE_COMMENT,
     parseIntervals,
     parseSectionHeader,
     PARTITION_COLUMN,
@@ -222,6 +224,10 @@ export const PAJEK_ISSUE = Object.freeze({
     NEGATIVE_LIST_ENTRY: "W_PAJEK_NEGATIVE_LIST_ENTRY",
     /** An integer beyond 2^53 was stored as the nearest 64-bit float; pass `long: "string"` to keep every digit. */
     PRECISION: PRECISION_CODE,
+    /** A number alone at the end of a row, after its parameters (Pajek writes a trailing `0`); it is ignored. */
+    TRAILING_VALUE: "W_PAJEK_TRAILING_VALUE",
+    /** A line whose value is `NaN`; the line is kept without a value. */
+    NAN_VALUE: "W_PAJEK_NAN_VALUE",
 });
 
 /** The common options the Pajek importer reads (the rest is reported by reportUnusedOptions). */
@@ -251,6 +257,8 @@ const FIRST_VERTEX_VALUES: ReadonlySet<unknown> = new Set([0, 1, "auto"]);
 /** A numeral that is not a finite number (`1e999`, `NaN`, `Infinity`): never a parameter key. */
 const NUMERAL = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i;
 const NON_FINITE_WORD = /^[+-]?(?:nan|inf|infinity)$/i;
+/** A line value Pajek writes for a missing value. */
+const NAN_WORD = /^[+-]?nan$/i;
 
 const LABEL_DECL: ColumnDecl = {
     name: LABEL_COLUMN,
@@ -291,7 +299,8 @@ function spellsDecl(): ColumnDecl {
 }
 
 /**
- * The position column declaration (design section 5.2: f64 x 3, role position, units "file").
+ * The position column declaration (design section 5.2: f64 x 3, role position, units "file"), with
+ * its spelling for `extractPositions()`.
  * @param sourceDims - 2 or 3, the coordinate count of the first vertex line with coordinates
  * @returns a fresh declaration
  */
@@ -303,7 +312,9 @@ function positionDecl(sourceDims: number): ColumnDecl {
         nullable: true,
         role: "position",
         origin: { format: "pajek", id: "coordinates" },
-        extra: { sourceDims, units: "file" },
+        // Pajek draws y downward (USAir97.net has Deadhorse, Alaska at y 0.10 and Miami at 0.53),
+        // centers depth on 0.5, and NetworkX writes "0.0 0.0" for a node with no position
+        extra: { sourceDims, units: "file", yAxis: "down", zOrigin: 0.5, zeroUnplaced: true },
     };
 }
 
@@ -335,6 +346,8 @@ interface RowExtras {
     readonly values: string[];
     /** The spells of an interval token, or null. */
     spells: [number, number][] | null;
+    /** A vertex shape keyword written among the parameters (Pajek reads it anywhere), lower-cased, or null. */
+    shape: string | null;
 }
 
 /** The section the parser is in. */
@@ -483,6 +496,9 @@ class PajekParser {
 
     private readonly edgeParams = new Map<string, TextCellWriter>();
 
+    /** Whether a `% graphty.styles` comment was kept for the style reader. */
+    private styleBlockKept = false;
+
     /**
      * Create the parser for one import call.
      * @param sink - the sink
@@ -504,6 +520,22 @@ class PajekParser {
         this.coercer = new IdCoercer(options.ids);
     }
 
+    /**
+     * Keep the first `% graphty.styles <json>` comment for the style reader (a file graphty wrote carries its styles
+     * there; Pajek skips comment lines).
+     * @param text - a comment or blank line
+     */
+    private comment(text: string): void {
+        if (this.styleBlockKept) {
+            return;
+        }
+        const trimmed = text.trimStart();
+        if (trimmed.startsWith(PAJEK_STYLE_COMMENT)) {
+            this.styleBlockKept = true;
+            this.report.keepForStyles(trimmed.slice(PAJEK_STYLE_COMMENT.length));
+        }
+    }
+
     /**
      * Handle one line; every problem of the line is recorded as an issue and the line skipped.
      * @param text - the line without its terminator
@@ -512,6 +544,7 @@ class PajekParser {
      */
     line(text: string, line: number): boolean {
         if (isCommentOrBlank(text)) {
+            this.comment(text);
             return false;
         }
         const afterObjectHeader = this.objectHeader;
@@ -1050,6 +1083,7 @@ class PajekParser {
             i++;
         }
         const extras = this.extras(tokens, i, "node", line);
+        shape = extras.shape ?? shape;
         const restored = this.restoredId(extras);
         this.createNodes();
         // write
@@ -1329,6 +1363,14 @@ class PajekParser {
         if (i < tokens.length && isNumericText(tokens[i])) {
             valueText = tokens[i];
             i++;
+        } else if (i < tokens.length && NAN_WORD.test(tokens[i])) {
+            this.report.warnOnce(
+                "validation-error",
+                PAJEK_ISSUE.NAN_VALUE,
+                `a line value ${JSON.stringify(tokens[i])} is not a number; the line is kept without a value`,
+                { line },
+            );
+            i++;
         }
         const extras = this.extras(tokens, i, "edge", line);
         const { weightFrom } = this.options;
@@ -1607,7 +1649,7 @@ class PajekParser {
      * @returns the parsed extras
      */
     private extras(tokens: readonly string[], start: number, domain: "node" | "edge", line: number): RowExtras {
-        const extras: RowExtras = { keys: [], values: [], spells: null };
+        const extras: RowExtras = { keys: [], values: [], spells: null, shape: null };
         const seen = new Set<string>();
         for (let i = start; i < tokens.length;) {
             const token = tokens[i];
@@ -1616,13 +1658,14 @@ class PajekParser {
                 i++;
                 continue;
             }
+            if (domain === "node" && isShapeKeyword(token)) {
+                extras.shape = token.toLowerCase();
+                i++;
+                continue;
+            }
             if (i + 1 >= tokens.length) {
-                this.skip(domain);
-                throw new LineError(
-                    "parse-error",
-                    domain === "node" ? PAJEK_ISSUE.VERTEX_LINE : PAJEK_ISSUE.LINE,
-                    `parameter "${token}" has no value`,
-                );
+                this.loneLastToken(token, domain, line);
+                break;
             }
             if (seen.has(token)) {
                 this.report.warning(
@@ -1640,6 +1683,31 @@ class PajekParser {
         return extras;
     }
 
+    /**
+     * A token alone at the end of a row, with no value after it: a number is ignored (reported once);
+     * anything else is a parameter without its value, which skips the row.
+     * @param token - the token
+     * @param domain - what is skipped when the row is malformed
+     * @param line - the line number
+     */
+    private loneLastToken(token: string, domain: "node" | "edge", line: number): void {
+        if (isNumericText(token)) {
+            this.report.warnOnce(
+                "validation-error",
+                PAJEK_ISSUE.TRAILING_VALUE,
+                `the number ${JSON.stringify(token)} alone at the end of a row is not a parameter; it is ignored`,
+                { line },
+            );
+            return;
+        }
+        this.skip(domain);
+        throw new LineError(
+            "parse-error",
+            domain === "node" ? PAJEK_ISSUE.VERTEX_LINE : PAJEK_ISSUE.LINE,
+            `parameter "${token}" has no value`,
+        );
+    }
+
     /**
      * The spells of a row's interval token; a malformed one skips the row.
      * @param token - the token, starting with "["
@@ -1780,6 +1848,7 @@ export const pajekImporter: GraphImporter<PajekImportOptions> = Object.freeze({
     options: Object.freeze(["firstVertex"]),
     extensions: Object.freeze([".net", ".paj"]),
     mimeTypes: Object.freeze(["text/x-pajek", "text/plain"]),
+    styles: pajekStyles,
 
     /**
      * Confidence that the input is a Pajek network: it starts with `*Vertices` (or `*Network`),

package/src/formats/pajek/index.ts

@@ -6,3 +6,5 @@
 
 export { PAJEK_LOSS, pajekExporter, type PajekExportOptions } from "./exporter.js";
 export { PAJEK_ISSUE, pajekImporter, type PajekImportOptions } from "./importer.js";
+export { PAJEK_STYLE_CAPABILITIES } from "./styles.js";
+export { PAJEK_STYLE_COMMENT } from "./syntax.js";