@graphty/graph-io 0.0.0 → 0.2.1

package/dist/csv.js

@@ -0,0 +1,1702 @@
+import { aY as DICT_SAMPLE_ROWS, aX as DictHeuristic, V as ROLE_TAKEN_CODE$1, n as ID_MERGED_CODE$1, i as DUPLICATE_EDGE_ID_CODE$1, k as DUPLICATE_NODE_CODE$1, w as MISSING_ID_CODE$1, M as MISSING_ENDPOINT_CODE$1, m as EMPTY_INPUT_CODE$1, aC as resolveImportOptions, I as ImportReportBuilder, az as reportSinkOptions, aA as reportUnusedOptions, l as DirectionResolver, s as IdCoercer, a as throwIfAborted, ax as parseWeightText, aI as uniqueColumnName, S as RENAMED_CODE, af as declareResolved, a9 as capabilities, L as LOSS, au as joinText, ah as encodeChunks, aa as checkCapabilities, aB as resolveExportOptions, aw as pairFolding, aG as countMixedEdges, ai as explicitWeights, aV as joinListText, an as formatInteger, aj as formatDecimal, a8 as canonicalId, x as MIXED_DIRECTION_CODE, g as DIRECTION_FORCED_CODE, h as DIRECTION_REFUSED_CODE, W as SINK_OPTION_CODE, J as OPTION_IGNORED_CODE, C as COLUMN_RENAMED_CODE, r as INVALID_UTF8_CODE } from "./chunks/writer-DxSKC7TL.js";
+import { i as inferTextDtype, T as TextCellWriter, p as parseTextCell, W as WIDENING_UNSUPPORTED_CODE } from "./chunks/text-CajMdVFy.js";
+import { GraphFormatError, INVALID_INDEX } from "@graphty/graph-format";
+import { s as sniffNewline, a as sniffDelimiter, C as CsvRecordReader, B as BAD_QUOTE_CODE, U as UNCLOSED_QUOTE_CODE } from "./chunks/records-CGpxszm1.js";
+import { m as quoteCsvCell } from "./chunks/escape-DyI8JofU.js";
+const SOURCE_NAMES = Object.freeze([
+  "source",
+  "src",
+  "from",
+  "start",
+  "source_id",
+  "sourceid",
+  "fromnodeid",
+  "start_id",
+  ":start_id"
+]);
+const TARGET_NAMES = Object.freeze([
+  "target",
+  "dst",
+  "dest",
+  "to",
+  "end",
+  "target_id",
+  "targetid",
+  "tonodeid",
+  "end_id",
+  ":end_id"
+]);
+const ID_NAMES = Object.freeze(["id", "node", "name", "key"]);
+const LABEL_NAMES = Object.freeze(["label"]);
+const EDGE_ID_NAMES = Object.freeze(["id"]);
+const TYPE_NAME = "Type";
+const HEADER_MARKERS = /* @__PURE__ */ new Set([
+  ...SOURCE_NAMES,
+  ...TARGET_NAMES,
+  ...ID_NAMES,
+  ...LABEL_NAMES,
+  "weight",
+  "type",
+  "value"
+]);
+function findColumn(names, candidates) {
+  for (const candidate of candidates) {
+    const exact = names.indexOf(candidate);
+    if (exact >= 0) {
+      return exact;
+    }
+    const lower2 = candidate.toLowerCase();
+    const loose = names.findIndex((name) => name.toLowerCase() === lower2);
+    if (loose >= 0) {
+      return loose;
+    }
+  }
+  return -1;
+}
+function resolveColumnRef(names, ref, option) {
+  if (typeof ref === "number") {
+    if (!Number.isInteger(ref) || ref < 0 || ref >= names.length) {
+      throw new GraphFormatError(
+        "E_UNSUPPORTED",
+        `option ${option}: column ${ref} does not exist (the file has ${names.length} column(s))`,
+        { option, found: ref, columns: names.length }
+      );
+    }
+    return ref;
+  }
+  const index = findColumn(names, [ref]);
+  if (index < 0) {
+    throw new GraphFormatError("E_UNSUPPORTED", `option ${option}: no column named ${JSON.stringify(ref)}`, {
+      option,
+      found: ref,
+      columns: [...names]
+    });
+  }
+  return index;
+}
+function looksLikeHeader(first, second) {
+  let allText = true;
+  for (const cell of first) {
+    const text = cell.trim();
+    if (HEADER_MARKERS.has(text.toLowerCase())) {
+      return true;
+    }
+    if (text.length === 0 || inferTextDtype(text) !== "string") {
+      allText = false;
+    }
+  }
+  if (!allText || second === null) {
+    return false;
+  }
+  return second.some((cell) => cell.trim().length > 0 && inferTextDtype(cell.trim()) !== "string");
+}
+function positionalNames(width) {
+  const names = [];
+  for (let i = 1; i <= width; i++) {
+    names.push(`column${i}`);
+  }
+  return names;
+}
+function headerNames(cells) {
+  return cells.map((cell, i) => {
+    const name = cell.trim();
+    return name.length === 0 ? `column${i + 1}` : name;
+  });
+}
+class InferredColumn {
+  /**
+   * Create a column writer; nothing is declared until the first value or finish().
+   * @param name - the column name
+   * @param domain - node or edge
+   * @param sink - the sink
+   * @param report - the report a refused sampled value is recorded in (the flush has no line numbers)
+   * @param sampleRows - rows sampled before the dict decision; DICT_SAMPLE_ROWS by default
+   */
+  constructor(name, domain, sink, report, sampleRows = DICT_SAMPLE_ROWS) {
+    this.handle = INVALID_INDEX;
+    this.text = false;
+    this.dict = false;
+    this.decided = false;
+    this.candidate = true;
+    this.writer = null;
+    this.pendingRows = [];
+    this.pendingTexts = [];
+    this.name = name;
+    this.domain = domain;
+    this.sink = sink;
+    this.report = report;
+    this.heuristic = new DictHeuristic(sampleRows);
+  }
+  /**
+   * Whether the column was declared as a dict.
+   * @returns true after a dict decision
+   */
+  get isDict() {
+    return this.dict;
+  }
+  /**
+   * Write one set cell.
+   * @param row - the node or edge index
+   * @param text - the cell text (the empty string for a quoted empty cell)
+   */
+  write(row, text) {
+    if (this.decided) {
+      this.push(row, text);
+      return;
+    }
+    this.pendingRows.push(row);
+    this.pendingTexts.push(text);
+    if (this.candidate && inferTextDtype(text) !== "string") {
+      this.candidate = false;
+    }
+    const full = this.heuristic.observe(text);
+    if (full || !this.candidate) {
+      this.decide();
+    }
+  }
+  /**
+   * Decide an undecided column from what was sampled (or declare an all-empty column as string)
+   * and flush the sample. Call once at the end of the input.
+   */
+  finish() {
+    if (!this.decided) {
+      this.decide();
+    }
+    if (this.handle === INVALID_INDEX) {
+      this.handle = this.lookup();
+      if (this.handle === INVALID_INDEX) {
+        this.handle = this.declare("string");
+      }
+    }
+  }
+  /**
+   * Make the dtype decision: a dict when every sampled value is text and the cardinality is low
+   * and no column of the name exists yet; inference otherwise. A column the sink already holds
+   * (a caller's) receives the cell text when it is a string or dict column and the parsed value
+   * otherwise. The sample is flushed either way; a sampled value the sink refuses (a caller's
+   * typed column of the name) is recorded as an issue of this column and the flush continues.
+   */
+  decide() {
+    this.decided = true;
+    const existing = this.lookup();
+    if (existing !== INVALID_INDEX) {
+      this.handle = existing;
+      this.text = this.holdsText();
+    } else if (this.candidate && this.heuristic.decide() === "dict") {
+      this.dict = true;
+      this.text = true;
+      this.handle = this.declare("dict");
+    } else {
+      this.writer = new TextCellWriter(this.name, this.domain, this.sink, this.report);
+    }
+    const rows = this.pendingRows;
+    const texts = this.pendingTexts;
+    for (let i = 0; i < rows.length; i++) {
+      try {
+        this.push(rows[i], texts[i]);
+      } catch (err) {
+        this.report.recordError(err, { element: this.name });
+      }
+    }
+    rows.length = 0;
+    texts.length = 0;
+  }
+  /**
+   * Push one value: text into a dict or a caller's text column, the parsed scalar into a caller's
+   * typed column, and everything else through the inferred-column writer.
+   * @param row - the node or edge index
+   * @param text - the cell text
+   */
+  push(row, text) {
+    if (this.writer !== null) {
+      this.writer.write(row, text);
+      this.handle = this.writer.column;
+      return;
+    }
+    const value = this.text ? text : parseTextCell(text);
+    this.set(this.handle, row, value);
+  }
+  /**
+   * Set a cell in the sink's table for this domain.
+   * @param column - the handle or name
+   * @param row - the row
+   * @param value - the value
+   */
+  set(column, row, value) {
+    if (this.domain === "node") {
+      this.sink.setNodeValue(column, row, value);
+    } else {
+      this.sink.setEdgeValue(column, row, value);
+    }
+  }
+  /**
+   * The sink's handle for this column's name.
+   * @returns the handle, or INVALID_INDEX when the sink has no such column yet
+   */
+  lookup() {
+    return this.domain === "node" ? this.sink.nodeColumn(this.name) : this.sink.edgeColumn(this.name);
+  }
+  /**
+   * Whether the sink's existing column of this name is a string or dict column, probed through
+   * the sink's declare (the same shape returns the existing handle, another is E_COLUMN_EXISTS).
+   * @returns true when cell text is what the column holds
+   */
+  holdsText() {
+    for (const dtype of ["string", "dict"]) {
+      try {
+        this.declare(dtype);
+        return true;
+      } catch (err) {
+        if (!(err instanceof GraphFormatError) || err.code !== "E_COLUMN_EXISTS") {
+          throw err;
+        }
+      }
+    }
+    return false;
+  }
+  /**
+   * Declare the column with a fixed dtype.
+   * @param dtype - dict or string
+   * @returns the handle
+   */
+  declare(dtype) {
+    const decl = { name: this.name, dtype, nullable: true, origin: { format: "csv" } };
+    return this.domain === "node" ? this.sink.declareNodeColumn(decl) : this.sink.declareEdgeColumn(decl);
+  }
+}
+const EMPTY_INPUT_CODE = EMPTY_INPUT_CODE$1;
+const NO_ENDPOINT_COLUMNS_CODE = "E_CSV_NO_ENDPOINT_COLUMNS";
+const NO_ID_COLUMN_CODE = "E_CSV_NO_ID_COLUMN";
+const FIELD_COUNT_CODE = "E_CSV_FIELD_COUNT";
+const MISSING_ENDPOINT_CODE = MISSING_ENDPOINT_CODE$1;
+const MISSING_ID_CODE = MISSING_ID_CODE$1;
+const BAD_TYPE_CODE = "E_CSV_BAD_TYPE";
+const NO_DATA_ROWS_CODE = "W_CSV_NO_DATA_ROWS";
+const DUPLICATE_NODE_CODE = DUPLICATE_NODE_CODE$1;
+const ID_MERGED_CODE = ID_MERGED_CODE$1;
+const COLUMN_MISSING_CODE = "W_CSV_COLUMN_MISSING";
+const ROLE_TAKEN_CODE = ROLE_TAKEN_CODE$1;
+const DUPLICATE_EDGE_ID_CODE = DUPLICATE_EDGE_ID_CODE$1;
+const TABLE_MODES = /* @__PURE__ */ new Set(["edges", "nodes", "auto"]);
+const USED_OPTIONS = /* @__PURE__ */ new Set([
+  "ids",
+  "addMissingNodes",
+  "duplicateEdges",
+  "selfLoops",
+  "onMixedDirection",
+  "defaultDirected",
+  "weightFrom",
+  "weightDtype",
+  "errorLimit",
+  "signal",
+  "onProgress"
+]);
+const USED_OPTIONS_WITH_NODES = /* @__PURE__ */ new Set([
+  ...USED_OPTIONS,
+  "nodeIdFrom"
+]);
+const BAD_DELIMITERS = /* @__PURE__ */ new Set(['"', "\n", "\r"]);
+const COMMENT_CHARS = Object.freeze(["#", "%"]);
+function commentDirection(comments) {
+  for (const comment of comments) {
+    const text = comment.slice(1).trim().toLowerCase();
+    if (text.startsWith("directed graph") || text.startsWith("asym")) {
+      return true;
+    }
+    if (text.startsWith("undirected graph") || text.startsWith("sym") || text.startsWith("bip")) {
+      return false;
+    }
+  }
+  return null;
+}
+function resolveCsvOptions(options) {
+  const o = options ?? {};
+  if (o.delimiter !== void 0 && (typeof o.delimiter !== "string" || o.delimiter.length === 0)) {
+    throw new GraphFormatError("E_UNSUPPORTED", "option delimiter: expected a non-empty string", {
+      option: "delimiter",
+      found: o.delimiter
+    });
+  }
+  if (o.delimiter !== void 0 && BAD_DELIMITERS.has(o.delimiter)) {
+    throw new GraphFormatError("E_UNSUPPORTED", "option delimiter: a quote or a line break cannot delimit", {
+      option: "delimiter",
+      found: o.delimiter
+    });
+  }
+  if (o.header !== void 0 && o.header !== "auto" && typeof o.header !== "boolean") {
+    throw new GraphFormatError("E_UNSUPPORTED", 'option header: expected true, false or "auto"', {
+      option: "header",
+      found: o.header
+    });
+  }
+  if (o.table !== void 0 && !TABLE_MODES.has(o.table)) {
+    throw new GraphFormatError("E_UNSUPPORTED", 'option table: expected "edges", "nodes" or "auto"', {
+      option: "table",
+      found: o.table
+    });
+  }
+  for (const name of ["sourceColumn", "targetColumn", "idColumn"]) {
+    checkColumnRef(name, o[name]);
+  }
+  if (o.typeColumn !== null) {
+    checkColumnRef("typeColumn", o.typeColumn);
+  }
+  return {
+    delimiter: o.delimiter ?? null,
+    header: o.header ?? "auto",
+    table: o.table ?? "auto",
+    sourceColumn: o.sourceColumn ?? null,
+    targetColumn: o.targetColumn ?? null,
+    typeColumn: o.typeColumn,
+    idColumn: o.idColumn ?? null,
+    nodes: o.nodes ?? null
+  };
+}
+function checkColumnRef(name, value) {
+  if (value === void 0) {
+    return;
+  }
+  if (typeof value === "string" && value.length > 0) {
+    return;
+  }
+  if (typeof value === "number" && Number.isInteger(value) && value >= 0) {
+    return;
+  }
+  throw new GraphFormatError("E_UNSUPPORTED", `option ${name}: expected a column name or a 0-based position`, {
+    option: name,
+    found: value
+  });
+}
+function isBlank(text) {
+  return text.length === 0 || text.trim().length === 0;
+}
+function isUnset(text, quoted) {
+  return quoted !== true && isBlank(text);
+}
+const ABORT_CHECK_INTERVAL = 64;
+function uniqueNames(names, report, line) {
+  const seen = /* @__PURE__ */ new Set();
+  return names.map((name, i) => {
+    const unique = uniqueColumnName(name, String(i + 1), (n) => seen.has(n));
+    seen.add(unique);
+    if (unique !== name) {
+      report.warning(
+        "coercion",
+        RENAMED_CODE,
+        `column ${i + 1} "${name}" renamed to "${unique}": the header repeats the name`,
+        { line, element: name }
+      );
+    }
+    return unique;
+  });
+}
+function findFree(names, candidates, claimed) {
+  const masked = names.map((name, i) => claimed.has(i) ? "" : name);
+  return findColumn(masked, candidates);
+}
+function declareRoleColumn(sink, domain, decl, position, report, line) {
+  const withOrigin = { ...decl, origin: { ...decl.origin, id: String(position) } };
+  const resolved = declareResolved(sink, domain, withOrigin, report, { line, element: decl.name });
+  if (resolved.roleDropped) {
+    return resolved.handle;
+  }
+  return resolved.handle;
+}
+function parseKind(text) {
+  if (isBlank(text)) {
+    return void 0;
+  }
+  switch (text.trim().toLowerCase()) {
+    case "directed":
+      return "directed";
+    case "undirected":
+      return "undirected";
+    case "mutual":
+      return "mutual";
+    default:
+      return null;
+  }
+}
+class TableReader {
+  /**
+   * Create a table reader.
+   * @param state - the import state
+   * @param input - the table's input
+   * @param kind - what the table is, or "auto"
+   * @param progress - whether this table reports byte progress
+   */
+  constructor(state, input, kind, progress) {
+    this.plan = null;
+    this.writers = [];
+    this.idHandle = INVALID_INDEX;
+    this.labelHandle = INVALID_INDEX;
+    this.dataRows = 0;
+    this.nodeOrdinal = 0;
+    this.edgeIds = /* @__PURE__ */ new Set();
+    this.where = { line: null, element: null };
+    this.state = state;
+    this.kind = kind;
+    const readerOptions = {
+      delimiter: state.csv.delimiter,
+      comments: COMMENT_CHARS,
+      signal: state.common.signal,
+      onProgress: progress ? state.common.onProgress : null
+    };
+    this.reader = new CsvRecordReader(input, state.report, readerOptions);
+  }
+  /**
+   * Read every row; the reader is closed (and a stream cancelled) when the import aborts midway.
+   */
+  async read() {
+    const iterator = this.reader[Symbol.asyncIterator]();
+    try {
+      await this.readRows(iterator);
+    } finally {
+      await iterator.return(void 0);
+    }
+  }
+  /**
+   * Read the header (or decide there is none), resolve the plan, then push every row.
+   * @param iterator - the record iterator
+   */
+  async readRows(iterator) {
+    const { report } = this.state;
+    const first = await iterator.next();
+    const firstRow = first.done ? report.fail(EMPTY_INPUT_CODE, "the input is empty: no header row and no records") : first.value;
+    const firstLine = this.reader.line;
+    const firstQuoted = this.reader.quoted.slice(0, firstRow.length);
+    const pending = [];
+    let header;
+    const { header: mode } = this.state.csv;
+    if (mode === "auto") {
+      const second = await iterator.next();
+      const secondRow = second.done ? null : second.value;
+      const secondLine = this.reader.line;
+      const secondQuoted = this.reader.quoted.slice(0, secondRow?.length ?? 0);
+      header = looksLikeHeader(firstRow, secondRow);
+      if (!header) {
+        pending.push({ row: firstRow, quoted: firstQuoted, line: firstLine });
+      }
+      if (secondRow !== null) {
+        pending.push({ row: secondRow, quoted: secondQuoted, line: secondLine });
+      }
+    } else {
+      header = mode;
+      if (!header) {
+        pending.push({ row: firstRow, quoted: firstQuoted, line: firstLine });
+      }
+    }
+    const names = header ? uniqueNames(headerNames(firstRow), report, firstLine) : positionalNames(firstRow.length);
+    if (this.kind !== "nodes" && this.state.commentDirected === null) {
+      this.state.commentDirected = commentDirection(this.reader.leadingComments);
+    }
+    this.plan = this.resolvePlan(names, header, firstLine);
+    this.prepareColumns(firstLine);
+    for (const { row, quoted, line } of pending) {
+      this.processRow(row, quoted, line);
+    }
+    const { signal } = this.state.common;
+    let sinceCheck = 0;
+    for (; ; ) {
+      const next = await iterator.next();
+      if (next.done) {
+        break;
+      }
+      this.processRow(next.value, this.reader.quoted, this.reader.line);
+      if (++sinceCheck >= ABORT_CHECK_INTERVAL) {
+        sinceCheck = 0;
+        throwIfAborted(signal);
+      }
+    }
+    for (const writer of this.writers) {
+      writer?.finish();
+    }
+    if (this.dataRows === 0 && header) {
+      report.warning("missing-value", NO_DATA_ROWS_CODE, "the table has a header and no data rows", {
+        line: firstLine
+      });
+    }
+  }
+  /**
+   * Decide the table's columns from its header.
+   * @param names - the column names
+   * @param header - whether the file has a header row
+   * @param line - the header line
+   * @returns the plan; the import aborts when no endpoints (or id) resolve
+   */
+  resolvePlan(names, header, line) {
+    const { csv, report } = this.state;
+    const width = names.length;
+    let source = -1;
+    let target = -1;
+    if (this.kind !== "nodes") {
+      if (csv.sourceColumn !== null) {
+        source = resolveColumnRef(names, csv.sourceColumn, "sourceColumn");
+      } else if (header) {
+        source = findColumn(names, SOURCE_NAMES);
+      } else {
+        source = width >= 2 ? 0 : -1;
+      }
+      if (csv.targetColumn !== null) {
+        target = resolveColumnRef(names, csv.targetColumn, "targetColumn");
+      } else if (header) {
+        target = findColumn(names, TARGET_NAMES);
+      } else {
+        target = width >= 2 ? 1 : -1;
+      }
+      if (source >= 0 && target >= 0 && source === target) {
+        throw new GraphFormatError("E_UNSUPPORTED", "sourceColumn and targetColumn name the same column", {
+          option: "targetColumn",
+          found: names[target]
+        });
+      }
+    }
+    if (source >= 0 && target >= 0) {
+      return this.edgePlan(names, header, source, target);
+    }
+    const shown = names.map((n) => JSON.stringify(n)).join(", ");
+    if (this.kind === "edges" || this.kind === "auto" && (csv.sourceColumn !== null || csv.targetColumn !== null)) {
+      report.fail(
+        NO_ENDPOINT_COLUMNS_CODE,
+        `no source / target columns in the header (${shown}); a node table goes in the nodes option`,
+        { line },
+        { columns: [...names] }
+      );
+    }
+    const idResolves = header ? findColumn(names, ID_NAMES) >= 0 : width >= 1;
+    if (this.kind === "auto" && csv.idColumn === null && !idResolves) {
+      report.fail(
+        NO_ENDPOINT_COLUMNS_CODE,
+        `no source / target columns and no id column in the header (${shown}); the input is neither an edge table nor a node table`,
+        { line },
+        { columns: [...names] }
+      );
+    }
+    return this.nodePlan(names, header, line);
+  }
+  /**
+   * The columns of an edge table.
+   * @param names - the column names
+   * @param header - whether the file has a header row
+   * @param source - the source column
+   * @param target - the target column
+   * @returns the plan
+   */
+  edgePlan(names, header, source, target) {
+    const { csv, common, report } = this.state;
+    const claimed = /* @__PURE__ */ new Set([source, target]);
+    let weight = -1;
+    if (common.weightFrom !== null) {
+      if (header) {
+        weight = findFree(names, [common.weightFrom], claimed);
+        if (weight < 0 && this.state.weightFromExplicit) {
+          report.warning(
+            "missing-value",
+            COLUMN_MISSING_CODE,
+            `weight column ${JSON.stringify(common.weightFrom)} not found; edges are unweighted`,
+            { line: this.reader.line, element: common.weightFrom }
+          );
+        }
+      } else if (names.length >= 3 && !claimed.has(2)) {
+        weight = 2;
+      }
+    }
+    if (weight >= 0) {
+      claimed.add(weight);
+    }
+    let type = -1;
+    if (csv.typeColumn === void 0) {
+      if (header && names[source] === "Source" && names[target] === "Target") {
+        type = findFree(names, [TYPE_NAME], claimed);
+        if (type >= 0 && names[type] !== TYPE_NAME) {
+          type = -1;
+        }
+      }
+    } else if (csv.typeColumn !== null) {
+      type = resolveColumnRef(names, csv.typeColumn, "typeColumn");
+      if (claimed.has(type)) {
+        throw new GraphFormatError("E_UNSUPPORTED", "typeColumn names an endpoint or weight column", {
+          option: "typeColumn",
+          found: names[type]
+        });
+      }
+    }
+    if (type >= 0) {
+      claimed.add(type);
+    }
+    const id = header ? findFree(names, EDGE_ID_NAMES, claimed) : -1;
+    if (id >= 0) {
+      claimed.add(id);
+    }
+    const label = header ? findFree(names, LABEL_NAMES, claimed) : -1;
+    if (label >= 0) {
+      claimed.add(label);
+    }
+    const attributes = [];
+    for (let i = 0; i < names.length; i++) {
+      if (!claimed.has(i)) {
+        attributes.push(i);
+      }
+    }
+    return { kind: "edges", names, width: names.length, source, target, weight, type, id, label, attributes };
+  }
+  /**
+   * The columns of a node table.
+   * @param names - the column names
+   * @param header - whether the file has a header row
+   * @param line - the header line
+   * @returns the plan; the import aborts when no id column resolves
+   */
+  nodePlan(names, header, line) {
+    const { csv, common, report } = this.state;
+    const claimed = /* @__PURE__ */ new Set();
+    let idColumn = -1;
+    if (csv.idColumn !== null) {
+      idColumn = resolveColumnRef(names, csv.idColumn, "idColumn");
+    } else if (header) {
+      idColumn = findColumn(names, ID_NAMES);
+    } else if (names.length >= 1) {
+      idColumn = 0;
+    }
+    const label = header ? findFree(names, LABEL_NAMES, new Set(idColumn >= 0 ? [idColumn] : [])) : -1;
+    let id;
+    switch (common.nodeIdFrom) {
+      case "label":
+        if (label < 0) {
+          report.fail(NO_ID_COLUMN_CODE, 'nodeIdFrom is "label" but the node table has no label column', {
+            line
+          });
+        }
+        id = label;
+        break;
+      case "index":
+        id = -1;
+        break;
+      default:
+        if (idColumn < 0) {
+          report.fail(
+            NO_ID_COLUMN_CODE,
+            `no id column in the node table header (${names.map((n) => JSON.stringify(n)).join(", ")})`,
+            { line },
+            { columns: [...names] }
+          );
+        }
+        id = idColumn;
+        claimed.add(idColumn);
+        break;
+    }
+    if (label >= 0) {
+      claimed.add(label);
+    }
+    const attributes = [];
+    for (let i = 0; i < names.length; i++) {
+      if (!claimed.has(i)) {
+        attributes.push(i);
+      }
+    }
+    return { kind: "nodes", names, width: names.length, id, label, attributes };
+  }
+  /**
+   * Declare the role columns and create a writer per attribute column.
+   * @param line - the header line
+   */
+  prepareColumns(line) {
+    const plan = this.requirePlan();
+    const { sink, report } = this.state;
+    const domain = plan.kind === "edges" ? "edge" : "node";
+    const origin = { format: "csv" };
+    if (plan.kind === "edges" && plan.id >= 0) {
+      this.idHandle = declareRoleColumn(
+        sink,
+        "edge",
+        { name: plan.names[plan.id], dtype: "string", nullable: true, role: "id", unique: true, origin },
+        plan.id + 1,
+        report,
+        line
+      );
+    }
+    if (plan.label >= 0) {
+      this.labelHandle = declareRoleColumn(
+        sink,
+        domain,
+        { name: plan.names[plan.label], dtype: "string", nullable: true, role: "label", origin },
+        plan.label + 1,
+        report,
+        line
+      );
+    }
+    this.writers = plan.names.map(() => null);
+    for (const index of plan.attributes) {
+      this.writers[index] = new InferredColumn(plan.names[index], domain, sink, report);
+    }
+  }
+  /**
+   * The plan, which exists once the header was read.
+   * @returns the plan
+   */
+  requirePlan() {
+    if (this.plan === null) {
+      throw new GraphFormatError("E_UNSUPPORTED", "the header has not been read", { reason: "no plan" });
+    }
+    return this.plan;
+  }
+  /**
+   * Push one data row.
+   * @param row - the cells
+   * @param quoted - whether each cell was quoted (a quoted empty cell is the empty string)
+   * @param line - the row's line
+   */
+  processRow(row, quoted, line) {
+    const plan = this.requirePlan();
+    this.dataRows++;
+    if (plan.kind === "edges") {
+      this.processEdgeRow(plan, row, quoted, line);
+    } else {
+      this.processNodeRow(plan, row, quoted, line);
+    }
+  }
+  /**
+   * Push one edge row: endpoints, weight, direction, then the attribute cells.
+   * @param plan - the edge plan
+   * @param row - the cells
+   * @param quoted - whether each cell was quoted
+   * @param line - the row's line
+   */
+  processEdgeRow(plan, row, quoted, line) {
+    const { report, sink, resolver, common } = this.state;
+    const { counts } = report;
+    if (row.length !== plan.width) {
+      report.error(
+        "validation-error",
+        FIELD_COUNT_CODE,
+        `line ${line}: ${row.length} field(s), the header has ${plan.width}`,
+        { line }
+      );
+      counts.skippedEdges++;
+      return;
+    }
+    const sourceText = row[plan.source];
+    const targetText = row[plan.target];
+    const sourceMissing = isUnset(sourceText, quoted[plan.source]);
+    if (sourceMissing || isUnset(targetText, quoted[plan.target])) {
+      report.error(
+        "missing-value",
+        MISSING_ENDPOINT_CODE,
+        `line ${line}: blank ${sourceMissing ? "source" : "target"} cell`,
+        { line }
+      );
+      counts.skippedEdges++;
+      return;
+    }
+    let kind = this.state.commentDirected ?? common.defaultDirected ? "directed" : "undirected";
+    if (plan.type >= 0) {
+      const parsed = parseKind(row[plan.type]);
+      if (parsed === null) {
+        report.error(
+          "validation-error",
+          BAD_TYPE_CODE,
+          `line ${line}: Type ${JSON.stringify(row[plan.type])} is not Directed, Undirected or Mutual`,
+          { line }
+        );
+        counts.skippedEdges++;
+        return;
+      }
+      if (parsed !== void 0) {
+        kind = parsed;
+      }
+    }
+    const { where } = this;
+    where.line = line;
+    where.element = null;
+    const idText = plan.id >= 0 && !isUnset(row[plan.id], quoted[plan.id]) ? row[plan.id] : null;
+    if (idText !== null) {
+      if (this.edgeIds.has(idText)) {
+        report.error(
+          "validation-error",
+          DUPLICATE_EDGE_ID_CODE,
+          `line ${line}: edge id ${JSON.stringify(idText)} repeats an earlier row's; the row is skipped`,
+          { line, element: idText }
+        );
+        counts.skippedEdges++;
+        return;
+      }
+      this.edgeIds.add(idText);
+    }
+    let edge;
+    try {
+      const source = this.coerce(sourceText);
+      const target = this.coerce(targetText);
+      const weight = plan.weight >= 0 ? parseWeightText(row[plan.weight]) : void 0;
+      if (!this.state.headerSet) {
+        this.state.headerSet = true;
+        resolver.setHeader(kind !== "undirected", where);
+      }
+      const sourceNew = sink.indexOf(source) === INVALID_INDEX;
+      const targetNew = source !== target && sink.indexOf(target) === INVALID_INDEX;
+      const before = sink.edgeCount;
+      edge = resolver.addEdge(source, target, kind, weight, where);
+      counts.edges += sink.edgeCount - before;
+      counts.nodes += (sourceNew ? 1 : 0) + (targetNew ? 1 : 0);
+    } catch (err) {
+      where.element = idText ?? `${sourceText}->${targetText}`;
+      report.recordError(err, where);
+      counts.skippedEdges++;
+      return;
+    }
+    if (idText !== null) {
+      this.writeRole(this.idHandle, "edge", edge, idText, plan.names[plan.id], line);
+    }
+    if (plan.label >= 0 && !isUnset(row[plan.label], quoted[plan.label])) {
+      this.writeRole(this.labelHandle, "edge", edge, row[plan.label], plan.names[plan.label], line);
+    }
+    this.writeAttributes(plan, row, quoted, edge, line);
+  }
+  /**
+   * Push one node row: the id, then the label and attribute cells.
+   * @param plan - the node plan
+   * @param row - the cells
+   * @param quoted - whether each cell was quoted
+   * @param line - the row's line
+   */
+  processNodeRow(plan, row, quoted, line) {
+    const { report, sink } = this.state;
+    const { counts } = report;
+    const ordinal = this.nodeOrdinal++;
+    if (row.length !== plan.width) {
+      report.error(
+        "validation-error",
+        FIELD_COUNT_CODE,
+        `line ${line}: ${row.length} field(s), the header has ${plan.width}`,
+        { line }
+      );
+      counts.skippedNodes++;
+      return;
+    }
+    const idText = plan.id >= 0 ? row[plan.id] : String(ordinal);
+    if (plan.id >= 0 && isUnset(idText, quoted[plan.id])) {
+      report.error("missing-value", MISSING_ID_CODE, `line ${line}: blank id cell`, { line });
+      counts.skippedNodes++;
+      return;
+    }
+    const { where } = this;
+    where.line = line;
+    where.element = idText;
+    let index;
+    try {
+      const id = plan.id >= 0 ? this.coerce(idText) : ordinal;
+      if (sink.indexOf(id) !== INVALID_INDEX) {
+        report.warning(
+          "merged",
+          DUPLICATE_NODE_CODE,
+          `line ${line}: node ${JSON.stringify(id)} already exists; its attributes are overwritten`,
+          where
+        );
+      } else {
+        counts.nodes++;
+      }
+      index = sink.addNode(id);
+    } catch (err) {
+      report.recordError(err, where);
+      counts.skippedNodes++;
+      return;
+    }
+    if (plan.label >= 0 && !isUnset(row[plan.label], quoted[plan.label])) {
+      this.writeRole(this.labelHandle, "node", index, row[plan.label], plan.names[plan.label], line);
+    }
+    this.writeAttributes(plan, row, quoted, index, line);
+  }
+  /**
+   * Coerce an id cell, reporting a merge under `ids: "number"`.
+   * @param text - the cell text
+   * @returns the id
+   */
+  coerce(text) {
+    const id = this.state.coercer.text(text);
+    const merge = this.state.coercer.lastMerge;
+    if (merge !== null) {
+      this.state.report.warnOnce(
+        "coercion",
+        ID_MERGED_CODE,
+        `id ${JSON.stringify(merge.text)} merged with ${JSON.stringify(merge.previousText)} as ${merge.id} under ids: "number"`,
+        this.where
+      );
+    }
+    return id;
+  }
+  /**
+   * Write a role column cell (edge id, label).
+   * @param handle - the column handle
+   * @param domain - node or edge
+   * @param row - the node or edge index
+   * @param text - the cell text
+   * @param name - the column name, for issues
+   * @param line - the row's line
+   */
+  writeRole(handle, domain, row, text, name, line) {
+    try {
+      if (domain === "node") {
+        this.state.sink.setNodeValue(handle, row, text);
+      } else {
+        this.state.sink.setEdgeValue(handle, row, text);
+      }
+    } catch (err) {
+      this.state.report.recordError(err, { line, element: name });
+    }
+  }
+  /**
+   * Write the attribute cells of a row: an unquoted blank cell is unset, a quoted one (`""`,
+   * `" "`) is the text it holds.
+   * @param plan - the plan
+   * @param row - the cells
+   * @param quoted - whether each cell was quoted
+   * @param index - the node or edge index
+   * @param line - the row's line
+   */
+  writeAttributes(plan, row, quoted, index, line) {
+    for (const k of plan.attributes) {
+      const text = row[k];
+      if (isUnset(text, quoted[k])) {
+        continue;
+      }
+      const writer = this.writers[k];
+      if (writer === null) {
+        continue;
+      }
+      try {
+        writer.write(index, text);
+      } catch (err) {
+        this.state.report.recordError(err, { line, element: writer.name });
+      }
+    }
+  }
+}
+const HEAD_BYTES = 4096;
+const OTHER_FORMAT = /^\s*(<|[[{]|(strict\s+)?(di)?graph(\s+\S+)?\s*\{|\*vertices|creator\b|graph\s*\[)/i;
+function sniff(head) {
+  const text = new TextDecoder("utf-8").decode(head.subarray(0, HEAD_BYTES));
+  const body = text.startsWith(String.fromCharCode(65279)) ? text.slice(1) : text;
+  if (body.trim().length === 0 || OTHER_FORMAT.test(body)) {
+    return 0;
+  }
+  const newline = sniffNewline(body);
+  const delimiter = sniffDelimiter(body, newline);
+  if (delimiter === null) {
+    return 0;
+  }
+  const end = body.indexOf(newline);
+  const firstLine = end < 0 ? body : body.slice(0, end);
+  const names = headerNames(firstLine.replace(/\r$/, "").split(delimiter));
+  if (findColumn(names, SOURCE_NAMES) >= 0 && findColumn(names, TARGET_NAMES) >= 0) {
+    return 0.9;
+  }
+  if (findColumn(names, ID_NAMES) >= 0) {
+    return 0.6;
+  }
+  return 0.3;
+}
+async function importCsv(input, sink, options) {
+  const common = resolveImportOptions(options, { ids: "canonical", defaultDirected: true, weightFrom: "weight" });
+  const csv = resolveCsvOptions(options);
+  const report = new ImportReportBuilder("csv", common.errorLimit);
+  reportSinkOptions(sink, options, report);
+  reportUnusedOptions(
+    options,
+    report,
+    csv.table === "nodes" || csv.nodes !== null ? USED_OPTIONS_WITH_NODES : USED_OPTIONS
+  );
+  const state = {
+    sink,
+    report,
+    common,
+    csv,
+    weightFromExplicit: typeof options?.weightFrom === "string",
+    coercer: new IdCoercer(common.ids),
+    resolver: new DirectionResolver(sink, report, common.onMixedDirection),
+    headerSet: false,
+    commentDirected: null
+  };
+  if (csv.nodes !== null) {
+    await new TableReader(state, csv.nodes, "nodes", false).read();
+  }
+  await new TableReader(state, input, csv.table, true).read();
+  if (state.coercer.mergeCount > 1) {
+    report.warning(
+      "coercion",
+      ID_MERGED_CODE,
+      `${state.coercer.mergeCount} id cell(s) merged into ids other cells already produced under ids: "number"`
+    );
+  }
+  throwIfAborted(common.signal);
+  return report.finish();
+}
+const csvImporter = Object.freeze({
+  format: "csv",
+  extensions: Object.freeze([".csv", ".tsv", ".edges", ".edgelist"]),
+  mimeTypes: Object.freeze(["text/csv", "text/tab-separated-values", "text/plain"]),
+  sniff,
+  import: importCsv
+});
+const CSV_LOSS = Object.freeze({
+  /** Two node ids share one text (a number and a string); export() throws E_INVALID_ID. */
+  ID_TEXT_COLLISION: LOSS.ID_TEXT_COLLISION,
+  /** Ids whose text reads back as the other type under the canonical rule. */
+  ID_TEXT_TYPE: LOSS.ID_TEXT_TYPE,
+  /** The generic dialect has no direction column; an undirected or mixed graph reads back as directed. */
+  DIRECTION_DROPPED: "W_CSV_DIRECTION_DROPPED",
+  /** Mutual pairs are written as two directed rows. */
+  MUTUAL_EXPANDED: LOSS.MUTUAL_EXPANDED,
+  /** An attribute column named like a reserved header is not written. */
+  RESERVED_NAME: "W_CSV_RESERVED_NAME",
+  /** A column without a role that the importer gives one back by its name. */
+  ROLE_ASSUMED: LOSS.ROLE_ASSUMED,
+  /** A role column (id, label) whose name the importer does not recognise; the role is lost. */
+  ROLE_NAME: "W_CSV_ROLE_NAME",
+  /** A role column (id, label) that is not string / dict reads back as string. */
+  TEXT_ROLE: "W_CSV_TEXT_ROLE",
+  /** NaN / Infinity in a numeric column read back as text. */
+  NONFINITE: "W_CSV_NONFINITE",
+  /** A text column whose every value reads back as a number or boolean. */
+  TEXT_INFERRED: LOSS.TEXT_INFERRED,
+  /** A dict column whose cardinality makes the importer read it back as string, or the reverse. */
+  STORAGE_CLASS_CHANGED: LOSS.STORAGE_CLASS,
+  /** Node attributes are written by a `table: "nodes"` export only. */
+  NODE_TABLE: "W_CSV_NODE_TABLE",
+  /** The edge table carries no node without an edge: isolated nodes vanish on re-import. */
+  ISOLATED_NODES: "W_CSV_ISOLATED_NODES",
+  /** The edge table lists nodes by first appearance; the node order (and indices) change on re-import. */
+  NODE_ORDER: "W_CSV_NODE_ORDER"
+});
+const CSV_CAPABILITIES = capabilities({
+  mixedDirection: true,
+  multiEdges: true,
+  selfLoops: true,
+  edgeIds: "optional",
+  idCharset: "any",
+  dtypes: ["bool", "i32", "f64", "string", "dict"]
+});
+const DIALECTS = {
+  gephi: { source: "Source", target: "Target", type: "Type", id: "Id", label: "Label", weight: "Weight" },
+  generic: { source: "source", target: "target", type: null, id: "id", label: "label", weight: "weight" }
+};
+const KEPT_ROLES = /* @__PURE__ */ new Set(["id", "label"]);
+const SKIPPED_ROLES = /* @__PURE__ */ new Set([
+  "directed",
+  "pair",
+  "mutual",
+  "weight",
+  "timeText",
+  "position",
+  "color",
+  "size",
+  "shape",
+  "thickness",
+  "parent",
+  "parents",
+  "start",
+  "end",
+  "timestamp",
+  "timestamps",
+  "spells",
+  "open"
+]);
+function resolveCsvExportOptions(options) {
+  const o = options ?? {};
+  if (o.dialect !== void 0 && o.dialect !== "gephi" && o.dialect !== "generic") {
+    throw new GraphFormatError("E_UNSUPPORTED", 'option dialect: expected "gephi" or "generic"', {
+      option: "dialect",
+      found: o.dialect
+    });
+  }
+  if (o.table !== void 0 && o.table !== "edges" && o.table !== "nodes") {
+    throw new GraphFormatError("E_UNSUPPORTED", 'option table: expected "edges" or "nodes"', {
+      option: "table",
+      found: o.table
+    });
+  }
+  if (o.delimiter !== void 0 && (typeof o.delimiter !== "string" || o.delimiter.length !== 1 || o.delimiter === '"' || o.delimiter === "\n" || o.delimiter === "\r")) {
+    throw new GraphFormatError(
+      "E_UNSUPPORTED",
+      "option delimiter: expected one character other than a quote or a line break",
+      { option: "delimiter", found: o.delimiter }
+    );
+  }
+  if (o.newline !== void 0 && o.newline !== "\n" && o.newline !== "\r\n") {
+    throw new GraphFormatError("E_UNSUPPORTED", "option newline: expected LF or CRLF", {
+      option: "newline",
+      found: o.newline
+    });
+  }
+  if (o.header !== void 0 && typeof o.header !== "boolean") {
+    throw new GraphFormatError("E_UNSUPPORTED", "option header: expected a boolean", {
+      option: "header",
+      found: o.header
+    });
+  }
+  return {
+    dialect: DIALECTS[o.dialect ?? "gephi"],
+    table: o.table ?? "edges",
+    delimiter: o.delimiter ?? ",",
+    newline: o.newline ?? "\n",
+    header: o.header ?? true
+  };
+}
+function scalarText(dtype, value) {
+  switch (dtype) {
+    case "bool":
+      return value === true ? "true" : "false";
+    case "f32":
+    case "f64":
+      return typeof value === "number" ? formatDecimal(value, dtype) : String(value);
+    case "i32":
+    case "u32":
+    case "u8":
+      return typeof value === "number" ? formatInteger(value) : String(value);
+    case "string":
+    case "dict":
+      return typeof value === "string" ? value : String(value);
+    case "json":
+      return JSON.stringify(value) ?? "";
+    default:
+      return String(value);
+  }
+}
+function cellText(column, row) {
+  if (!column.isSet(row)) {
+    return null;
+  }
+  switch (column.dtype) {
+    case "list": {
+      const items = column.sliceOf(row);
+      const { dtype } = column.child;
+      return joinListText(
+        items.map((item) => scalarText(dtype, item)),
+        "semicolon"
+      );
+    }
+    case "json":
+      return JSON.stringify(column.values[row]) ?? "";
+    case "bool":
+    case "string":
+    case "dict":
+      return scalarText(column.dtype, column.value(row));
+    default: {
+      const { components } = column.meta;
+      const { data } = column;
+      if (components === 1) {
+        return scalarText(column.dtype, data[row]);
+      }
+      const parts = [];
+      for (let k = 0; k < components; k++) {
+        parts.push(scalarText(column.dtype, data[row * components + k]));
+      }
+      return parts.join(";");
+    }
+  }
+}
+function idNotes(snapshot, values, note) {
+  const { ids } = snapshot;
+  if (ids.kind === "mixed") {
+    const seen = /* @__PURE__ */ new Set();
+    let collisions = 0;
+    for (let i = 0; i < ids.size; i++) {
+      const text = String(ids.idOf(i));
+      if (seen.has(text)) {
+        collisions++;
+      } else {
+        seen.add(text);
+      }
+    }
+    if (collisions > 0) {
+      note(
+        CSV_LOSS.ID_TEXT_COLLISION,
+        `${collisions} node id(s) share their text with another id (a number and a string); export() will throw E_INVALID_ID`,
+        null,
+        collisions
+      );
+    }
+  }
+  if (values && ids.kind !== "identity" && ids.kind !== "dense") {
+    let changed = 0;
+    for (let i = 0; i < ids.size; i++) {
+      const id = ids.idOf(i);
+      if (typeof canonicalId(String(id)) !== typeof id) {
+        changed++;
+      }
+    }
+    if (changed > 0) {
+      note(
+        CSV_LOSS.ID_TEXT_TYPE,
+        `${changed} node id(s) read back as the other type under ids: "canonical" (a string "1" becomes 1, a number 1.5 becomes "1.5")`,
+        null,
+        changed
+      );
+    }
+  }
+}
+function planExport(snapshot, options, values) {
+  const common = resolveExportOptions(options);
+  const csv = resolveCsvExportOptions(options);
+  const notes = [];
+  const note = (code, message, column = null, count = null) => {
+    notes.push(Object.freeze({ code, message, column, count }));
+  };
+  const { ids } = snapshot;
+  const idText = (index) => String(ids.idOf(index));
+  idNotes(snapshot, values, note);
+  const folding = pairFolding(snapshot);
+  const edgeRows = [];
+  for (let e = 0; e < snapshot.edgeCount; e++) {
+    if (!folding.folded(e)) {
+      edgeRows.push(e);
+    }
+  }
+  if (csv.dialect.type === null) {
+    const mixed = countMixedEdges(snapshot);
+    if (!snapshot.directed) {
+      note(
+        CSV_LOSS.DIRECTION_DROPPED,
+        `the generic dialect has no direction column; ${snapshot.edgeCount} undirected edge(s) read back as directed unless the importer is told otherwise`,
+        null,
+        snapshot.edgeCount
+      );
+    } else if (mixed > 0) {
+      note(
+        CSV_LOSS.DIRECTION_DROPPED,
+        `the generic dialect has no direction column; ${mixed} undirected edge(s) of a mixed graph read back as one directed edge each`,
+        null,
+        mixed
+      );
+    }
+  }
+  if (folding.mutualCount > 0) {
+    note(
+      CSV_LOSS.MUTUAL_EXPANDED,
+      `${folding.mutualCount} mutual pair(s) are written as two directed rows; the mutual mark is lost`,
+      null,
+      folding.mutualCount
+    );
+  }
+  if (csv.table === "edges") {
+    noteNodeCoverage(snapshot, edgeRows, note);
+  }
+  const weights = explicitWeights(snapshot);
+  const edgeId = snapshot.edges.byRole("id");
+  const edgeLabel = snapshot.edges.byRole("label");
+  const edgeReserved = new Set([csv.dialect.source, csv.dialect.target, csv.dialect.weight].map(lower));
+  if (csv.dialect.type !== null) {
+    edgeReserved.add(lower(csv.dialect.type));
+  }
+  const edgeColumns = attributeColumns(
+    snapshot.edges,
+    "edge",
+    edgeReserved,
+    edgeId,
+    edgeLabel,
+    csv.table === "edges" ? note : null
+  );
+  if (csv.table === "edges" && values) {
+    checkRoleColumn(edgeId, "id", EDGE_ID_NAMES, "edge", edgeRows, note);
+    checkRoleColumn(edgeLabel, "label", LABEL_NAMES, "edge", edgeRows, note);
+    for (const { column } of edgeColumns) {
+      checkValues(column, "edge", edgeRows, note);
+    }
+  }
+  const nodeLabel = snapshot.nodes.byRole("label");
+  const nodeReserved = /* @__PURE__ */ new Set([lower(csv.dialect.id)]);
+  const nodeRows = [];
+  if (csv.table === "nodes" && values) {
+    for (let i = 0; i < snapshot.nodeCount; i++) {
+      nodeRows.push(i);
+    }
+  }
+  const nodeColumns = attributeColumns(
+    snapshot.nodes,
+    "node",
+    nodeReserved,
+    null,
+    nodeLabel,
+    csv.table === "nodes" ? note : null
+  );
+  if (csv.table === "nodes") {
+    if (values) {
+      checkRoleColumn(nodeLabel, "label", LABEL_NAMES, "node", nodeRows, note);
+      for (const { column } of nodeColumns) {
+        checkValues(column, "node", nodeRows, note);
+      }
+    }
+  } else {
+    const written = nodeColumns.length + (nodeLabel === null ? 0 : 1);
+    if (written > 0) {
+      note(
+        CSV_LOSS.NODE_TABLE,
+        `${written} node column(s) are written by a table: "nodes" export only`,
+        null,
+        written
+      );
+    }
+  }
+  return {
+    csv,
+    common,
+    notes,
+    edgeRows,
+    folding,
+    edgeId,
+    edgeLabel,
+    weights,
+    edgeColumns,
+    nodeLabel,
+    nodeColumns,
+    idText
+  };
+}
+function noteNodeCoverage(snapshot, edgeRows, note) {
+  const { nodeCount } = snapshot;
+  if (nodeCount === 0) {
+    return;
+  }
+  const list = snapshot.edgeList();
+  const seen = new Uint8Array(nodeCount);
+  let next = 0;
+  let reordered = 0;
+  const mention = (index) => {
+    if (seen[index] === 1) {
+      return;
+    }
+    seen[index] = 1;
+    if (index !== next) {
+      reordered++;
+    }
+    next++;
+  };
+  for (const e of edgeRows) {
+    mention(list.src[e]);
+    mention(list.dst[e]);
+  }
+  const isolated = nodeCount - next;
+  if (isolated > 0) {
+    note(
+      CSV_LOSS.ISOLATED_NODES,
+      `${isolated} node(s) have no edge and cannot be written by the edge table; write the node table (table: "nodes") to keep them`,
+      null,
+      isolated
+    );
+  }
+  if (reordered > 0) {
+    note(
+      CSV_LOSS.NODE_ORDER,
+      `${reordered} node(s) are first mentioned by an edge row out of index order; a re-import numbers nodes by first appearance`,
+      null,
+      reordered
+    );
+  }
+}
+function lower(name) {
+  return name.toLowerCase();
+}
+function attributeColumns(table, domain, reserved, idColumn, labelColumn, note) {
+  const out = [];
+  for (const column of table) {
+    const { name, role } = column.meta;
+    if (column === idColumn || column === labelColumn) {
+      continue;
+    }
+    if (role !== null && SKIPPED_ROLES.has(role)) {
+      continue;
+    }
+    const low = lower(name);
+    const set = column.length - column.nullCount;
+    const isIdName = domain === "edge" ? findColumn([name], EDGE_ID_NAMES) >= 0 : false;
+    if (reserved.has(low) || isIdName || idColumn !== null && lower(idColumn.meta.name) === low) {
+      note?.(
+        CSV_LOSS.RESERVED_NAME,
+        `${domain} column "${name}" is not written: the name is reserved for the ${isIdName ? "edge id" : low} column`,
+        name,
+        set
+      );
+      continue;
+    }
+    if (findColumn([name], LABEL_NAMES) >= 0) {
+      if (labelColumn !== null) {
+        note?.(
+          CSV_LOSS.RESERVED_NAME,
+          `${domain} column "${name}" is not written: the name is reserved for the label column`,
+          name,
+          set
+        );
+        continue;
+      }
+      note?.(
+        CSV_LOSS.ROLE_ASSUMED,
+        `${domain} column "${name}" reads back with the label role (string)`,
+        name,
+        set
+      );
+    }
+    out.push({ column, header: name });
+  }
+  return out;
+}
+function checkRoleColumn(column, role, names, domain, rows, note) {
+  if (column === null) {
+    return;
+  }
+  const { name } = column.meta;
+  if (findColumn([name], names) < 0) {
+    note(
+      CSV_LOSS.ROLE_NAME,
+      `${domain} column "${name}" (${role}) is written under its name, which the importer does not map to the ${role} role`,
+      name,
+      countSet(column, rows)
+    );
+  }
+  if (column.dtype !== "string" && column.dtype !== "dict") {
+    note(
+      CSV_LOSS.TEXT_ROLE,
+      `${domain} column "${name}" (${role}) is ${column.dtype}; it reads back as string`,
+      name,
+      countSet(column, rows)
+    );
+  }
+  checkValues(column, domain, rows, note, true);
+}
+function countSet(column, rows) {
+  let count = 0;
+  for (const row of rows) {
+    if (column.isSet(row)) {
+      count++;
+    }
+  }
+  return count;
+}
+const WIDENING = { bool: 0, i32: 1, f64: 2, string: 3 };
+const TEXT_DTYPES = ["bool", "i32", "f64", "string"];
+function checkValues(column, domain, rows, note, roleColumn = false) {
+  const { name, dtype } = column.meta;
+  const label = `${domain} column "${name}"`;
+  if (column.dtype === "f32" || column.dtype === "f64") {
+    let nonFinite = 0;
+    const { components } = column.meta;
+    const { data } = column;
+    for (const row of rows) {
+      if (!column.isSet(row)) {
+        continue;
+      }
+      for (let k = 0; k < components; k++) {
+        if (!Number.isFinite(data[row * components + k])) {
+          nonFinite++;
+          break;
+        }
+      }
+    }
+    if (nonFinite > 0) {
+      note(CSV_LOSS.NONFINITE, `${label}: ${nonFinite} non-finite value(s) read back as text`, name, nonFinite);
+    }
+    return;
+  }
+  if (dtype !== "string" && dtype !== "dict") {
+    return;
+  }
+  let widest = -1;
+  let candidate = true;
+  let set = 0;
+  const heuristic = new DictHeuristic(DICT_SAMPLE_ROWS);
+  for (const row of rows) {
+    if (!column.isSet(row)) {
+      continue;
+    }
+    const text = column.value(row);
+    if (typeof text !== "string") {
+      continue;
+    }
+    set++;
+    const kind = inferTextDtype(text);
+    widest = Math.max(widest, WIDENING[kind]);
+    if (!heuristic.decided) {
+      if (kind !== "string") {
+        candidate = false;
+      }
+      heuristic.observe(text);
+    }
+  }
+  if (roleColumn || widest < 0) {
+    return;
+  }
+  const readsAsDict = candidate && heuristic.decide() === "dict";
+  if (widest < WIDENING.string && !readsAsDict) {
+    note(CSV_LOSS.TEXT_INFERRED, `${label}: every value reads back as ${TEXT_DTYPES[widest]}`, name, set);
+    return;
+  }
+  if (dtype === "dict" && !readsAsDict) {
+    note(
+      CSV_LOSS.STORAGE_CLASS_CHANGED,
+      `${label}: reads back as string (cardinality too high for a dict)`,
+      name,
+      null
+    );
+  } else if (dtype === "string" && readsAsDict) {
+    note(CSV_LOSS.STORAGE_CLASS_CHANGED, `${label}: reads back as dict (low cardinality)`, name, null);
+  }
+}
+function typeText(snapshot, plan, e) {
+  if (!snapshot.directed || !plan.folding.sourceDirected(e)) {
+    return "Undirected";
+  }
+  return "Directed";
+}
+function* lines(snapshot, plan) {
+  const { csv } = plan;
+  const { delimiter, newline } = csv;
+  const quote = (text) => quoteCsvCell(text, delimiter);
+  const cell = (column, row) => {
+    const text = cellText(column, row);
+    return text === null ? "" : quote(text);
+  };
+  if (csv.table === "nodes") {
+    const headers2 = [csv.dialect.id];
+    if (plan.nodeLabel !== null) {
+      headers2.push(plan.nodeLabel.meta.name);
+    }
+    for (const { header } of plan.nodeColumns) {
+      headers2.push(header);
+    }
+    if (csv.header) {
+      yield headers2.map(quote).join(delimiter) + newline;
+    }
+    for (let i = 0; i < snapshot.nodeCount; i++) {
+      const cells = [quote(plan.idText(i))];
+      if (plan.nodeLabel !== null) {
+        cells.push(cell(plan.nodeLabel, i));
+      }
+      for (const { column } of plan.nodeColumns) {
+        cells.push(cell(column, i));
+      }
+      yield cells.join(delimiter) + newline;
+    }
+    return;
+  }
+  const headers = [csv.dialect.source, csv.dialect.target];
+  if (csv.dialect.type !== null) {
+    headers.push(csv.dialect.type);
+  }
+  if (plan.edgeId !== null) {
+    headers.push(plan.edgeId.meta.name);
+  }
+  if (plan.edgeLabel !== null) {
+    headers.push(plan.edgeLabel.meta.name);
+  }
+  if (plan.weights.weighted) {
+    headers.push(csv.dialect.weight);
+  }
+  for (const { header } of plan.edgeColumns) {
+    headers.push(header);
+  }
+  if (csv.header) {
+    yield headers.map(quote).join(delimiter) + newline;
+  }
+  const list = snapshot.edgeList();
+  for (const e of plan.edgeRows) {
+    const cells = [quote(plan.idText(list.src[e])), quote(plan.idText(list.dst[e]))];
+    if (csv.dialect.type !== null) {
+      cells.push(typeText(snapshot, plan, e));
+    }
+    if (plan.edgeId !== null) {
+      cells.push(cell(plan.edgeId, e));
+    }
+    if (plan.edgeLabel !== null) {
+      cells.push(cell(plan.edgeLabel, e));
+    }
+    if (plan.weights.weighted) {
+      cells.push(plan.weights.text(e) ?? "");
+    }
+    for (const { column } of plan.edgeColumns) {
+      cells.push(cell(column, e));
+    }
+    yield cells.join(delimiter) + newline;
+  }
+}
+function prepare(snapshot, options) {
+  const plan = planExport(snapshot, options, false);
+  const collision = plan.notes.find((n) => n.code === CSV_LOSS.ID_TEXT_COLLISION);
+  if (collision !== void 0) {
+    throw new GraphFormatError("E_INVALID_ID", collision.message, {
+      reason: "collision",
+      count: collision.count
+    });
+  }
+  return plan;
+}
+function check(snapshot, options) {
+  const plan = planExport(snapshot, options, true);
+  return Object.freeze([
+    ...checkCapabilities(snapshot, CSV_CAPABILITIES, plan.common, { roles: KEPT_ROLES }),
+    ...plan.notes
+  ]);
+}
+const csvExporter = Object.freeze({
+  format: "csv",
+  capabilities: CSV_CAPABILITIES,
+  check,
+  export(snapshot, options) {
+    return encodeChunks(lines(snapshot, prepare(snapshot, options)));
+  },
+  exportToString(snapshot, options) {
+    return joinText(lines(snapshot, prepare(snapshot, options)));
+  }
+});
+const CSV_ISSUE = Object.freeze({
+  /** The input is empty (fatal). */
+  EMPTY_INPUT: EMPTY_INPUT_CODE,
+  /** The input holds invalid UTF-8 (fatal). */
+  INVALID_UTF8: INVALID_UTF8_CODE,
+  /** The header names neither endpoint columns nor an id column (fatal). */
+  NO_ENDPOINT_COLUMNS: NO_ENDPOINT_COLUMNS_CODE,
+  /** A node table without an id column (fatal). */
+  NO_ID_COLUMN: NO_ID_COLUMN_CODE,
+  /** A row with a different field count than the header. */
+  FIELD_COUNT: FIELD_COUNT_CODE,
+  /** An edge row with a blank source or target. */
+  MISSING_ENDPOINT: MISSING_ENDPOINT_CODE,
+  /** A node row with a blank id. */
+  MISSING_ID: MISSING_ID_CODE,
+  /** A Type cell outside Directed / Undirected / Mutual. */
+  BAD_TYPE: BAD_TYPE_CODE,
+  /** An unterminated quoted field (fatal). */
+  UNCLOSED_QUOTE: UNCLOSED_QUOTE_CODE,
+  /** Text after a closing quote (fatal). */
+  QUOTE: BAD_QUOTE_CODE,
+  /** A header and no data rows. */
+  NO_DATA_ROWS: NO_DATA_ROWS_CODE,
+  /** A node table row repeating an id. */
+  DUPLICATE_NODE: DUPLICATE_NODE_CODE,
+  /** An edge row repeating an edge id (skipped). */
+  DUPLICATE_EDGE_ID: DUPLICATE_EDGE_ID_CODE,
+  /** Two id cells merged into one number under ids "number". */
+  ID_MERGED: ID_MERGED_CODE,
+  /** An explicitly named weight column the file does not have. */
+  COLUMN_MISSING: COLUMN_MISSING_CODE,
+  /** A column whose role another column of the sink already holds. */
+  ROLE_TAKEN: ROLE_TAKEN_CODE,
+  /** A column renamed `<name>#<position>` (a repeated header, or a name the sink holds with another shape). */
+  COLUMN_RENAMED: COLUMN_RENAMED_CODE,
+  /** A common option the importer has no use for was given. */
+  OPTION_IGNORED: OPTION_IGNORED_CODE,
+  /** A builder-policy option the sink does not honour. */
+  SINK_OPTION: SINK_OPTION_CODE,
+  /** The sink refused the file's direction. */
+  DIRECTION_REFUSED: DIRECTION_REFUSED_CODE,
+  /** Edges forced to the policy's direction. */
+  DIRECTION_FORCED: DIRECTION_FORCED_CODE,
+  /** A mixed file under onMixedDirection "error" (fatal). */
+  MIXED_DIRECTION: MIXED_DIRECTION_CODE,
+  /** A text column the sink could not widen to the dtype its cells imply. */
+  WIDENING_UNSUPPORTED: WIDENING_UNSUPPORTED_CODE
+});
+export {
+  CSV_CAPABILITIES,
+  CSV_ISSUE,
+  CSV_LOSS,
+  csvExporter,
+  csvImporter
+};
+//# sourceMappingURL=csv.js.map