@graphty/graph-io 0.3.47 → 0.3.49

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

@@ -27,8 +27,9 @@ import { agree, plural } from "../../common/plural.js";
 import { ImportReportBuilder } from "../../common/report.js";
 import { isNumericText, TextCellWriter, WIDENING_UNSUPPORTED_CODE } from "../../common/text.js";
 import { isWeightField, parseWeightText } from "../../common/weights.js";
-import { pajekStyles } from "./styles.js";
-import { decodeCharacterReferences, isCommentOrBlank, isIntervalToken, isProjectObject, isSectionLine, isShapeKeyword, isVertexNumber, LABEL_COLUMN, ORIGINAL_ID_KEY, PAJEK_STYLE_COMMENT, parseIntervals, parseSectionHeader, PARTITION_COLUMN, POSITION_COLUMN, RELATION_COLUMN, SHAPE_COLUMN, SPELLS_COLUMN, tokenize, VALUE_COLUMN, VALUE_FIELD, VECTOR_COLUMN, } from "./syntax.js";
+import { resolvePajekDraw } from "./draw.js";
+import { PAJEK_POINTS_PER_UNIT, pajekStyles } from "./styles.js";
+import { decodeCharacterReferences, isCommentOrBlank, isIntervalToken, isProjectObject, isSectionLine, isShapeKeyword, isVertexNumber, LABEL_COLUMN, ORIGINAL_ID_KEY, PAJEK_STYLE_COMMENT, parseIntervals, parseSectionHeader, PARTITION_COLUMN, POSITION_COLUMN, RELATION_COLUMN, SHAPE_COLUMN, SPELLS_COLUMN, tokenize, VALUE_COLUMN, VALUE_FIELD, VECTOR_COLUMN, VOIDING_KEYS, } from "./syntax.js";
 /**
  * Issue codes of the Pajek importer.
  * @category Built-in formats
@@ -213,9 +214,10 @@ function spellsDecl() {
  * 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
+ * @param window - the Draw window the coordinates are stretched to
  * @returns a fresh declaration
  */
