@graphty/graph-io 0.3.24 → 0.3.26

package/dist/chunks/export-BTI4yQgy.js

@@ -0,0 +1,4333 @@
+import { GraphFormatError, INVALID_INDEX } from "@graphty/graph-format";
+const FETCH_CODE = "E_FETCH";
+const MISSING_ID_CODE = "E_MISSING_ID";
+const MISSING_ENDPOINT_CODE = "E_MISSING_ENDPOINT";
+const DUPLICATE_NODE_CODE = "W_DUPLICATE_NODE";
+const NO_GRAPH_CODE = "E_NO_GRAPH";
+const MULTIPLE_GRAPHS_CODE = "W_MULTIPLE_GRAPHS";
+const EMPTY_INPUT_CODE = "E_EMPTY_INPUT";
+const SYNTAX_CODE = "E_SYNTAX";
+const XML_SYNTAX_CODE = "E_XML_SYNTAX";
+const UNKNOWN_ELEMENT_CODE = "W_UNKNOWN_ELEMENT";
+const STRAY_TEXT_CODE = "W_STRAY_TEXT";
+const UNKNOWN_PARENT_CODE = "E_UNKNOWN_PARENT";
+const HYPEREDGE_CODE = "E_HYPEREDGE";
+const DUPLICATE_KEY_CODE = "E_DUPLICATE_KEY";
+const COLUMN_RENAMED_CODE = "W_COLUMN_RENAMED";
+const COLUMN_DROPPED_CODE = "W_COLUMN_DROPPED";
+const ROLE_TAKEN_CODE = "W_ROLE_TAKEN";
+const PRECISION_CODE = "W_PRECISION";
+const ID_MERGED_CODE = "W_ID_MERGED";
+const SINK_OPTION_CODE = "W_SINK_OPTION";
+const OPTION_IGNORED_CODE = "W_OPTION_IGNORED";
+const INVALID_UTF8_CODE = "E_INVALID_UTF8";
+const INVALID_ENCODING_CODE = "E_INVALID_ENCODING";
+const ENCODING_FALLBACK_CODE = "W_ENCODING_FALLBACK";
+const UNKNOWN_ENCODING_CODE = "W_UNKNOWN_ENCODING";
+const ENCODING_CONFLICT_CODE = "W_ENCODING_CONFLICT";
+const CONTROL_CHARACTER_CODE = "W_CONTROL_CHARACTER";
+const FOREIGN_FORMAT_CODE = "E_FOREIGN_FORMAT";
+const ISSUES_SUPPRESSED_CODE = "W_ISSUES_SUPPRESSED";
+const UNKNOWN_XML_ATTRIBUTE_CODE = "W_UNKNOWN_XML_ATTRIBUTE";
+const DIRECTION_REFUSED_CODE = "W_DIRECTION_REFUSED";
+const DIRECTION_FORCED_CODE = "W_DIRECTION_FORCED";
+const MIXED_DIRECTION_CODE = "E_MIXED_DIRECTION";
+const COUNT_HINT_CODE = "W_COUNT_HINT";
+const UNKNOWN_ATTR_TYPE_CODE = "W_UNKNOWN_ATTR_TYPE";
+const BAD_DEFAULT_CODE = "W_BAD_DEFAULT";
+const BAD_OPTIONS_CODE = "W_BAD_OPTIONS";
+const DUPLICATE_EDGE_ID_CODE = "E_DUPLICATE_EDGE_ID";
+const BAD_VALUE_CODE = "E_BAD_VALUE";
+const WIDENED_CODE = "W_WIDENED";
+const DANGLING_REFERENCE_CODE = "W_DANGLING_REFERENCE";
+const DUPLICATE_ATTRIBUTE_CODE = "W_DUPLICATE_ATTRIBUTE";
+const PARENT_CYCLE_CODE = "E_PARENT_CYCLE";
+const EQUATION_AS_TEXT_CODE = "W_EQUATION_AS_TEXT";
+const STYLES_NOT_IMPORTED_CODE = "W_STYLES_NOT_IMPORTED";
+const BAD_ASPECT_BLOCK_CODE = "E_BAD_ASPECT_BLOCK";
+const MULTI_ASPECT_FRAGMENT_CODE = "W_MULTI_ASPECT_FRAGMENT";
+const SINGLE_OBJECT_ASPECT_CODE = "W_SINGLE_OBJECT_ASPECT";
+const JSON_NONSTANDARD_NUMBER_CODE = "W_JSON_NONSTANDARD_NUMBER";
+const ASPECT_ORDER_CODE = "W_ASPECT_ORDER";
+const COUNT_MISMATCH_CODE = "W_COUNT_MISMATCH";
+const STATUS_FAILED_CODE = "E_STATUS_FAILED";
+const STATUS_WARNING_CODE = "W_STATUS_WARNING";
+const TOO_LARGE_CODE = "E_TOO_LARGE";
+const COLUMN_TYPE_CODE = "E_COLUMN_TYPE";
+const GRAPH_NOT_FOUND_CODE = "E_GRAPH_NOT_FOUND";
+const AMBIGUOUS_GRAPH_NAME_CODE = "E_AMBIGUOUS_GRAPH_NAME";
+const DUPLICATE_EDGE_CODE = "E_DUPLICATE_EDGE";
+const SELF_LOOP_CODE = "E_SELF_LOOP";
+const EDGES_MERGED_CODE = "W_EDGES_MERGED";
+const SELF_LOOPS_DROPPED_CODE = "W_SELF_LOOPS_DROPPED";
+const UNKNOWN_OPTION_CODE = "W_UNKNOWN_OPTION";
+const BAD_LINE_CODE = "E_BAD_LINE";
+const WEIGHT_NOT_FOUND_CODE = "W_WEIGHT_NOT_FOUND";
+const ROLE_DROPPED_CODE = "W_ROLE_DROPPED";
+const PARENTS_DROPPED_CODE = "W_PARENTS_DROPPED";
+const TEMPORAL_DROPPED_CODE = "W_TEMPORAL_DROPPED";
+const MUTUAL_EXPANDED_CODE = "W_MUTUAL_EXPANDED";
+const MUTUAL_AS_UNDIRECTED_CODE = "W_MUTUAL_AS_UNDIRECTED";
+const ID_TEXT_TYPE_CODE = "W_ID_TEXT_TYPE";
+const ID_TEXT_COLLISION_CODE = "E_ID_TEXT_COLLISION";
+const TEMPORAL_TEXT_DROPPED_CODE = "W_TEMPORAL_TEXT_DROPPED";
+const WEIGHTS_DROPPED_CODE = "W_WEIGHTS_DROPPED";
+const WEIGHT_KEY_CLASH_CODE = "W_WEIGHT_KEY_CLASH";
+const ROLE_ASSUMED_CODE = "W_ROLE_ASSUMED";
+const COLUMN_RENAMED_LOSS_CODE = "W_COLUMN_NAME_CHANGED";
+const EMPTY_COLUMN_DROPPED_CODE = "W_EMPTY_COLUMN_DROPPED";
+const STORAGE_CLASS_CODE = "W_STORAGE_CLASS_CHANGED";
+const INTEGRAL_F64_CODE = "W_INTEGRAL_F64_AS_I32";
+const TEXT_INFERRED_CODE = "W_TEXT_INFERRED";
+const XML_ILLEGAL_CHAR_CODE = "E_XML_ILLEGAL_CHAR";
+const COLUMN_AS_PROPERTY_VALUE_CODE = "W_COLUMN_AS_PROPERTY_VALUE";
+const RELATION_ASSUMED_CODE = "W_RELATION_ASSUMED";
+const TYPEDEF_NODES_CODE = "W_TYPEDEF_NODES";
+const GRAPH_COLUMN_AS_METADATA_CODE = "W_GRAPH_COLUMN_AS_METADATA";
+const DIRECTION_DROPPED_CODE = "W_DIRECTION_DROPPED";
+const NONFINITE_AS_NULL_CODE = "W_NONFINITE_AS_NULL";
+const NODE_ORDER_CODE = "W_NODE_ORDER";
+const OPTIONS_GAINED_CODE = "W_OPTIONS_GAINED";
+const ELEMENT_ISSUE = Object.freeze({
+  /** A node id of a type the graph cannot hold (an empty id, a non-finite number, an object). The node is skipped. */
+  INVALID_ID: "E_INVALID_ID",
+  /** An edge names a node the file never declares, while `addMissingNodes` is false. The edge is skipped. */
+  UNKNOWN_NODE: "E_UNKNOWN_NODE",
+  /**
+   * An edge weight that is not a number (text such as "2,5" with a decimal comma, NaN, a boolean). The whole edge is
+   * skipped, not only its weight.
+   */
+  INVALID_WEIGHT: "E_INVALID_WEIGHT",
+  /** A second edge between the same two nodes, while `duplicateEdges` is "error". The edge is skipped. */
+  DUPLICATE_EDGE: DUPLICATE_EDGE_CODE,
+  /** An edge from a node to itself, while `selfLoops` is "error". The edge is skipped. */
+  SELF_LOOP: SELF_LOOP_CODE,
+  /** An edge id declared twice. The second edge is skipped. */
+  DUPLICATE_EDGE_ID: DUPLICATE_EDGE_ID_CODE
+});
+const INPUT_ISSUE = Object.freeze({
+  /** The input is empty or holds only whitespace. The import stops. */
+  EMPTY_INPUT: EMPTY_INPUT_CODE,
+  /** The input, or one of its lines, is longer than a JavaScript string can hold. The import stops. */
+  TOO_LARGE: TOO_LARGE_CODE,
+  /** A byte order mark, the encoding option and the declared encoding disagree. */
+  ENCODING_CONFLICT: ENCODING_CONFLICT_CODE,
+  /** A control character or a stray U+FEFF in the text, or an ignored trailing Ctrl-Z. */
+  CONTROL_CHARACTER: CONTROL_CHARACTER_CODE,
+  /** The input is an HTML page, a PDF, compressed or zip data, or an image. The import stops. */
+  FOREIGN_FORMAT: FOREIGN_FORMAT_CODE,
+  /** Warnings of one code beyond the number a report keeps, counted in one warning. */
+  ISSUES_SUPPRESSED: ISSUES_SUPPRESSED_CODE
+});
+function plural(n) {
+  return n === 1 ? "" : "s";
+}
+function agree(n, one, many) {
+  return n === 1 ? one : many;
+}
+function elementCount(nodes, edges) {
+  const parts = [];
+  if (nodes > 0 || edges === 0) {
+    parts.push(`${nodes} node${plural(nodes)}`);
+  }
+  if (edges > 0) {
+    parts.push(`${edges} edge${plural(edges)}`);
+  }
+  return parts.join(" and ");
+}
+function withArticle(word) {
+  return `${/^[aeiou]/i.test(word) ? "an" : "a"} ${word}`;
+}
+const TIME_TEXT_ROLE = "timeText";
+const TIME_TEXT_SUFFIX = ".text";
+const DATE_TIME$1 = /^(-?[0-9]{4,})-([0-9]{2})-([0-9]{2})(?:[T ]([0-9]{2}):([0-9]{2})(?::([0-9]{2})(?:\.([0-9]{1,9}))?)?)?(Z|z|[+-][0-9]{2}(?::?[0-9]{2})?)?$/;
+const TIME$1 = /^([0-9]{2}):([0-9]{2})(?::([0-9]{2})(?:\.([0-9]{1,9}))?)?(Z|z|[+-][0-9]{2}(?::?[0-9]{2})?)?$/;
+const NUMERIC = /^[+-]?([0-9]+(\.[0-9]*)?|\.[0-9]+)([eE][+-]?[0-9]+)?$/;
+const MS_PER_MINUTE = 6e4;
+const MS_PER_DAY = 864e5;
+function parseTemporal(text, kind) {
+  let value;
+  switch (kind) {
+    case "date":
+    case "dateTime":
+    case "localDateTime":
+      value = parseDateTime(text, kind);
+      break;
+    case "time":
+    case "localTime":
+      value = parseTime(text, kind);
+      break;
+    default: {
+      const name = kind;
+      throw new GraphFormatError("E_COLUMN_TYPE", `unknown temporal kind ${name}`, { kind: name });
+    }
+  }
+  const canonical = formatTemporal(value, kind);
+  return { value, text: canonical === text ? null : text };
+}
+function parseTimeText(text, timeFormat) {
+  const trimmed = text.trim();
+  switch (timeFormat) {
+    case "integer":
+    case "double":
+      return parseNumericTime(trimmed);
+    case "date":
+      return parseTemporal(trimmed, "date");
+    case "dateTime":
+      return parseTemporal(trimmed, "dateTime");
+    case null:
+      return NUMERIC.test(trimmed) ? parseNumericTime(trimmed) : parseTemporal(trimmed, "dateTime");
+    default: {
+      const name = timeFormat;
+      throw new GraphFormatError("E_COLUMN_TYPE", `unknown timeformat ${name}`, { timeFormat: name });
+    }
+  }
+}
+function formatTemporal(value, kind) {
+  switch (kind) {
+    case "date": {
+      const d = new Date(value);
+      return `${year(d)}-${pad2(d.getUTCMonth() + 1)}-${pad2(d.getUTCDate())}`;
+    }
+    case "dateTime":
+    case "localDateTime": {
+      const d = new Date(value);
+      const date = `${year(d)}-${pad2(d.getUTCMonth() + 1)}-${pad2(d.getUTCDate())}`;
+      const time = clock(d.getUTCHours(), d.getUTCMinutes(), d.getUTCSeconds(), d.getUTCMilliseconds());
+      return kind === "dateTime" ? `${date}T${time}Z` : `${date}T${time}`;
+    }
+    case "time":
+    case "localTime": {
+      const ms = (value % MS_PER_DAY + MS_PER_DAY) % MS_PER_DAY;
+      const h = Math.floor(ms / 36e5);
+      const m = Math.floor(ms % 36e5 / MS_PER_MINUTE);
+      const s = Math.floor(ms % MS_PER_MINUTE / 1e3);
+      const text = clock(h, m, s, ms % 1e3);
+      return kind === "time" ? `${text}Z` : text;
+    }
+    default: {
+      const name = kind;
+      throw new GraphFormatError("E_COLUMN_TYPE", `unknown temporal kind ${name}`, { kind: name });
+    }
+  }
+}
+function formatTimeValue(value, timeFormat) {
+  switch (timeFormat) {
+    case "date":
+      return formatTemporal(value, "date");
+    case "dateTime":
+      return formatTemporal(value, "dateTime");
+    case "integer":
+    case "double":
+    case null:
+      return String(value);
+    default: {
+      const name = timeFormat;
+      throw new GraphFormatError("E_COLUMN_TYPE", `unknown timeformat ${name}`, { timeFormat: name });
+    }
+  }
+}
+function timeTextCompanion(column) {
+  return {
+    name: column + TIME_TEXT_SUFFIX,
+    dtype: "string",
+    role: TIME_TEXT_ROLE,
+    nullable: true,
+    extra: { for: column }
+  };
+}
+function parseNumericTime(text) {
+  if (!NUMERIC.test(text)) {
+    throw new GraphFormatError("E_COLUMN_TYPE", `"${text}" is not a numeric time`, { value: text });
+  }
+  const value = Number(text);
+  return { value, text: String(value) === text ? null : text };
+}
+function parseDateTime(text, kind) {
+  const m = DATE_TIME$1.exec(text);
+  if (m === null) {
+    throw new GraphFormatError("E_COLUMN_TYPE", `"${text}" is not an ISO-8601 ${kind}`, { value: text, kind });
+  }
+  const y = Number(m[1]);
+  const month = Number(m[2]);
+  const day = Number(m[3]);
+  const hour = m[4] === void 0 ? 0 : Number(m[4]);
+  const minute = m[5] === void 0 ? 0 : Number(m[5]);
+  const second = m[6] === void 0 ? 0 : Number(m[6]);
+  const ms = m[7] === void 0 ? 0 : fractionMs(m[7]);
+  if (month < 1 || month > 12 || day < 1 || day > 31 || hour > 24 || minute > 59 || second > 60) {
+    throw new GraphFormatError("E_COLUMN_TYPE", `"${text}" is out of range for a ${kind}`, { value: text, kind });
+  }
+  const d = /* @__PURE__ */ new Date(0);
+  d.setUTCFullYear(y, month - 1, day);
+  d.setUTCHours(hour, minute, second, ms);
+  if (d.getUTCDate() !== day && hour !== 24) {
+    throw new GraphFormatError("E_COLUMN_TYPE", `"${text}" is not a calendar date`, { value: text, kind });
+  }
+  const offset = m[8] === void 0 ? 0 : offsetMinutes(m[8]);
+  return d.getTime() - offset * MS_PER_MINUTE;
+}
+function parseTime(text, kind) {
+  const m = TIME$1.exec(text);
+  if (m === null) {
+    throw new GraphFormatError("E_COLUMN_TYPE", `"${text}" is not an ISO-8601 ${kind}`, { value: text, kind });
+  }
+  const hour = Number(m[1]);
+  const minute = Number(m[2]);
+  const second = m[3] === void 0 ? 0 : Number(m[3]);
+  const ms = m[4] === void 0 ? 0 : fractionMs(m[4]);
+  if (hour > 24 || minute > 59 || second > 60) {
+    throw new GraphFormatError("E_COLUMN_TYPE", `"${text}" is out of range for a ${kind}`, { value: text, kind });
+  }
+  const local = ((hour * 60 + minute) * 60 + second) * 1e3 + ms;
+  const offset = m[5] === void 0 ? 0 : offsetMinutes(m[5]);
+  const utc = local - offset * MS_PER_MINUTE;
+  return (utc % MS_PER_DAY + MS_PER_DAY) % MS_PER_DAY;
+}
+function fractionMs(digits) {
+  return Math.floor(Number(`0.${digits}`) * 1e3);
+}
+function offsetMinutes(zone) {
+  if (zone === "Z" || zone === "z") {
+    return 0;
+  }
+  const sign = zone.startsWith("-") ? -1 : 1;
+  const digits = zone.slice(1).replace(":", "");
+  const hours = Number(digits.slice(0, 2));
+  const minutes = digits.length > 2 ? Number(digits.slice(2, 4)) : 0;
+  return sign * (hours * 60 + minutes);
+}
+function pad2(n) {
+  return n < 10 ? `0${n}` : String(n);
+}
+function year(d) {
+  const y = d.getUTCFullYear();
+  const abs = String(Math.abs(y)).padStart(4, "0");
+  return y < 0 ? `-${abs}` : abs;
+}
+function clock(h, m, s, ms) {
+  const base = `${pad2(h)}:${pad2(m)}:${pad2(s)}`;
+  return ms === 0 ? base : `${base}.${String(ms).padStart(3, "0")}`;
+}
+const BOOLEAN = { dtype: "bool", kind: "boolean" };
+const INTEGER = { dtype: "i32", kind: "integer" };
+const LONG = { dtype: "f64", kind: "long", precision: true };
+const FLOAT = { dtype: "f32", kind: "float" };
+const DOUBLE = { dtype: "f64", kind: "double" };
+const STRING = { dtype: "string", kind: "string" };
+const DATE = { dtype: "f64", kind: "temporal", temporal: "date" };
+const DATE_TIME = { dtype: "f64", kind: "temporal", temporal: "dateTime" };
+const LOCAL_DATE_TIME = { dtype: "f64", kind: "temporal", temporal: "localDateTime" };
+const TIME = { dtype: "f64", kind: "temporal", temporal: "time" };
+const LOCAL_TIME = { dtype: "f64", kind: "temporal", temporal: "localTime" };
+const DURATION = { dtype: "string", kind: "duration" };
+const POINT = { dtype: "json", kind: "point" };
+const RECORD = { dtype: "json", kind: "json" };
+const GEXF_SCALARS = {
+  integer: INTEGER,
+  long: LONG,
+  double: DOUBLE,
+  float: FLOAT,
+  boolean: BOOLEAN,
+  string: STRING,
+  anyuri: STRING,
+  char: STRING,
+  byte: INTEGER,
+  short: INTEGER,
+  bigdecimal: STRING,
+  biginteger: STRING,
+  date: DATE,
+  datetime: DATE_TIME
+};
+const GRAPHML_SCALARS = {
+  boolean: BOOLEAN,
+  int: INTEGER,
+  long: LONG,
+  float: FLOAT,
+  double: DOUBLE,
+  string: STRING
+};
+const GML_SCALARS = {
+  int: INTEGER,
+  real: DOUBLE,
+  string: STRING,
+  record: RECORD
+};
+const NEO4J_SCALARS = {
+  int: INTEGER,
+  integer: LONG,
+  long: LONG,
+  float: FLOAT,
+  double: DOUBLE,
+  boolean: BOOLEAN,
+  byte: INTEGER,
+  short: INTEGER,
+  char: STRING,
+  string: STRING,
+  point: POINT,
+  date: DATE,
+  localtime: LOCAL_TIME,
+  time: TIME,
+  localdatetime: LOCAL_DATE_TIME,
+  datetime: DATE_TIME,
+  duration: DURATION
+};
+const TABLES = {
+  gexf: GEXF_SCALARS,
+  graphml: GRAPHML_SCALARS,
+  gml: GML_SCALARS,
+  neo4j: NEO4J_SCALARS
+};
+const INTEGER_TEXT$1 = /^[+-]?[0-9]+$/;
+const DECIMAL_TEXT = /^[+-]?([0-9]+(\.[0-9]*)?|\.[0-9]+)([eE][+-]?[0-9]+)?$/;
+const I32_MIN = -2147483648;
+const I32_MAX = 2147483647;
+function mapDeclaredType(format, type, long) {
+  const table = TABLES[format];
+  let key = type.trim().toLowerCase();
+  let list2 = false;
+  if (format === "gexf" && key.startsWith("list") && key.length > 4) {
+    list2 = true;
+    key = key.slice(4);
+  } else if (format === "neo4j" && key.endsWith("[]")) {
+    list2 = true;
+    key = key.slice(0, -2);
+  } else if (format === "gml" && key === "list") {
+    return {
+      declared: type,
+      dtype: "list",
+      itemDtype: "json",
+      kind: "json",
+      list: true,
+      temporal: null,
+      precision: false
+    };
+  }
+  let entry = table[key];
+  if (entry === void 0) {
+    return null;
+  }
+  if (entry.kind === "long" && long === "string") {
+    entry = STRING;
+  }
+  return {
+    declared: type,
+    dtype: list2 ? "list" : entry.dtype,
+    itemDtype: list2 ? entry.dtype : null,
+    kind: entry.kind,
+    list: list2,
+    temporal: entry.temporal ?? null,
+    precision: entry.precision ?? false
+  };
+}
+function stringSpec(declared) {
+  return {
+    declared: declared ?? "",
+    dtype: "string",
+    itemDtype: null,
+    kind: "string",
+    list: false,
+    temporal: null,
+    precision: false
+  };
+}
+function parseScalarText(text, kind, temporal = null) {
+  switch (kind) {
+    case "boolean": {
+      const value = parseBooleanText(text);
+      if (value === null) {
+        throw typeError(text, kind);
+      }
+      return value;
+    }
+    case "integer": {
+      const trimmed = text.trim();
+      if (!INTEGER_TEXT$1.test(trimmed)) {
+        throw typeError(text, kind);
+      }
+      const value = Number(trimmed);
+      if (value < I32_MIN || value > I32_MAX) {
+        throw new GraphFormatError("E_COLUMN_TYPE", `"${trimmed}" is outside the 32-bit integer range`, {
+          value: trimmed,
+          kind
+        });
+      }
+      return value;
+    }
+    case "long": {
+      const trimmed = text.trim();
+      if (!INTEGER_TEXT$1.test(trimmed)) {
+        throw typeError(text, kind);
+      }
+      return Number(trimmed);
+    }
+    case "float":
+    case "double":
+      return parseDecimalText(text, kind);
+    case "string":
+    case "duration":
+      return text;
+    case "temporal": {
+      if (temporal === null) {
+        throw new GraphFormatError("E_COLUMN_TYPE", "a temporal value needs its temporal kind", { kind });
+      }
+      return parseTemporal(text.trim(), temporal).value;
+    }
+    case "point":
+      return parsePointText(text);
+    case "json":
+      return parseJsonText(text);
+    default: {
+      const name = kind;
+      throw new GraphFormatError("E_COLUMN_TYPE", `unknown value kind ${name}`, { kind: name });
+    }
+  }
+}
+function parseBooleanText(text) {
+  switch (text.trim().toLowerCase()) {
+    case "true":
+    case "1":
+      return true;
+    case "false":
+    case "0":
+      return false;
+    default:
+      return null;
+  }
+}
+function parseDecimalText(text, kind = "double") {
+  const trimmed = text.trim();
+  if (DECIMAL_TEXT.test(trimmed)) {
+    return Number(trimmed);
+  }
+  switch (trimmed) {
+    case "INF":
+    case "+INF":
+    case "Infinity":
+    case "+Infinity":
+      return Infinity;
+    case "-INF":
+    case "-Infinity":
+      return -Infinity;
+    case "NaN":
+      return NaN;
+    default:
+      throw typeError(text, kind);
+  }
+}
+function overflowsToInfinity(text) {
+  const trimmed = text.trim();
+  return /^[+-]?[0-9.]/.test(trimmed) && Number(trimmed) === (trimmed.startsWith("-") ? -Infinity : Infinity);
+}
+function parsePointText(text) {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) {
+    throw typeError(text, "point");
+  }
+  const out = {};
+  const inner = trimmed.slice(1, -1).trim();
+  if (inner.length === 0) {
+    return out;
+  }
+  for (const part of inner.split(",")) {
+    const colon = part.indexOf(":");
+    if (colon < 0) {
+      throw typeError(text, "point");
+    }
+    const key = part.slice(0, colon).trim().replace(/^["']|["']$/g, "");
+    const raw = part.slice(colon + 1).trim();
+    if (key.length === 0) {
+      throw typeError(text, "point");
+    }
+    if (DECIMAL_TEXT.test(raw)) {
+      out[key] = Number(raw);
+    } else if (raw.startsWith("'") && raw.endsWith("'") || raw.startsWith('"') && raw.endsWith('"')) {
+      out[key] = raw.slice(1, -1);
+    } else {
+      throw typeError(text, "point");
+    }
+  }
+  return out;
+}
+function parseJsonText(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw typeError(text, "json");
+  }
+}
+function typeError(text, kind) {
+  const shown = text.length > 40 ? `${text.slice(0, 40)}...` : text;
+  return new GraphFormatError("E_COLUMN_TYPE", `"${shown}" is not ${withArticle(kind)}`, { value: text, kind });
+}
+function splitListText(text, syntax) {
+  const trimmed = text.trim();
+  if (trimmed.length === 0) {
+    return [];
+  }
+  switch (syntax) {
+    case "gexf": {
+      if (isBracketed(trimmed)) {
+        return splitBracketed(trimmed);
+      }
+      const separator = firstSeparator(trimmed, ["|", ",", ";"]);
+      return separator === null ? [trimmed] : splitOn(trimmed, separator);
+    }
+    case "brackets":
+      return isBracketed(trimmed) ? splitBracketed(trimmed) : [trimmed];
+    case "pipe":
+      return splitOn(trimmed, "|");
+    case "comma":
+      return splitOn(trimmed, ",");
+    case "semicolon":
+      return splitOn(trimmed, ";");
+    default: {
+      const name = syntax;
+      throw new GraphFormatError("E_UNSUPPORTED", `unknown list syntax ${name}`, {
+        option: "listSyntax",
+        found: name
+      });
+    }
+  }
+}
+function joinListText(items, syntax) {
+  switch (syntax) {
+    case "gexf":
+    case "brackets":
+      return `[${items.map(quoteBracketItem).join(", ")}]`;
+    case "pipe":
+      return items.join("|");
+    case "comma":
+      return items.join(",");
+    case "semicolon":
+      return items.join(";");
+    default: {
+      const name = syntax;
+      throw new GraphFormatError("E_UNSUPPORTED", `unknown list syntax ${name}`, {
+        option: "listSyntax",
+        found: name
+      });
+    }
+  }
+}
+function isBracketed(text) {
+  return text.length >= 2 && text.startsWith("[") && text.endsWith("]");
+}
+function firstSeparator(text, candidates) {
+  for (const candidate of candidates) {
+    if (text.includes(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function splitOn(text, separator) {
+  return text.split(separator).map((item) => item.trim());
+}
+function splitBracketed(text) {
+  const inner = text.slice(1, -1);
+  const items = [];
+  const n = inner.length;
+  if (inner.trim().length === 0) {
+    return items;
+  }
+  let i = 0;
+  for (; ; ) {
+    while (i < n && isSpace(inner.charCodeAt(i))) {
+      i++;
+    }
+    let item = "";
+    if (i < n && (inner[i] === '"' || inner[i] === "'")) {
+      const quote = inner[i];
+      i++;
+      while (i < n) {
+        if (inner[i] === quote) {
+          if (inner[i + 1] === quote) {
+            item += quote;
+            i += 2;
+            continue;
+          }
+          i++;
+          break;
+        }
+        item += inner[i];
+        i++;
+      }
+    }
+    let end = inner.indexOf(",", i);
+    if (end < 0) {
+      end = n;
+    }
+    item += inner.slice(i, end).trim();
+    items.push(item);
+    i = end;
+    if (i >= n) {
+      return items;
+    }
+    i++;
+    if (inner.slice(i).trim().length === 0) {
+      items.push("");
+      return items;
+    }
+  }
+}
+function isSpace(c) {
+  return c === 32 || c === 9 || c === 13 || c === 10;
+}
+function quoteBracketItem(item) {
+  if (item.length === 0 || /[,[\]"']/.test(item) || item !== item.trim()) {
+    return `"${item.replace(/"/g, '""')}"`;
+  }
+  return item;
+}
+const UNKNOWN_TYPE_CODE = UNKNOWN_ATTR_TYPE_CODE;
+const RENAMED_CODE = COLUMN_RENAMED_CODE;
+const DICT_SAMPLE_ROWS = 1024;
+function declareAttribute(input) {
+  const issues = [];
+  const listSyntax = input.listSyntax ?? "gexf";
+  let spec;
+  if (input.type === null) {
+    spec = stringSpec(null);
+  } else {
+    const mapped = mapDeclaredType(input.format, input.type, input.long);
+    if (mapped === null) {
+      spec = stringSpec(input.type);
+      issues.push({
+        category: "unsupported",
+        code: UNKNOWN_TYPE_CODE,
+        message: `${input.format} type "${input.type}" is not supported; values kept as text`
+      });
+    } else {
+      spec = mapped;
+    }
+  }
+  const { name, renamed } = resolveName(input);
+  if (renamed) {
+    issues.push({
+      category: "coercion",
+      code: RENAMED_CODE,
+      message: `attribute "${input.title ?? input.id ?? ""}" renamed to "${name}": the name was taken`
+    });
+  }
+  const decl = {
+    name,
+    dtype: spec.dtype,
+    nullable: true,
+    origin: {
+      format: input.format,
+      id: input.id,
+      title: input.title !== null && input.title !== name ? input.title : null,
+      type: input.type,
+      namespace: input.namespace ?? null
+    }
+  };
+  if (spec.list) {
+    decl.itemDtype = spec.itemDtype ?? "string";
+  }
+  if (input.role !== void 0 && input.role !== null) {
+    decl.role = input.role;
+  }
+  if (input.dynamic === true) {
+    decl.dynamic = true;
+  }
+  const optionsText = input.optionsText ?? null;
+  if (optionsText !== null) {
+    try {
+      const options = splitListText(optionsText, listSyntax).map((item) => parseItem(item, spec));
+      decl.options = options;
+      if (spec.dtype === "string" && !spec.list && options.every((o) => typeof o === "string")) {
+        decl.dtype = "dict";
+        spec = { ...spec, dtype: "dict" };
+      }
+    } catch (err) {
+      issues.push({
+        category: "validation-error",
+        code: BAD_OPTIONS_CODE,
+        message: `options "${optionsText}" of attribute "${name}" do not parse as ${spec.declared}: ${messageOf$1(err)}`
+      });
+    }
+  }
+  const defaultText = input.defaultText ?? null;
+  if (defaultText !== null) {
+    try {
+      decl.default = parseDeclaredValue(defaultText, spec, listSyntax);
+    } catch (err) {
+      issues.push({
+        category: "validation-error",
+        code: BAD_DEFAULT_CODE,
+        message: `default "${defaultText}" of attribute "${name}" does not parse as ${spec.declared}: ${messageOf$1(err)}`
+      });
+    }
+  }
+  const companion = spec.temporal !== null && !spec.list ? timeTextCompanion(name) : null;
+  return { decl, spec, listSyntax, companion, renamed, issues };
+}
+function parseDeclaredValue(text, spec, listSyntax) {
+  if (spec.list) {
+    return splitListText(text, listSyntax).map((item) => parseItem(item, spec));
+  }
+  return parseItem(text, spec);
+}
+function parseDeclaredTemporal(text, spec) {
+  if (spec.temporal === null || spec.list) {
+    throw new GraphFormatError("E_COLUMN_TYPE", `"${spec.declared}" is not a scalar temporal type`, {
+      declared: spec.declared
+    });
+  }
+  return parseTemporal(text.trim(), spec.temporal);
+}
+const INTEGER_TEXT = /^[+-]?[0-9]+$/;
+function losesPrecision(spec, text) {
+  if (!spec.precision) {
+    return false;
+  }
+  const trimmed = text.trim();
+  if (!INTEGER_TEXT.test(trimmed)) {
+    return false;
+  }
+  const n = Number(trimmed);
+  return !Number.isFinite(n) || BigInt(trimmed) !== BigInt(n);
+}
+function declareOn(sink, domain, decl) {
+  return domain === "node" ? sink.declareNodeColumn(decl) : sink.declareEdgeColumn(decl);
+}
+function declareResolved(sink, domain, decl, report, where) {
+  let current = decl;
+  let renamed = false;
+  let roleDropped = false;
+  for (; ; ) {
+    try {
+      return { handle: declareOn(sink, domain, current), decl: current, renamed, roleDropped };
+    } catch (err) {
+      if (!(err instanceof GraphFormatError)) {
+        throw err;
+      }
+      if (err.code === "E_COLUMN_EXISTS" && !renamed) {
+        const taken = takenIn(sink, domain);
+        const id = current.origin?.id ?? null;
+        const name = uniqueColumnName(current.name, id, taken);
+        report.warning(
+          "coercion",
+          COLUMN_RENAMED_CODE,
+          `${domain} column "${current.name}" renamed to "${name}": the sink already holds that name with another shape`,
+          { ...where, element: where?.element ?? current.name }
+        );
+        current = { ...current, name };
+        renamed = true;
+        continue;
+      }
+      if (err.code === "E_DUPLICATE_ROLE" && current.role !== void 0 && !roleDropped) {
+        const holder = typeof err.details.holder === "string" ? err.details.holder : "another column";
+        report.warning(
+          "coercion",
+          ROLE_TAKEN_CODE,
+          `${domain} column "${current.name}" loses the ${current.role} role: "${holder}" already holds it`,
+          { ...where, element: where?.element ?? current.name }
+        );
+        const { role: _role, ...withoutRole } = current;
+        current = withoutRole;
+        roleDropped = true;
+        continue;
+      }
+      throw err;
+    }
+  }
+}
+function declareCompanion(sink, domain, companion, report) {
+  try {
+    return declareOn(sink, domain, companion);
+  } catch (err) {
+    if (err instanceof GraphFormatError && err.code === "E_DUPLICATE_ROLE") {
+      report?.warnOnce(
+        "coercion",
+        ROLE_TAKEN_CODE,
+        `${domain} column "${companion.name}" is declared without the timeText role: another companion holds it (exporters use extra.for)`,
+        { element: companion.name }
+      );
+      const { role: _role, ...withoutRole } = companion;
+      return declareOn(sink, domain, withoutRole);
+    }
+    throw err;
+  }
+}
+function takenIn(sink, domain) {
+  return (name) => (domain === "node" ? sink.nodeColumn(name) : sink.edgeColumn(name)) !== INVALID_INDEX;
+}
+function uniqueColumnName(name, id, taken) {
+  if (!taken(name)) {
+    return name;
+  }
+  const base = id === null ? name : `${name}#${id}`;
+  if (id !== null && !taken(base)) {
+    return base;
+  }
+  for (let n = 2; ; n++) {
+    const candidate = `${base}#${n}`;
+    if (!taken(candidate)) {
+      return candidate;
+    }
+  }
+}
+class DictHeuristic {
+  /**
+   * Create a heuristic.
+   * @param sampleRows - rows observed before deciding; DICT_SAMPLE_ROWS by default
+   */
+  constructor(sampleRows = DICT_SAMPLE_ROWS) {
+    this.distinct = /* @__PURE__ */ new Set();
+    this.rowsSeen = 0;
+    this.sampleRows = sampleRows;
+  }
+  /**
+   * Rows observed so far.
+   * @returns the count
+   */
+  get rows() {
+    return this.rowsSeen;
+  }
+  /**
+   * Distinct values observed so far.
+   * @returns the count
+   */
+  get distinctCount() {
+    return this.distinct.size;
+  }
+  /**
+   * Whether the sample is full.
+   * @returns true once sampleRows values were observed
+   */
+  get decided() {
+    return this.rowsSeen >= this.sampleRows;
+  }
+  /**
+   * Observe one value.
+   * @param value - the value text
+   * @returns true when this observation completed the sample
+   */
+  observe(value) {
+    this.rowsSeen++;
+    if (this.distinct.size < this.rowsSeen) {
+      this.distinct.add(value);
+    }
+    return this.rowsSeen === this.sampleRows;
+  }
+  /**
+   * The dtype the sample suggests: dict when the distinct count is below rows / 2 (and at least
+   * one row was seen), string otherwise. Valid before the sample is full (end of input).
+   * @returns "dict" or "string"
+   */
+  decide() {
+    return this.rowsSeen > 0 && this.distinct.size * 2 < this.rowsSeen ? "dict" : "string";
+  }
+}
+function resolveName(input) {
+  const preferred = input.title !== null && input.title.length > 0 ? input.title : input.id;
+  if (preferred === null || preferred.length === 0) {
+    throw new GraphFormatError("E_COLUMN_TYPE", "an attribute declaration needs a title or an id", {
+      field: "name",
+      format: input.format
+    });
+  }
+  if (input.taken === void 0) {
+    return { name: preferred, renamed: false };
+  }
+  const name = uniqueColumnName(preferred, input.id, input.taken);
+  return { name, renamed: name !== preferred };
+}
+function parseItem(text, spec) {
+  return parseScalarText(text, spec.kind, spec.temporal);
+}
+function messageOf$1(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+const DIRECTED_COLUMN = "graphty.directed";
+const PAIR_COLUMN = "graphty.pair";
+const MUTUAL_COLUMN = "graphty.mutual";
+const DIRECTED_DECL = { name: DIRECTED_COLUMN, dtype: "bool", role: "directed" };
+const PAIR_DECL = { name: PAIR_COLUMN, dtype: "u32", role: "pair", refersTo: "edge" };
+const MUTUAL_DECL = { name: MUTUAL_COLUMN, dtype: "bool", role: "mutual" };
+class DirectionResolver {
+  /**
+   * Create a resolver.
+   * @param sink - the sink edges are pushed into
+   * @param report - the report issues are recorded in
+   * @param policy - the resolved onMixedDirection option
+   */
+  constructor(sink, report, policy) {
+    this.directedHandle = INVALID_INDEX;
+    this.pairHandle = INVALID_INDEX;
+    this.mutualHandle = INVALID_INDEX;
+    this.firstEdge = -1;
+    this.nextEdge = -1;
+    this.forcedCount = 0;
+    this.headerSet = false;
+    this.mirrorOfLast = INVALID_INDEX;
+    this.sink = sink;
+    this.report = report;
+    this.policy = policy;
+  }
+  /**
+   * The sink's current direction.
+   * @returns true when directed
+   */
+  get directed() {
+    return this.sink.directed;
+  }
+  /**
+   * Whether the graph holds undirected edges stored as two edges.
+   * @returns true once the first such edge was added
+   */
+  get expanded() {
+    return this.pairHandle !== INVALID_INDEX;
+  }
+  /**
+   * Set the graph's direction before the first edge: the direction the file declares, or the
+   * `defaultDirected` option for a file that declares none. Under `onMixedDirection` "directed" or
+   * "undirected" that direction is used instead, with a warning when it differs. When the sink
+   * cannot change direction (a caller's builder that already holds edges or was locked), the
+   * sink's direction stands and a warning is recorded.
+   * @param headerDirected - the direction the file declares (or the default)
+   * @param where - the line of the header, when known
+   */
+  setHeader(headerDirected, where) {
+    this.headerSet = true;
+    let wanted = headerDirected;
+    if (this.policy === "directed" || this.policy === "undirected") {
+      wanted = this.policy === "directed";
+      if (wanted !== headerDirected) {
+        this.report.warnOnce(
+          "coercion",
+          DIRECTION_FORCED_CODE,
+          `the file declares ${direction(headerDirected)} edges; read as ${direction(wanted)} per onMixedDirection`,
+          { line: where?.line ?? null },
+          `${DIRECTION_FORCED_CODE}:${direction(headerDirected)}`
+        );
+      }
+    }
+    const { sink } = this;
+    if (sink.directed === wanted) {
+      this.adoptExisting();
+      return;
+    }
+    try {
+      if (wanted && sink.edgeCount > 0 && !sink.directedLocked) {
+        const before = sink.edgeCount;
+        sink.setDirected(true, { expand: true });
+        this.adoptExpansionColumns();
+        this.report.counts.expandedMixed += before;
+      } else {
+        sink.setDirected(wanted);
+      }
+    } catch (err) {
+      if (!(err instanceof GraphFormatError) || err.code !== "E_DIRECTED") {
+        throw err;
+      }
+      this.report.warning(
+        "coercion",
+        DIRECTION_REFUSED_CODE,
+        `the file is ${direction(wanted)} but the sink is ${direction(sink.directed)} (${reasonOf(err)}); read as ${direction(sink.directed)}`,
+        { line: where?.line ?? null }
+      );
+    }
+    this.adoptExisting();
+  }
+  /**
+   * Pick up reserved columns a caller's sink already holds (an earlier expansion), so every edge
+   * pushed from now on gets its graphty.directed value.
+   */
+  adoptExisting() {
+    if (this.pairHandle === INVALID_INDEX && this.sink.edgeColumn(PAIR_COLUMN) !== INVALID_INDEX) {
+      this.adoptExpansionColumns();
+    }
+  }
+  /**
+   * The second edge of the edge the last addEdge() call added, when that edge was stored as two;
+   * otherwise INVALID_INDEX (4294967295). An edge attribute or weight you set after addEdge()
+   * belongs on both: set it on the index addEdge() returned and, when this is not INVALID_INDEX,
+   * on this index too.
+   * @returns the second edge's index, or INVALID_INDEX
+   */
+  get lastMirror() {
+    return this.mirrorOfLast;
+  }
+  /**
+   * Add one edge. An edge with the graph's direction is added as it is; one with the other
+   * direction is stored as two edges, given the graph's direction, or refused, as
+   * `onMixedDirection` says. When it is stored as two, the return value is the first and
+   * `lastMirror` the second.
+   * @param source - the source id
+   * @param target - the target id
+   * @param kind - the edge's direction in the file
+   * @param weight - the weight, or undefined when the file gives none
+   * @param where - the line and element, for issues
+   * @returns the index of the edge added (the first one, when it was stored as two)
+   */
+  addEdge(source, target, kind, weight, where) {
+    if (!this.headerSet) {
+      throw new GraphFormatError("E_DIRECTED", "DirectionResolver.setHeader() must run before the first edge", {
+        reason: "header not set"
+      });
+    }
+    const { sink } = this;
+    this.mirrorOfLast = INVALID_INDEX;
+    const edgeDirected = kind !== "undirected";
+    if (edgeDirected === sink.directed && kind !== "mutual") {
+      const e = sink.addEdge(source, target, weight);
+      this.track(e);
+      if (this.directedHandle !== INVALID_INDEX) {
+        sink.setEdgeValue(this.directedHandle, e, edgeDirected);
+      }
+      return e;
+    }
+    switch (this.policy) {
+      case "directed":
+      case "undirected": {
+        this.forcedCount++;
+        this.report.warnOnce(
+          "coercion",
+          DIRECTION_FORCED_CODE,
+          `${kind} edges read as ${direction(sink.directed)} per onMixedDirection`,
+          where,
+          `${DIRECTION_FORCED_CODE}:${kind}`
+        );
+        const e = sink.addEdge(source, target, weight);
+        this.track(e);
+        if (this.directedHandle !== INVALID_INDEX) {
+          sink.setEdgeValue(this.directedHandle, e, sink.directed);
+        }
+        return e;
+      }
+      case "error":
+        this.report.error(
+          "validation-error",
+          MIXED_DIRECTION_CODE,
+          `${kind} edge in a ${direction(sink.directed)} graph (onMixedDirection: "error")`,
+          where
+        );
+        throw this.report.abort("mixed direction refused", { code: MIXED_DIRECTION_CODE });
+      case "expand":
+        return this.expand(source, target, kind, weight, where);
+      default: {
+        const name = this.policy;
+        throw new GraphFormatError("E_UNSUPPORTED", `unknown onMixedDirection ${name}`, {
+          option: "onMixedDirection",
+          found: name
+        });
+      }
+    }
+  }
+  /**
+   * How many edges were given a direction other than their own, under `onMixedDirection`
+   * "directed" or "undirected".
+   * @returns the count
+   */
+  get forced() {
+    return this.forcedCount;
+  }
+  /**
+   * Expand one edge that differs from the sink's direction.
+   * @param source - the source id
+   * @param target - the target id
+   * @param kind - the edge's direction in the file
+   * @param weight - the weight, or undefined
+   * @param where - the line and element, for issues
+   * @returns the primary edge index
+   */
+  expand(source, target, kind, weight, where) {
+    const { sink } = this;
+    if (!sink.directed) {
+      try {
+        const before = sink.edgeCount;
+        sink.setDirected(true, { expand: true });
+        this.adoptExpansionColumns();
+        this.report.counts.expandedMixed += before;
+      } catch (err) {
+        if (!(err instanceof GraphFormatError) || err.code !== "E_DIRECTED") {
+          throw err;
+        }
+        this.report.error(
+          "coercion",
+          DIRECTION_REFUSED_CODE,
+          `${direction(true)} edge in a locked ${direction(false)} sink cannot be expanded`,
+          where
+        );
+        throw this.report.abort("the sink refused the expansion to directed", {
+          code: DIRECTION_REFUSED_CODE,
+          reason: err.details.reason
+        });
+      }
+      if (kind === "directed") {
+        const e = sink.addEdge(source, target, weight);
+        this.track(e);
+        sink.setEdgeValue(this.directedHandle, e, true);
+        return e;
+      }
+    }
+    this.ensureExpansionColumns();
+    const first = sink.addEdge(source, target, weight);
+    this.track(first);
+    const mutual = kind === "mutual";
+    sink.setEdgeValue(this.directedHandle, first, mutual);
+    this.report.counts.expandedMixed++;
+    if (mutual) {
+      this.ensureMutualColumn();
+      sink.setEdgeValue(this.mutualHandle, first, true);
+    }
+    const u = sink.indexOf(source);
+    const v = sink.indexOf(target);
+    if (u === v) {
+      return first;
+    }
+    const mirror = sink.addEdge(target, source, weight);
+    this.track(mirror);
+    this.mirrorOfLast = mirror;
+    sink.setEdgeValue(this.directedHandle, mirror, mutual);
+    sink.setEdgeValue(this.pairHandle, first, mirror);
+    sink.setEdgeValue(this.pairHandle, mirror, first);
+    return first;
+  }
+  /**
+   * Note an edge index this resolver pushed, for the backfill of graphty.directed.
+   * @param e - the edge index
+   */
+  track(e) {
+    if (this.firstEdge < 0) {
+      this.firstEdge = e;
+    }
+    this.nextEdge = e + 1;
+  }
+  /**
+   * Pick up the reserved columns the builder wrote during its own expansion.
+   */
+  adoptExpansionColumns() {
+    this.directedHandle = this.sink.declareEdgeColumn(DIRECTED_DECL);
+    this.pairHandle = this.sink.declareEdgeColumn(PAIR_DECL);
+  }
+  /**
+   * Declare the reserved columns on first use in a directed sink and backfill graphty.directed
+   * = true for every edge this resolver pushed so far (they were directed in the source).
+   */
+  ensureExpansionColumns() {
+    if (this.pairHandle !== INVALID_INDEX) {
+      return;
+    }
+    this.directedHandle = this.sink.declareEdgeColumn(DIRECTED_DECL);
+    this.pairHandle = this.sink.declareEdgeColumn(PAIR_DECL);
+    if (this.firstEdge >= 0) {
+      for (let e = this.firstEdge; e < this.nextEdge; e++) {
+        this.sink.setEdgeValue(this.directedHandle, e, true);
+      }
+    }
+  }
+  /** Declare graphty.mutual on first use. */
+  ensureMutualColumn() {
+    if (this.mutualHandle === INVALID_INDEX) {
+      this.mutualHandle = this.sink.declareEdgeColumn(MUTUAL_DECL);
+    }
+  }
+}
+function reasonOf(err) {
+  const { reason } = err.details;
+  return typeof reason === "string" ? reason : "refused";
+}
+function direction(directed) {
+  return directed ? "directed" : "undirected";
+}
+function pairFolding(snapshot, options = {}) {
+  const foldMutual = options.foldMutual ?? false;
+  const directedColumn = roleColumn(snapshot.edges.byRole("directed"), "bool");
+  const pairColumn = roleColumn(snapshot.edges.byRole("pair"), "u32");
+  const mutualColumn = roleColumn(snapshot.edges.byRole("mutual"), "bool");
+  const { edgeCount } = snapshot;
+  const mateOf = (e) => {
+    if (pairColumn === null || !pairColumn.isSet(e)) {
+      return INVALID_INDEX;
+    }
+    const mate = pairColumn.value(e);
+    return typeof mate === "number" && mate !== INVALID_INDEX ? mate : INVALID_INDEX;
+  };
+  const sourceDirected = (e) => directedColumn === null || !directedColumn.isSet(e) || directedColumn.value(e) === true;
+  const isMutual = (e) => {
+    if (mutualColumn === null) {
+      return false;
+    }
+    if (mutualColumn.isSet(e) && mutualColumn.value(e) === true) {
+      return true;
+    }
+    const mate = mateOf(e);
+    return mate !== INVALID_INDEX && mutualColumn.isSet(mate) && mutualColumn.value(mate) === true;
+  };
+  const folded = (e) => {
+    const mate = mateOf(e);
+    if (mate === INVALID_INDEX || mate >= e) {
+      return false;
+    }
+    return !sourceDirected(e) || foldMutual && isMutual(e);
+  };
+  let mutualCount = 0;
+  if (mutualColumn !== null) {
+    for (let e = 0; e < edgeCount; e++) {
+      if (mutualColumn.isSet(e) && mutualColumn.value(e) === true && mateOf(e) > e) {
+        mutualCount++;
+      }
+    }
+  }
+  return { expanded: pairColumn !== null, mutualCount, folded, mateOf, sourceDirected, isMutual };
+}
+function roleColumn(column, dtype) {
+  return column !== null && column.dtype === dtype ? column : null;
+}
+const CANONICAL_INTEGER = /^-?(0|[1-9][0-9]*)$/;
+function canonicalId(text) {
+  if (text !== "-0" && CANONICAL_INTEGER.test(text)) {
+    const n = Number(text);
+    if (Number.isSafeInteger(n)) {
+      return n;
+    }
+  }
+  return text;
+}
+function isCanonicalIntegerText(text) {
+  return typeof canonicalId(text) === "number";
+}
+function coerceIdText(text, mode) {
+  switch (mode) {
+    case "keep":
+    case "string":
+      return text;
+    case "canonical":
+      return canonicalId(text);
+    case "number": {
+      if (text.trim().length === 0) {
+        throw invalidId(text, "empty text is not a number");
+      }
+      const n = Number(text);
+      if (!Number.isFinite(n)) {
+        throw invalidId(text, "not a finite number");
+      }
+      return n;
+    }
+    default: {
+      const name = mode;
+      throw new GraphFormatError("E_UNSUPPORTED", `unknown id coercion ${name}`, { option: "ids", found: name });
+    }
+  }
+}
+function coerceId(value, mode) {
+  if (typeof value === "string") {
+    return coerceIdText(value, mode);
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw invalidId(value, "not a finite number");
+    }
+    return mode === "string" ? String(value) : value;
+  }
+  if (mode === "string" && (typeof value === "boolean" || typeof value === "bigint" || value === null)) {
+    return String(value);
+  }
+  throw invalidId(value, `a ${value === null ? "null" : typeof value} is not an id under ids: "${mode}"`);
+}
+function invalidId(value, reason) {
+  const shown = typeof value === "string" || typeof value === "number" ? value : typeof value;
+  return new GraphFormatError("E_INVALID_ID", `invalid node id ${JSON.stringify(shown)}: ${reason}`, {
+    reason,
+    value: typeof value === "bigint" ? value.toString() : value
+  });
+}
+class IdCoercer {
+  /**
+   * Create a coercer.
+   * @param mode - the rule
+   */
+  constructor(mode) {
+    this.mergeCount = 0;
+    this.lastMerge = null;
+    this.mode = mode;
+    this.firstText = mode === "number" ? /* @__PURE__ */ new Map() : null;
+  }
+  /**
+   * Coerce a text cell, recording a merge under "number" when a different text already produced
+   * the same number.
+   * @param text - the cell text
+   * @returns the id
+   */
+  text(text) {
+    const id = coerceIdText(text, this.mode);
+    this.lastMerge = null;
+    if (this.firstText !== null && typeof id === "number") {
+      const previous = this.firstText.get(id);
+      if (previous === void 0) {
+        this.firstText.set(id, text);
+      } else if (previous !== text) {
+        this.mergeCount++;
+        this.lastMerge = { id, text, previousText: previous };
+      }
+    }
+    return id;
+  }
+  /**
+   * Coerce a typed value.
+   * @param value - the value
+   * @returns the id
+   */
+  value(value) {
+    if (typeof value === "string") {
+      return this.text(value);
+    }
+    this.lastMerge = null;
+    return coerceId(value, this.mode);
+  }
+}
+const HEAD_BYTES = 1024;
+const BOM_BYTES = 4;
+function canonicalEncoding(label) {
+  try {
+    return new TextDecoder(label.trim()).encoding;
+  } catch {
+    return null;
+  }
+}
+function bomEncoding(head) {
+  if (startsWithBytes(head, [255, 254, 0, 0])) {
+    return "utf-32le";
+  }
+  if (startsWithBytes(head, [0, 0, 254, 255])) {
+    return "utf-32be";
+  }
+  if (startsWithBytes(head, [239, 187, 191])) {
+    return "utf-8";
+  }
+  if (startsWithBytes(head, [255, 254])) {
+    return "utf-16le";
+  }
+  if (startsWithBytes(head, [254, 255])) {
+    return "utf-16be";
+  }
+  return null;
+}
+function startsWithBytes(bytes, signature) {
+  return bytes.byteLength >= signature.length && signature.every((b, i) => bytes[i] === b);
+}
+function bomlessUtf16(head) {
+  const pairs = Math.min(head.byteLength >> 1, 512);
+  if (pairs < 2) {
+    return null;
+  }
+  let le = 0;
+  let be = 0;
+  for (let i = 0; i < pairs; i++) {
+    const even = head[2 * i];
+    const odd = head[2 * i + 1];
+    if (even !== 0 && odd === 0) {
+      le++;
+    } else if (even === 0 && odd !== 0) {
+      be++;
+    }
+  }
+  if (le >= pairs * 0.9) {
+    return "utf-16le";
+  }
+  return be >= pairs * 0.9 ? "utf-16be" : null;
+}
+function xmlDeclarationUtf16(head) {
+  if (startsWithBytes(head, [60, 0, 63, 0])) {
+    return "utf-16le";
+  }
+  return startsWithBytes(head, [0, 60, 0, 63]) ? "utf-16be" : null;
+}
+function foreignKind(head) {
+  if (typeof head !== "string") {
+    if (startsWithBytes(head, [31, 139])) {
+      return "gzip-compressed data (decompress it first)";
+    }
+    if (startsWithBytes(head, [80, 75, 3, 4]) || startsWithBytes(head, [80, 75, 5, 6])) {
+      return "a zip archive (a Cytoscape session (.cys) is read by the cys importer; extract any other graph file from it first)";
+    }
+    if (startsWithBytes(head, [137, 80, 78, 71])) {
+      return "a PNG image";
+    }
+  }
+  const text = typeof head === "string" ? head.slice(0, 64) : String.fromCodePoint(...head.subarray(0, 64));
+  const utf8Bom = String.fromCodePoint(239, 187, 191);
+  let body = text.startsWith(utf8Bom) ? text.slice(3) : text;
+  body = body.startsWith(BOM) ? body.slice(1) : body;
+  if (body.startsWith("%PDF-")) {
+    return "a PDF document";
+  }
+  if (/^\s*(<!doctype\s+html[\s>]|<html[\s>])/i.test(body)) {
+    return "an HTML document (likely an error page saved in place of the file)";
+  }
+  return null;
+}
+function refuseForeign(head, report, options) {
+  const foreign = foreignKind(head);
+  if (foreign !== null && !(options.xml === true && foreign.startsWith("an HTML"))) {
+    report.fail(FOREIGN_FORMAT_CODE, `the input is ${foreign}, not ${report.format} text`);
+  }
+}
+function sameFamily(a, b) {
+  return a === b || a.startsWith("utf-16") && b.startsWith("utf-16");
+}
+class ByteDecoder {
+  /**
+   * Create the decoder of one import.
+   * @param report - where warnings and the fatal decode error go
+   * @param options - the encoding option and the format's declaration reader
+   */
+  constructor(report, options) {
+    this.report = report;
+    this.options = options;
+    this.decoder = null;
+    this.encoding = "utf-8";
+    this.mayFallBack = false;
+    this.asciiSoFar = true;
+    this.carry = new Uint8Array(0);
+    this.offset = 0;
+    this.fellBack = false;
+    this.control = null;
+    this.subAt = -1;
+    this.textFollows = false;
+    this.declaredUtf8 = false;
+    this.mixedPending = false;
+  }
+  /**
+   * Whether start() ran.
+   * @returns true once the encoding is chosen
+   */
+  get started() {
+    return this.decoder !== null;
+  }
+  /**
+   * Choose the encoding from the first bytes of the input: a BOM, else the option, else the
+   * declaration, else UTF-8 (see the module comment), warning where two of them disagree.
+   * @param head - the first bytes (up to the declaration size; fewer when the input is shorter)
+   */
+  start(head) {
+    refuseForeign(head, this.report, this.options);
+    const explicit = this.options.encoding ?? null;
+    const bom = bomEncoding(head);
+    if (bom === "utf-32le" || bom === "utf-32be") {
+      this.report.fail(
+        INVALID_ENCODING_CODE,
+        `the input starts with a ${bom.toUpperCase()} byte order mark; UTF-32 is not supported (convert the file to UTF-8)`,
+        void 0,
+        { byteOffset: 0 }
+      );
+    }
+    if (bom !== null) {
+      const option = explicit === null ? null : canonicalEncoding(explicit);
+      if (option !== null && option !== bom) {
+        this.conflict(`the encoding option says ${option} but the byte order mark says ${bom}; read as ${bom}`);
+      }
+      this.checkDeclaration(head, bom, "its byte order mark says");
+      this.use(bom, false);
+      return;
+    }
+    if (explicit !== null) {
+      this.use(explicit, false);
+      this.checkDeclaration(head, this.encoding, "the encoding option says");
+      return;
+    }
+    const xmlUtf16 = xmlDeclarationUtf16(head);
+    if (xmlUtf16 !== null) {
+      this.checkDeclaration(head, xmlUtf16, "its XML declaration's byte pattern says");
+      this.use(xmlUtf16, false);
+      return;
+    }
+    const utf16 = bomlessUtf16(head);
+    if (utf16 !== null && this.options.bomlessUtf16 === true) {
+      this.use(utf16, false);
+      return;
+    }
+    if (utf16 !== null) {
+      this.report.fail(
+        INVALID_ENCODING_CODE,
+        `the input looks like ${utf16} text without a byte order mark (every other byte is 0); pass the encoding option ${JSON.stringify(utf16)} to read it`,
+        void 0,
+        { byteOffset: 0 }
+      );
+    }
+    const declared = this.declared(head, "windows-1252");
+    if (declared !== null) {
+      const canonical = canonicalEncoding(declared);
+      if (canonical === null) {
+        this.report.warning(
+          "unsupported",
+          UNKNOWN_ENCODING_CODE,
+          `the input declares the encoding ${JSON.stringify(declared)}, which this platform cannot decode; reading it as UTF-8`,
+          { element: declared }
+        );
+      } else if (canonical.startsWith("utf-16")) {
+        this.conflict(
+          `the input declares ${JSON.stringify(declared)} but has no byte order mark and its bytes are not UTF-16; read as UTF-8`
+        );
+      } else if (canonical === "utf-8") {
+        this.declaredUtf8 = true;
+      } else {
+        this.use(canonical, false);
+        return;
+      }
+    }
+    this.use("utf-8", true);
+  }
+  /**
+   * The encoding the head declares, read through the format's declaration reader.
+   * @param head - the first bytes
+   * @param encoding - the encoding to read the head in for the reader
+   * @returns the declared label, or null (also for a format without declarations)
+   */
+  declared(head, encoding) {
+    const reader = this.options.declaredEncoding;
+    return reader === void 0 ? null : reader(new TextDecoder(encoding).decode(head));
+  }
+  /**
+   * Warn when the file declares an encoding other than the one a BOM or the option chose.
+   * @param head - the first bytes
+   * @param chosen - the encoding the input is read in
+   * @param why - what chose it, for the message
+   */
+  checkDeclaration(head, chosen, why) {
+    const declared = this.declared(head, chosen);
+    const canonical = declared === null ? null : canonicalEncoding(declared);
+    if (canonical !== null && !sameFamily(canonical, chosen)) {
+      this.conflict(
+        `the input declares the encoding ${JSON.stringify(declared)} but ${why} ${chosen}; read as ${chosen}`
+      );
+    }
+  }
+  /**
+   * Record a W_ENCODING_CONFLICT warning.
+   * @param message - which sources disagree and which applies
+   */
+  conflict(message) {
+    this.report.warning("coercion", ENCODING_CONFLICT_CODE, message);
+  }
+  /**
+   * Decode the next bytes.
+   * @param input - the bytes
+   * @param stream - whether more bytes follow
+   * @returns the text
+   */
+  decode(input, stream) {
+    const bytes = typeof SharedArrayBuffer === "function" && input.buffer instanceof SharedArrayBuffer ? input.slice() : input;
+    const decoder = this.decoder;
+    if (this.fellBack || this.mayFallBack && this.asciiSoFar) {
+      this.watch(bytes, !stream);
+      if (this.fellBack && this.control !== null) {
+        this.binary(this.control);
+      }
+    }
+    const text = this.decodeOrRecover(decoder, bytes, stream);
+    if (this.mixedPending) {
+      this.reportUtf8After(bytes, this.offset);
+    }
+    if (this.asciiSoFar && this.mayFallBack) {
+      this.trackAscii(bytes, text);
+    }
+    if (this.mayFallBack && this.options.nulIsBinary === true && text.includes("\0")) {
+      this.binary({ at: this.offset + bytes.indexOf(0), byte: 0 });
+    }
+    this.offset += bytes.byteLength;
+    return text;
+  }
+  /**
+   * Decode bytes, recovering from bytes that are not valid in the encoding.
+   * @param decoder - the decoder
+   * @param bytes - the bytes
+   * @param stream - whether more bytes follow
+   * @returns the text
+   */
+  decodeOrRecover(decoder, bytes, stream) {
+    try {
+      return decoder.decode(bytes, { stream });
+    } catch (err) {
+      if (!(err instanceof TypeError)) {
+        throw err;
+      }
+      return this.recover(bytes, stream);
+    }
+  }
+  /**
+   * Track whether the input is ASCII so far. While it is, every character is one byte, so the
+   * bytes not yet emitted are held back for a fallback.
+   * @param bytes - the bytes just decoded
+   * @param text - their text
+   */
+  trackAscii(bytes, text) {
+    if (/[\u0080-\uffff]/.test(text)) {
+      this.asciiSoFar = false;
+      this.carry = new Uint8Array(0);
+      return;
+    }
+    const all = this.carry.byteLength === 0 ? bytes : concatBytes([this.carry, bytes]);
+    this.carry = all.slice(text.length);
+  }
+  /**
+   * Flush the bytes held back because a text chunk follows (the input switches from bytes to
+   * strings): a multi-byte sequence cut there is invalid UTF-8, never windows-1252 text.
+   * @param flush - the flush to run (the decoder's own, or the head's)
+   * @returns the text of the held-back bytes
+   */
+  flushBeforeText(flush) {
+    this.textFollows = true;
+    try {
+      return flush();
+    } finally {
+      this.textFollows = false;
+    }
+  }
+  /**
+   * A decode failed: switch to windows-1252 when allowed, else fail the import with the position
+   * of the first byte that is not valid.
+   * @param bytes - the bytes that failed
+   * @param stream - whether more bytes follow
+   * @returns the bytes decoded as windows-1252
+   */
+  recover(bytes, stream) {
+    const all = this.carry.byteLength === 0 ? bytes : concatBytes([this.carry, bytes]);
+    const base = this.offset - this.carry.byteLength;
+    const bad = this.encoding === "utf-8" ? invalidUtf8(all) : null;
+    const at = base + (bad === null ? 0 : bad.index);
+    if (this.mayFallBack && this.asciiSoFar) {
+      if (this.control !== null) {
+        return this.binary(this.control);
+      }
+      if (this.textFollows && bad?.cut === true) {
+        return this.report.fail(
+          INVALID_UTF8_CODE,
+          `invalid UTF-8 at byte ${at}: a byte chunk ends inside a multi-byte sequence and a text chunk follows`,
+          void 0,
+          { byteOffset: at }
+        );
+      }
+      if (!stream && bad?.truncated === true) {
+        return this.report.fail(
+          INVALID_UTF8_CODE,
+          `the input ends in the middle of a UTF-8 sequence at byte ${at} (it may be truncated)`,
+          void 0,
+          { byteOffset: at }
+        );
+      }
+      if (!startsWithUtf8(all)) {
+        const cutNote = !stream && bad?.cut === true ? ": it ends inside a multi-byte UTF-8 sequence, so it may be truncated" : "";
+        this.report.warning(
+          "coercion",
+          ENCODING_FALLBACK_CODE,
+          this.declaredUtf8 ? `the input declares UTF-8 but is not valid UTF-8 (at byte ${at}); everything before was ASCII, so it is read as windows-1252 (pass the encoding option to choose another)` : `the input is not valid UTF-8 (at byte ${at}${cutNote}) and declares no encoding; read as windows-1252 (pass the encoding option to choose another)`
+        );
+        this.use("windows-1252", false);
+        this.fellBack = true;
+        this.mixedPending = true;
+        this.reportUtf8After(all, base);
+        return this.decoder.decode(all, { stream });
+      }
+    }
+    if (this.encoding === "utf-8") {
+      const after = this.mayFallBack ? " after valid non-ASCII UTF-8 text; pass the encoding option" : "";
+      return this.report.fail(INVALID_UTF8_CODE, `invalid UTF-8 at byte ${at}${after}`, void 0, {
+        byteOffset: at
+      });
+    }
+    const end = this.offset + bytes.byteLength;
+    const odd = !stream && this.encoding.startsWith("utf-16") && end % 2 === 1;
+    return this.report.fail(
+      INVALID_ENCODING_CODE,
+      odd ? `the input ends with half a ${this.encoding} code unit at byte ${end - 1} (it may be truncated)` : `the bytes near byte ${base} are not valid ${this.encoding}`,
+      void 0,
+      { byteOffset: odd ? end - 1 : base }
+    );
+  }
+  /**
+   * After the windows-1252 fallback, report once that later bytes hold a valid multi-byte UTF-8
+   * sequence: the input mixes encodings, and those characters are read as two or three
+   * windows-1252 characters each.
+   * @param bytes - bytes being decoded as windows-1252
+   * @param start - the byte offset of the first of them
+   */
+  reportUtf8After(bytes, start) {
+    const at = utf8SequenceIndex(bytes);
+    if (at < 0) {
+      return;
+    }
+    this.mixedPending = false;
+    this.report.warning(
+      "coercion",
+      ENCODING_FALLBACK_CODE,
+      `bytes read as windows-1252 hold valid UTF-8 (at byte ${start + at}): the input mixes encodings, and its UTF-8 characters are read as windows-1252 (pass the encoding option to choose one)`
+    );
+  }
+  /**
+   * Note the first control byte of the next bytes (see `control`).
+   * @param bytes - the bytes, starting at `offset`
+   * @param final - whether they end the input
+   */
+  watch(bytes, final) {
+    if (this.control !== null || bytes.byteLength === 0) {
+      return;
+    }
+    if (this.subAt >= 0) {
+      this.control = { at: this.subAt, byte: 26 };
+      return;
+    }
+    const index = controlByte(bytes, true);
+    if (index >= 0) {
+      this.control = { at: this.offset + index, byte: bytes[index] };
+    } else if (!final && bytes[bytes.byteLength - 1] === 26) {
+      this.subAt = this.offset + bytes.byteLength - 1;
+    }
+  }
+  /**
+   * Fail the import as binary data.
+   * @param control - the control byte that shows it
+   * @param control.at - its offset
+   * @param control.byte - its value
+   * @returns never
+   */
+  binary(control) {
+    const hex = control.byte.toString(16).padStart(2, "0");
+    return this.report.fail(
+      INVALID_UTF8_CODE,
+      `the input is binary data, not text: control byte 0x${hex} at byte ${control.at}`,
+      void 0,
+      { byteOffset: control.at }
+    );
+  }
+  /**
+   * Switch to an encoding.
+   * @param label - the encoding label
+   * @param mayFallBack - whether a UTF-8 failure may switch to windows-1252
+   */
+  use(label, mayFallBack) {
+    this.decoder = new TextDecoder(label, { fatal: true, ignoreBOM: true });
+    this.encoding = this.decoder.encoding;
+    this.mayFallBack = mayFallBack;
+  }
+}
+function utf8SequenceIndex(bytes) {
+  for (let i = 0; i < bytes.byteLength; i++) {
+    if (bytes[i] >= 194 && isUtf8SequenceAt(bytes, i)) {
+      return i;
+    }
+  }
+  return -1;
+}
+function startsWithUtf8(bytes) {
+  const i = bytes.findIndex((b) => b >= 128);
+  return i >= 0 && isUtf8SequenceAt(bytes, i);
+}
+const STRICT_UTF8 = new TextDecoder("utf-8", { fatal: true });
+function isUtf8SequenceAt(bytes, i) {
+  const lead = bytes[i];
+  let length = 0;
+  if (lead >= 194 && lead <= 223) {
+    length = 2;
+  } else if (lead >= 224 && lead <= 239) {
+    length = 3;
+  } else if (lead >= 240 && lead <= 244) {
+    length = 4;
+  }
+  if (length === 0 || i + length > bytes.byteLength) {
+    return false;
+  }
+  try {
+    STRICT_UTF8.decode(bytes.subarray(i, i + length));
+    return true;
+  } catch {
+    return false;
+  }
+}
+const CP437_HIGH = [
+  199,
+  252,
+  233,
+  226,
+  228,
+  224,
+  229,
+  231,
+  234,
+  235,
+  232,
+  239,
+  238,
+  236,
+  196,
+  197,
+  201,
+  230,
+  198,
+  244,
+  246,
+  242,
+  251,
+  249,
+  255,
+  214,
+  220,
+  162,
+  163,
+  165,
+  8359,
+  402,
+  225,
+  237,
+  243,
+  250,
+  241,
+  209,
+  170,
+  186,
+  191,
+  8976,
+  172,
+  189,
+  188,
+  161,
+  171,
+  187,
+  9617,
+  9618,
+  9619,
+  9474,
+  9508,
+  9569,
+  9570,
+  9558,
+  9557,
+  9571,
+  9553,
+  9559,
+  9565,
+  9564,
+  9563,
+  9488,
+  9492,
+  9524,
+  9516,
+  9500,
+  9472,
+  9532,
+  9566,
+  9567,
+  9562,
+  9556,
+  9577,
+  9574,
+  9568,
+  9552,
+  9580,
+  9575,
+  9576,
+  9572,
+  9573,
+  9561,
+  9560,
+  9554,
+  9555,
+  9579,
+  9578,
+  9496,
+  9484,
+  9608,
+  9604,
+  9612,
+  9616,
+  9600,
+  945,
+  223,
+  915,
+  960,
+  931,
+  963,
+  181,
+  964,
+  934,
+  920,
+  937,
+  948,
+  8734,
+  966,
+  949,
+  8745,
+  8801,
+  177,
+  8805,
+  8804,
+  8992,
+  8993,
+  247,
+  8776,
+  176,
+  8729,
+  183,
+  8730,
+  8319,
+  178,
+  9632,
+  160
+];
+function invalidUtf8(bytes) {
+  let i = 0;
+  while (i < bytes.byteLength) {
+    const lead = bytes[i];
+    const sequence = lead < 128 ? ASCII_SEQUENCE : utf8Sequence(lead);
+    if (sequence === null) {
+      return { index: i, truncated: false, cut: false };
+    }
+    const problem = checkContinuation(bytes, i, sequence);
+    if (problem !== null) {
+      return problem;
+    }
+    i += sequence.need + 1;
+  }
+  return { index: 0, truncated: false, cut: false };
+}
+const ASCII_SEQUENCE = { need: 0, low: 128, high: 191 };
+function utf8Sequence(lead) {
+  if (lead >= 194 && lead <= 223) {
+    return { need: 1, low: 128, high: 191 };
+  }
+  if (lead >= 224 && lead <= 239) {
+    return { need: 2, low: lead === 224 ? 160 : 128, high: lead === 237 ? 159 : 191 };
+  }
+  if (lead >= 240 && lead <= 244) {
+    return { need: 3, low: lead === 240 ? 144 : 128, high: lead === 244 ? 143 : 191 };
+  }
+  return null;
+}
+function checkContinuation(bytes, i, sequence) {
+  for (let k = 1; k <= sequence.need; k++) {
+    if (i + k >= bytes.byteLength) {
+      return { index: i, truncated: k > 1, cut: true };
+    }
+    const next = bytes[i + k];
+    const low = k === 1 ? sequence.low : 128;
+    const high = k === 1 ? sequence.high : 191;
+    if (next < low || next > high) {
+      return { index: i, truncated: false, cut: false };
+    }
+  }
+  return null;
+}
+function controlByte(bytes, final) {
+  const last = bytes.byteLength - 1;
+  return bytes.findIndex(
+    (b, i) => b < 32 && b !== 9 && b !== 10 && b !== 12 && b !== 13 && !(b === 26 && final && i === last)
+  );
+}
+function decodeEntryName(bytes, cp437 = false) {
+  try {
+    return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
+  } catch {
+    if (!cp437) {
+      return new TextDecoder("windows-1252").decode(bytes);
+    }
+    let out = "";
+    for (const byte of bytes) {
+      out += String.fromCodePoint(byte < 128 ? byte : CP437_HIGH[byte - 128]);
+    }
+    return out;
+  }
+}
+function concatBytes(chunks) {
+  if (chunks.length === 1) {
+    return chunks[0];
+  }
+  const out = new Uint8Array(chunks.reduce((sum, c) => sum + c.byteLength, 0));
+  let offset = 0;
+  for (const chunk of chunks) {
+    out.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return out;
+}
+const DECODE_SLICE = 256 * 1024;
+const BOM = String.fromCharCode(65279);
+const SUB = String.fromCodePoint(26);
+const MAX_TEXT_LENGTH = 2 ** 29 - 24;
+const CONTROL_CHARACTER = new RegExp(
+  `[${String.fromCodePoint(0)}-${String.fromCodePoint(8, 11, 14)}-${String.fromCodePoint(31, 127)}-${String.fromCodePoint(159)}${BOM}]`
+);
+function isImportInput(input) {
+  if (typeof input === "string" || asBytes(input) !== null) {
+    return true;
+  }
+  if (typeof input !== "object" || input === null) {
+    return false;
+  }
+  return typeof input.getReader === "function" || Symbol.asyncIterator in input;
+}
+function asBytes(value) {
+  if (value instanceof Uint8Array) {
+    return value;
+  }
+  if (ArrayBuffer.isView(value) && Object.prototype.toString.call(value) === "[object Uint8Array]") {
+    return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+  }
+  return null;
+}
+function normalizeInput(input) {
+  if (typeof input === "string") {
+    return input;
+  }
+  const bytes = asBytes(input);
+  if (bytes !== null) {
+    return bytes;
+  }
+  if (isImportInput(input)) {
+    return input;
+  }
+  const tag = Object.prototype.toString.call(input).slice(8, -1);
+  let found = input === null ? "null" : typeof input;
+  let fix = "";
+  if (tag === "ArrayBuffer" || tag === "SharedArrayBuffer") {
+    found = `an ${tag}`;
+    fix = "; wrap it as new Uint8Array(buffer)";
+  } else if (ArrayBuffer.isView(input)) {
+    found = `a ${tag}`;
+    fix = "; pass new Uint8Array(view.buffer, view.byteOffset, view.byteLength)";
+  } else if (typeof input === "object" && input !== null) {
+    const object = input;
+    if (typeof object.stream === "function" && typeof object.size === "number") {
+      found = "a Blob or File";
+      fix = "; pass blob.stream()";
+    } else if ("body" in object && typeof object.arrayBuffer === "function") {
+      found = "a fetch Response";
+      fix = "; pass response.body";
+    } else {
+      found = `an object (${tag})`;
+    }
+  }
+  throw new GraphFormatError(
+    "E_UNSUPPORTED",
+    `the input is ${found}; an importer reads a string, a Uint8Array, a ReadableStream or an async iterable of strings and Uint8Arrays${fix}`,
+    { reason: "input type", found }
+  );
+}
+function inputLength(input) {
+  if (typeof input === "string") {
+    return input.length;
+  }
+  if (input instanceof Uint8Array) {
+    return input.byteLength;
+  }
+  return null;
+}
+function utf8Length(text) {
+  let bytes = 0;
+  let i = 0;
+  while (i < text.length) {
+    const c = text.charCodeAt(i);
+    const pair = c >= 55296 && c <= 56319 && (text.charCodeAt(i + 1) & 64512) === 56320;
+    if (c < 128) {
+      bytes++;
+    } else if (c < 2048) {
+      bytes += 2;
+    } else {
+      bytes += pair ? 4 : 3;
+    }
+    i += pair ? 2 : 1;
+  }
+  return bytes;
+}
+function throwIfAborted(signal) {
+  if (signal === null || signal === void 0 || !signal.aborted) {
+    return;
+  }
+  const { reason } = signal;
+  if (reason === void 0) {
+    throw abortError();
+  }
+  throw reason;
+}
+function abortError() {
+  const message = "The import was aborted";
+  if (typeof DOMException === "function") {
+    return new DOMException(message, "AbortError");
+  }
+  const err = new Error(message);
+  err.name = "AbortError";
+  return err;
+}
+function abortable(promise, signal) {
+  if (signal === null || typeof signal.addEventListener !== "function") {
+    return promise;
+  }
+  return new Promise((resolve, reject) => {
+    const onAbort = () => {
+      try {
+        throwIfAborted(signal);
+      } catch (err) {
+        reject(err);
+      }
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise.then(
+      (value) => {
+        signal.removeEventListener("abort", onAbort);
+        resolve(value);
+      },
+      (err) => {
+        signal.removeEventListener("abort", onAbort);
+        reject(err);
+      }
+    );
+  });
+}
+function lockReader(stream) {
+  if (stream.locked) {
+    throw new GraphFormatError(
+      "E_UNSUPPORTED",
+      "the input ReadableStream is locked: another reader holds it (release it, or pass a fresh stream)",
+      { reason: "stream locked" }
+    );
+  }
+  return stream.getReader();
+}
+class TextFilter {
+  /**
+   * Create the filter of one import.
+   * @param report - where the warnings and the fatal errors go
+   * @param options - whether an empty input is valid, whether the format is XML
+   */
+  constructor(report, options) {
+    this.report = report;
+    this.options = options;
+    this.first = true;
+    this.content = false;
+    this.heldSub = false;
+    this.warned = false;
+    this.strayBom = false;
+  }
+  /**
+   * Filter the next decoded text.
+   * @param chunk - the text
+   * @returns the text to hand on
+   */
+  push(chunk) {
+    let text = this.heldSub ? SUB + chunk : chunk;
+    this.heldSub = false;
+    if (text.length === 0) {
+      return text;
+    }
+    if (this.first) {
+      text = this.skipByteOrderMarks(text);
+      if (text.length === 0) {
+        return text;
+      }
+      this.first = false;
+      refuseForeign(text, this.report, this.options);
+    }
+    if (text.endsWith(SUB)) {
+      this.heldSub = true;
+      text = text.slice(0, -1);
+    }
+    if (!this.content && /\S/.test(text)) {
+      this.content = true;
+    }
+    if (!this.warned) {
+      this.warnControl(text);
+    }
+    return text;
+  }
+  /**
+   * Drop the byte order marks the input starts with, warning when there is more than one.
+   * @param text - the first text
+   * @returns the text without them
+   */
+  skipByteOrderMarks(text) {
+    let start = 0;
+    while (text.codePointAt(start) === 65279) {
+      start++;
+    }
+    if (start > 1 && !this.strayBom) {
+      this.strayBom = true;
+      this.report.warning(
+        "validation-error",
+        CONTROL_CHARACTER_CODE,
+        `the input starts with ${start} byte order marks (U+FEFF); the extra ones were ignored`,
+        { element: "U+FEFF" }
+      );
+    }
+    return text.slice(start);
+  }
+  /**
+   * Warn, once, about the first control character the text holds.
+   * @param text - the text
+   */
+  warnControl(text) {
+    const match = CONTROL_CHARACTER.exec(text);
+    if (match === null) {
+      return;
+    }
+    this.warned = true;
+    const code = (match[0].codePointAt(0) ?? 0).toString(16).toUpperCase().padStart(4, "0");
+    const around = JSON.stringify(text.slice(Math.max(0, match.index - 20), match.index + 20));
+    this.report.warning(
+      "validation-error",
+      CONTROL_CHARACTER_CODE,
+      `the input holds the control character U+${code} (in ${around}); it is kept in the id or value it is part of`,
+      { element: `U+${code}` }
+    );
+  }
+  /** The input ended: drop a held Ctrl-Z with a warning, and refuse an input without content. */
+  end() {
+    if (this.heldSub) {
+      this.report.warning(
+        "validation-error",
+        CONTROL_CHARACTER_CODE,
+        "the input ends with a Ctrl-Z (0x1A), the DOS end-of-file marker; it was ignored",
+        { element: "U+001A" }
+      );
+    }
+    if (!this.content && this.options.allowEmpty !== true) {
+      this.report.fail(EMPTY_INPUT_CODE, this.first ? "the input is empty" : "the input holds only whitespace");
+    }
+  }
+}
+function reportTextEncoding(report, encoding) {
+  if (encoding !== null && encoding !== void 0) {
+    report.warning(
+      "unsupported",
+      OPTION_IGNORED_CODE,
+      "option encoding has no effect on text input, which is already decoded",
+      { element: "encoding" }
+    );
+  }
+}
+async function* textChunks(rawInput, report, options = {}) {
+  const input = normalizeInput(rawInput);
+  const signal = options.signal ?? null;
+  const onProgress = options.onProgress ?? null;
+  const filter = new TextFilter(report, options);
+  throwIfAborted(signal);
+  if (typeof input === "string") {
+    reportTextEncoding(report, options.encoding);
+    const total = onProgress === null ? 0 : utf8Length(input);
+    let done2 = 0;
+    let start = 0;
+    while (start < input.length) {
+      throwIfAborted(signal);
+      let end = Math.min(start + DECODE_SLICE, input.length);
+      const highSurrogate = (input.charCodeAt(end - 1) & 64512) === 55296;
+      if (end < input.length && highSurrogate) {
+        end++;
+      }
+      const piece = start === 0 && end === input.length ? input : input.slice(start, end);
+      start = end;
+      const text = filter.push(piece);
+      if (text.length > 0) {
+        yield text;
+      }
+      if (onProgress !== null) {
+        done2 += utf8Length(piece);
+        onProgress(done2, total);
+      }
+    }
+    if (input.length === 0) {
+      onProgress?.(0, 0);
+    }
+    filter.end();
+    return;
+  }
+  const decoder = new ByteDecoder(report, options);
+  const headBytes = Math.max(options.declarationBytes ?? HEAD_BYTES, BOM_BYTES);
+  if (input instanceof Uint8Array) {
+    const length = input.byteLength;
+    decoder.start(input.subarray(0, headBytes));
+    for (let offset = 0; offset < length; offset += DECODE_SLICE) {
+      throwIfAborted(signal);
+      if (input.byteLength !== length) {
+        throw new GraphFormatError(
+          "E_UNSUPPORTED",
+          "the input's buffer was detached (transferred) or resized during the import",
+          { reason: "detached" }
+        );
+      }
+      const slice = input.subarray(offset, Math.min(offset + DECODE_SLICE, length));
+      const text = filter.push(decoder.decode(slice, offset + DECODE_SLICE < length));
+      if (text.length > 0) {
+        yield text;
+      }
+      onProgress?.(Math.min(offset + DECODE_SLICE, length), length);
+    }
+    if (length === 0) {
+      onProgress?.(0, 0);
+    }
+    filter.end();
+    return;
+  }
+  const needed = options.declaredEncoding === void 0 ? BOM_BYTES : headBytes;
+  let done = 0;
+  let head = [];
+  let headLength = 0;
+  const flushHead = (stream) => {
+    const bytes = concatBytes(head);
+    head = [];
+    headLength = 0;
+    decoder.start(bytes.subarray(0, headBytes));
+    return decoder.decode(bytes, stream);
+  };
+  const chunks = isReadableStream(input) ? streamChunks(input, signal) : input;
+  for await (const chunk of chunks) {
+    throwIfAborted(signal);
+    let text;
+    const bytes = typeof chunk === "string" ? null : asBytes(chunk);
+    if (typeof chunk === "string") {
+      let pending = "";
+      if (headLength > 0) {
+        pending = decoder.flushBeforeText(() => flushHead(false));
+      } else if (decoder.started) {
+        pending = decoder.flushBeforeText(() => decoder.decode(new Uint8Array(0), false));
+      } else {
+        decoder.start(new Uint8Array(0));
+      }
+      text = filter.push(pending + chunk);
+      done += onProgress === null ? 0 : utf8Length(chunk);
+    } else if (bytes !== null) {
+      done += bytes.byteLength;
+      if (decoder.started) {
+        text = filter.push(decoder.decode(bytes, true));
+      } else {
+        head.push(bytes);
+        headLength += bytes.byteLength;
+        text = headLength >= needed ? filter.push(flushHead(true)) : "";
+      }
+    } else {
+      throw new GraphFormatError("E_UNSUPPORTED", "an input chunk must be a string or a Uint8Array", {
+        reason: "chunk type",
+        found: typeof chunk
+      });
+    }
+    if (text.length > 0) {
+      yield text;
+    }
+    onProgress?.(done);
+  }
+  let tail = "";
+  if (headLength > 0) {
+    tail = flushHead(false);
+  } else if (decoder.started) {
+    tail = decoder.decode(new Uint8Array(0), false);
+  }
+  tail = filter.push(tail);
+  if (tail.length > 0) {
+    yield tail;
+  }
+  filter.end();
+  onProgress?.(done, done);
+}
+function isReadableStream(input) {
+  return typeof input.getReader === "function";
+}
+async function* streamChunks(stream, signal) {
+  const reader = lockReader(stream);
+  let finished = false;
+  try {
+    for (; ; ) {
+      throwIfAborted(signal);
+      const { done, value } = await abortable(reader.read(), signal);
+      if (done) {
+        finished = true;
+        return;
+      }
+      yield value;
+    }
+  } finally {
+    if (!finished) {
+      await reader.cancel(signal?.reason).catch(() => void 0);
+    }
+    reader.releaseLock();
+  }
+}
+async function readBytes(rawInput, options = {}) {
+  const input = normalizeInput(rawInput);
+  const signal = options.signal ?? null;
+  throwIfAborted(signal);
+  if (typeof input === "string") {
+    return null;
+  }
+  if (input instanceof Uint8Array) {
+    options.onProgress?.(input.byteLength, input.byteLength);
+    return input;
+  }
+  const parts = [];
+  let done = 0;
+  for await (const chunk of isReadableStream(input) ? streamChunks(input, signal) : input) {
+    throwIfAborted(signal);
+    if (typeof chunk === "string") {
+      return null;
+    }
+    const bytes = asBytes(chunk);
+    if (bytes === null) {
+      throw new GraphFormatError("E_UNSUPPORTED", "an input chunk must be a string or a Uint8Array", {
+        reason: "chunk type",
+        found: typeof chunk
+      });
+    }
+    parts.push(bytes);
+    done += bytes.byteLength;
+    options.onProgress?.(done);
+  }
+  options.onProgress?.(done, done);
+  return parts.length === 0 ? new Uint8Array(0) : concatBytes(parts);
+}
+function tooLarge(report, message, line) {
+  report.failWith("unsupported", TOO_LARGE_CODE, message, line === void 0 ? void 0 : { line });
+}
+async function readText(rawInput, report, options = {}) {
+  const input = normalizeInput(rawInput);
+  if (typeof input === "string") {
+    throwIfAborted(options.signal);
+    reportTextEncoding(report, options.encoding);
+    const filter = new TextFilter(report, options);
+    const text = filter.push(input);
+    filter.end();
+    if (options.onProgress !== null && options.onProgress !== void 0) {
+      const total = utf8Length(input);
+      options.onProgress(total, total);
+    }
+    return text;
+  }
+  const parts = [];
+  let length = 0;
+  for await (const chunk of textChunks(input, report, options)) {
+    length += chunk.length;
+    if (length > MAX_TEXT_LENGTH) {
+      tooLarge(
+        report,
+        `the document is longer than ${MAX_TEXT_LENGTH} characters, the most one JavaScript string holds`
+      );
+    }
+    parts.push(chunk);
+  }
+  return parts.length === 1 ? parts[0] : parts.join("");
+}
+class LineReader {
+  /**
+   * Create a reader over an input; nothing is read until iteration starts.
+   * @param input - the input
+   * @param report - the report decode errors are recorded in
+   * @param options - cancellation and progress
+   */
+  constructor(input, report, options = {}) {
+    this.lineNumber = 0;
+    this.input = input;
+    this.report = report;
+    this.options = options;
+  }
+  /**
+   * The 1-based number of the line most recently yielded.
+   * @returns the line number; 0 before the first line
+   */
+  get line() {
+    return this.lineNumber;
+  }
+  /**
+   * The E_TOO_LARGE message of a line longer than one string.
+   * @returns the message
+   */
+  lineTooLong() {
+    return `a line is longer than ${MAX_TEXT_LENGTH} characters, the most one JavaScript string holds`;
+  }
+  /**
+   * Iterate the lines.
+   * @yields one line at a time, terminator removed
+   * @returns nothing
+   */
+  async *[Symbol.asyncIterator]() {
+    const pending = [];
+    let pendingLength = 0;
+    let trailingCr = false;
+    for await (const chunk of textChunks(this.input, this.report, this.options)) {
+      let start = 0;
+      const end = chunk.length;
+      if (trailingCr) {
+        trailingCr = false;
+        this.lineNumber++;
+        const joined = pending.join("");
+        pending.length = 0;
+        pendingLength = 0;
+        yield joined.slice(0, -1);
+        if (chunk.charCodeAt(0) === 10) {
+          start = 1;
+        }
+      }
+      let nl = chunk.indexOf("\n", start);
+      let cr = chunk.indexOf("\r", start);
+      while (nl >= 0 || cr >= 0) {
+        let cut;
+        let next;
+        if (cr >= 0 && (nl < 0 || cr < nl)) {
+          if (cr === end - 1) {
+            break;
+          }
+          cut = cr;
+          next = chunk.charCodeAt(cr + 1) === 10 ? cr + 2 : cr + 1;
+        } else {
+          cut = nl;
+          next = nl + 1;
+        }
+        this.lineNumber++;
+        const piece = chunk.slice(start, cut);
+        if (pending.length === 0) {
+          yield piece;
+        } else {
+          if (pendingLength + piece.length > MAX_TEXT_LENGTH) {
+            tooLarge(this.report, this.lineTooLong(), this.lineNumber);
+          }
+          pending.push(piece);
+          const joined = pending.join("");
+          pending.length = 0;
+          pendingLength = 0;
+          yield joined;
+        }
+        start = next;
+        if (nl >= 0 && nl < next) {
+          nl = chunk.indexOf("\n", next);
+        }
+        if (cr >= 0 && cr < next) {
+          cr = chunk.indexOf("\r", next);
+        }
+      }
+      if (start < end) {
+        pendingLength += end - start;
+        if (pendingLength > MAX_TEXT_LENGTH) {
+          tooLarge(this.report, this.lineTooLong(), this.lineNumber + 1);
+        }
+        pending.push(start === 0 ? chunk : chunk.slice(start));
+        trailingCr = chunk.charCodeAt(end - 1) === 13;
+      }
+    }
+    if (pending.length > 0) {
+      this.lineNumber++;
+      const joined = pending.join("");
+      yield joined.endsWith("\r") ? joined.slice(0, -1) : joined;
+    }
+  }
+}
+const ID_COERCIONS = /* @__PURE__ */ new Set(["keep", "canonical", "string", "number"]);
+const NODE_ID_SOURCES = /* @__PURE__ */ new Set(["id", "label", "index"]);
+const DUPLICATE_POLICIES = /* @__PURE__ */ new Set(["keep", "error", "first", "last", "sum", "min", "max"]);
+const SELF_LOOP_POLICIES = /* @__PURE__ */ new Set(["keep", "drop", "error"]);
+const IMPORT_MIXED_POLICIES = /* @__PURE__ */ new Set(["expand", "directed", "undirected", "error"]);
+const EXPORT_MIXED_POLICIES = /* @__PURE__ */ new Set(["error", "directed", "undirected"]);
+const WEIGHT_DTYPES = /* @__PURE__ */ new Set(["f32", "f64"]);
+const LONG_MODES = /* @__PURE__ */ new Set(["f64", "string"]);
+const HYPEREDGE_POLICIES = /* @__PURE__ */ new Set(["error", "skip", "star", "clique"]);
+const SANITIZE_MODES = /* @__PURE__ */ new Set(["error", "mangle"]);
+const DEFAULT_ERROR_LIMIT = 100;
+const SINK_OPTION_NAMES = ["addMissingNodes", "duplicateEdges", "selfLoops", "weightDtype"];
+function reportSinkOptions(sink, options, report, enforcesMissingNodes = false) {
+  if (options === void 0) {
+    return 0;
+  }
+  let recorded = 0;
+  for (const name of SINK_OPTION_NAMES) {
+    const wanted = options[name];
+    const actual = sink.options[name];
+    if (wanted === void 0 || wanted === actual) {
+      continue;
+    }
+    if (name === "addMissingNodes" && enforcesMissingNodes && wanted === false) {
+      continue;
+    }
+    report.warning(
+      "coercion",
+      SINK_OPTION_CODE,
+      `option ${name}: ${JSON.stringify(wanted)} requested but the sink uses ${JSON.stringify(actual)}; the sink's setting applies`,
+      { element: name }
+    );
+    recorded++;
+  }
+  return recorded;
+}
+const IGNORABLE_OPTION_NAMES = [
+  "ids",
+  "nodeIdFrom",
+  "addMissingNodes",
+  "duplicateEdges",
+  "selfLoops",
+  "onMixedDirection",
+  "defaultDirected",
+  "weightFrom",
+  "weightDtype",
+  "long",
+  "restoreMangledIds",
+  "hyperedges"
+];
+const FIXED_DEFAULTS = {
+  nodeIdFrom: "id",
+  duplicateEdges: "keep",
+  selfLoops: "keep",
+  onMixedDirection: "expand",
+  weightDtype: "f64",
+  long: "f64",
+  restoreMangledIds: true,
+  hyperedges: "skip"
+};
+function reportUnusedOptions(options, report, used) {
+  if (options === void 0) {
+    return 0;
+  }
+  let recorded = 0;
+  for (const name of IGNORABLE_OPTION_NAMES) {
+    if (used.has(name) || SINK_OPTION_NAMES.includes(name)) {
+      continue;
+    }
+    const value = options[name];
+    if (value === void 0 || value === FIXED_DEFAULTS[name]) {
+      continue;
+    }
+    report.warning(
+      "unsupported",
+      OPTION_IGNORED_CODE,
+      `option ${name}: ${JSON.stringify(value)} has no effect on the ${report.format} importer`,
+      { element: name }
+    );
+    recorded++;
+  }
+  return recorded;
+}
+function graphChosen(options) {
+  return options?.graphIndex !== void 0 || options?.graphName !== void 0;
+}
+function graphNamesText(names) {
+  const shown = names.slice(0, 10).map((n, i) => `${i} ${n === null ? "(unnamed)" : JSON.stringify(n)}`);
+  const more = names.length > shown.length ? `, and ${names.length - shown.length} more` : "";
+  return `; the file holds ${shown.join(", ")}${more}`;
+}
+function chooseGraph(names, options, report) {
+  const { graphIndex, graphName } = options ?? {};
+  if (graphIndex !== void 0 && (typeof graphIndex !== "number" || !Number.isInteger(graphIndex) || graphIndex < 0)) {
+    throw new GraphFormatError(
+      "E_UNSUPPORTED",
+      `option graphIndex: ${describe(graphIndex)} is not a non-negative integer`,
+      {
+        option: "graphIndex",
+        found: graphIndex
+      }
+    );
+  }
+  if (graphName !== void 0 && typeof graphName !== "string") {
+    throw new GraphFormatError("E_UNSUPPORTED", `option graphName: ${describe(graphName)} is not a string`, {
+      option: "graphName",
+      found: graphName
+    });
+  }
+  if (graphIndex !== void 0 && graphName !== void 0) {
+    throw new GraphFormatError("E_UNSUPPORTED", "options graphIndex and graphName both choose a graph; pass one", {
+      option: "graphName",
+      found: graphName
+    });
+  }
+  if (names.length === 0) {
+    return report.fail(NO_GRAPH_CODE, "the input holds no graph");
+  }
+  if (graphName !== void 0) {
+    const matches = names.flatMap((name, i) => name === graphName ? [i] : []);
+    if (matches.length > 1) {
+      return report.fail(
+        AMBIGUOUS_GRAPH_NAME_CODE,
+        `graphName ${JSON.stringify(graphName)} names the graphs at indexes ${matches.join(", ")}; pass graphIndex`,
+        { element: graphName }
+      );
+    }
+    if (matches.length === 0) {
+      return report.fail(
+        GRAPH_NOT_FOUND_CODE,
+        `graphName ${JSON.stringify(graphName)} names none of the ${names.length} graph${plural(names.length)}${graphNamesText(names)}`,
+        { element: graphName },
+        { names: [...names] }
+      );
+    }
+    return matches[0];
+  }
+  const index = graphIndex ?? 0;
+  if (index >= names.length) {
+    return report.fail(
+      GRAPH_NOT_FOUND_CODE,
+      `graphIndex ${index} is beyond the ${names.length} graph${plural(names.length)}${graphNamesText(names)}`
+    );
+  }
+  return index;
+}
+function resolveImportOptions(options, defaults) {
+  const o = options ?? {};
+  return Object.freeze({
+    ids: enumOption("ids", o.ids, defaults.ids, ID_COERCIONS),
+    nodeIdFrom: enumOption("nodeIdFrom", o.nodeIdFrom, "id", NODE_ID_SOURCES),
+    addMissingNodes: booleanOption("addMissingNodes", o.addMissingNodes, defaults.addMissingNodes ?? true),
+    duplicateEdges: enumOption("duplicateEdges", o.duplicateEdges, "keep", DUPLICATE_POLICIES),
+    selfLoops: enumOption("selfLoops", o.selfLoops, "keep", SELF_LOOP_POLICIES),
+    onMixedDirection: enumOption("onMixedDirection", o.onMixedDirection, "expand", IMPORT_MIXED_POLICIES),
+    defaultDirected: booleanOption("defaultDirected", o.defaultDirected, defaults.defaultDirected),
+    weightFrom: weightFromOption(o.weightFrom, defaults.weightFrom),
+    weightDtype: enumOption("weightDtype", o.weightDtype, "f64", WEIGHT_DTYPES),
+    long: enumOption("long", o.long, "f64", LONG_MODES),
+    restoreMangledIds: booleanOption("restoreMangledIds", o.restoreMangledIds, true),
+    hyperedges: enumOption("hyperedges", o.hyperedges, "skip", HYPEREDGE_POLICIES),
+    errorLimit: errorLimitOption(o.errorLimit),
+    signal: signalOption(o.signal),
+    onProgress: progressOption(o.onProgress),
+    encoding: encodingOption(o.encoding)
+  });
+}
+function resolveExportOptions(options) {
+  const o = options ?? {};
+  return Object.freeze({
+    sanitizeIds: enumOption("sanitizeIds", o.sanitizeIds, "error", SANITIZE_MODES),
+    onMixedDirection: enumOption("onMixedDirection", o.onMixedDirection, "error", EXPORT_MIXED_POLICIES)
+  });
+}
+function enumOption(name, value, fallback, allowed) {
+  if (value === void 0) {
+    return fallback;
+  }
+  if (typeof value !== "string" || !allowed.has(value)) {
+    throw new GraphFormatError(
+      "E_UNSUPPORTED",
+      `option ${name}: ${describe(value)} is not one of ${list(allowed)}`,
+      {
+        option: name,
+        found: value,
+        supported: [...allowed]
+      }
+    );
+  }
+  return value;
+}
+function booleanOption(name, value, fallback) {
+  if (value === void 0) {
+    return fallback;
+  }
+  if (typeof value !== "boolean") {
+    throw new GraphFormatError("E_UNSUPPORTED", `option ${name}: ${describe(value)} is not a boolean`, {
+      option: name,
+      found: value
+    });
+  }
+  return value;
+}
+function weightFromOption(value, fallback) {
+  if (value === void 0) {
+    return fallback;
+  }
+  if (value === null || typeof value === "string" && value.length > 0) {
+    return value;
+  }
+  throw new GraphFormatError(
+    "E_UNSUPPORTED",
+    `option weightFrom: ${describe(value)} is not an attribute name or null`,
+    { option: "weightFrom", found: value }
+  );
+}
+function errorLimitOption(value) {
+  if (value === void 0) {
+    return DEFAULT_ERROR_LIMIT;
+  }
+  if (typeof value === "number" && value >= 0 && (Number.isInteger(value) || value === Infinity)) {
+    return value;
+  }
+  throw new GraphFormatError(
+    "E_UNSUPPORTED",
+    `option errorLimit: ${describe(value)} is not a non-negative integer or Infinity`,
+    { option: "errorLimit", found: value }
+  );
+}
+function signalOption(value) {
+  if (value === void 0 || value === null) {
+    return null;
+  }
+  if (typeof value === "object" && typeof value.aborted === "boolean") {
+    return value;
+  }
+  throw new GraphFormatError("E_UNSUPPORTED", `option signal: ${describe(value)} is not an AbortSignal`, {
+    option: "signal",
+    found: typeof value
+  });
+}
+function progressOption(value) {
+  if (value === void 0 || value === null) {
+    return null;
+  }
+  if (typeof value === "function") {
+    return value;
+  }
+  throw new GraphFormatError("E_UNSUPPORTED", `option onProgress: ${describe(value)} is not a function`, {
+    option: "onProgress",
+    found: typeof value
+  });
+}
+function encodingOption(value) {
+  if (value === void 0 || value === null) {
+    return null;
+  }
+  const canonical = typeof value === "string" ? canonicalEncoding(value) : null;
+  if (canonical === null) {
+    throw new GraphFormatError(
+      "E_UNSUPPORTED",
+      `option encoding: ${describe(value)} is not an encoding this platform's TextDecoder knows`,
+      { option: "encoding", found: value }
+    );
+  }
+  return canonical;
+}
+function forDecodedText(options) {
+  return { ...options, encoding: void 0, onProgress: void 0 };
+}
+const FORMAT_DIALECTS = Object.freeze({
+  csv: Object.freeze(["gephi", "generic"]),
+  json: Object.freeze(["node-link", "d3", "jgf", "cytoscape", "graphology", "vis", "obographs"])
+});
+function otherFormatDialect(format, value) {
+  return typeof value === "string" && Object.entries(FORMAT_DIALECTS).some(([f, names]) => f !== format && names.includes(value));
+}
+function describe(value) {
+  switch (typeof value) {
+    case "string":
+      return JSON.stringify(value);
+    case "number":
+    case "boolean":
+      return String(value);
+    default:
+      return value === null ? "null" : typeof value;
+  }
+}
+function list(allowed) {
+  return [...allowed].map((v) => JSON.stringify(v)).join(", ");
+}
+class ImportError extends GraphFormatError {
+  /**
+   * Create an ImportError.
+   * @param message - a plain-ASCII human-readable message
+   * @param report - the partial report
+   * @param details - optional machine-readable context; its `code` names the issue that stopped the import
+   */
+  constructor(message, report, details) {
+    super("E_IMPORT", message, details);
+    this.name = "ImportError";
+    Object.defineProperty(this, "report", { value: report, enumerable: false });
+    this.issue = stoppingIssue(report.issues, details?.code);
+  }
+}
+function stoppingIssue(issues, code) {
+  let lastError = null;
+  for (let i = issues.length - 1; i >= 0; i--) {
+    if (issues[i].code === code) {
+      return issues[i];
+    }
+    if (lastError === null && issues[i].severity === "error") {
+      lastError = issues[i];
+    }
+  }
+  return lastError;
+}
+const MAX_WARNINGS_PER_CODE = 1e3;
+const CATEGORY_BY_CODE = {
+  E_UNKNOWN_NODE: "missing-value",
+  E_UNKNOWN_COLUMN: "missing-value",
+  E_DIRECTED: "coercion",
+  E_TOO_LARGE: "unsupported",
+  E_UNSUPPORTED: "unsupported",
+  E_GPU_INELIGIBLE: "unsupported"
+};
+const PARSE_ERROR_CODE = "E_PARSE";
+function withLine(message, where) {
+  const line = where?.line;
+  return line === void 0 || line === null || message.includes(`line ${line}`) ? message : `line ${line}: ${message}`;
+}
+class ImportReportBuilder {
+  /**
+   * Create a builder for one import call.
+   * @param format - the importer's format name
+   * @param errorLimit - errors tolerated before the import aborts; Infinity for no limit
+   */
+  constructor(format, errorLimit) {
+    this.counts = { nodes: 0, edges: 0, skippedNodes: 0, skippedEdges: 0, expandedMixed: 0 };
+    this.issueList = [];
+    this.lossList = [];
+    this.onceCodes = /* @__PURE__ */ new Set();
+    this.warningsByCode = /* @__PURE__ */ new Map();
+    this.errors = 0;
+    this.warnings = 0;
+    this.truncatedFlag = false;
+    this.format = format;
+    this.errorLimit = errorLimit;
+    this.startedAt = now();
+  }
+  /**
+   * Issues recorded so far, in order.
+   * @returns the live list (not copied; finish() copies)
+   */
+  get issues() {
+    return this.issueList;
+  }
+  /**
+   * Issues with severity "error".
+   * @returns the count
+   */
+  get errorCount() {
+    return this.errors;
+  }
+  /**
+   * Issues with severity "warning".
+   * @returns the count
+   */
+  get warningCount() {
+    return this.warnings;
+  }
+  /**
+   * Whether the error limit was exceeded.
+   * @returns true once an error beyond the limit was recorded
+   */
+  get truncated() {
+    return this.truncatedFlag;
+  }
+  /**
+   * Loss notes recorded so far.
+   * @returns the live list
+   */
+  get lossy() {
+    return this.lossList;
+  }
+  /**
+   * Record an error. When the count goes beyond the error limit the report is marked truncated
+   * and an ImportError carrying it is thrown; the importer does not catch that.
+   * @param category - the issue category
+   * @param code - a stable code such as "E_UNKNOWN_NODE"
+   * @param message - a plain-ASCII message
+   * @param where - the line and element, when known
+   * @returns the recorded issue
+   */
+  error(category, code, message, where) {
+    const issue = makeIssue(category, "error", code, message, where);
+    this.issueList.push(issue);
+    this.errors++;
+    if (this.errors > this.errorLimit) {
+      this.truncatedFlag = true;
+      throw this.abort(`error limit of ${this.errorLimit} exceeded: ${withLine(message, where)}`, {
+        code,
+        limit: this.errorLimit
+      });
+    }
+    return issue;
+  }
+  /**
+   * Record a warning; warnings never count toward the limit. Beyond MAX_WARNINGS_PER_CODE
+   * warnings of one code the warning is counted, not kept: finish() adds one W_ISSUES_SUPPRESSED
+   * warning per such code with the number dropped.
+   * @param category - the issue category
+   * @param code - a stable code such as "W_WIDENED"
+   * @param message - a plain-ASCII message
+   * @param where - the line and element, when known
+   * @returns the recorded issue
+   */
+  warning(category, code, message, where) {
+    const issue = makeIssue(category, "warning", code, message, where);
+    const seen = (this.warningsByCode.get(code) ?? 0) + 1;
+    this.warningsByCode.set(code, seen);
+    if (seen <= MAX_WARNINGS_PER_CODE) {
+      this.issueList.push(issue);
+      this.warnings++;
+    }
+    return issue;
+  }
+  /**
+   * Record a warning the first time its key is seen and ignore later repeats, for conditions
+   * that would otherwise produce one warning per row.
+   * @param category - the issue category
+   * @param code - the stable code
+   * @param message - a plain-ASCII message
+   * @param where - the line and element, when known
+   * @param key - what repeats are deduplicated on; the code itself by default (pass `code:column`
+   * to warn once per column)
+   * @returns the recorded issue, or null when the key was already recorded
+   */
+  warnOnce(category, code, message, where, key = code) {
+    if (this.onceCodes.has(key)) {
+      return null;
+    }
+    this.onceCodes.add(key);
+    return this.warning(category, code, message, where);
+  }
+  /**
+   * Record something the importer could not represent.
+   * @param code - a stable code
+   * @param message - a plain-ASCII message
+   * @param column - the affected column, or null
+   * @param count - the affected count, or null
+   * @returns the recorded note
+   */
+  loss(code, message, column = null, count = null) {
+    const note = Object.freeze({ code, message, column, count });
+    this.lossList.push(note);
+    return note;
+  }
+  /**
+   * The per-element catch: record a thrown GraphFormatError as an error
+   * issue with its code and the category the code implies. Anything else is re-thrown unchanged:
+   * an ImportError (the import already aborted), an abort reason, and any other thrown value (a
+   * TypeError or RangeError is a programming error in the importer or the sink, never a defect of
+   * the input, so it must surface as an exception rather than as an issue blamed on the file).
+   * @param err - the thrown value
+   * @param where - the line and element, when known
+   * @returns the recorded issue
+   */
+  recordError(err, where) {
+    if (err instanceof GraphFormatError && !(err instanceof ImportError)) {
+      const category = CATEGORY_BY_CODE[err.code] ?? "validation-error";
+      if (err.code === "E_TOO_LARGE") {
+        return this.failWith(category, err.code, err.message, where);
+      }
+      return this.error(category, err.code, err.message, where);
+    }
+    throw err;
+  }
+  /**
+   * A builder that starts from everything this one recorded so far: issues, counts, loss notes,
+   * the warnOnce keys, the error and warning counts and the truncation flag. For an importer that
+   * reads its input once and emits several graphs, each with its own report.
+   * @returns the copy; later records to either builder do not reach the other
+   */
+  fork() {
+    const copy = new ImportReportBuilder(this.format, this.errorLimit);
+    Object.assign(copy.counts, this.counts);
+    copy.issueList.push(...this.issueList);
+    copy.lossList.push(...this.lossList);
+    for (const key of this.onceCodes) {
+      copy.onceCodes.add(key);
+    }
+    for (const [code, count] of this.warningsByCode) {
+      copy.warningsByCode.set(code, count);
+    }
+    copy.errors = this.errors;
+    copy.warnings = this.warnings;
+    copy.truncatedFlag = this.truncatedFlag;
+    return copy;
+  }
+  /**
+   * Build the ImportError that aborts the import, carrying the report so far. The caller throws
+   * it; this method only constructs it so it can be used in expression position.
+   * @param message - a plain-ASCII message
+   * @param details - optional machine-readable context
+   * @returns the error to throw
+   */
+  abort(message, details) {
+    return new ImportError(message, this.finish(), details);
+  }
+  /**
+   * Record a fatal parse error and abort: the issue is recorded (even beyond the error limit)
+   * and an ImportError carrying the report is thrown.
+   * @param code - a stable code such as "E_INVALID_UTF8"
+   * @param message - a plain-ASCII message
+   * @param where - the line and element, when known
+   * @param details - optional machine-readable context for the ImportError
+   */
+  fail(code, message, where, details) {
+    this.failWith("parse-error", code, message, where, details);
+  }
+  /**
+   * Record a fatal error of any category and abort, as fail() does for a parse error: a size
+   * limit (E_TOO_LARGE, category "unsupported") stops an import without being a defect of the
+   * syntax. A fatal error is not the error limit: `truncated` stays as it was.
+   * @param category - the issue category
+   * @param code - a stable code
+   * @param message - a plain-ASCII message
+   * @param where - the line and element, when known
+   * @param details - optional machine-readable context for the ImportError
+   */
+  failWith(category, code, message, where, details) {
+    this.issueList.push(makeIssue(category, "error", code, message, where));
+    this.errors++;
+    throw this.abort(withLine(message, where), { code, ...details });
+  }
+  /**
+   * Add a finished report to this one: its issues after the ones recorded so far, its counts, its
+   * loss notes and its truncated flag. Use it when an importer hands part of the work to another
+   * importer (for example, a wrapper around the CSV importer) and returns one report for both. The issues
+   * keep their codes; errors added this way do not count toward this report's error limit, since
+   * the other importer applied its own.
+   * @param report - the report the other importer returned
+   * @returns this builder
+   * @example
+   * ```ts
+   * const report = new ImportReportBuilder("netscope", opts.errorLimit);
+   * const text = await readText(input, report, opts);
+   * report.include(await csvImporter.import(text, sink, options));
+   * return report.finish();
+   * ```
+   */
+  include(report) {
+    for (const issue of report.issues) {
+      this.issueList.push(issue);
+      if (issue.severity === "error") {
+        this.errors++;
+      } else {
+        this.warnings++;
+      }
+    }
+    const { counts } = report;
+    this.counts.nodes += counts.nodes;
+    this.counts.edges += counts.edges;
+    this.counts.skippedNodes += counts.skippedNodes;
+    this.counts.skippedEdges += counts.skippedEdges;
+    this.counts.expandedMixed += counts.expandedMixed;
+    this.lossList.push(...report.lossy);
+    this.truncatedFlag ||= report.truncated;
+    return this;
+  }
+  /**
+   * The report as it stands: a frozen snapshot with the parse duration so far. Can be called more
+   * than once; each call reflects everything recorded up to that point.
+   * @returns the report
+   */
+  finish() {
+    const { nodes, edges, skippedNodes, skippedEdges, expandedMixed } = this.counts;
+    const suppressed = [];
+    for (const [code, seen] of this.warningsByCode) {
+      if (seen > MAX_WARNINGS_PER_CODE) {
+        const more = seen - MAX_WARNINGS_PER_CODE;
+        suppressed.push(
+          makeIssue(
+            "unsupported",
+            "warning",
+            ISSUES_SUPPRESSED_CODE,
+            `${more} more ${code} warning${plural(more)} ${agree(more, "was", "were")} not kept (the report keeps the first ${MAX_WARNINGS_PER_CODE})`,
+            { element: code }
+          )
+        );
+      }
+    }
+    return Object.freeze({
+      format: this.format,
+      counts: Object.freeze({ nodes, edges, skippedNodes, skippedEdges, expandedMixed }),
+      issues: Object.freeze([...this.issueList, ...suppressed]),
+      errorCount: this.errors,
+      warningCount: this.warnings + suppressed.length,
+      truncated: this.truncatedFlag,
+      lossy: Object.freeze([...this.lossList]),
+      durationMs: now() - this.startedAt
+    });
+  }
+}
+function makeIssue(category, severity, code, message, where) {
+  return Object.freeze({
+    category,
+    severity,
+    code,
+    message,
+    line: where?.line ?? null,
+    element: where?.element ?? null
+  });
+}
+function isAbortError(err) {
+  if (typeof err !== "object" || err === null) {
+    return false;
+  }
+  const { name } = err;
+  return name === "AbortError" || name === "TimeoutError";
+}
+function messageOf(err) {
+  if (err instanceof Error) {
+    return err.message;
+  }
+  if (typeof err === "string") {
+    return err;
+  }
+  return `non-error thrown (${typeof err})`;
+}
+function now() {
+  return typeof performance === "object" ? performance.now() : Date.now();
+}
+function formatF32(value) {
+  if (!Number.isFinite(value)) {
+    return String(value);
+  }
+  if (value === 0) {
+    return Object.is(value, -0) ? "-0" : "0";
+  }
+  for (let digits = 1; digits <= 9; digits++) {
+    const text = value.toPrecision(digits);
+    if (Math.fround(Number(text)) === value) {
+      return String(Number(text));
+    }
+  }
+  return String(value);
+}
+function survivesF32(value) {
+  return Number(formatF32(Math.fround(value))) === value;
+}
+function formatF64(value) {
+  return Object.is(value, -0) ? "-0" : String(value);
+}
+function idText(id) {
+  return typeof id === "number" ? formatF64(id) : id;
+}
+function formatDecimal(value, dtype = "f64") {
+  if (!Number.isFinite(value)) {
+    return String(value);
+  }
+  if (Object.is(value, -0)) {
+    return "-0.0";
+  }
+  const text = formatNumber(value, dtype);
+  return text.includes(".") || text.includes("e") ? text : `${text}.0`;
+}
+function formatGmlReal(value, dtype = "f64") {
+  if (Number.isNaN(value)) {
+    return "NAN";
+  }
+  if (!Number.isFinite(value)) {
+    return value > 0 ? "+INF" : "-INF";
+  }
+  const text = formatDecimal(value, dtype);
+  if (text.includes(".")) {
+    return text;
+  }
+  const e = text.indexOf("e");
+  return `${text.slice(0, e)}.0${text.slice(e)}`;
+}
+function formatInteger(value) {
+  if (Number.isSafeInteger(value) || !Number.isFinite(value)) {
+    return String(value);
+  }
+  return BigInt(value).toString();
+}
+function formatNumber(value, dtype) {
+  return dtype === "f32" ? formatF32(value) : formatF64(value);
+}
+const DEFAULT_WEIGHT = 1;
+function isWeightField(name, weightFrom) {
+  return weightFrom !== null && name === weightFrom;
+}
+function parseWeightText(text, report) {
+  const trimmed = text.trim();
+  if (trimmed.length === 0) {
+    return void 0;
+  }
+  let value;
+  try {
+    value = parseDecimalText(trimmed);
+  } catch (err) {
+    throw invalidWeight(text, err);
+  }
+  if (Number.isNaN(value)) {
+    throw invalidWeight(text, null);
+  }
+  if (report !== void 0) {
+    reportWeightPrecision(trimmed, value, report);
+  }
+  return value;
+}
+function reportWeightPrecision(text, value, report) {
+  if (!Number.isSafeInteger(value) && Number.isFinite(value) && /^[+-]?\d+$/.test(text) && BigInt(text) !== BigInt(value)) {
+    report.warnOnce(
+      "precision",
+      PRECISION_CODE,
+      `edge weights: integers beyond 2^53 are stored as the nearest double (first: ${text})`,
+      void 0,
+      `${PRECISION_CODE}:edge weight`
+    );
+  }
+}
+function weightFromValue(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (typeof value === "number") {
+    if (Number.isNaN(value)) {
+      throw invalidWeight(value, null);
+    }
+    return value;
+  }
+  if (typeof value === "string") {
+    return parseWeightText(value);
+  }
+  throw invalidWeight(value, null);
+}
+function invalidWeight(value, cause) {
+  let shown;
+  switch (typeof value) {
+    case "string":
+      shown = JSON.stringify(value);
+      break;
+    case "number":
+      shown = String(value);
+      break;
+    default:
+      shown = typeof value;
+  }
+  return new GraphFormatError("E_INVALID_WEIGHT", `invalid edge weight ${shown}`, {
+    value: typeof value === "object" ? typeof value : value,
+    cause: cause instanceof Error ? cause.message : null
+  });
+}
+const NEGATIVE_ZERO_TEXT = "-0";
+const NUMERIC_DTYPES = /* @__PURE__ */ new Set(["f32", "f64", "i32", "u32", "u8"]);
+function weightFormatter(dtype) {
+  switch (dtype) {
+    case "f32":
+      return formatF32;
+    case "f64":
+      return formatF64;
+    default:
+      return formatInteger;
+  }
+}
+function explicitWeights(snapshot) {
+  const shadowColumn = snapshot.edges.byRole("weight");
+  const shadow = shadowColumn !== null && NUMERIC_DTYPES.has(shadowColumn.dtype) ? shadowColumn : null;
+  if (shadow !== null) {
+    const dtype = shadow.dtype === "f32" ? "f32" : "f64";
+    const format = weightFormatter(shadow.dtype);
+    return {
+      weighted: true,
+      dtype,
+      isExplicit: (e) => shadow.isSet(e),
+      value: (e) => shadow.value(e),
+      text: (e, integral = false) => {
+        if (!shadow.isSet(e)) {
+          return null;
+        }
+        const value = shadow.value(e);
+        if (Object.is(value, -0)) {
+          return NEGATIVE_ZERO_TEXT;
+        }
+        return integral && Number.isInteger(value) ? formatInteger(value) : format(value);
+      }
+    };
+  }
+  const { weights } = snapshot.edgeList();
+  if (weights === null || !snapshot.flags.weighted) {
+    return {
+      weighted: false,
+      dtype: "f32",
+      isExplicit: () => false,
+      value: () => DEFAULT_WEIGHT,
+      text: () => null
+    };
+  }
+  return {
+    weighted: true,
+    dtype: "f32",
+    isExplicit: () => true,
+    value: (e) => weights[e],
+    text: (e, integral = false) => {
+      const value = weights[e];
+      if (Object.is(value, -0)) {
+        return NEGATIVE_ZERO_TEXT;
+      }
+      return integral && Number.isInteger(value) ? formatInteger(value) : formatF32(value);
+    }
+  };
+}
+function edgeWeights(snapshot) {
+  const { weights } = snapshot.edgeList();
+  if (weights === null) {
+    return null;
+  }
+  const out = Float64Array.from(weights);
+  const exact = snapshot.edges.byRole("weight");
+  if (exact !== null) {
+    for (let e = 0; e < out.length; e++) {
+      const v = exact.value(e);
+      if (typeof v === "number") {
+        out[e] = v;
+      }
+    }
+  }
+  return out;
+}
+const ID_CHARSET_REFUSAL = "E_ID_CHARSET";
+const LOSS = Object.freeze({
+  /**
+   * A node or edge attribute is not written: the format has no attributes, or none of this kind
+   * (`CheckExtras.attributes` false).
+   */
+  COLUMN_DROPPED: COLUMN_DROPPED_CODE,
+  /**
+   * The graph has both directed and undirected edges, the format holds one direction per file, and
+   * `onMixedDirection` is "directed" or "undirected": every edge is written with that direction.
+   */
+  MIXED_DIRECTION: "W_MIXED_DIRECTION",
+  /**
+   * The graph has both directed and undirected edges and `onMixedDirection` is "error". An import stops; a save to a
+   * format that holds one direction per file fails with E_DIRECTED. Pass "directed" or "undirected" to read or write
+   * it anyway.
+   */
+  MIXED_DIRECTION_ERROR: MIXED_DIRECTION_CODE,
+  /** Parallel edges in a format without them. */
+  MULTI_EDGES: "W_MULTI_EDGES",
+  /** Self-loops in a format without them. */
+  SELF_LOOPS: "W_SELF_LOOPS",
+  /**
+   * The format needs an id on every edge and the graph has none, so the file gets ids e0, e1, e2 and so on, which
+   * read back as edge ids.
+   */
+  EDGE_IDS_GENERATED: "W_EDGE_IDS_GENERATED",
+  /** The graph has edge ids and the format has no place for them, so they are not written. */
+  EDGE_IDS_DROPPED: "W_EDGE_IDS_DROPPED",
+  /** Ids outside the format's charset are rewritten (sanitizeIds "mangle"). */
+  ID_MANGLED: "W_ID_MANGLED",
+  /**
+   * Node ids the format cannot write, under `sanitizeIds: "error"`; the save fails with E_INVALID_ID. Pass
+   * `sanitizeIds: "mangle"` to rewrite them.
+   */
+  ID_CHARSET: ID_CHARSET_REFUSAL,
+  /** The format numbers nodes 1..N; ids that are not their 1-based index are kept as labels only. */
+  ID_RENUMBERED: "W_ID_RENUMBERED",
+  /**
+   * An attribute's type is one the format cannot store as it is (for example, a 32-bit float in a format that has only 64-bit
+   * numbers), so it reads back with the nearest type the format has.
+   */
+  DTYPE: "W_DTYPE_UNSUPPORTED",
+  /**
+   * An attribute with several numbers per element (other than a position) is written as separate values or a list,
+   * and does not read back as one attribute.
+   */
+  COMPONENTS: "W_COMPONENTS_FLATTENED",
+  /** A list column in a format without lists. */
+  LIST: "W_LIST_UNSUPPORTED",
+  /** A json column in a format without nested values. */
+  JSON: "W_JSON_UNSUPPORTED",
+  /** A declared default in a format without defaults. */
+  DEFAULT: "W_DEFAULT_DROPPED",
+  /** Declared options in a format without enumerations. */
+  OPTIONS: "W_OPTIONS_DROPPED",
+  /** A parent / parents column in a format without containment. */
+  HIERARCHY: "W_HIERARCHY_DROPPED",
+  /** A start / end / timestamp column in a format without temporal support. */
+  TEMPORAL: TEMPORAL_DROPPED_CODE,
+  /** A `<column>.text` companion the format cannot carry. */
+  TEMPORAL_TEXT: TEMPORAL_TEXT_DROPPED_CODE,
+  /** An attribute with a role the format has no place for is written as a plain attribute; the role is lost. */
+  ROLE: ROLE_DROPPED_CODE,
+  /** A parents (multi-parent) column in a format with single containment only. */
+  PARENTS: PARENTS_DROPPED_CODE,
+  /** A mutual pair written as two directed edges without the mutual mark. */
+  MUTUAL_EXPANDED: MUTUAL_EXPANDED_CODE,
+  /** A mutual pair written as one undirected edge; the mark is lost and the pair reads back undirected. */
+  MUTUAL_AS_UNDIRECTED: MUTUAL_AS_UNDIRECTED_CODE,
+  /** Node ids whose written text reads back as the other type under the importer's id rule. */
+  ID_TEXT_TYPE: ID_TEXT_TYPE_CODE,
+  /**
+   * Two node ids would be written as the same text (the number 5 and the text "5"); the save fails with
+   * E_INVALID_ID.
+   */
+  ID_TEXT_COLLISION: ID_TEXT_COLLISION_CODE,
+  /**
+   * An attribute without the weight role is named like the attribute graph-io reads weights from (for example, `weight`), so
+   * it reads back as the edge weight.
+   */
+  WEIGHT_KEY_CLASH: WEIGHT_KEY_CLASH_CODE,
+  /**
+   * An attribute without a role is written where the format keeps a role (for example, a `name` column as the label), and
+   * reads back with that role.
+   */
+  ROLE_ASSUMED: ROLE_ASSUMED_CODE,
+  /**
+   * An attribute with a role (for example, the label) is written where the format keeps that role, and reads back under the
+   * name the format's importer gives it.
+   */
+  COLUMN_NAME_CHANGED: COLUMN_RENAMED_LOSS_CODE,
+  /** A declared column whose every row is unset vanishes through a format without declarations. */
+  EMPTY_COLUMN: EMPTY_COLUMN_DROPPED_CODE,
+  /**
+   * A text attribute reads back as a dictionary attribute, or the reverse, because the importer chooses by how often
+   * its values repeat. The values are the same.
+   */
+  STORAGE_CLASS: STORAGE_CLASS_CODE,
+  /**
+   * A number attribute whose values are all whole numbers reads back as integers, because the format does not record
+   * the type.
+   */
+  INTEGRAL_F64: INTEGRAL_F64_CODE,
+  /**
+   * A text value that reads back as a number or a boolean, because the format does not record that it was text (the
+   * text "42" reads back as the number 42).
+   */
+  TEXT_INFERRED: TEXT_INFERRED_CODE,
+  /** A text value holds a character XML 1.0 forbids (most control characters); the save fails with E_COLUMN_TYPE. */
+  XML_ILLEGAL_CHAR: XML_ILLEGAL_CHAR_CODE,
+  /**
+   * A text attribute stored as a dictionary, without a declared list of allowed values, reads back with its distinct
+   * values as that list.
+   */
+  OPTIONS_GAINED: OPTIONS_GAINED_CODE,
+  /** A spells column in a format without spells. */
+  SPELLS: "W_SPELLS_DROPPED",
+  /** Dynamic attribute values (extension tables) in a format without them. */
+  DYNAMIC_VALUES: "W_DYNAMIC_VALUES_DROPPED",
+  /** An open-interval column in a format without open intervals. */
+  OPEN_INTERVAL: "W_OPEN_INTERVAL",
+  /** Graph-level attributes in a format without them. */
+  GRAPH_ATTRIBUTES: "W_GRAPH_ATTRIBUTES_DROPPED",
+  /** A position column in a format without positions. */
+  POSITIONS: "W_POSITIONS_DROPPED",
+  /** Visual columns in a format without them. */
+  VIZ: "W_VIZ_DROPPED",
+  /** An extension table the format cannot carry. */
+  EXTENSION_TABLE: "W_EXTENSION_TABLE_DROPPED",
+  /** A NaN or infinite number the format cannot spell; not written (or written as null), it reads back unset. */
+  NONFINITE_AS_NULL: NONFINITE_AS_NULL_CODE,
+  /**
+   * The graph has edge weights and the file does not keep them (the format has no weights, or an option turned them
+   * off): every edge reads back with the default weight 1.
+   */
+  WEIGHTS_DROPPED: WEIGHTS_DROPPED_CODE
+});
+function refusedSave(notes, codes = {}) {
+  const note = notes.find((n) => n.code.startsWith("E_"));
+  if (note === void 0) {
+    return null;
+  }
+  const code = codes[note.code] ?? REFUSAL_CODES[note.code] ?? "E_UNSUPPORTED";
+  return new GraphFormatError(code, note.message, { code: note.code, column: note.column, count: note.count });
+}
+const REFUSAL_CODES = {
+  [ID_CHARSET_REFUSAL]: "E_INVALID_ID",
+  [ID_TEXT_COLLISION_CODE]: "E_INVALID_ID",
+  [MIXED_DIRECTION_CODE]: "E_DIRECTED",
+  [XML_ILLEGAL_CHAR_CODE]: "E_COLUMN_TYPE"
+};
+const NO_CAPABILITIES = Object.freeze({
+  mixedDirection: false,
+  multiEdges: false,
+  selfLoops: false,
+  edgeIds: "none",
+  idCharset: "any",
+  dtypes: Object.freeze([]),
+  components: false,
+  lists: false,
+  json: false,
+  defaults: false,
+  options: false,
+  hierarchy: false,
+  temporal: "none",
+  graphAttributes: false,
+  positions: false,
+  viz: false
+});
+function capabilities(supported) {
+  return Object.freeze({ ...NO_CAPABILITIES, ...supported, dtypes: Object.freeze([...supported.dtypes ?? []]) });
+}
+const STRUCTURAL_ROLES = /* @__PURE__ */ new Set(["directed", "pair", "mutual", "weight", "originalId"]);
+const VIZ_ROLES = /* @__PURE__ */ new Set(["color", "size", "shape", "thickness"]);
+const TEMPORAL_ROLES = /* @__PURE__ */ new Set(["start", "end", "timestamp", "timestamps"]);
+const HIERARCHY_ROLES = /* @__PURE__ */ new Set(["parent", "parents"]);
+function checkCapabilities(snapshot, caps, options, extras = {}) {
+  const notes = [];
+  const note = (code, message, column = null, count = null) => {
+    notes.push(Object.freeze({ code, message, column, count }));
+  };
+  const mixed = countMixedEdges(snapshot);
+  if (mixed > 0 && !caps.mixedDirection) {
+    if (options.onMixedDirection === "error") {
+      note(
+        LOSS.MIXED_DIRECTION_ERROR,
+        `${mixed} undirected edge${plural(mixed)} in a directed graph, and the format holds one direction per file, so the save fails unless onMixedDirection is "directed" or "undirected"`,
+        null,
+        mixed
+      );
+    } else {
+      note(
+        LOSS.MIXED_DIRECTION,
+        `${mixed} undirected edge${plural(mixed)} in a directed graph ${agree(mixed, "is", "are")} written as ${options.onMixedDirection} (onMixedDirection), and the format holds one direction per file`,
+        null,
+        mixed
+      );
+    }
+  }
+  if (snapshot.flags.multigraph && !caps.multiEdges) {
+    const parallel = countParallelArcs(snapshot);
+    note(
+      LOSS.MULTI_EDGES,
+      `${parallel} parallel edge${plural(parallel)}; the format has no parallel edges`,
+      null,
+      parallel
+    );
+  }
+  if (snapshot.selfLoopCount > 0 && !caps.selfLoops) {
+    note(
+      LOSS.SELF_LOOPS,
+      `${snapshot.selfLoopCount} self-loop${plural(snapshot.selfLoopCount)}; the format has no self-loops`,
+      null,
+      snapshot.selfLoopCount
+    );
+  }
+  const edgeIds = snapshot.edges.byRole("id");
+  if (caps.edgeIds === "required" && edgeIds === null && snapshot.edgeCount > 0) {
+    note(
+      LOSS.EDGE_IDS_GENERATED,
+      "the format requires edge ids, and the graph has none; the edges are written with generated ids, which read back as a new edge id column",
+      null,
+      snapshot.edgeCount
+    );
+  } else if (caps.edgeIds === "none" && edgeIds !== null) {
+    note(
+      LOSS.EDGE_IDS_DROPPED,
+      `edge id column "${edgeIds.meta.name}" cannot be written`,
+      edgeIds.meta.name,
+      snapshot.edgeCount
+    );
+  }
+  const unrepresentable = countUnrepresentableIds(snapshot, caps.idCharset);
+  if (unrepresentable > 0) {
+    if (caps.idCharset === "dense-1-based") {
+      note(
+        LOSS.ID_RENUMBERED,
+        options.sanitizeIds === "mangle" ? `${unrepresentable} node id${plural(unrepresentable)} ${agree(unrepresentable, "is", "are")} not their 1-based index; nodes are numbered 1..N, the original ids are written too, and an import with restoreMangledIds: true reads them back as the ids; they are also the labels of nodes without a label value` : `${unrepresentable} node id${plural(unrepresentable)} ${agree(unrepresentable, "is", "are")} not their 1-based index; nodes are numbered 1..N and ids kept as labels of the nodes without a label value (a node with one loses its id)`,
+        null,
+        unrepresentable
+      );
+    } else if (options.sanitizeIds === "mangle") {
+      note(
+        LOSS.ID_MANGLED,
+        `${unrepresentable} node id${plural(unrepresentable)} ${charsetText(caps.idCharset, unrepresentable)}, so they are rewritten; the original ids are written too, and an import with restoreMangledIds: true reads them back`,
+        null,
+        unrepresentable
+      );
+    } else {
+      note(
+        LOSS.ID_CHARSET,
+        `${unrepresentable} node id${plural(unrepresentable)} ${charsetText(caps.idCharset, unrepresentable)}, so the save fails unless sanitizeIds is "mangle"`,
+        null,
+        unrepresentable
+      );
+    }
+  }
+  if (extras.idsReadBack !== void 0) {
+    let retyped = 0;
+    for (let i = 0; i < snapshot.nodeCount; i++) {
+      const id = snapshot.ids.idOf(i);
+      if (coerceIdText(String(id), extras.idsReadBack) !== id) {
+        retyped++;
+      }
+    }
+    if (retyped > 0) {
+      note(
+        LOSS.ID_TEXT_TYPE,
+        `${retyped} node id${plural(retyped)} ${agree(retyped, "reads", "read")} back with another type (a number as text, or text as a number)`,
+        null,
+        retyped
+      );
+    }
+  }
+  checkWeights(snapshot, extras, note);
+  checkColumns(snapshot.nodes, "node", caps, extras, note);
+  checkColumns(snapshot.edges, "edge", caps, extras, note);
+  const graphColumns = snapshot.graph.names();
+  if (graphColumns.length > 0) {
+    if (caps.graphAttributes) {
+      checkColumns(snapshot.graph, "graph", caps, extras, note);
+    } else {
+      note(
+        LOSS.GRAPH_ATTRIBUTES,
+        `${graphColumns.length} graph attribute${plural(graphColumns.length)} cannot be written`,
+        null,
+        graphColumns.length
+      );
+    }
+  }
+  for (const [name, table] of snapshot.extensions) {
+    if (name.startsWith("temporal:")) {
+      if (caps.temporal !== "dynamic-values") {
+        note(
+          LOSS.DYNAMIC_VALUES,
+          `dynamic values of "${name}" (${table.rowCount} row${plural(table.rowCount)}) cannot be written`,
+          name,
+          table.rowCount
+        );
+      }
+    } else {
+      note(
+        LOSS.EXTENSION_TABLE,
+        `extension table "${name}" (${table.rowCount} row${plural(table.rowCount)}) cannot be written`,
+        name,
+        table.rowCount
+      );
+    }
+  }
+  return notes;
+}
+function charsetText(charset, n) {
+  const are = agree(n, "is", "are");
+  switch (charset) {
+    case "nmtoken":
+      return `${are} not XML name tokens (letters, digits and . - _ : only; no spaces)`;
+    case "integer":
+      return `${are} not integers`;
+    default:
+      return `cannot be written as ${charset} ids`;
+  }
+}
+function writesAttributes(domain, extras) {
+  if (domain === "node") {
+    return extras.nodeAttributes ?? extras.attributes;
+  }
+  if (domain === "edge") {
+    return extras.edgeAttributes ?? extras.attributes;
+  }
+  return extras.attributes;
+}
+function checkWeights(snapshot, extras, note) {
+  if (extras.weights === false && explicitWeights(snapshot).weighted) {
+    note(
+      LOSS.WEIGHTS_DROPPED,
+      `the edge weights are not written; ${snapshot.edgeCount} edge${plural(snapshot.edgeCount)} ${agree(snapshot.edgeCount, "reads", "read")} back with weight 1`,
+      null,
+      snapshot.edgeCount
+    );
+  }
+}
+const ROLE_WORDS = {
+  label: "labels",
+  weight: "weights",
+  id: "ids",
+  position: "positions",
+  originalId: "original ids"
+};
+function checkColumns(table, domain, caps, extras, note) {
+  for (const column of table) {
+    const { meta } = column;
+    const { name, role } = meta;
+    if (role !== null && STRUCTURAL_ROLES.has(role)) {
+      continue;
+    }
+    const label = `${domain} column "${name}"`;
+    if (role !== null && extras.roleNames !== void 0) {
+      const fixed = extras.roleNames[role];
+      if (fixed !== void 0 && fixed !== name) {
+        note(
+          LOSS.COLUMN_NAME_CHANGED,
+          `${label} (the ${ROLE_WORDS[role] ?? role}) is written as the format's own ${role} and reads back as "${fixed}"`,
+          name,
+          column.length - column.nullCount
+        );
+      }
+    }
+    if (domain === "edge" && role === "id") {
+      continue;
+    }
+    const named = extras.writtenColumns?.[domain]?.includes(name) ?? false;
+    if (writesAttributes(domain, extras) === false && !named && !(role !== null && (extras.roles?.has(role) ?? false))) {
+      note(LOSS.COLUMN_DROPPED, `${label} is not written`, name, column.length - column.nullCount);
+      continue;
+    }
+    if (role === "timeText") {
+      if (extras.temporalText !== true) {
+        note(
+          LOSS.TEMPORAL_TEXT,
+          `${label} (the original text of a date or time column) cannot be written`,
+          name,
+          column.length - column.nullCount
+        );
+      }
+      continue;
+    }
+    if (role === "position") {
+      if (!caps.positions) {
+        note(LOSS.POSITIONS, `${label} (positions) cannot be written`, name, column.length - column.nullCount);
+      } else if (extras.positionDtype !== void 0 && meta.dtype !== extras.positionDtype) {
+        note(
+          LOSS.DTYPE,
+          `${label} (positions) is ${meta.dtype}; the format reads positions back as ${extras.positionDtype}`,
+          name,
+          column.length - column.nullCount
+        );
+      }
+      continue;
+    }
+    if (role !== null && VIZ_ROLES.has(role)) {
+      if (!caps.viz) {
+        note(LOSS.VIZ, `${label} (${role}) cannot be written`, name, column.length - column.nullCount);
+      }
+      continue;
+    }
+    if (role !== null && HIERARCHY_ROLES.has(role)) {
+      if (!caps.hierarchy) {
+        note(LOSS.HIERARCHY, `${label} (${role}) cannot be written`, name, column.length - column.nullCount);
+      }
+      continue;
+    }
+    if (role !== null && TEMPORAL_ROLES.has(role)) {
+      if (caps.temporal === "none") {
+        note(LOSS.TEMPORAL, `${label} (${role}) cannot be written`, name, column.length - column.nullCount);
+      }
+      continue;
+    }
+    if (role === "spells") {
+      if (caps.temporal !== "spells" && caps.temporal !== "dynamic-values") {
+        note(LOSS.SPELLS, `${label} (spells) cannot be written`, name, column.length - column.nullCount);
+      }
+      continue;
+    }
+    if (role === "open" || role === "spellsOpen") {
+      if (extras.openIntervals !== true) {
+        note(
+          LOSS.OPEN_INTERVAL,
+          `${label} (open intervals) cannot be written`,
+          name,
+          column.length - column.nullCount
+        );
+      }
+      continue;
+    }
+    if (role !== null && !(extras.roles?.has(role) ?? false)) {
+      note(
+        LOSS.ROLE,
+        `${label} (${role}) is written as a plain attribute; the format has no ${role} slot and the role is lost`,
+        name,
+        column.length - column.nullCount
+      );
+    }
+    if (meta.dynamic && caps.temporal !== "dynamic-values") {
+      note(LOSS.DYNAMIC_VALUES, `${label} is dynamic; only its static value can be written`, name, null);
+    }
+    checkDtype(column, label, caps, note);
+    if (meta.default !== void 0 && !caps.defaults) {
+      note(LOSS.DEFAULT, `${label} declares a default; the format has no defaults`, name, null);
+    }
+    if (meta.options !== null && !caps.options) {
+      note(LOSS.OPTIONS, `${label} declares options; the format has no enumerations`, name, null);
+    }
+  }
+}
+function checkDtype(column, label, caps, note) {
+  const { meta } = column;
+  const { name } = meta;
+  const set = column.length - column.nullCount;
+  switch (meta.dtype) {
+    case "list":
+      if (!caps.lists) {
+        note(LOSS.LIST, `${label} is a list; the format has no lists`, name, set);
+      } else if (meta.itemDtype !== null && !caps.dtypes.includes(meta.itemDtype)) {
+        note(
+          LOSS.DTYPE,
+          `${label} holds ${meta.itemDtype} items; the format cannot keep that dtype`,
+          name,
+          set
+        );
+      } else if (meta.itemDtype === "dict") {
+        note(LOSS.DTYPE, `${label} holds dict items; list items read back as string`, name, set);
+      }
+      break;
+    case "json":
+      if (!caps.json) {
+        note(LOSS.JSON, `${label} holds nested values; the format has no nested values`, name, set);
+      }
+      break;
+    default:
+      if (!caps.dtypes.includes(meta.dtype)) {
+        note(LOSS.DTYPE, `${label} is ${meta.dtype}; the format cannot keep that dtype`, name, set);
+      }
+      if (meta.components > 1 && !caps.components) {
+        note(
+          LOSS.COMPONENTS,
+          `${label} has ${meta.components} components; the format has no strides`,
+          name,
+          set
+        );
+      }
+      break;
+  }
+}
+function countMixedEdges(snapshot) {
+  if (!snapshot.directed) {
+    return 0;
+  }
+  const directed = snapshot.edges.byRole("directed");
+  if (directed === null || directed.dtype !== "bool") {
+    return 0;
+  }
+  const pair = snapshot.edges.byRole("pair");
+  let undirectedRows = 0;
+  let paired = 0;
+  for (let e = 0; e < snapshot.edgeCount; e++) {
+    if (directed.isSet(e) && directed.value(e) === false) {
+      undirectedRows++;
+      if (pair !== null && pair.dtype === "u32" && pair.isSet(e) && pair.data[e] !== INVALID_INDEX) {
+        paired++;
+      }
+    }
+  }
+  return paired / 2 + (undirectedRows - paired);
+}
+function countParallelArcs(snapshot) {
+  const { rowPtr, colIdx, nodeCount } = snapshot;
+  let count = 0;
+  for (let u = 0; u < nodeCount; u++) {
+    for (let a = rowPtr[u] + 1; a < rowPtr[u + 1]; a++) {
+      if (colIdx[a] === colIdx[a - 1]) {
+        count++;
+      }
+    }
+  }
+  return snapshot.directed ? count : Math.ceil(count / 2);
+}
+const NAME_CHAR_RANGES = [
+  [45, 46],
+  [48, 58],
+  [65, 90],
+  [95, 95],
+  [97, 122],
+  [183, 183],
+  [192, 214],
+  [216, 246],
+  [248, 893],
+  [895, 8191],
+  [8204, 8205],
+  [8255, 8256],
+  [8304, 8591],
+  [11264, 12271],
+  [12289, 55295],
+  [63744, 64975],
+  [65008, 65533],
+  [65536, 983039]
+];
+function isNameChar(cp) {
+  for (const [lo, hi] of NAME_CHAR_RANGES) {
+    if (cp < lo) {
+      return false;
+    }
+    if (cp <= hi) {
+      return true;
+    }
+  }
+  return false;
+}
+function isNmtoken(text) {
+  if (text.length === 0) {
+    return false;
+  }
+  for (const ch of text) {
+    const cp = ch.codePointAt(0);
+    if (cp === void 0 || !isNameChar(cp)) {
+      return false;
+    }
+  }
+  return true;
+}
+function isRepresentableId(id, charset) {
+  switch (charset) {
+    case "any":
+      return true;
+    case "nmtoken":
+      return isNmtoken(String(id));
+    case "integer":
+      return typeof id === "number" && Number.isSafeInteger(id);
+    case "dense-1-based":
+      return false;
+    default: {
+      const name = charset;
+      throw new GraphFormatError("E_UNSUPPORTED", `unknown id charset ${name}`, { charset: name });
+    }
+  }
+}
+function countUnrepresentableIds(snapshot, charset) {
+  const { ids } = snapshot;
+  if (charset === "any") {
+    return 0;
+  }
+  if (charset === "dense-1-based") {
+    if (ids.kind === "identity" && ids.offset === 1) {
+      return 0;
+    }
+    let changed = 0;
+    for (let i = 0; i < ids.size; i++) {
+      if (ids.idOf(i) !== i + 1) {
+        changed++;
+      }
+    }
+    return changed;
+  }
+  let count = 0;
+  for (let i = 0; i < ids.size; i++) {
+    if (!isRepresentableId(ids.idOf(i), charset)) {
+      count++;
+    }
+  }
+  return count;
+}
+function sanitizeIds(snapshot, charset, mode) {
+  const { ids } = snapshot;
+  const n = ids.size;
+  if (charset === "dense-1-based") {
+    const changed = countUnrepresentableIds(snapshot, charset);
+    return {
+      charset,
+      changed,
+      idAt: (i) => i + 1,
+      isChanged: (i) => ids.idOf(i) !== i + 1,
+      originalAt: (i) => ids.idOf(i)
+    };
+  }
+  const unchanged = {
+    charset,
+    changed: 0,
+    idAt: (i) => ids.idOf(i),
+    isChanged: () => false,
+    originalAt: (i) => ids.idOf(i)
+  };
+  if (charset === "any") {
+    return unchanged;
+  }
+  const bad = [];
+  for (let i = 0; i < n; i++) {
+    if (!isRepresentableId(ids.idOf(i), charset)) {
+      bad.push(i);
+    }
+  }
+  if (bad.length === 0) {
+    return unchanged;
+  }
+  if (mode === "error") {
+    const first = ids.idOf(bad[0]);
+    throw new GraphFormatError(
+      "E_INVALID_ID",
+      `${bad.length} node id${plural(bad.length)} ${charsetText(charset, bad.length)} (first: ${JSON.stringify(first)} at index ${bad[0]}); pass sanitizeIds: "mangle" to rewrite them`,
+      { reason: "charset", charset, count: bad.length, id: first, index: bad[0] }
+    );
+  }
+  const written = /* @__PURE__ */ new Map();
+  if (charset === "nmtoken") {
+    const used = /* @__PURE__ */ new Set();
+    for (let i = 0; i < n; i++) {
+      const id = ids.idOf(i);
+      if (isRepresentableId(id, charset)) {
+        used.add(String(id));
+      }
+    }
+    for (const i of bad) {
+      const base = mangleNmtoken(String(ids.idOf(i)));
+      let candidate = base;
+      for (let k = 2; used.has(candidate); k++) {
+        candidate = `${base}_${k}`;
+      }
+      used.add(candidate);
+      written.set(i, candidate);
+    }
+  } else {
+    const used = /* @__PURE__ */ new Set();
+    for (let i = 0; i < n; i++) {
+      const id = ids.idOf(i);
+      if (typeof id === "number" && Number.isSafeInteger(id)) {
+        used.add(id);
+      }
+    }
+    let next = 0;
+    for (const i of bad) {
+      while (used.has(next)) {
+        next++;
+      }
+      used.add(next);
+      written.set(i, next);
+      next++;
+    }
+  }
+  return {
+    charset,
+    changed: bad.length,
+    idAt: (i) => written.get(i) ?? ids.idOf(i),
+    isChanged: (i) => written.has(i),
+    originalAt: (i) => ids.idOf(i)
+  };
+}
+function mangleNmtoken(text) {
+  let out = "";
+  for (const ch of text) {
+    const cp = ch.codePointAt(0);
+    out += cp !== void 0 && isNameChar(cp) ? ch : "_";
+  }
+  return out.length === 0 ? "_" : out;
+}
+export {
+  agree as $,
+  COLUMN_TYPE_CODE as A,
+  BAD_DEFAULT_CODE as B,
+  COLUMN_RENAMED_CODE as C,
+  DIRECTION_FORCED_CODE as D,
+  EMPTY_INPUT_CODE as E,
+  ELEMENT_ISSUE as F,
+  INPUT_ISSUE as G,
+  HYPEREDGE_CODE as H,
+  ID_MERGED_CODE as I,
+  ID_TEXT_TYPE_CODE as J,
+  ROLE_DROPPED_CODE as K,
+  LOSS as L,
+  MIXED_DIRECTION_CODE as M,
+  NO_GRAPH_CODE as N,
+  OPTION_IGNORED_CODE as O,
+  PRECISION_CODE as P,
+  PARENTS_DROPPED_CODE as Q,
+  ROLE_TAKEN_CODE as R,
+  SINK_OPTION_CODE as S,
+  MUTUAL_AS_UNDIRECTED_CODE as T,
+  UNKNOWN_ATTR_TYPE_CODE as U,
+  BAD_ASPECT_BLOCK_CODE as V,
+  MULTI_ASPECT_FRAGMENT_CODE as W,
+  XML_SYNTAX_CODE as X,
+  ASPECT_ORDER_CODE as Y,
+  STATUS_FAILED_CODE as Z,
+  STATUS_WARNING_CODE as _,
+  checkCapabilities as a,
+  COLUMN_DROPPED_CODE as a$,
+  uniqueColumnName as a0,
+  declareResolved as a1,
+  JSON_NONSTANDARD_NUMBER_CODE as a2,
+  BAD_VALUE_CODE as a3,
+  textChunks as a4,
+  MAX_TEXT_LENGTH as a5,
+  tooLarge as a6,
+  chooseGraph as a7,
+  ImportReportBuilder as a8,
+  idText as a9,
+  NODE_ORDER_CODE as aA,
+  GRAPH_COLUMN_AS_METADATA_CODE as aB,
+  TYPEDEF_NODES_CODE as aC,
+  RELATION_ASSUMED_CODE as aD,
+  sanitizeIds as aE,
+  formatDecimal as aF,
+  formatInteger as aG,
+  canonicalId as aH,
+  coerceIdText as aI,
+  survivesF32 as aJ,
+  isWeightField as aK,
+  parseWeightText as aL,
+  isAbortError as aM,
+  BAD_LINE_CODE as aN,
+  messageOf as aO,
+  describe as aP,
+  UNKNOWN_OPTION_CODE as aQ,
+  normalizeInput as aR,
+  foreignKind as aS,
+  ImportError as aT,
+  FETCH_CODE as aU,
+  EDGES_MERGED_CODE as aV,
+  SELF_LOOPS_DROPPED_CODE as aW,
+  WEIGHT_NOT_FOUND_CODE as aX,
+  lockReader as aY,
+  abortable as aZ,
+  BAD_OPTIONS_CODE as a_,
+  formatF32 as aa,
+  formatF64 as ab,
+  DictHeuristic as ac,
+  TOO_LARGE_CODE as ad,
+  AMBIGUOUS_GRAPH_NAME_CODE as ae,
+  GRAPH_NOT_FOUND_CODE as af,
+  SINGLE_OBJECT_ASPECT_CODE as ag,
+  STYLES_NOT_IMPORTED_CODE as ah,
+  PARENT_CYCLE_CODE as ai,
+  WIDENED_CODE as aj,
+  SYNTAX_CODE as ak,
+  resolveImportOptions as al,
+  throwIfAborted as am,
+  reportUnusedOptions as an,
+  reportSinkOptions as ao,
+  graphChosen as ap,
+  DirectionResolver as aq,
+  IdCoercer as ar,
+  weightFromValue as as,
+  COLUMN_AS_PROPERTY_VALUE_CODE as at,
+  ROLE_ASSUMED_CODE as au,
+  formatNumber as av,
+  isNameChar as aw,
+  XML_ILLEGAL_CHAR_CODE as ax,
+  RENAMED_CODE as ay,
+  LineReader as az,
+  plural as b,
+  otherFormatDialect as b$,
+  COLUMN_RENAMED_LOSS_CODE as b0,
+  CONTROL_CHARACTER_CODE as b1,
+  DEFAULT_ERROR_LIMIT as b2,
+  DIRECTED_COLUMN as b3,
+  DIRECTION_DROPPED_CODE as b4,
+  DUPLICATE_EDGE_CODE as b5,
+  EMPTY_COLUMN_DROPPED_CODE as b6,
+  EQUATION_AS_TEXT_CODE as b7,
+  FOREIGN_FORMAT_CODE as b8,
+  ID_TEXT_COLLISION_CODE as b9,
+  isNmtoken as bA,
+  mangleNmtoken as bB,
+  readText as bC,
+  refusedSave as bD,
+  countMixedEdges as bE,
+  canonicalEncoding as bF,
+  TIME_TEXT_ROLE as bG,
+  TIME_TEXT_SUFFIX as bH,
+  declareAttribute as bI,
+  overflowsToInfinity as bJ,
+  parseDeclaredTemporal as bK,
+  parseDeclaredValue as bL,
+  losesPrecision as bM,
+  parseTimeText as bN,
+  splitListText as bO,
+  timeTextCompanion as bP,
+  parseDecimalText as bQ,
+  formatTimeValue as bR,
+  mapDeclaredType as bS,
+  joinListText as bT,
+  formatTemporal as bU,
+  DICT_SAMPLE_ROWS as bV,
+  reportWeightPrecision as bW,
+  takenIn as bX,
+  declareOn as bY,
+  parseTemporal as bZ,
+  withArticle as b_,
+  INTEGRAL_F64_CODE as ba,
+  ISSUES_SUPPRESSED_CODE as bb,
+  MUTUAL_COLUMN as bc,
+  MUTUAL_EXPANDED_CODE as bd,
+  NONFINITE_AS_NULL_CODE as be,
+  NO_CAPABILITIES as bf,
+  OPTIONS_GAINED_CODE as bg,
+  PAIR_COLUMN as bh,
+  PARSE_ERROR_CODE as bi,
+  SELF_LOOP_CODE as bj,
+  STORAGE_CLASS_CODE as bk,
+  TEMPORAL_DROPPED_CODE as bl,
+  TEMPORAL_TEXT_DROPPED_CODE as bm,
+  TEXT_INFERRED_CODE as bn,
+  UNKNOWN_TYPE_CODE as bo,
+  WEIGHTS_DROPPED_CODE as bp,
+  WEIGHT_KEY_CLASH_CODE as bq,
+  coerceId as br,
+  declareCompanion as bs,
+  decodeEntryName as bt,
+  edgeWeights as bu,
+  forDecodedText as bv,
+  formatGmlReal as bw,
+  inputLength as bx,
+  isCanonicalIntegerText as by,
+  isImportInput as bz,
+  capabilities as c,
+  readBytes as c0,
+  elementCount as c1,
+  DIRECTION_REFUSED_CODE as d,
+  explicitWeights as e,
+  STRAY_TEXT_CODE as f,
+  UNKNOWN_ELEMENT_CODE as g,
+  UNKNOWN_XML_ATTRIBUTE_CODE as h,
+  DANGLING_REFERENCE_CODE as i,
+  COUNT_MISMATCH_CODE as j,
+  COUNT_HINT_CODE as k,
+  MULTIPLE_GRAPHS_CODE as l,
+  DUPLICATE_EDGE_ID_CODE as m,
+  DUPLICATE_NODE_CODE as n,
+  DUPLICATE_ATTRIBUTE_CODE as o,
+  pairFolding as p,
+  UNKNOWN_PARENT_CODE as q,
+  resolveExportOptions as r,
+  MISSING_ENDPOINT_CODE as s,
+  MISSING_ID_CODE as t,
+  DUPLICATE_KEY_CODE as u,
+  ENCODING_CONFLICT_CODE as v,
+  UNKNOWN_ENCODING_CODE as w,
+  ENCODING_FALLBACK_CODE as x,
+  INVALID_ENCODING_CODE as y,
+  INVALID_UTF8_CODE as z
+};
+//# sourceMappingURL=export-BTI4yQgy.js.map