@graphty/graph-io 0.3.16 → 0.3.18

package/dist/chunks/{writer-BtWpUaiH.js → report-BOk0p5y8.js}

@@ -30,6 +30,21 @@ 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 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 GRAPH_NOT_FOUND_CODE = "E_GRAPH_NOT_FOUND";
+const AMBIGUOUS_GRAPH_NAME_CODE = "E_AMBIGUOUS_GRAPH_NAME";
 const ROLE_DROPPED_CODE = "W_ROLE_DROPPED";
 const PARENTS_DROPPED_CODE = "W_PARENTS_DROPPED";
 const TEMPORAL_DROPPED_CODE = "W_TEMPORAL_DROPPED";
@@ -1451,6 +1466,13 @@ function startsWithUtf8(bytes) {
     return false;
   }
 }
+function decodeEntryName(bytes) {
+  try {
+    return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
+  } catch {
+    return new TextDecoder("windows-1252").decode(bytes);
+  }
+}
 function concatBytes(chunks) {
   if (chunks.length === 1) {
     return chunks[0];
@@ -1792,6 +1814,58 @@ function reportUnusedOptions(options, report, used) {
   }
   return recorded;
 }
+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(s)`,
+        { 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(s)`);
+  }
+  return index;
+}
 function resolveImportOptions(options, defaults) {
   const o = options ?? {};
   return Object.freeze({
@@ -2148,924 +2222,119 @@ function isAbortError(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 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 {
-  SYNTAX_CODE as $,
-  MULTIPLE_GRAPHS_CODE as A,
-  BAD_DEFAULT_CODE as B,
+  RENAMED_CODE as $,
+  AMBIGUOUS_GRAPH_NAME_CODE as A,
+  BAD_ASPECT_BLOCK_CODE as B,
   COLUMN_RENAMED_CODE as C,
-  DEFAULT_CHUNK_BYTES as D,
+  DANGLING_REFERENCE_CODE as D,
   EMPTY_COLUMN_DROPPED_CODE as E,
-  MUTUAL_AS_UNDIRECTED_CODE as F,
-  MUTUAL_COLUMN as G,
+  INVALID_UTF8_CODE as F,
+  GRAPH_NOT_FOUND_CODE as G,
   HYPEREDGE_CODE as H,
   ImportReportBuilder as I,
-  MUTUAL_EXPANDED_CODE as J,
-  NO_GRAPH_CODE as K,
-  LOSS as L,
+  IdCoercer as J,
+  ImportError as K,
+  LineReader as L,
   MISSING_ENDPOINT_CODE as M,
-  NO_CAPABILITIES as N,
-  OPTIONS_GAINED_CODE as O,
-  OPTION_IGNORED_CODE as P,
-  PAIR_COLUMN as Q,
-  PARENTS_DROPPED_CODE as R,
-  PARSE_ERROR_CODE as S,
-  PRECISION_CODE as T,
-  RENAMED_CODE as U,
-  ROLE_ASSUMED_CODE as V,
-  ROLE_DROPPED_CODE as W,
-  ROLE_TAKEN_CODE as X,
-  SINK_OPTION_CODE as Y,
-  STORAGE_CLASS_CODE as Z,
-  STRAY_TEXT_CODE as _,
+  MISSING_ID_CODE as N,
+  MIXED_DIRECTION_CODE as O,
+  MULTIPLE_GRAPHS_CODE as P,
+  MUTUAL_AS_UNDIRECTED_CODE as Q,
+  MUTUAL_COLUMN as R,
+  MUTUAL_EXPANDED_CODE as S,
+  NO_GRAPH_CODE as T,
+  OPTIONS_GAINED_CODE as U,
+  OPTION_IGNORED_CODE as V,
+  PAIR_COLUMN as W,
+  PARENTS_DROPPED_CODE as X,
+  PARENT_CYCLE_CODE as Y,
+  PARSE_ERROR_CODE as Z,
+  PRECISION_CODE as _,
   throwIfAborted as a,
-  DICT_SAMPLE_ROWS as a$,
-  TEMPORAL_DROPPED_CODE as a0,
-  TEMPORAL_TEXT_DROPPED_CODE as a1,
-  TEXT_INFERRED_CODE as a2,
-  UNKNOWN_ATTR_TYPE_CODE as a3,
-  UNKNOWN_ELEMENT_CODE as a4,
-  UNKNOWN_ENCODING_CODE as a5,
-  UNKNOWN_PARENT_CODE as a6,
-  UNKNOWN_TYPE_CODE as a7,
-  WEIGHT_KEY_CLASH_CODE as a8,
-  XML_ILLEGAL_CHAR_CODE as a9,
-  parseWeightText as aA,
-  readText as aB,
-  reportSinkOptions as aC,
-  reportUnusedOptions as aD,
-  resolveExportOptions as aE,
-  resolveImportOptions as aF,
-  sanitizeIds as aG,
-  toReadableStream as aH,
-  isNameChar as aI,
-  countMixedEdges as aJ,
-  weightFromValue as aK,
-  uniqueColumnName as aL,
-  TIME_TEXT_ROLE as aM,
-  TIME_TEXT_SUFFIX as aN,
-  declareAttribute as aO,
-  parseDeclaredTemporal as aP,
-  parseDeclaredValue as aQ,
-  losesPrecision as aR,
-  parseTimeText as aS,
-  splitListText as aT,
-  timeTextCompanion as aU,
-  parseDecimalText as aV,
-  formatTimeValue as aW,
-  mapDeclaredType as aX,
-  joinListText as aY,
-  formatTemporal as aZ,
-  DictHeuristic as a_,
-  XML_SYNTAX_CODE as aa,
-  canonicalId as ab,
-  capabilities as ac,
-  checkCapabilities as ad,
-  coerceId as ae,
-  coerceIdText as af,
-  collectBytes as ag,
-  declareCompanion as ah,
-  declareResolved as ai,
-  decodeChunks as aj,
-  encodeChunks as ak,
-  explicitWeights as al,
-  formatDecimal as am,
-  formatF32 as an,
-  formatF64 as ao,
-  formatGmlReal as ap,
-  formatInteger as aq,
-  inputLength as ar,
-  isAbortError as as,
-  isCanonicalIntegerText as at,
-  isImportInput as au,
-  isNmtoken as av,
-  isWeightField as aw,
-  joinText as ax,
-  mangleNmtoken as ay,
-  pairFolding as az,
-  BAD_OPTIONS_CODE as b,
-  declareOn as b0,
-  takenIn as b1,
-  COLUMN_RENAMED_LOSS_CODE as c,
-  COUNT_HINT_CODE as d,
-  DEFAULT_ERROR_LIMIT as e,
-  DIRECTED_COLUMN as f,
-  DIRECTION_FORCED_CODE as g,
-  DIRECTION_REFUSED_CODE as h,
-  DUPLICATE_EDGE_ID_CODE as i,
-  DUPLICATE_KEY_CODE as j,
-  DUPLICATE_NODE_CODE as k,
-  DirectionResolver as l,
-  EMPTY_INPUT_CODE as m,
-  ENCODING_FALLBACK_CODE as n,
-  ID_MERGED_CODE as o,
-  ID_TEXT_COLLISION_CODE as p,
-  ID_TEXT_TYPE_CODE as q,
-  INTEGRAL_F64_CODE as r,
-  INVALID_ENCODING_CODE as s,
+  ROLE_ASSUMED_CODE as a0,
+  ROLE_DROPPED_CODE as a1,
+  ROLE_TAKEN_CODE as a2,
+  SINK_OPTION_CODE as a3,
+  STATUS_FAILED_CODE as a4,
+  STATUS_WARNING_CODE as a5,
+  STORAGE_CLASS_CODE as a6,
+  STRAY_TEXT_CODE as a7,
+  STYLES_NOT_IMPORTED_CODE as a8,
+  SYNTAX_CODE as a9,
+  reportSinkOptions as aA,
+  reportUnusedOptions as aB,
+  resolveExportOptions as aC,
+  resolveImportOptions as aD,
+  uniqueColumnName as aE,
+  TIME_TEXT_ROLE as aF,
+  TIME_TEXT_SUFFIX as aG,
+  declareAttribute as aH,
+  parseDeclaredTemporal as aI,
+  parseDeclaredValue as aJ,
+  losesPrecision as aK,
+  parseTimeText as aL,
+  splitListText as aM,
+  timeTextCompanion as aN,
+  parseDecimalText as aO,
+  formatTimeValue as aP,
+  mapDeclaredType as aQ,
+  joinListText as aR,
+  formatTemporal as aS,
+  DictHeuristic as aT,
+  DICT_SAMPLE_ROWS as aU,
+  declareOn as aV,
+  takenIn as aW,
+  TEMPORAL_DROPPED_CODE as aa,
+  TEMPORAL_TEXT_DROPPED_CODE as ab,
+  TEXT_INFERRED_CODE as ac,
+  TOO_LARGE_CODE as ad,
+  UNKNOWN_ATTR_TYPE_CODE as ae,
+  UNKNOWN_ELEMENT_CODE as af,
+  UNKNOWN_ENCODING_CODE as ag,
+  UNKNOWN_PARENT_CODE as ah,
+  UNKNOWN_TYPE_CODE as ai,
+  WEIGHT_KEY_CLASH_CODE as aj,
+  WIDENED_CODE as ak,
+  XML_ILLEGAL_CHAR_CODE as al,
+  XML_SYNTAX_CODE as am,
+  canonicalId as an,
+  chooseGraph as ao,
+  coerceId as ap,
+  coerceIdText as aq,
+  declareCompanion as ar,
+  declareResolved as as,
+  decodeEntryName as at,
+  inputLength as au,
+  isAbortError as av,
+  isCanonicalIntegerText as aw,
+  isImportInput as ax,
+  pairFolding as ay,
+  readText as az,
+  ASPECT_ORDER_CODE as b,
+  BAD_DEFAULT_CODE as c,
+  BAD_OPTIONS_CODE as d,
+  BAD_VALUE_CODE as e,
+  COLUMN_RENAMED_LOSS_CODE as f,
+  COUNT_HINT_CODE as g,
+  COUNT_MISMATCH_CODE as h,
+  DEFAULT_ERROR_LIMIT as i,
+  DIRECTED_COLUMN as j,
+  DIRECTION_FORCED_CODE as k,
+  DIRECTION_REFUSED_CODE as l,
+  DUPLICATE_ATTRIBUTE_CODE as m,
+  DUPLICATE_EDGE_ID_CODE as n,
+  DUPLICATE_KEY_CODE as o,
+  DUPLICATE_NODE_CODE as p,
+  DirectionResolver as q,
+  EMPTY_INPUT_CODE as r,
+  ENCODING_FALLBACK_CODE as s,
   textChunks as t,
-  INVALID_UTF8_CODE as u,
-  IdCoercer as v,
-  ImportError as w,
-  LineReader as x,
-  MISSING_ID_CODE as y,
-  MIXED_DIRECTION_CODE as z
+  EQUATION_AS_TEXT_CODE as u,
+  ID_MERGED_CODE as v,
+  ID_TEXT_COLLISION_CODE as w,
+  ID_TEXT_TYPE_CODE as x,
+  INTEGRAL_F64_CODE as y,
+  INVALID_ENCODING_CODE as z
 };
-//# sourceMappingURL=writer-BtWpUaiH.js.map
+//# sourceMappingURL=report-BOk0p5y8.js.map