-function positionDecl(sourceDims) {
+function positionDecl(sourceDims, window) {
     return {
         name: POSITION_COLUMN,
         dtype: "f64",
@@ -224,10 +226,22 @@ function positionDecl(sourceDims) {
         role: "position",
         origin: { format: "pajek", id: "coordinates" },
         // 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 },
+        // centers depth on 0.5, and NetworkX writes "0.0 0.0" for a node with no position; one unit
+        // is the Draw window's width in points across and its height down (500 each by default,
+        // PAJEK_POINTS_PER_UNIT): Pajek stretches 0..1 to the window one axis at a time
+        extra: {
+            sourceDims,
+            units: "file",
+            pxPerUnit: window.width,
+            ...(window.height === window.width ? {} : { pxPerUnitY: window.height }),
+            yAxis: "down",
+            zOrigin: 0.5,
+            zeroUnplaced: true,
+        },
     };
 }
+/** The Draw window a file is drawn in without `pajekDraw`: the square Pajek's EPS export maps 0..1 to. */
+const DEFAULT_WINDOW = { width: PAJEK_POINTS_PER_UNIT, height: PAJEK_POINTS_PER_UNIT };
 /** A problem with one line, recorded as an issue by the per-line catch. */
 class LineError extends Error {
     /**
@@ -266,8 +280,15 @@ class PajekParser {
      * @param report - the report
      * @param options - the resolved common options
      * @param firstVertex - the firstVertex format option
+     * @param window - the Draw window the coordinates are stretched to
      */
-    constructor(sink, report, options, firstVertex) {
+    constructor(sink, report, options, firstVertex, window = DEFAULT_WINDOW) {
+        /** The `% graphty.styles` block kept for the styles, or null. */
+        this.keptBlock = null;
+        /**
+         * The vertices whose line Pajek 6.02 draws with none of its parameters (`VOIDING_KEYS`), by index, for the styles.
+         */
+        this.voided = [];
         this.section = "none";
         /** The direction of the current line section. */
         this.kind = "directed";
@@ -331,6 +352,7 @@ class PajekParser {
         this.edgeParams = new Map();
         /** Whether a `% graphty.styles` comment was kept for the style reader. */
         this.styleBlockKept = false;
+        this.window = window;
         this.sink = sink;
         this.report = report;
         this.options = options;
@@ -350,7 +372,8 @@ class PajekParser {
         const trimmed = text.trimStart();
         if (trimmed.startsWith(PAJEK_STYLE_COMMENT)) {
             this.styleBlockKept = true;
-            this.report.keepForStyles(trimmed.slice(PAJEK_STYLE_COMMENT.length));
+            this.keptBlock = trimmed.slice(PAJEK_STYLE_COMMENT.length);
+            this.report.keepForStyles(this.keptBlock);
         }
     }
     /**
@@ -762,6 +785,57 @@ class PajekParser {
      */
     vertexLine(text, line) {
         const tokens = this.tokens(text, "node", line);
+        const { k, pos } = this.vertexNumber(tokens, line);
+        // parse everything before writing anything
+        let i = 1;
+        let label = null;
+        if (tokens.length > 1 && !startsWithCoordinates(text, tokens)) {
+            label = this.labelOf(tokens[1], k, line);
+            i = 2;
+        }
+        const { xyz, dims, next } = this.vertexCoordinates(tokens, i, k);
+        i = next;
+        this.checkCoordinates(text, tokens, i, dims === 2 && label !== null, k, line);
+        let shape = null;
+        if (i < tokens.length && isShapeKeyword(tokens[i])) {
+            shape = tokens[i].toLowerCase();
+            i++;
+        }
+        const extras = this.extras(tokens, i, "node", line);
+        shape = extras.shape ?? shape;
+        const restored = this.restoredId(extras);
+        this.createNodes();
+        // write
+        const repeated = this.markVertexSeen(pos, k, line);
+        const index = this.vertexIndex(pos, k, label, restored, repeated, line);
+        if (shape === null && dims > 0 && extras.keys.length > 0 && VOIDING_KEYS.has(extras.keys[0])) {
+            this.voided.push(index);
+        }
+        if (label !== null) {
+            this.labelHandle = this.nodeHandle(this.labelHandle, LABEL_DECL, line);
+            this.sink.setNodeValue(this.labelHandle, index, label);
+        }
+        if (dims > 0) {
+            this.writePosition(index, dims, xyz, k, line);
+        }
+        if (shape !== null) {
+            this.writeShape(index, shape, line);
+        }
+        for (let p = 0; p < extras.keys.length; p++) {
+            this.writeParameter("node", extras.keys[p], index, extras.values[p]);
+        }
+        if (extras.spells !== null) {
+            this.nodeSpellsHandle = this.nodeHandle(this.nodeSpellsHandle, spellsDecl(), line);
+            this.sink.setNodeValue(this.nodeSpellsHandle, index, extras.spells);
+        }
+    }
+    /**
+     * A vertex line's number, checked: it starts the line and is in the declared range.
+     * @param tokens - the line's tokens
+     * @param line - the line number
+     * @returns the vertex number and its position
+     */
+    vertexNumber(tokens, line) {
         if (!isVertexNumber(tokens[0])) {
             this.report.counts.skippedNodes++;
             throw new LineError("parse-error", PAJEK_ISSUE.VERTEX_LINE, `a vertex line starts with a vertex number, not "${tokens[0]}"`);
@@ -776,62 +850,68 @@ class PajekParser {
             this.outOfRange++;
             throw new LineError("validation-error", PAJEK_ISSUE.VERTEX_RANGE, `vertex ${k} is outside ${this.base}..${this.base + this.vertexCount - 1}`);
         }
-        // parse everything before writing anything
-        let i = 1;
-        let label = null;
-        if (tokens.length > 1 && !startsWithCoordinates(text, tokens)) {
-            label = this.labelOf(tokens[1], k, line);
-            i = 2;
-        }
-        let x = 0;
-        let y = 0;
-        let z = 0;
-        let dims = 0;
+        return { k, pos };
+    }
+    /**
+     * A vertex line's coordinates: two or three numbers, or none; a single one is an error.
+     * @param tokens - the line's tokens
+     * @param i - where the coordinates would start
+     * @param k - the vertex number
+     * @returns x, y and z (0 when absent), how many were read, and the index after them
+     */
+    vertexCoordinates(tokens, i, k) {
         if (i + 1 < tokens.length && isNumericText(tokens[i]) && isNumericText(tokens[i + 1])) {
-            x = Number(tokens[i]);
-            y = Number(tokens[i + 1]);
-            i += 2;
-            dims = 2;
-            if (i < tokens.length && isNumericText(tokens[i])) {
-                z = Number(tokens[i]);
-                i++;
-                dims = 3;
+            const x = Number(tokens[i]);
+            const y = Number(tokens[i + 1]);
+            if (i + 2 < tokens.length && isNumericText(tokens[i + 2])) {
+                return { xyz: [x, y, Number(tokens[i + 2])], dims: 3, next: i + 3 };
             }
+            return { xyz: [x, y, 0], dims: 2, next: i + 2 };
         }
-        else if (i < tokens.length && isNumericText(tokens[i])) {
+        if (i < tokens.length && isNumericText(tokens[i])) {
             this.report.counts.skippedNodes++;
             throw new LineError("parse-error", PAJEK_ISSUE.VERTEX_LINE, `vertex ${k}: a single coordinate "${tokens[i]}"; coordinates are x y [z]`);
         }
-        this.checkCoordinates(text, tokens, i, dims === 2 && label !== null, k, line);
-        let shape = null;
-        if (i < tokens.length && isShapeKeyword(tokens[i])) {
-            shape = tokens[i].toLowerCase();
-            i++;
-        }
-        const extras = this.extras(tokens, i, "node", line);
-        shape = extras.shape ?? shape;
-        const restored = this.restoredId(extras);
-        this.createNodes();
-        // write
-        const repeated = this.seen[pos] !== 0;
-        if (repeated) {
+        return { xyz: [0, 0, 0], dims: 0, next: i };
+    }
+    /**
+     * Marks a vertex's position as having a line, warning when it already had one.
+     * @param pos - the vertex's position
+     * @param k - the vertex number
+     * @param line - the line number
+     * @returns whether the vertex already had a line
+     */
+    markVertexSeen(pos, k, line) {
+        if (this.seen[pos] !== 0) {
             this.report.warning("merged", PAJEK_ISSUE.DUPLICATE_NODE, `vertex ${k} has more than one line; the later values overwrite`, { line, element: String(k) });
+            return true;
         }
-        else {
-            this.seen[pos] = 1;
-            this.seenCount++;
-        }
-        let index;
-        if (this.idOfPos !== null && !repeated && this.options.nodeIdFrom === "label") {
-            index = this.deferredNode(this.idOfPos, pos, k, label, line, "label");
+        this.seen[pos] = 1;
+        this.seenCount++;
+        return false;
+    }
+    /**
+     * The node index a vertex line writes to, creating the node when its id is deferred to its line.
+     * @param pos - the vertex's position
+     * @param k - the vertex number
+     * @param label - the line's label, or null
+     * @param restored - the original id the line carries, or null
+     * @param repeated - whether the vertex already had a line
+     * @param line - the line number
+     * @returns the node index
+     */
+    vertexIndex(pos, k, label, restored, repeated, line) {
+        const { idOfPos } = this;
+        if (idOfPos !== null && !repeated && this.options.nodeIdFrom === "label") {
+            return this.deferredNode(idOfPos, pos, k, label, line, "label");
         }
-        else if (this.idOfPos !== null && this.idOfPos[pos] === undefined) {
+        if (idOfPos !== null && idOfPos[pos] === undefined) {
             // restore mode: the earlier positions without a line yet get their numbers first, so the
             // index order is the vertex number order whatever the line order (the identity id map
             // of an ordered file); then this vertex with its original id, or its number
             for (let p = this.filledBelow; p < pos; p++) {
-                if (this.idOfPos[p] === undefined) {
-                    this.numberedNode(this.idOfPos, p);
+                if (idOfPos[p] === undefined) {
+                    this.numberedNode(idOfPos, p);
                 }
             }
             // after the loop on purpose: a throw part-way leaves the mark at its smaller, still
@@ -839,46 +919,40 @@ class PajekParser {
             if (pos > this.filledBelow) {
                 this.filledBelow = pos;
             }
-            index = this.deferredNode(this.idOfPos, pos, k, restored, line, "originalId");
-        }
-        else {
-            index = this.indexOfPos[pos];
-            if (restored !== null && !repeated) {
-                // an out-of-order line: the vertex already exists under its number
-                this.report.warning("coercion", PAJEK_ISSUE.ORIGINAL_ID_UNRESTORED, `vertex ${k} carries ${ORIGINAL_ID_KEY} ${JSON.stringify(restored)} but a later vertex's line came first and created it under its number; the original id is not restored`, { line, element: String(k) });
-            }
-        }
-        const { sink } = this;
-        if (label !== null) {
-            if (this.labelHandle === INVALID_INDEX) {
-                this.labelHandle = declareResolved(sink, "node", LABEL_DECL, this.report, { line }).handle;
-            }
-            sink.setNodeValue(this.labelHandle, index, label);
-        }
-        if (dims > 0) {
-            this.writePosition(index, dims, [x, y, z], k, line);
+            return this.deferredNode(idOfPos, pos, k, restored, line, "originalId");
         }
-        if (shape !== null) {
-            if (this.shapeHandle === INVALID_INDEX && this.nodeParams.has(SHAPE_COLUMN)) {
-                // an earlier `shape "<text>"` parameter owns the column: the keyword is written there
-                this.writeParameter("node", SHAPE_COLUMN, index, shape);
-            }
-            else {
-                if (this.shapeHandle === INVALID_INDEX) {
-                    this.shapeHandle = declareResolved(sink, "node", SHAPE_DECL, this.report, { line }).handle;
-                }
-                sink.setNodeValue(this.shapeHandle, index, shape);
-            }
-        }
-        for (let p = 0; p < extras.keys.length; p++) {
-            this.writeParameter("node", extras.keys[p], index, extras.values[p]);
+        if (restored !== null && !repeated) {
+            // an out-of-order line: the vertex already exists under its number
+            this.report.warning("coercion", PAJEK_ISSUE.ORIGINAL_ID_UNRESTORED, `vertex ${k} carries ${ORIGINAL_ID_KEY} ${JSON.stringify(restored)} but a later vertex's line came first and created it under its number; the original id is not restored`, { line, element: String(k) });
         }
-        if (extras.spells !== null) {
-            if (this.nodeSpellsHandle === INVALID_INDEX) {
-                this.nodeSpellsHandle = declareResolved(sink, "node", spellsDecl(), this.report, { line }).handle;
-            }
-            sink.setNodeValue(this.nodeSpellsHandle, index, extras.spells);
+        return this.indexOfPos[pos];
+    }
+    /**
+     * A node column's handle, declared on first use.
+     * @param handle - the handle so far, or INVALID_INDEX
+     * @param decl - the column's declaration
+     * @param line - the line number
+     * @returns the handle
+     */
+    nodeHandle(handle, decl, line) {
+        return handle === INVALID_INDEX
+            ? declareResolved(this.sink, "node", decl, this.report, { line }).handle
+            : handle;
+    }
+    /**
+     * Writes a vertex's shape keyword: to the shape column, or to an earlier `shape "<text>"` parameter's column.
+     * @param index - the node index
+     * @param shape - the keyword
+     * @param line - the line number
+     */
+    writeShape(index, shape, line) {
+        if (this.shapeHandle === INVALID_INDEX && this.nodeParams.has(SHAPE_COLUMN)) {
+            // an earlier `shape "<text>"` parameter owns the column: the keyword is written there
+            this.writeParameter("node", SHAPE_COLUMN, index, shape);
+            return;
         }
+        this.shapeHandle = this.nodeHandle(this.shapeHandle, SHAPE_DECL, line);
+        this.sink.setNodeValue(this.shapeHandle, index, shape);
     }
     /**
      * A vertex label as written, its character references decoded.
@@ -929,7 +1003,9 @@ class PajekParser {
     writePosition(index, dims, point, k, line) {
         if (this.positionHandle === INVALID_INDEX) {
             this.coordDims = dims;
-            this.positionHandle = declareResolved(this.sink, "node", positionDecl(dims), this.report, { line }).handle;
+            this.positionHandle = declareResolved(this.sink, "node", positionDecl(dims, this.window), this.report, {
+                line,
+            }).handle;
         }
         else if (dims !== this.coordDims) {
             this.report.warnOnce("validation-error", PAJEK_ISSUE.COORD_DIMS, `vertex lines mix ${this.coordDims} and ${dims} coordinates; the position column records sourceDims ${this.coordDims}`, { line, element: String(k) });
@@ -1263,7 +1339,7 @@ class PajekParser {
         for (let i = start; i < tokens.length;) {
             const token = tokens[i];
             if (token.startsWith("[")) {
-                extras.spells = this.intervals(token, domain);
+                extras.spells = this.intervals(token, domain, line);
                 i++;
                 continue;
             }
@@ -1281,8 +1357,12 @@ class PajekParser {
             }
             seen.add(token);
             extras.keys.push(token);
-            extras.values.push(tokens[i + 1]);
-            i += 2;
+            // a color written as three fractions, `c 0.700 0.700 0.700` (Pajek's course data, 1CRN.NET), is one
+            // value, kept as written; a key is never a number, so the reading is unambiguous. Pajek 6.02 reads no
+            // color from it (the style reader leaves the line its carried or default color)
+            const triple = COLOR_KEYS.has(token) ? colorTriple(tokens, i + 1) : null;
+            extras.values.push(triple ?? tokens[i + 1]);
+            i += triple === null ? 2 : 4;
         }
         return extras;
     }
@@ -1302,12 +1382,15 @@ class PajekParser {
         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.
+     * The spells of a row's interval token. A token not closed by "]" skips the row; a closed one
+     * whose times cannot be read (`[287-?]`, lin-rel4.net) is reported and dropped, and the rest of
+     * the row (its label, coordinates and parameters) is kept.
      * @param token - the token, starting with "["
-     * @param domain - what is skipped when the token is malformed
-     * @returns the spells, or null for an empty `[]`, which is no spell at all
+     * @param domain - what is skipped when the token is not closed
+     * @param line - the line number
+     * @returns the spells, or null for an empty `[]`, which is no spell at all, and for a dropped one
      */
-    intervals(token, domain) {
+    intervals(token, domain, line) {
         if (!isIntervalToken(token)) {
             this.skip(domain);
             throw new LineError("validation-error", PAJEK_ISSUE.INTERVAL, `time interval ${token} is not closed by "]"`);
@@ -1317,8 +1400,8 @@ class PajekParser {
             return spells.length === 0 ? null : spells;
         }
         catch (err) {
-            this.skip(domain);
-            throw new LineError("validation-error", PAJEK_ISSUE.INTERVAL, err instanceof Error ? err.message : String(err));
+            this.report.error("validation-error", PAJEK_ISSUE.INTERVAL, `${err instanceof Error ? err.message : String(err)}; the interval is dropped and the rest of the line kept`, { line });
+            return null;
         }
     }
     /**
@@ -1357,6 +1440,19 @@ class PajekParser {
         writer.write(row, text);
     }
 }
+/** The parameters that hold a color, which a file may also write as three fractions `r g b`. */
+const COLOR_KEYS = new Set(["ic", "bc", "lc", "c"]);
+/**
+ * A color written as three numbers from 0 to 1 at a row's tokens, as one value `r g b`.
+ * @param tokens - the row's tokens
+ * @param at - the first of the three
+ * @returns the color text, or null when the three tokens are not such numbers
+ */
+function colorTriple(tokens, at) {
+    const parts = tokens.slice(at, at + 3);
+    const fraction = (t) => /^[01]?(?:\.\d+)?$/.test(t) && t !== "" && Number(t) <= 1;
+    return parts.length === 3 && parts.every(fraction) ? parts.join(" ") : null;
+}
 /**
  * Whether a vertex line has coordinates but no label: the token after the vertex number is bare
  * (not quoted) and starts a run of exactly two numbers, which cannot be a label and one
@@ -1421,10 +1517,29 @@ function headSection(text) {
  */
 export const pajekImporter = Object.freeze({
     format: "pajek",
-    options: Object.freeze(["firstVertex"]),
+    options: Object.freeze(["firstVertex", "pajekDraw"]),
     extensions: Object.freeze([".net", ".paj"]),
     mimeTypes: Object.freeze(["text/x-pajek", "text/plain"]),
     styles: pajekStyles,
+    /**
+     * Where Pajek 6.02 draws a network whose vertices have no coordinates: round a circle in vertex order, the first
+     * on the left, the rest going clockwise on screen (y down), at radius 0.4 about the middle of the Draw window
+     * (pajek-iliad: 311 vertices 200 points from the middle of its 500-point window). A file with coordinates is read
+     * from its position column.
+     * @param snapshot - the imported graph
+     * @returns the circle for a file with no coordinates, else null
+     */
+    positions(snapshot) {
+        if (snapshot.nodes.byRole("position") !== null) {
+            return null;
+        }
+        return {
+            units: "file",
+            pxPerUnit: PAJEK_POINTS_PER_UNIT,
+            yAxis: "down",
+            unplacedCircle: { center: [0.5, 0.5], radius: 0.4, startDegrees: 180, direction: 1 },
+        };
+    },
     /**
      * Confidence that the input is a Pajek network: it starts with `*Vertices` (or `*Network`),
      * after any `%` comment lines.
@@ -1453,10 +1568,11 @@ export const pajekImporter = Object.freeze({
         }
         const resolved = resolveImportOptions(options, DEFAULTS);
         const firstVertex = firstVertexOption(options?.firstVertex);
+        const draw = resolvePajekDraw(options?.pajekDraw);
         const report = new ImportReportBuilder("pajek", resolved.errorLimit);
         reportSinkOptions(sink, options, report);
         reportUnusedOptions(options, report, USED_OPTIONS);
-        const parser = new PajekParser(sink, report, resolved, firstVertex);
+        const parser = new PajekParser(sink, report, resolved, firstVertex, draw ?? DEFAULT_WINDOW);
         const reader = new LineReader(input, report, resolved);
         // after the first network: only its successors' headers are counted
         let rest = null;
@@ -1478,6 +1594,9 @@ export const pajekImporter = Object.freeze({
             }
         }
         parser.finish();
+        if (draw !== null || parser.voided.length > 0) {
+            report.keepForStyles({ block: parser.keptBlock, pajekDraw: draw ?? undefined, voided: parser.voided });
+        }
         if (rest !== null) {
             const objects = rest.objects > 0 ? `; ${rest.objects} *Partition / *Vector object(s) after them are not read` : "";
             report.warning("unsupported", PAJEK_ISSUE.MULTIPLE_GRAPHS, `the project file holds ${rest.count} more network${plural(rest.count)} after the first; the first is read (graphIndex or graphName chooses another; importAllGraphs() reads every one)${objects}`, { line: restLine });
@@ -1497,13 +1616,25 @@ export const pajekImporter = Object.freeze({
     async importAll(input, sinkFor, options) {
         const resolved = resolveImportOptions(options, DEFAULTS);
         const firstVertex = firstVertexOption(options?.firstVertex);
+        const draw = resolvePajekDraw(options?.pajekDraw);
         const reports = [new ImportReportBuilder("pajek", resolved.errorLimit)];
         reportUnusedOptions(options, reports[0], USED_OPTIONS);
         const open = () => {
             const report = reports[reports.length - 1];
             const sink = sinkFor(reports.length - 1);
             reportSinkOptions(sink, options, report);
-            return new PajekParser(sink, report, resolved, firstVertex);
+            return new PajekParser(sink, report, resolved, firstVertex, draw ?? DEFAULT_WINDOW);
+        };
+        const close = (p) => {
+            p.finish();
+            const last = reports.at(-1);
+            if (last !== undefined && (draw !== null || p.voided.length > 0)) {
+                last.keepForStyles({
+                    block: p.keptBlock,
+                    pajekDraw: draw ?? undefined,
+                    voided: p.voided,
+                });
+            }
         };
         let parser = open();
         // decoding issues belong to the file, so they go to the first network's report
@@ -1512,7 +1643,7 @@ export const pajekImporter = Object.freeze({
         for await (const raw of reader) {
             const text = withoutStrayBom(raw);
             if (parser.line(text, reader.line)) {
-                parser.finish();
+                close(parser);
                 reports.push(new ImportReportBuilder("pajek", resolved.errorLimit));
                 parser = open();
                 parser.line(text, reader.line);
@@ -1522,7 +1653,7 @@ export const pajekImporter = Object.freeze({
                 throwIfAborted(resolved.signal);
             }
         }
-        parser.finish();
+        close(parser);
         throwIfAborted(resolved.signal);
         return reports.map((r) => r.finish());
     },