@graphty/graph-io 0.3.16 → 0.3.18

package/dist/chunks/writer-GAdltGmC.js

@@ -0,0 +1,827 @@
+import { GraphFormatError, INVALID_INDEX } from "@graphty/graph-format";
+import { aO as parseDecimalText, U as OPTIONS_GAINED_CODE, al as XML_ILLEGAL_CHAR_CODE, ac as TEXT_INFERRED_CODE, y as INTEGRAL_F64_CODE, a6 as STORAGE_CLASS_CODE, E as EMPTY_COLUMN_DROPPED_CODE, f as COLUMN_RENAMED_LOSS_CODE, a0 as ROLE_ASSUMED_CODE, aj as WEIGHT_KEY_CLASH_CODE, w as ID_TEXT_COLLISION_CODE, x as ID_TEXT_TYPE_CODE, Q as MUTUAL_AS_UNDIRECTED_CODE, S as MUTUAL_EXPANDED_CODE, X as PARENTS_DROPPED_CODE, a1 as ROLE_DROPPED_CODE, ab as TEMPORAL_TEXT_DROPPED_CODE, aa as TEMPORAL_DROPPED_CODE, O as MIXED_DIRECTION_CODE } from "./report-BOk0p5y8.js";
+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 formatF64(value) {
+  return Object.is(value, -0) ? "-0" : String(value);
+}
+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) {
+  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);
+  }
+  return value;
+}
+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);
+    }
+  };
+}
+const LOSS = Object.freeze({
+  /** The format has no mixed direction; expanded pairs are written per onMixedDirection. */
+  MIXED_DIRECTION: "W_MIXED_DIRECTION",
+  /** The format has no mixed direction and onMixedDirection is "error": export() will throw E_DIRECTED. */
+  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 requires edge ids and the snapshot has none; canonical e0..e{E-1} are generated. */
+  EDGE_IDS_GENERATED: "W_EDGE_IDS_GENERATED",
+  /** The snapshot has an edge id column and the format cannot write one. */
+  EDGE_IDS_DROPPED: "W_EDGE_IDS_DROPPED",
+  /** Ids outside the format's charset are rewritten (sanitizeIds "mangle"). */
+  ID_MANGLED: "W_ID_MANGLED",
+  /** Ids outside the format's charset and sanitizeIds "error": export() will throw E_INVALID_ID. */
+  ID_CHARSET: "E_ID_CHARSET",
+  /** The format numbers nodes 1..N; ids that are not their 1-based index are kept as labels only. */
+  ID_RENUMBERED: "W_ID_RENUMBERED",
+  /** A column dtype the format does not keep as declared. */
+  DTYPE: "W_DTYPE_UNSUPPORTED",
+  /** A multi-component column in a format without strides. */
+  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 (design section 5.1) the format cannot carry. */
+  TEMPORAL_TEXT: TEMPORAL_TEXT_DROPPED_CODE,
+  /** A role column the format has no slot for; written as a plain attribute, the role 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 share one written text; export() throws E_INVALID_ID. */
+  ID_TEXT_COLLISION: ID_TEXT_COLLISION_CODE,
+  /** A plain column named like the importer's weight key reads back as THE weight. */
+  WEIGHT_KEY_CLASH: WEIGHT_KEY_CLASH_CODE,
+  /** A role-less column whose written name the importer maps to a role. */
+  ROLE_ASSUMED: ROLE_ASSUMED_CODE,
+  /** A role column written into the format's slot reads back under the importer's fixed name. */
+  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 string / dict column that reads back as the other storage class (the dictionary heuristic). */
+  STORAGE_CLASS: STORAGE_CLASS_CODE,
+  /** An f64 column whose set values are all integral reads back as i32 through an untyped format. */
+  INTEGRAL_F64: INTEGRAL_F64_CODE,
+  /** Text cells that read back as numbers or booleans under the 5.1 grammar. */
+  TEXT_INFERRED: TEXT_INFERRED_CODE,
+  /** A string cell holding a character XML 1.0 forbids; export() throws E_COLUMN_TYPE. */
+  XML_ILLEGAL_CHAR: XML_ILLEGAL_CHAR_CODE,
+  /** A dict column without declared options gains one on re-import. */
+  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 (design section 5.1). */
+  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"
+});
+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(s) in a directed graph; the format has no mixed direction and onMixedDirection is "error"`,
+        null,
+        mixed
+      );
+    } else {
+      note(
+        LOSS.MIXED_DIRECTION,
+        `${mixed} undirected edge(s) in a directed graph written as ${options.onMixedDirection}`,
+        null,
+        mixed
+      );
+    }
+  }
+  if (snapshot.flags.multigraph && !caps.multiEdges) {
+    const parallel = countParallelArcs(snapshot);
+    note(LOSS.MULTI_EDGES, `${parallel} parallel edge(s); the format has no parallel edges`, null, parallel);
+  }
+  if (snapshot.selfLoopCount > 0 && !caps.selfLoops) {
+    note(
+      LOSS.SELF_LOOPS,
+      `${snapshot.selfLoopCount} self-loop(s); 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; canonical e0..e{E-1} are generated and not written back",
+      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(s) are not their 1-based index; nodes are numbered 1..N, the originals kept in the exporter's originalId attribute (restored by restoreMangledIds) and as labels of the nodes without a label value` : `${unrepresentable} node id(s) 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(s) outside the ${caps.idCharset} charset are rewritten; originals kept in the originalId attribute`,
+        null,
+        unrepresentable
+      );
+    } else {
+      note(
+        LOSS.ID_CHARSET,
+        `${unrepresentable} node id(s) outside the ${caps.idCharset} charset; export() will throw unless sanitizeIds is "mangle"`,
+        null,
+        unrepresentable
+      );
+    }
+  }
+  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(s) 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(s)) cannot be written`,
+          name,
+          table.rowCount
+        );
+      }
+    } else {
+      note(
+        LOSS.EXTENSION_TABLE,
+        `extension table "${name}" (${table.rowCount} row(s)) cannot be written`,
+        name,
+        table.rowCount
+      );
+    }
+  }
+  return notes;
+}
+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} (${role}) is written into the format's ${role} slot and reads back as "${fixed}"`,
+          name,
+          column.length - column.nullCount
+        );
+      }
+    }
+    if (domain === "edge" && role === "id") {
+      continue;
+    }
+    if (role === "timeText") {
+      if (extras.temporalText !== true) {
+        note(
+          LOSS.TEMPORAL_TEXT,
+          `${label} (the lexical form of a temporal column, design section 5.1) 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(s) cannot be written as ${charset} (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;
+}
+const DEFAULT_CHUNK_BYTES = 64 * 1024;
+async function* encodeChunks(parts, chunkBytes = DEFAULT_CHUNK_BYTES) {
+  const encoder = new TextEncoder();
+  let pending = [];
+  let pendingUnits = 0;
+  for await (const part of parts) {
+    if (part.length === 0) {
+      continue;
+    }
+    pending.push(part);
+    pendingUnits += part.length;
+    if (pendingUnits >= chunkBytes) {
+      yield encoder.encode(pending.length === 1 ? pending[0] : pending.join(""));
+      pending = [];
+      pendingUnits = 0;
+    }
+  }
+  if (pending.length > 0) {
+    yield encoder.encode(pending.length === 1 ? pending[0] : pending.join(""));
+  }
+}
+async function joinText(parts) {
+  const collected = [];
+  for await (const part of parts) {
+    collected.push(part);
+  }
+  return collected.join("");
+}
+async function decodeChunks(chunks) {
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  const parts = [];
+  for await (const chunk of chunks) {
+    parts.push(decoder.decode(chunk, { stream: true }));
+  }
+  parts.push(decoder.decode());
+  return parts.join("");
+}
+async function collectBytes(chunks) {
+  const parts = [];
+  let total = 0;
+  for await (const chunk of chunks) {
+    parts.push(chunk);
+    total += chunk.byteLength;
+  }
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const part of parts) {
+    out.set(part, offset);
+    offset += part.byteLength;
+  }
+  return out;
+}
+function toReadableStream(chunks) {
+  const iterator = chunks[Symbol.asyncIterator]();
+  return new ReadableStream({
+    async pull(controller) {
+      const { done, value } = await iterator.next();
+      if (done) {
+        controller.close();
+        return;
+      }
+      controller.enqueue(value);
+    },
+    async cancel() {
+      await iterator.return?.(void 0);
+    }
+  });
+}
+export {
+  DEFAULT_CHUNK_BYTES as D,
+  LOSS as L,
+  NO_CAPABILITIES as N,
+  checkCapabilities as a,
+  collectBytes as b,
+  capabilities as c,
+  decodeChunks as d,
+  encodeChunks as e,
+  explicitWeights as f,
+  formatDecimal as g,
+  formatF32 as h,
+  formatF64 as i,
+  formatGmlReal as j,
+  formatInteger as k,
+  isNmtoken as l,
+  isWeightField as m,
+  joinText as n,
+  mangleNmtoken as o,
+  parseWeightText as p,
+  isNameChar as q,
+  countMixedEdges as r,
+  sanitizeIds as s,
+  toReadableStream as t,
+  weightFromValue as w
+};
+//# sourceMappingURL=writer-GAdltGmC.js.map