@graphty/graph-io 0.0.0 → 0.2.0

package/dist/chunks/importer-CpCpfbxr.js

@@ -0,0 +1,2015 @@
+import { GraphFormatError, INVALID_INDEX } from "@graphty/graph-format";
+import { L as LOSS, au as joinText, ah as encodeChunks, aB as resolveExportOptions, aD as sanitizeIds, aa as checkCapabilities, aw as pairFolding, a9 as capabilities, ai as explicitWeights, al as formatF64, aj as formatDecimal, ak as formatF32, an as formatInteger, a8 as canonicalId, W as SINK_OPTION_CODE, J as OPTION_IGNORED_CODE, V as ROLE_TAKEN_CODE, S as RENAMED_CODE, n as ID_MERGED_CODE, k as DUPLICATE_NODE_CODE, Z as SYNTAX_CODE, r as INVALID_UTF8_CODE, aC as resolveImportOptions, I as ImportReportBuilder, az as reportSinkOptions, aA as reportUnusedOptions, v as LineReader, a as throwIfAborted, l as DirectionResolver, s as IdCoercer, ac as coerceIdText, af as declareResolved, at as isWeightField, ax as parseWeightText } from "./writer-DxSKC7TL.js";
+import { i as isPajekLabel, q as quotePajekLabel } from "./escape-DyI8JofU.js";
+import { W as WIDENING_UNSUPPORTED_CODE, a as isNumericText, T as TextCellWriter } from "./text-CajMdVFy.js";
+const LABEL_COLUMN = "label";
+const POSITION_COLUMN = "position";
+const SHAPE_COLUMN = "shape";
+const RELATION_COLUMN = "relation";
+const SPELLS_COLUMN = "spells";
+const VALUE_COLUMN = "value";
+const VALUE_FIELD = "value";
+const SHAPES = /* @__PURE__ */ new Set(["ellipse", "box", "diamond", "triangle", "cross", "empty"]);
+const ORIGINAL_ID_KEY = "graphty_originalId";
+const SECTION_KINDS = /* @__PURE__ */ new Map([
+  ["network", "network"],
+  ["vertices", "vertices"],
+  ["arcs", "arcs"],
+  ["edges", "edges"],
+  ["arcslist", "arcslist"],
+  ["edgeslist", "edgeslist"],
+  ["matrix", "matrix"]
+]);
+const INTEGER_TEXT = /^[+-]?[0-9]+$/;
+const TIME_POINT = /^(\*|[+-]?[0-9]+(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?)(?:-(\*|[+-]?[0-9]+(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?))?$/;
+function tokenize(line) {
+  const tokens = [];
+  let current = "";
+  let started = false;
+  let quoted = false;
+  for (let i = 0; i < line.length; i++) {
+    const c = line.charCodeAt(i);
+    if (c === 34) {
+      quoted = !quoted;
+      started = true;
+      continue;
+    }
+    if (!quoted && (c === 32 || c === 9 || c === 13 || c === 12 || c === 11)) {
+      if (started) {
+        tokens.push(current);
+        current = "";
+        started = false;
+      }
+      continue;
+    }
+    current += line[i];
+    started = true;
+  }
+  if (quoted) {
+    return null;
+  }
+  if (started) {
+    tokens.push(current);
+  }
+  return tokens;
+}
+function isCommentOrBlank(line) {
+  for (let i = 0; i < line.length; i++) {
+    const c = line.charCodeAt(i);
+    if (c === 32 || c === 9 || c === 13 || c === 12 || c === 11) {
+      continue;
+    }
+    return c === 37;
+  }
+  return true;
+}
+function isSectionLine(line) {
+  for (let i = 0; i < line.length; i++) {
+    const c = line.charCodeAt(i);
+    if (c === 32 || c === 9 || c === 13 || c === 12 || c === 11) {
+      continue;
+    }
+    return c === 42;
+  }
+  return false;
+}
+function parseSectionHeader(line) {
+  const tokens = tokenize(line.trimStart().slice(1));
+  if (tokens === null || tokens.length === 0 || tokens[0].length === 0) {
+    return null;
+  }
+  const keyword = tokens[0];
+  const kind = SECTION_KINDS.get(keyword.toLowerCase()) ?? "unsupported";
+  let count = null;
+  let secondCount = null;
+  let relation = null;
+  let name = null;
+  const extra = [];
+  let i = 1;
+  switch (kind) {
+    case "vertices":
+      if (i < tokens.length && INTEGER_TEXT.test(tokens[i])) {
+        count = Number(tokens[i]);
+        i++;
+        if (i < tokens.length && INTEGER_TEXT.test(tokens[i])) {
+          secondCount = Number(tokens[i]);
+          i++;
+        }
+      }
+      break;
+    case "arcs":
+    case "edges":
+    case "arcslist":
+    case "edgeslist":
+    case "matrix":
+      if (i < tokens.length && tokens[i].startsWith(":") && INTEGER_TEXT.test(tokens[i].slice(1))) {
+        relation = Number(tokens[i].slice(1));
+        i++;
+        if (i < tokens.length) {
+          name = tokens[i];
+          i++;
+        }
+      }
+      break;
+    case "network":
+      if (i < tokens.length) {
+        name = tokens.slice(i).join(" ");
+        i = tokens.length;
+      }
+      break;
+    case "unsupported":
+      i = tokens.length;
+      break;
+    default: {
+      const unknown = kind;
+      throw new Error(`unknown section kind ${unknown}`);
+    }
+  }
+  for (; i < tokens.length; i++) {
+    extra.push(tokens[i]);
+  }
+  return { kind, keyword, count, secondCount, relation, name, extra };
+}
+function isVertexNumber(token) {
+  if (token.length === 0) {
+    return false;
+  }
+  for (let i = 0; i < token.length; i++) {
+    const c = token.charCodeAt(i);
+    if (c < 48 || c > 57) {
+      return false;
+    }
+  }
+  return true;
+}
+function isIntervalToken(token) {
+  return token.length >= 2 && token.startsWith("[") && token.endsWith("]");
+}
+function parseIntervals(token) {
+  const body = token.slice(1, -1);
+  if (body.trim().length === 0) {
+    throw new Error(`empty time interval ${token}`);
+  }
+  const spells = [];
+  for (const part of body.split(",")) {
+    const match = TIME_POINT.exec(part.trim());
+    if (match === null) {
+      throw new Error(`malformed time interval ${token}: "${part}" is not a-b, a-* or a`);
+    }
+    const start = match[1] === "*" ? -Infinity : Number(match[1]);
+    const endText = match[2];
+    let end;
+    if (endText === void 0) {
+      end = start;
+    } else if (endText === "*") {
+      end = Infinity;
+    } else {
+      end = Number(endText);
+    }
+    if (start > end) {
+      throw new Error(`malformed time interval ${token}: ${match[1]} is after ${endText ?? ""}`);
+    }
+    spells.push([start, end]);
+  }
+  return spells;
+}
+function formatIntervals(spells) {
+  const parts = [];
+  for (const [start, end] of spells) {
+    const s = start === -Infinity ? "*" : String(start);
+    if (start === end) {
+      parts.push(s);
+    } else {
+      parts.push(`${s}-${end === Infinity ? "*" : String(end)}`);
+    }
+  }
+  return `[${parts.join(",")}]`;
+}
+function isParameterKey(text) {
+  if (text.length === 0 || /[\s"]/.test(text) || text.startsWith("[") || text.startsWith("*")) {
+    return false;
+  }
+  if (SHAPES.has(text)) {
+    return false;
+  }
+  return !/^[+-]?(\.[0-9]|[0-9])/.test(text);
+}
+const PAJEK_LOSS = Object.freeze({
+  /** A label or text value holds a double quote or a line break; export() will throw E_UNSUPPORTED. */
+  TEXT: "E_PAJEK_TEXT",
+  /** A column whose name cannot be a parameter key (whitespace, a quote, numeric, a shape keyword); skipped. */
+  KEY_DROPPED: "W_PAJEK_KEY_DROPPED",
+  /** A label role column that is not text; its values are written as text and re-import as string. */
+  LABEL_AS_TEXT: "W_PAJEK_LABEL_AS_TEXT",
+  /** A non-finite f64 value; written as Infinity / NaN text, which re-imports as string. */
+  NONFINITE_AS_TEXT: "W_PAJEK_NONFINITE_AS_TEXT",
+  /** A mutual pair; written as one undirected edge, the mark lost. */
+  MUTUAL_AS_UNDIRECTED: LOSS.MUTUAL_AS_UNDIRECTED,
+  /** A start / end / timestamp role column; Pajek intervals are written from the spells role only. */
+  TEMPORAL_DROPPED: LOSS.TEMPORAL,
+  /** A position column with a stride other than 2 or 3. */
+  POSITION_STRIDE: "W_PAJEK_POSITION_STRIDE",
+  /** meta.extra.pajek.firstMode is not a count within 0..N; the two-mode header is not written. */
+  FIRST_MODE_DROPPED: "W_PAJEK_FIRST_MODE_DROPPED",
+  /** A role column Pajek has no slot for (kind, ...) written as a plain parameter; the role is lost. */
+  ROLE_DROPPED: LOSS.ROLE,
+  /** A `shape` column with a value outside the shape keywords is written as a parameter (a string on re-import). */
+  SHAPE_AS_PARAMETER: "W_PAJEK_SHAPE_AS_PARAMETER",
+  /** A vertex line with coordinates, a shape or parameters needs a label: the id text is written and reads back as a label. */
+  LABEL_GAINED: "W_PAJEK_LABEL_GAINED",
+  /** A role-less node column named `label` reads back with the label role (its values become the vertex labels). */
+  ROLE_ASSUMED: LOSS.ROLE_ASSUMED,
+  /** Under sanitizeIds "mangle": an original id whose text reads back as the other type under ids "canonical". */
+  ID_TEXT_TYPE: LOSS.ID_TEXT_TYPE
+});
+const SLOT_ROLES = /* @__PURE__ */ new Set(["label"]);
+const ROLE_NAMES = Object.freeze({ label: "label" });
+const STRUCTURAL_ROLES = /* @__PURE__ */ new Set([
+  "directed",
+  "pair",
+  "mutual",
+  "weight",
+  "timeText",
+  "originalId"
+]);
+const CHECKED_ROLES = /* @__PURE__ */ new Set([
+  "color",
+  "size",
+  "shape",
+  "thickness",
+  "parent",
+  "parents",
+  "open"
+]);
+const DROPPED_TEMPORAL_ROLES = /* @__PURE__ */ new Set(["start", "end", "timestamp", "timestamps"]);
+const CAPABILITIES = capabilities({
+  mixedDirection: true,
+  multiEdges: true,
+  selfLoops: true,
+  edgeIds: "none",
+  idCharset: "dense-1-based",
+  dtypes: ["f64", "i32", "bool", "string"],
+  temporal: "spells",
+  positions: true
+});
+function plan(table, domain, notes) {
+  const planned = [];
+  const rows = (column) => column.length - column.nullCount;
+  for (const column of table) {
+    const { meta } = column;
+    const { role, name, dtype } = meta;
+    if (role === "label" && domain === "node") {
+      if (dtype !== "string" && dtype !== "dict" && notes !== null) {
+        notes.push(
+          note(
+            PAJEK_LOSS.LABEL_AS_TEXT,
+            `node column "${name}" (label) is ${dtype}; labels are text and re-import as string`,
+            name,
+            rows(column)
+          )
+        );
+      }
+      planned.push({ column, slot: "label" });
+      continue;
+    }
+    if (role === "position") {
+      if (domain === "node" && (meta.components === 2 || meta.components === 3)) {
+        planned.push({ column, slot: "position" });
+      } else if (notes !== null && domain === "node") {
+        notes.push(
+          note(
+            PAJEK_LOSS.POSITION_STRIDE,
+            `node column "${name}" (position) has ${meta.components} components; Pajek coordinates are x y [z]`,
+            name,
+            rows(column)
+          )
+        );
+      } else if (notes !== null) {
+        notes.push(
+          note(LOSS.POSITIONS, `edge column "${name}" (position) cannot be written`, name, rows(column))
+        );
+      }
+      continue;
+    }
+    if (role === "spells") {
+      if (dtype === "list" && (meta.itemDtype === "f64" || meta.itemDtype === "i32" || meta.itemDtype === "f32")) {
+        planned.push({ column, slot: "spells" });
+        continue;
+      }
+      if (notes !== null) {
+        notes.push(
+          note(
+            LOSS.SPELLS,
+            `${domain} column "${name}" (spells) is not a list of number pairs; it cannot be written`,
+            name,
+            rows(column)
+          )
+        );
+      }
+      continue;
+    }
+    if (role !== null && DROPPED_TEMPORAL_ROLES.has(role)) {
+      if (notes !== null) {
+        notes.push(
+          note(
+            PAJEK_LOSS.TEMPORAL_DROPPED,
+            `${domain} column "${name}" (${role}) cannot be written; Pajek intervals come from the spells role`,
+            name,
+            rows(column)
+          )
+        );
+      }
+      continue;
+    }
+    if (role !== null && (STRUCTURAL_ROLES.has(role) || CHECKED_ROLES.has(role))) {
+      continue;
+    }
+    if (domain === "edge" && role === "id") {
+      continue;
+    }
+    if (dtype === "list" || dtype === "json") {
+      continue;
+    }
+    if (domain === "node" && name === SHAPE_COLUMN && (dtype === "dict" || dtype === "string")) {
+      if (allShapeKeywords(column)) {
+        planned.push({ column, slot: "shape" });
+        continue;
+      }
+      if (notes !== null && dtype === "dict") {
+        notes.push(
+          note(
+            PAJEK_LOSS.SHAPE_AS_PARAMETER,
+            `node column "${name}" holds values outside the Pajek shape keywords; it is written as a parameter and reads back as string`,
+            name,
+            rows(column)
+          )
+        );
+      }
+      planned.push({ column, slot: "param" });
+      continue;
+    }
+    if (domain === "edge" && name === RELATION_COLUMN && (dtype === "dict" || dtype === "string")) {
+      planned.push({ column, slot: "relation" });
+      continue;
+    }
+    if (!isParameterKey(name)) {
+      if (notes !== null) {
+        notes.push(
+          note(
+            PAJEK_LOSS.KEY_DROPPED,
+            `${domain} column "${name}" cannot be a Pajek parameter key; it is not written`,
+            name,
+            rows(column)
+          )
+        );
+      }
+      continue;
+    }
+    planned.push({ column, slot: "param" });
+  }
+  return planned;
+}
+function labelNotes(snapshot, nodePlan, notes) {
+  let labels = null;
+  let carried = 0;
+  for (const { column, slot } of nodePlan) {
+    if (slot === "label") {
+      labels = column;
+    } else if (slot !== "skip" && slot !== "relation") {
+      carried++;
+    }
+  }
+  const plain = [...snapshot.nodes].find((c) => c.meta.role === null && c.meta.name === LABEL_COLUMN);
+  if (plain !== void 0) {
+    notes.push(
+      note(
+        PAJEK_LOSS.ROLE_ASSUMED,
+        `node column "${LABEL_COLUMN}" has no role; written as a parameter, it reads back as the vertex label (role label)`,
+        LABEL_COLUMN,
+        plain.length - plain.nullCount
+      )
+    );
+  }
+  if (carried === 0) {
+    return;
+  }
+  let gained = 0;
+  for (let i = 0; i < snapshot.nodeCount; i++) {
+    if (labels === null || !labels.isSet(i)) {
+      gained++;
+    }
+  }
+  if (gained > 0) {
+    notes.push(
+      note(
+        PAJEK_LOSS.LABEL_GAINED,
+        `${gained} vertex line(s) carry coordinates, a shape or parameters and need a label; the id text is written there and reads back as a label`,
+        labels === null ? LABEL_COLUMN : labels.meta.name,
+        gained
+      )
+    );
+  }
+}
+function allShapeKeywords(column) {
+  for (let r = 0; r < column.length; r++) {
+    if (column.isSet(r) && !SHAPES.has(column.value(r))) {
+      return false;
+    }
+  }
+  return true;
+}
+function note(code, message, column = null, count = null) {
+  return Object.freeze({ code, message, column, count });
+}
+function numberText(value, dtype) {
+  switch (dtype) {
+    case "i32":
+    case "u32":
+    case "u8":
+      return formatInteger(value);
+    case "f32":
+      return formatF32(value);
+    case "f64":
+      return formatDecimal(value, "f64");
+    default: {
+      const name = dtype;
+      throw new Error(`unknown numeric dtype ${name}`);
+    }
+  }
+}
+function cellText(column, row) {
+  switch (column.dtype) {
+    case "f32":
+    case "f64":
+    case "i32":
+    case "u32":
+    case "u8": {
+      const value = column.value(row);
+      if (typeof value === "number") {
+        return numberText(value, column.dtype);
+      }
+      const parts = [];
+      const vector = value;
+      for (let k = 0; k < vector.length; k++) {
+        parts.push(numberText(vector[k], column.dtype));
+      }
+      return parts.join(" ");
+    }
+    case "bool":
+      return column.value(row) === true ? "true" : "false";
+    case "dict":
+    case "string":
+      return column.value(row);
+    case "list":
+    case "json":
+      return JSON.stringify(column.value(row));
+    default: {
+      const name = column.dtype;
+      throw new Error(`unknown dtype ${name}`);
+    }
+  }
+}
+function checkCells(planned, domain, notes) {
+  for (const { column, slot } of planned) {
+    if (slot === "position" || slot === "spells") {
+      continue;
+    }
+    const { name } = column.meta;
+    let badText = 0;
+    let nonFinite = 0;
+    for (let r = 0; r < column.length; r++) {
+      if (!column.isSet(r)) {
+        continue;
+      }
+      if (column.dtype === "f64" || column.dtype === "f32") {
+        const value = column.value(r);
+        if (typeof value === "number") {
+          if (!Number.isFinite(value)) {
+            nonFinite++;
+          }
+        } else if (value !== void 0 && !Array.from(value).every((v) => Number.isFinite(v))) {
+          nonFinite++;
+        }
+      } else if (column.dtype === "string" || column.dtype === "dict") {
+        if (!isPajekLabel(column.value(r))) {
+          badText++;
+        }
+      }
+    }
+    if (badText > 0) {
+      notes.push(
+        note(
+          PAJEK_LOSS.TEXT,
+          `${badText} value(s) of ${domain} column "${name}" hold a double quote or a line break; Pajek cannot write them`,
+          name,
+          badText
+        )
+      );
+    }
+    if (nonFinite > 0) {
+      notes.push(
+        note(
+          PAJEK_LOSS.NONFINITE_AS_TEXT,
+          `${nonFinite} non-finite value(s) of ${domain} column "${name}" are written as text`,
+          name,
+          nonFinite
+        )
+      );
+    }
+  }
+}
+function firstModeOf(snapshot) {
+  const { pajek } = snapshot.meta.extra;
+  if (typeof pajek !== "object" || pajek === null) {
+    return null;
+  }
+  const value = pajek.firstMode;
+  if (value === void 0) {
+    return null;
+  }
+  if (typeof value === "number" && Number.isInteger(value) && value >= 0 && value <= snapshot.nodeCount) {
+    return value;
+  }
+  return NaN;
+}
+function labelOf(labels, ids, i, needed) {
+  if (labels !== null && labels.isSet(i)) {
+    return cellText(labels, i);
+  }
+  if (needed || ids.isChanged(i)) {
+    return idText(ids.originalAt(i));
+  }
+  return null;
+}
+function idText(id) {
+  return typeof id === "number" ? formatF64(id) : id;
+}
+function spellsText(column, row) {
+  if (column.dtype !== "list" || !column.isSet(row)) {
+    return null;
+  }
+  const items = column.sliceOf(row);
+  if (items.length === 0) {
+    return null;
+  }
+  const pairs = [];
+  for (const item of items) {
+    const pair = item;
+    pairs.push([pair[0], pair[1]]);
+  }
+  return formatIntervals(pairs);
+}
+function coordinatesText(column, i, writeZ) {
+  if (!column.isSet(i)) {
+    return null;
+  }
+  const dtype = column.dtype;
+  const vector = column.value(i);
+  const x = numberText(vector[0], dtype);
+  const y = numberText(vector[1], dtype);
+  if (column.meta.components === 3 && writeZ) {
+    return `${x} ${y} ${numberText(vector[2], dtype)}`;
+  }
+  return `${x} ${y}`;
+}
+function needsZ(column) {
+  if (column.meta.components !== 3) {
+    return false;
+  }
+  if (column.meta.extra.sourceDims !== 2) {
+    return true;
+  }
+  for (let i = 0; i < column.length; i++) {
+    if (column.isSet(i)) {
+      const vector = column.value(i);
+      if (vector[2] !== 0) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function* writeParts(snapshot, options) {
+  const ids = sanitizeIds(snapshot, CAPABILITIES.idCharset, options.mangle ? "mangle" : "error");
+  const nodePlan = withoutReservedKey(plan(snapshot.nodes, "node", null), options.mangle);
+  const edgePlan = plan(snapshot.edges, "edge", null);
+  const preflight = [];
+  checkCells(nodePlan, "node", preflight);
+  checkCells(edgePlan, "edge", preflight);
+  checkIdTexts(snapshot.nodeCount, ids, options.mangle, preflight);
+  for (const n of preflight) {
+    if (n.code === PAJEK_LOSS.TEXT) {
+      throw new GraphFormatError("E_UNSUPPORTED", n.message, {
+        reason: "pajek label",
+        column: n.column,
+        count: n.count
+      });
+    }
+  }
+  if (options.networkHeader && snapshot.meta.name !== null) {
+    yield `*Network ${snapshot.meta.name}
+`;
+  }
+  const firstMode = firstModeOf(snapshot);
+  yield firstMode !== null && !Number.isNaN(firstMode) ? `*Vertices ${snapshot.nodeCount} ${firstMode}
+` : `*Vertices ${snapshot.nodeCount}
+`;
+  yield* writeVertices(snapshot, ids, nodePlan, options.mangle);
+  yield* writeLines(snapshot, edgePlan);
+}
+function withoutReservedKey(nodePlan, mangle) {
+  if (!mangle) {
+    return nodePlan;
+  }
+  return nodePlan.filter((p) => !(p.slot === "param" && p.column.meta.name === ORIGINAL_ID_KEY));
+}
+function checkIdTexts(nodeCount, ids, mangle, notes) {
+  let badText = 0;
+  let typeChanged = 0;
+  for (let i = 0; i < nodeCount; i++) {
+    if (!ids.isChanged(i)) {
+      continue;
+    }
+    const original = ids.originalAt(i);
+    const text = idText(original);
+    if (!isPajekLabel(text)) {
+      badText++;
+    } else if (mangle && typeof canonicalId(text) !== typeof original) {
+      typeChanged++;
+    }
+  }
+  if (badText > 0) {
+    notes.push(
+      note(
+        PAJEK_LOSS.TEXT,
+        `${badText} node id(s) hold a double quote or a line break; Pajek cannot write them as labels or parameters`,
+        null,
+        badText
+      )
+    );
+  }
+  if (typeChanged > 0) {
+    notes.push(
+      note(
+        PAJEK_LOSS.ID_TEXT_TYPE,
+        `${typeChanged} original id(s) read back from ${ORIGINAL_ID_KEY} as the other type under ids: "canonical" (a string "1" becomes 1, a number 1.5 becomes "1.5")`,
+        null,
+        typeChanged
+      )
+    );
+  }
+}
+function* writeVertices(snapshot, ids, nodePlan, mangle) {
+  let labels = null;
+  let position = null;
+  let shape = null;
+  let nodeSpells = null;
+  const nodeParams = [];
+  for (const { column, slot } of nodePlan) {
+    switch (slot) {
+      case "label":
+        labels = column;
+        break;
+      case "position":
+        position = column;
+        break;
+      case "shape":
+        shape = column;
+        break;
+      case "spells":
+        nodeSpells = column;
+        break;
+      case "param":
+        nodeParams.push(column);
+        break;
+      case "relation":
+      case "skip":
+        break;
+      default: {
+        const name = slot;
+        throw new Error(`unknown slot ${name}`);
+      }
+    }
+  }
+  const writeZ = position !== null && needsZ(position);
+  for (let i = 0; i < snapshot.nodeCount; i++) {
+    const parts = [];
+    if (position !== null) {
+      const coordinates = coordinatesText(position, i, writeZ);
+      if (coordinates !== null) {
+        parts.push(coordinates);
+      }
+    }
+    if (shape !== null && shape.isSet(i)) {
+      const keyword = cellText(shape, i);
+      if (SHAPES.has(keyword)) {
+        parts.push(keyword);
+      } else {
+        parts.push(`${SHAPE_COLUMN} ${quotePajekLabel(keyword)}`);
+      }
+    }
+    for (const column of nodeParams) {
+      if (column.isSet(i)) {
+        parts.push(`${column.meta.name} ${quotePajekLabel(cellText(column, i))}`);
+      }
+    }
+    if (mangle && ids.isChanged(i)) {
+      parts.push(`${ORIGINAL_ID_KEY} ${quotePajekLabel(idText(ids.originalAt(i)))}`);
+    }
+    if (nodeSpells !== null) {
+      const spells = spellsText(nodeSpells, i);
+      if (spells !== null) {
+        parts.push(spells);
+      }
+    }
+    const label = labelOf(labels, ids, i, parts.length > 0);
+    let line = String(i + 1);
+    if (label !== null) {
+      line += ` ${quotePajekLabel(label)}`;
+    }
+    if (parts.length > 0) {
+      line += ` ${parts.join(" ")}`;
+    }
+    yield `${line}
+`;
+  }
+}
+function* writeLines(snapshot, edgePlan) {
+  const folding = pairFolding(snapshot, { foldMutual: true });
+  const weights = explicitWeights(snapshot);
+  const { src, dst } = snapshot.edgeList();
+  let relation = null;
+  let edgeSpells = null;
+  const edgeParams = [];
+  for (const { column, slot } of edgePlan) {
+    switch (slot) {
+      case "relation":
+        relation = column;
+        break;
+      case "spells":
+        edgeSpells = column;
+        break;
+      case "param":
+        edgeParams.push(column);
+        break;
+      case "label":
+      case "position":
+      case "shape":
+      case "skip":
+        break;
+      default: {
+        const name = slot;
+        throw new Error(`unknown slot ${name}`);
+      }
+    }
+  }
+  const relationNumbers = /* @__PURE__ */ new Map();
+  let currentKind = null;
+  let currentRelation = null;
+  let sectionOpen = false;
+  for (let e = 0; e < snapshot.edgeCount; e++) {
+    if (folding.folded(e)) {
+      continue;
+    }
+    const directed = snapshot.directed && folding.sourceDirected(e) && !folding.isMutual(e);
+    const kind = directed ? "arcs" : "edges";
+    const relationName = relation !== null && relation.isSet(e) ? cellText(relation, e) : null;
+    if (!sectionOpen || kind !== currentKind || relationName !== currentRelation) {
+      currentKind = kind;
+      currentRelation = relationName;
+      sectionOpen = true;
+      const keyword = kind === "arcs" ? "*Arcs" : "*Edges";
+      if (relationName === null) {
+        yield `${keyword}
+`;
+      } else {
+        let number = relationNumbers.get(relationName);
+        if (number === void 0) {
+          number = relationNumbers.size + 1;
+          relationNumbers.set(relationName, number);
+        }
+        yield `${keyword} :${number} ${quotePajekLabel(relationName)}
+`;
+      }
+    }
+    let line = `${src[e] + 1} ${dst[e] + 1}`;
+    const weight = weights.text(e);
+    if (weight !== null) {
+      line += ` ${weight}`;
+    }
+    for (const column of edgeParams) {
+      if (column.isSet(e)) {
+        line += ` ${column.meta.name} ${quotePajekLabel(cellText(column, e))}`;
+      }
+    }
+    if (edgeSpells !== null) {
+      const spells = spellsText(edgeSpells, e);
+      if (spells !== null) {
+        line += ` ${spells}`;
+      }
+    }
+    yield `${line}
+`;
+  }
+  if (!sectionOpen) {
+    yield snapshot.directed ? "*Arcs\n" : "*Edges\n";
+  }
+}
+function resolvePajekOptions(options) {
+  const common = resolveExportOptions(options);
+  const value = options?.networkHeader;
+  if (value !== void 0 && typeof value !== "boolean") {
+    throw new GraphFormatError("E_UNSUPPORTED", "option networkHeader: not a boolean", {
+      option: "networkHeader",
+      found: typeof value
+    });
+  }
+  return { networkHeader: value ?? false, mangle: common.sanitizeIds === "mangle" };
+}
+const pajekExporter = Object.freeze({
+  format: "pajek",
+  capabilities: CAPABILITIES,
+  /**
+   * Pre-flight: the generic capability gaps plus the Pajek-specific ones.
+   * @param snapshot - the snapshot
+   * @param options - export options
+   * @returns the loss notes, empty when the export is exact
+   */
+  check(snapshot, options) {
+    const resolved = resolveExportOptions(options);
+    const { mangle } = resolvePajekOptions(options);
+    const notes = [];
+    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 !== void 0) {
+        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 = /* @__PURE__ */ new Set();
+    for (const { column, slot } of [...nodePlan, ...edgePlan]) {
+      if (slot === "shape" || slot === "relation") {
+        owned.add(`${column.meta.domain}:${column.meta.name}`);
+      } else if (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
+    })) {
+      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;
+        }
+      }
+      if (n.code === LOSS.COLUMN_NAME_CHANGED && n.message.startsWith("edge 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(s) 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;
+  },
+  /**
+   * Write the snapshot as UTF-8 chunks.
+   * @param snapshot - the snapshot
+   * @param options - export options
+   * @returns the chunks
+   */
+  export(snapshot, options) {
+    const resolved = resolvePajekOptions(options);
+    return encodeChunks(writeParts(snapshot, resolved));
+  },
+  /**
+   * Write the snapshot as one string.
+   * @param snapshot - the snapshot
+   * @param options - export options
+   * @returns the document
+   */
+  exportToString(snapshot, options) {
+    const resolved = resolvePajekOptions(options);
+    return joinText(writeParts(snapshot, resolved));
+  }
+});
+const PAJEK_ISSUE = Object.freeze({
+  /** The input holds invalid UTF-8 (fatal). */
+  INVALID_UTF8: INVALID_UTF8_CODE,
+  /** Fatal: no `*Vertices` section (an empty file, or not a Pajek network). */
+  NO_VERTICES: "E_PAJEK_NO_VERTICES",
+  /** Fatal: `*Vertices` without a vertex count, or one the sink cannot hold. */
+  VERTICES_COUNT: "E_PAJEK_VERTICES_COUNT",
+  /** Aborts: a second `*Vertices` or `*Network` section; only one network per file is read. */
+  MULTIPLE_NETWORKS: "E_PAJEK_MULTIPLE_NETWORKS",
+  /** A data line before the first section header. */
+  OUTSIDE_SECTION: "E_PAJEK_OUTSIDE_SECTION",
+  /** A section header the importer cannot parse. */
+  SYNTAX: SYNTAX_CODE,
+  /** A double quote not closed before the end of the line. */
+  UNTERMINATED_QUOTE: "E_PAJEK_UNTERMINATED_QUOTE",
+  /** A vertex line the grammar does not accept. */
+  VERTEX_LINE: "E_PAJEK_VERTEX_LINE",
+  /** A vertex number outside the declared range. */
+  VERTEX_RANGE: "E_PAJEK_VERTEX_RANGE",
+  /** Fewer vertex lines than `*Vertices` declares (vertices without a line have no label). */
+  VERTEX_COUNT: "E_PAJEK_VERTEX_COUNT",
+  /** A second line for the same vertex; the later values overwrite. */
+  DUPLICATE_NODE: DUPLICATE_NODE_CODE,
+  /** A line (arc, edge, list or matrix row) the grammar does not accept. */
+  LINE: "E_PAJEK_LINE",
+  /** A line endpoint outside the declared vertex range (the core's code, forwarded). */
+  UNKNOWN_NODE: "E_UNKNOWN_NODE",
+  /** A malformed time interval token. */
+  INTERVAL: "E_PAJEK_INTERVAL",
+  /** A `*Matrix` section with the wrong number of rows. */
+  MATRIX_ROWS: "E_PAJEK_MATRIX_ROWS",
+  /** A project-file section (`*Partition`, `*Vector`, ...) the importer does not read. */
+  UNSUPPORTED_SECTION: "E_PAJEK_UNSUPPORTED_SECTION",
+  /** Tokens after a section header the grammar does not account for. */
+  HEADER_EXTRA: "W_PAJEK_HEADER_EXTRA",
+  /** The file declares vertices but no line section. */
+  NO_LINES: "W_PAJEK_NO_LINES",
+  /** Vertex numbering starts at 0 rather than 1. */
+  ZERO_BASED: "W_PAJEK_ZERO_BASED",
+  /** Vertex lines mix two and three coordinates. */
+  COORD_DIMS: "W_PAJEK_COORD_DIMS",
+  /** Two vertices share a label under nodeIdFrom "label" and became one node. */
+  LABEL_MERGED: "W_PAJEK_LABEL_MERGED",
+  /** Two distinct label texts became one numeric id under ids "number". */
+  ID_MERGED: ID_MERGED_CODE,
+  /** A parameter column of `2.0`-style text kept at the value-inferred dtype (the sink cannot widen). */
+  WIDENING_UNSUPPORTED: WIDENING_UNSUPPORTED_CODE,
+  /** A structural column (label, position, shape, spells, relation) renamed `<name>#<id>` because the name was taken (design section 5.6). */
+  COLUMN_RENAMED: RENAMED_CODE,
+  /** A structural column declared without its role because the sink already holds it. */
+  ROLE_TAKEN: ROLE_TAKEN_CODE,
+  /** Two vertices carry the same `graphty_originalId` under restoreMangledIds and became one node. */
+  ORIGINAL_ID_MERGED: "W_PAJEK_ORIGINAL_ID_MERGED",
+  /** A vertex line's `graphty_originalId` came after a later vertex's line had created it under its number. */
+  ORIGINAL_ID_UNRESTORED: "W_PAJEK_ORIGINAL_ID_UNRESTORED",
+  /** A common option the importer has no use for (weightFrom naming a parameter and restoreMangledIds are honoured; long, hyperedges are not). */
+  OPTION_IGNORED: OPTION_IGNORED_CODE,
+  /** A builder-policy option the caller passed that the caller's sink does not use (the shared W_SINK_OPTION). */
+  SINK_OPTION: SINK_OPTION_CODE
+});
+const USED_OPTIONS = /* @__PURE__ */ new Set([
+  "ids",
+  "nodeIdFrom",
+  "restoreMangledIds",
+  "addMissingNodes",
+  "duplicateEdges",
+  "selfLoops",
+  "onMixedDirection",
+  "defaultDirected",
+  "weightFrom",
+  "weightDtype",
+  "errorLimit",
+  "signal",
+  "onProgress"
+]);
+const DEFAULTS = { ids: "canonical", defaultDirected: true, weightFrom: VALUE_FIELD };
+const ABORT_CHECK_INTERVAL = 64;
+const FIRST_VERTEX_VALUES = /* @__PURE__ */ new Set([0, 1, "auto"]);
+const LABEL_DECL = {
+  name: LABEL_COLUMN,
+  dtype: "string",
+  nullable: true,
+  role: "label",
+  origin: { format: "pajek", id: "label" }
+};
+const SHAPE_DECL = {
+  name: SHAPE_COLUMN,
+  dtype: "dict",
+  nullable: true,
+  origin: { format: "pajek", id: "shape" }
+};
+const RELATION_DECL = {
+  name: RELATION_COLUMN,
+  dtype: "dict",
+  nullable: true,
+  origin: { format: "pajek", id: "relation" }
+};
+function spellsDecl() {
+  return {
+    name: SPELLS_COLUMN,
+    dtype: "list",
+    itemDtype: "f64",
+    itemComponents: 2,
+    nullable: true,
+    role: "spells",
+    origin: { format: "pajek", id: "interval" }
+  };
+}
+function positionDecl(sourceDims) {
+  return {
+    name: POSITION_COLUMN,
+    dtype: "f32",
+    components: 3,
+    nullable: true,
+    role: "position",
+    origin: { format: "pajek", id: "coordinates" },
+    extra: { sourceDims, units: "file" }
+  };
+}
+class LineError extends Error {
+  /**
+   * Create a line error.
+   * @param category - the issue category
+   * @param code - the issue code
+   * @param message - a plain-ASCII message
+   */
+  constructor(category, code, message) {
+    super(message);
+    this.name = "PajekLineError";
+    this.category = category;
+    this.code = code;
+  }
+}
+class PajekParser {
+  /**
+   * Create the parser for one import call.
+   * @param sink - the sink
+   * @param report - the report
+   * @param options - the resolved common options
+   * @param firstVertex - the firstVertex format option
+   */
+  constructor(sink, report, options, firstVertex) {
+    this.section = "none";
+    this.kind = "directed";
+    this.relation = null;
+    this.vertexCount = -1;
+    this.firstMode = null;
+    this.networkName = null;
+    this.base = 1;
+    this.baseKnown = false;
+    this.nodesCreated = false;
+    this.verticesDone = false;
+    this.sawLineSection = false;
+    this.indexOfPos = new Uint32Array(0);
+    this.idOfPos = null;
+    this.seen = new Uint8Array(0);
+    this.seenCount = 0;
+    this.filledBelow = 0;
+    this.matrixRows = 0;
+    this.coordDims = 0;
+    this.labelHandle = INVALID_INDEX;
+    this.positionHandle = INVALID_INDEX;
+    this.shapeHandle = INVALID_INDEX;
+    this.nodeSpellsHandle = INVALID_INDEX;
+    this.relationHandle = INVALID_INDEX;
+    this.edgeSpellsHandle = INVALID_INDEX;
+    this.nodeParams = /* @__PURE__ */ new Map();
+    this.edgeParams = /* @__PURE__ */ new Map();
+    this.sink = sink;
+    this.report = report;
+    this.options = options;
+    this.firstVertex = firstVertex;
+    this.resolver = new DirectionResolver(sink, report, options.onMixedDirection);
+    this.coercer = new IdCoercer(options.ids);
+  }
+  /**
+   * Handle one line; every problem of the line is recorded as an issue and the line skipped.
+   * @param text - the line without its terminator
+   * @param line - the 1-based line number
+   */
+  line(text, line) {
+    if (isCommentOrBlank(text)) {
+      return;
+    }
+    try {
+      if (isSectionLine(text)) {
+        this.header(text, line);
+        return;
+      }
+      switch (this.section) {
+        case "none":
+          throw new LineError(
+            "parse-error",
+            PAJEK_ISSUE.OUTSIDE_SECTION,
+            "data before the first section header; a Pajek network starts with *Vertices"
+          );
+        case "vertices":
+          this.vertexLine(text, line);
+          return;
+        case "lines":
+          this.edgeLine(text, line);
+          return;
+        case "list":
+          this.listLine(text, line);
+          return;
+        case "matrix":
+          this.matrixLine(text, line);
+          return;
+        case "skip":
+          return;
+        default: {
+          const name = this.section;
+          throw new Error(`unknown section state ${name}`);
+        }
+      }
+    } catch (err) {
+      if (err instanceof LineError) {
+        this.report.error(err.category, err.code, err.message, { line });
+        return;
+      }
+      this.report.recordError(err, { line });
+    }
+  }
+  /**
+   * End of input: the vertex set is completed, a network without line sections gets the default
+   * direction, and the metadata is written.
+   */
+  finish() {
+    if (this.vertexCount < 0) {
+      this.report.fail(PAJEK_ISSUE.NO_VERTICES, "not a Pajek network: no *Vertices section found");
+    }
+    this.endSection();
+    this.finishVertices();
+    if (!this.sawLineSection) {
+      this.report.warning(
+        "validation-error",
+        PAJEK_ISSUE.NO_LINES,
+        "the file declares vertices but no *Arcs, *Edges, *Arcslist, *Edgeslist or *Matrix section"
+      );
+      this.resolver.setHeader(this.options.defaultDirected);
+    }
+    if (this.coercer.mergeCount > 0) {
+      this.report.warning(
+        "coercion",
+        PAJEK_ISSUE.ID_MERGED,
+        `${this.coercer.mergeCount} label(s) merged into an id another label already produced under ids "number"`
+      );
+    }
+    const meta = {
+      sourceFormat: "pajek",
+      ...this.networkName === null ? {} : { name: this.networkName },
+      ...this.firstMode === null ? {} : { extra: { pajek: { firstMode: this.firstMode } } }
+    };
+    this.sink.setMeta(meta);
+  }
+  // ============================================================ headers
+  /**
+   * A section header line.
+   * @param text - the line
+   * @param line - the line number
+   */
+  header(text, line) {
+    const skipping = this.section === "skip";
+    this.endSection();
+    const h = parseSectionHeader(text);
+    if (h === null) {
+      this.section = "skip";
+      throw new LineError("parse-error", PAJEK_ISSUE.SYNTAX, `cannot read the section header "${text}"`);
+    }
+    if (h.extra.length > 0) {
+      this.report.warning(
+        "validation-error",
+        PAJEK_ISSUE.HEADER_EXTRA,
+        `ignored ${h.extra.length} unexpected token(s) after *${h.keyword}: ${h.extra.join(" ")}`,
+        { line }
+      );
+    }
+    switch (h.kind) {
+      case "network":
+        if (this.networkName !== null || this.vertexCount >= 0) {
+          this.refuseSecondNetwork(h.keyword, line);
+        }
+        this.networkName = h.name ?? "";
+        this.section = "none";
+        return;
+      case "vertices":
+        if (skipping && this.vertexCount >= 0) {
+          this.section = "skip";
+          return;
+        }
+        this.verticesHeader(h, line);
+        return;
+      case "arcs":
+      case "edges":
+        this.lineSection(h, line, "lines", h.kind === "arcs" ? "directed" : "undirected");
+        return;
+      case "arcslist":
+      case "edgeslist":
+        this.lineSection(h, line, "list", h.kind === "arcslist" ? "directed" : "undirected");
+        return;
+      case "matrix":
+        this.lineSection(h, line, "matrix", "directed");
+        this.matrixRows = 0;
+        return;
+      case "unsupported":
+        this.section = "skip";
+        this.report.error(
+          "unsupported",
+          PAJEK_ISSUE.UNSUPPORTED_SECTION,
+          `the *${h.keyword} section is not supported; its lines are skipped`,
+          { line }
+        );
+        return;
+      default: {
+        const name = h.kind;
+        throw new Error(`unknown section kind ${name}`);
+      }
+    }
+  }
+  /**
+   * `*Vertices N [N1]`.
+   * @param h - the header
+   * @param line - the line number
+   */
+  verticesHeader(h, line) {
+    if (this.vertexCount >= 0) {
+      this.refuseSecondNetwork(h.keyword, line);
+    }
+    if (h.count === null) {
+      this.report.fail(PAJEK_ISSUE.VERTICES_COUNT, "*Vertices needs a vertex count", { line });
+    }
+    if (!Number.isSafeInteger(h.count)) {
+      this.report.fail(PAJEK_ISSUE.VERTICES_COUNT, `*Vertices ${h.count}: not a count`, { line });
+    }
+    try {
+      this.sink.reserve(h.count);
+    } catch (err) {
+      const reason = err instanceof Error ? err.message : String(err);
+      this.report.fail(
+        PAJEK_ISSUE.VERTICES_COUNT,
+        `*Vertices ${h.count}: the sink cannot hold that many (${reason})`,
+        {
+          line
+        }
+      );
+    }
+    this.vertexCount = h.count;
+    if (h.secondCount !== null) {
+      this.firstMode = h.secondCount;
+    }
+    this.section = "vertices";
+    this.indexOfPos = new Uint32Array(h.count);
+    this.seen = new Uint8Array(h.count);
+    this.filledBelow = 0;
+    if (this.options.nodeIdFrom === "label" || this.restoresIds()) {
+      this.idOfPos = new Array(h.count);
+    }
+    if (this.firstVertex !== "auto") {
+      this.setBase(this.firstVertex, line);
+    }
+  }
+  /**
+   * A line section header: the vertex set is completed, the first one sets the sink's direction
+   * (rule 1 of design section 8.4), later ones only switch the kind.
+   * @param h - the header
+   * @param line - the line number
+   * @param section - the parser state for the section
+   * @param kind - the direction of its lines
+   */
+  lineSection(h, line, section, kind) {
+    if (this.vertexCount < 0) {
+      this.report.fail(
+        PAJEK_ISSUE.NO_VERTICES,
+        `*${h.keyword} before *Vertices; a Pajek network starts with *Vertices`,
+        { line }
+      );
+    }
+    this.finishVertices();
+    if (!this.sawLineSection) {
+      this.sawLineSection = true;
+      this.resolver.setHeader(kind === "directed", { line });
+    }
+    this.section = section;
+    this.kind = kind;
+    this.relation = h.relation === null ? null : h.name ?? String(h.relation);
+  }
+  /**
+   * Refuse a second network: an issue, then ImportError with the report so far.
+   * @param keyword - the header keyword
+   * @param line - the line number
+   */
+  refuseSecondNetwork(keyword, line) {
+    const message = `*${keyword} starts a second network; the importer reads one network per file`;
+    this.report.error("unsupported", PAJEK_ISSUE.MULTIPLE_NETWORKS, message, { line });
+    throw this.report.abort(message, { code: PAJEK_ISSUE.MULTIPLE_NETWORKS, line });
+  }
+  /**
+   * Checks that run when a section ends.
+   */
+  endSection() {
+    if (this.section === "matrix" && this.matrixRows !== this.vertexCount) {
+      this.report.error(
+        "validation-error",
+        PAJEK_ISSUE.MATRIX_ROWS,
+        `*Matrix has ${this.matrixRows} row(s); *Vertices declares ${this.vertexCount}`
+      );
+    }
+    this.section = "none";
+  }
+  // ============================================================ vertices
+  /**
+   * Fix the vertex numbering base and, under nodeIdFrom "id" / "index", create the declared
+   * vertices in number order so the id map is identity.
+   * @param base - 0 or 1
+   * @param line - the line number
+   */
+  setBase(base, line) {
+    this.base = base;
+    this.baseKnown = true;
+    if (base === 0) {
+      this.report.warning(
+        "coercion",
+        PAJEK_ISSUE.ZERO_BASED,
+        "vertex numbering starts at 0; Pajek numbers vertices from 1",
+        { line }
+      );
+    }
+  }
+  /**
+   * Push vertices base..base+N-1 in order (nodeIdFrom "id" / "index"), so the id map is identity;
+   * called on the first vertex line (once it is known that the lines carry no `graphty_originalId`
+   * parameter to restore) or when the vertex section ends without one.
+   */
+  createNodes() {
+    if (this.nodesCreated || this.idOfPos !== null) {
+      return;
+    }
+    this.nodesCreated = true;
+    const n = this.vertexCount;
+    const { sink } = this;
+    for (let pos = 0; pos < n; pos++) {
+      this.indexOfPos[pos] = sink.addNode(this.idOfNumber(pos + this.base));
+    }
+    this.report.counts.nodes += n;
+  }
+  /**
+   * The id of a vertex number under nodeIdFrom "id" (the number coerced by the ids rule) or
+   * "index" (the position).
+   * @param k - the vertex number
+   * @returns the id
+   */
+  idOfNumber(k) {
+    if (this.options.nodeIdFrom === "index") {
+      return k - this.base;
+    }
+    switch (this.options.ids) {
+      case "canonical":
+      case "number":
+        return k;
+      case "keep":
+      case "string":
+        return String(k);
+      default:
+        return coerceIdText(String(k), this.options.ids);
+    }
+  }
+  /**
+   * The id of a vertex position, for addEdge.
+   * @param pos - the vertex number minus the base
+   * @returns the id
+   */
+  idAt(pos) {
+    if (this.idOfPos !== null) {
+      return this.idOfPos[pos];
+    }
+    return this.idOfNumber(pos + this.base);
+  }
+  /**
+   * Complete the vertex set once the vertex section is over: vertices without a line are
+   * created (under "label" or a restored `graphty_originalId` with their number as the id), and
+   * a partial list is reported.
+   */
+  finishVertices() {
+    if (this.verticesDone) {
+      return;
+    }
+    this.verticesDone = true;
+    if (!this.baseKnown) {
+      this.setBase(1, 0);
+    }
+    const n = this.vertexCount;
+    this.createNodes();
+    if (this.idOfPos !== null) {
+      for (let pos = 0; pos < n; pos++) {
+        if (this.idOfPos[pos] === void 0) {
+          this.numberedNode(this.idOfPos, pos);
+        }
+      }
+    }
+    const lines = this.seenCount + this.report.counts.skippedNodes;
+    if (this.seenCount > 0 && lines < n) {
+      this.report.error(
+        "validation-error",
+        PAJEK_ISSUE.VERTEX_COUNT,
+        `*Vertices declares ${n} vertices but ${lines} vertex line(s) were read; the others have no label`
+      );
+    }
+  }
+  /**
+   * A vertex line: `number [label] [x y [z]] [shape] [key value ...] [interval]`.
+   * @param text - the line
+   * @param line - the line number
+   */
+  vertexLine(text, line) {
+    const tokens = this.tokens(text, "node");
+    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]}"`
+      );
+    }
+    const k = Number(tokens[0]);
+    if (!this.baseKnown) {
+      this.setBase(k === 0 ? 0 : 1, line);
+    }
+    const pos = k - this.base;
+    if (pos < 0 || pos >= this.vertexCount) {
+      this.report.counts.skippedNodes++;
+      throw new LineError(
+        "validation-error",
+        PAJEK_ISSUE.VERTEX_RANGE,
+        `vertex ${k} is outside ${this.base}..${this.base + this.vertexCount - 1}`
+      );
+    }
+    let i = 1;
+    const label = tokens.length > 1 ? tokens[1] : null;
+    if (label !== null) {
+      i = 2;
+    }
+    let x = 0;
+    let y = 0;
+    let z = 0;
+    let dims = 0;
+    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;
+      }
+    } else 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]`
+      );
+    }
+    let shape = null;
+    if (i < tokens.length && SHAPES.has(tokens[i])) {
+      shape = tokens[i];
+      i++;
+    }
+    const extras = this.extras(tokens, i, "node");
+    const restored = this.restoredId(extras);
+    this.createNodes();
+    const repeated = this.seen[pos] !== 0;
+    if (repeated) {
+      this.report.warning(
+        "merged",
+        PAJEK_ISSUE.DUPLICATE_NODE,
+        `vertex ${k} has more than one line; the later values overwrite`,
+        { line, element: String(k) }
+      );
+    } 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");
+    } else if (this.idOfPos !== null && this.idOfPos[pos] === void 0) {
+      for (let p = this.filledBelow; p < pos; p++) {
+        if (this.idOfPos[p] === void 0) {
+          this.numberedNode(this.idOfPos, p);
+        }
+      }
+      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) {
+        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) {
+      if (this.positionHandle === INVALID_INDEX) {
+        this.coordDims = dims;
+        this.positionHandle = declareResolved(sink, "node", positionDecl(dims), 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) }
+        );
+      }
+      sink.setNodeValue(this.positionHandle, index, [x, y, z]);
+    }
+    if (shape !== null) {
+      if (this.shapeHandle === INVALID_INDEX && this.nodeParams.has(SHAPE_COLUMN)) {
+        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 (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);
+    }
+  }
+  /**
+   * Whether a `graphty_originalId` parameter is restored as the vertex id: restoreMangledIds
+   * under nodeIdFrom "id" (under "label" / "index" the parameter stays an ordinary column).
+   * @returns true when the vertex lines may carry restorable ids
+   */
+  restoresIds() {
+    return this.options.restoreMangledIds && this.options.nodeIdFrom === "id";
+  }
+  /**
+   * Push a vertex whose id is its number (restore mode, a position whose line has not come or
+   * carries no original id; or the end of the vertex section under "label").
+   * @param ids - the id per vertex position
+   * @param pos - the vertex position
+   */
+  numberedNode(ids, pos) {
+    const id = this.idOfNumber(pos + this.base);
+    ids[pos] = id;
+    this.indexOfPos[pos] = this.sink.addNode(id);
+    this.report.counts.nodes++;
+  }
+  /**
+   * The `graphty_originalId` parameter of a vertex line, taken out of the extras when it is to be
+   * restored as the id (restoreMangledIds, under nodeIdFrom "id"); otherwise null and the
+   * parameter stays an ordinary column.
+   * @param extras - the parsed extras
+   * @returns the original id text, or null
+   */
+  restoredId(extras) {
+    if (!this.restoresIds()) {
+      return null;
+    }
+    const at = extras.keys.indexOf(ORIGINAL_ID_KEY);
+    if (at < 0) {
+      return null;
+    }
+    const [text] = extras.values.splice(at, 1);
+    extras.keys.splice(at, 1);
+    return text;
+  }
+  /**
+   * Push the node of a vertex line whose id comes from the line itself: its label under
+   * nodeIdFrom "label", or its restored `graphty_originalId` (the number when the line carries
+   * none), reporting a merge when the id was seen before.
+   * @param ids - the id per vertex position
+   * @param pos - the vertex position
+   * @param k - the vertex number
+   * @param text - the label or original id text, or null
+   * @param line - the line number
+   * @param from - which text the id comes from
+   * @returns the node index
+   */
+  deferredNode(ids, pos, k, text, line, from) {
+    const id = text === null ? this.idOfNumber(k) : this.coercer.text(text);
+    const before = this.sink.indexOf(id);
+    const index = this.sink.addNode(id);
+    ids[pos] = id;
+    this.indexOfPos[pos] = index;
+    this.report.counts.nodes++;
+    if (before !== INVALID_INDEX) {
+      this.report.warning(
+        "merged",
+        from === "label" ? PAJEK_ISSUE.LABEL_MERGED : PAJEK_ISSUE.ORIGINAL_ID_MERGED,
+        from === "label" ? `vertex ${k} has the label ${JSON.stringify(String(id))} of an earlier vertex; both are one node` : `vertex ${k} has the ${ORIGINAL_ID_KEY} ${JSON.stringify(String(id))} of an earlier vertex; both are one node`,
+        { line, element: String(k) }
+      );
+    }
+    return index;
+  }
+  // ============================================================ lines
+  /**
+   * An arc or edge line: `u v [value] [key value ...] [interval]`.
+   * @param text - the line
+   * @param line - the line number
+   */
+  edgeLine(text, line) {
+    const tokens = this.tokens(text, "edge");
+    if (tokens.length < 2 || !isVertexNumber(tokens[0]) || !isVertexNumber(tokens[1])) {
+      this.report.counts.skippedEdges++;
+      throw new LineError(
+        "parse-error",
+        PAJEK_ISSUE.LINE,
+        `a line starts with two vertex numbers, not "${tokens.slice(0, 2).join(" ")}"`
+      );
+    }
+    const u = this.endpoint(Number(tokens[0]));
+    const v = this.endpoint(Number(tokens[1]));
+    let i = 2;
+    let valueText = null;
+    if (i < tokens.length && isNumericText(tokens[i])) {
+      valueText = tokens[i];
+      i++;
+    }
+    const extras = this.extras(tokens, i, "edge");
+    const { weightFrom } = this.options;
+    let weight;
+    let valueIsWeight = false;
+    if (isWeightField(VALUE_FIELD, weightFrom)) {
+      valueIsWeight = true;
+      if (valueText !== null) {
+        weight = this.weightOf(valueText);
+      }
+    } else if (weightFrom !== null) {
+      const at = extras.keys.indexOf(weightFrom);
+      if (at >= 0) {
+        weight = this.weightOf(extras.values[at]);
+        extras.keys.splice(at, 1);
+        extras.values.splice(at, 1);
+      }
+    }
+    const e = this.pushEdge(u, v, weight, line);
+    if (valueText !== null && !valueIsWeight) {
+      this.writeParameter("edge", VALUE_COLUMN, e, valueText);
+    }
+    this.writeEdgeExtras(e, extras);
+  }
+  /**
+   * An adjacency list line of `*Arcslist` / `*Edgeslist`: `v n1 n2 ...`.
+   * @param text - the line
+   * @param line - the line number
+   */
+  listLine(text, line) {
+    const tokens = this.tokens(text, "edge");
+    for (const token of tokens) {
+      if (!isVertexNumber(token)) {
+        this.report.counts.skippedEdges++;
+        throw new LineError(
+          "parse-error",
+          PAJEK_ISSUE.LINE,
+          `an adjacency list holds vertex numbers only, not "${token}"`
+        );
+      }
+    }
+    const u = this.endpoint(Number(tokens[0]));
+    for (let i = 1; i < tokens.length; i++) {
+      const v = this.endpoint(Number(tokens[i]));
+      const e = this.pushEdge(u, v, void 0, line);
+      this.writeRelation(e);
+    }
+  }
+  /**
+   * A `*Matrix` row: N values, every non-zero entry an arc from the row's vertex with that value.
+   * @param text - the line
+   * @param line - the line number
+   */
+  matrixLine(text, line) {
+    const tokens = this.tokens(text, "edge");
+    const row = this.matrixRows;
+    this.matrixRows++;
+    if (row >= this.vertexCount) {
+      throw new LineError(
+        "validation-error",
+        PAJEK_ISSUE.MATRIX_ROWS,
+        `*Matrix row ${row + 1} is beyond the ${this.vertexCount} declared vertices`
+      );
+    }
+    if (tokens.length !== this.vertexCount) {
+      throw new LineError(
+        "parse-error",
+        PAJEK_ISSUE.LINE,
+        `*Matrix row ${row + 1} has ${tokens.length} value(s); *Vertices declares ${this.vertexCount}`
+      );
+    }
+    for (const token of tokens) {
+      if (!isNumericText(token)) {
+        throw new LineError(
+          "parse-error",
+          PAJEK_ISSUE.LINE,
+          `*Matrix row ${row + 1}: "${token}" is not a number`
+        );
+      }
+    }
+    for (let j = 0; j < tokens.length; j++) {
+      const value = Number(tokens[j]);
+      if (value === 0) {
+        continue;
+      }
+      const e = this.pushEdge(row, j, value, line);
+      this.writeRelation(e);
+    }
+  }
+  /**
+   * Push one line through the direction resolver, counting the logical edges it produced.
+   * @param u - the source position
+   * @param v - the target position
+   * @param weight - the weight, or undefined for none
+   * @param line - the line number
+   * @returns the primary logical edge index
+   */
+  pushEdge(u, v, weight, line) {
+    const { sink } = this;
+    const before = sink.edgeCount;
+    const e = this.resolver.addEdge(this.idAt(u), this.idAt(v), this.kind, weight, { line });
+    this.report.counts.edges += sink.edgeCount - before;
+    return e;
+  }
+  /**
+   * Write the relation, parameters and spells of a line on its primary half.
+   * @param e - the edge index
+   * @param extras - the parsed extras
+   */
+  writeEdgeExtras(e, extras) {
+    const { sink } = this;
+    this.writeRelation(e);
+    for (let p = 0; p < extras.keys.length; p++) {
+      this.writeParameter("edge", extras.keys[p], e, extras.values[p]);
+    }
+    if (extras.spells !== null) {
+      if (this.edgeSpellsHandle === INVALID_INDEX) {
+        this.edgeSpellsHandle = declareResolved(sink, "edge", spellsDecl(), this.report).handle;
+      }
+      sink.setEdgeValue(this.edgeSpellsHandle, e, extras.spells);
+    }
+  }
+  /**
+   * Write the current section's relation name on an edge, when the section has one.
+   * @param e - the edge index
+   */
+  writeRelation(e) {
+    if (this.relation === null) {
+      return;
+    }
+    if (this.relationHandle === INVALID_INDEX) {
+      this.relationHandle = declareResolved(this.sink, "edge", RELATION_DECL, this.report).handle;
+    }
+    this.sink.setEdgeValue(this.relationHandle, e, this.relation);
+  }
+  /**
+   * A line endpoint: the vertex number checked against the declared range; a reference outside
+   * it is a missing-value error and the line is skipped (Pajek's `*Vertices N` bounds the id space,
+   * so addMissingNodes does not apply).
+   * @param k - the vertex number
+   * @returns the vertex position
+   */
+  endpoint(k) {
+    const pos = k - this.base;
+    if (pos < 0 || pos >= this.vertexCount) {
+      this.report.counts.skippedEdges++;
+      throw new LineError(
+        "missing-value",
+        PAJEK_ISSUE.UNKNOWN_NODE,
+        `vertex ${k} is outside ${this.base}..${this.base + this.vertexCount - 1}`
+      );
+    }
+    return pos;
+  }
+  /**
+   * The weight of a line value text.
+   * @param text - the text
+   * @returns the weight; E_INVALID_WEIGHT is recorded by the caller's catch
+   */
+  weightOf(text) {
+    try {
+      return parseWeightText(text);
+    } catch (err) {
+      this.report.counts.skippedEdges++;
+      throw err;
+    }
+  }
+  // ============================================================ shared
+  /**
+   * Tokenize a data line.
+   * @param text - the line
+   * @param domain - what is skipped on an unterminated quote
+   * @returns the tokens (at least one: blank lines never reach here)
+   */
+  tokens(text, domain) {
+    const tokens = tokenize(text);
+    if (tokens === null) {
+      if (domain === "node") {
+        this.report.counts.skippedNodes++;
+      } else {
+        this.report.counts.skippedEdges++;
+      }
+      throw new LineError("parse-error", PAJEK_ISSUE.UNTERMINATED_QUOTE, "a double quote is not closed");
+    }
+    return tokens;
+  }
+  /**
+   * The `key value` parameters and the interval token at the end of a row, validated before
+   * anything is written.
+   * @param tokens - the row's tokens
+   * @param start - the first token to read
+   * @param domain - what is skipped when the row is malformed
+   * @returns the parsed extras
+   */
+  extras(tokens, start, domain) {
+    const extras = { keys: [], values: [], spells: null };
+    for (let i = start; i < tokens.length; ) {
+      const token = tokens[i];
+      if (isIntervalToken(token)) {
+        try {
+          extras.spells = parseIntervals(token);
+        } catch (err) {
+          this.skip(domain);
+          throw new LineError(
+            "validation-error",
+            PAJEK_ISSUE.INTERVAL,
+            err instanceof Error ? err.message : String(err)
+          );
+        }
+        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`
+        );
+      }
+      extras.keys.push(token);
+      extras.values.push(tokens[i + 1]);
+      i += 2;
+    }
+    return extras;
+  }
+  /**
+   * Count a skipped element.
+   * @param domain - node or edge
+   */
+  skip(domain) {
+    if (domain === "node") {
+      this.report.counts.skippedNodes++;
+    } else {
+      this.report.counts.skippedEdges++;
+    }
+  }
+  /**
+   * Write one `key value` parameter cell through the column's text writer (the 5.1 grammar per
+   * column, the lexical form kept). A `shape` parameter next to the shape keyword column goes
+   * into that column (a dict takes any text), and a shape keyword next to a `shape` parameter
+   * column into that one, so a file mixing the two spellings reads as one column.
+   * @param domain - node or edge
+   * @param key - the parameter key (the column name)
+   * @param row - the node or edge index
+   * @param text - the value text
+   */
+  writeParameter(domain, key, row, text) {
+    if (domain === "node" && key === SHAPE_COLUMN && this.shapeHandle !== INVALID_INDEX) {
+      this.sink.setNodeValue(this.shapeHandle, row, text);
+      return;
+    }
+    const writers = domain === "node" ? this.nodeParams : this.edgeParams;
+    let writer = writers.get(key);
+    if (writer === void 0) {
+      writer = new TextCellWriter(key, domain, this.sink, this.report);
+      writers.set(key, writer);
+    }
+    writer.write(row, text);
+  }
+}
+function firstVertexOption(value) {
+  if (value === void 0) {
+    return "auto";
+  }
+  if (FIRST_VERTEX_VALUES.has(value)) {
+    return value;
+  }
+  throw new GraphFormatError(
+    "E_UNSUPPORTED",
+    `option firstVertex: ${JSON.stringify(value) ?? typeof value} is not 0, 1 or "auto"`,
+    {
+      option: "firstVertex",
+      found: value
+    }
+  );
+}
+const HEAD_PATTERN = /^\s*\*(vertices|network)\b/i;
+const pajekImporter = Object.freeze({
+  format: "pajek",
+  extensions: Object.freeze([".net", ".paj"]),
+  mimeTypes: Object.freeze(["text/x-pajek", "text/plain"]),
+  /**
+   * Confidence that the input is a Pajek network: it starts with `*Vertices` (or `*Network`).
+   * @param head - the first bytes
+   * @returns 0.9 for a `*Vertices` start, 0.8 for `*Network`, 0 otherwise
+   */
+  sniff(head) {
+    const text = new TextDecoder("utf-8").decode(head.subarray(0, Math.min(head.byteLength, 512)));
+    const match = HEAD_PATTERN.exec(text.startsWith(String.fromCharCode(65279)) ? text.slice(1) : text);
+    if (match === null) {
+      return 0;
+    }
+    return match[1].toLowerCase() === "vertices" ? 0.9 : 0.8;
+  },
+  /**
+   * Read a Pajek network into the sink.
+   * @param input - the text, bytes or stream
+   * @param sink - the sink
+   * @param options - common and Pajek options
+   * @returns the report
+   */
+  async import(input, sink, options) {
+    const resolved = resolveImportOptions(options, DEFAULTS);
+    const firstVertex = firstVertexOption(options?.firstVertex);
+    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 reader = new LineReader(input, report, resolved);
+    let sinceCheck = 0;
+    for await (const text of reader) {
+      parser.line(text, reader.line);
+      if (++sinceCheck >= ABORT_CHECK_INTERVAL) {
+        sinceCheck = 0;
+        throwIfAborted(resolved.signal);
+      }
+    }
+    parser.finish();
+    throwIfAborted(resolved.signal);
+    return report.finish();
+  }
+});
+export {
+  PAJEK_ISSUE as P,
+  PAJEK_LOSS as a,
+  pajekImporter as b,
+  pajekExporter as p
+};
+//# sourceMappingURL=importer-CpCpfbxr.js.map