@graphty/graph-io 0.3.24 → 0.3.26

package/dist/chunks/{exporter-BGrsWamJ.js → exporter-Dxh231ZF.js}

@@ -1,12 +1,13 @@
 import { GraphFormatError } from "@graphty/graph-format";
-import { V as resolveExportOptions, X as pairFolding } from "./report-B1z4WT9e.js";
-import { c as capabilities, L as LOSS, a as checkCapabilities } from "./export-Bh60Dv-n.js";
-import { i as isRecord, P as POSITION_COLUMN } from "./json-elements-DDS8N2Dd.js";
-import { e as explicitWeights } from "./weights-Dzba96G3.js";
-import { j as joinText, e as encodeChunks } from "./writer-C7flM-Ih.js";
-import { a as CX2_FORMAT, O as ORIGINAL_ID_ATTRIBUTE, b as cx2Type, B as BYPASS_NAMESPACE } from "./importer-vi3bSdtw.js";
+import { a as CX2_FORMAT, s as stringify, d as directionNotes, p as planNodeIds, O as ORIGINAL_ID_ATTRIBUTE, n as nonFinitePositions, b as planEdgeIds, e as cx2Type, f as aspectBlock, B as BYPASS_NAMESPACE, g as declaredType } from "./importer-DfVu6j59.js";
+import { c as capabilities, L as LOSS, r as resolveExportOptions, a as checkCapabilities, p as pairFolding, e as explicitWeights, b as plural } from "./export-BTI4yQgy.js";
+import { i as isRecord, P as POSITION_COLUMN } from "./json-elements-3tnyt5uZ.js";
+import { j as joinText, e as encodeChunks } from "./writer-DxjgHwSe.js";
 const CX2_LOSS = Object.freeze({
-  /** Every edge is written directed: an undirected snapshot, or the undirected pairs of a mixed one. */
+  /**
+   * Every edge is written as directed, so an undirected graph, or the undirected edges of a mixed graph, read back
+   * as directed.
+   */
   UNDIRECTED_AS_DIRECTED: "W_CX2_UNDIRECTED_AS_DIRECTED",
   /** A nested (json) column is written as a string attribute holding its JSON text. */
   JSON_AS_STRING: "W_CX2_JSON_AS_STRING",
@@ -14,17 +15,26 @@ const CX2_LOSS = Object.freeze({
   NONFINITE_AS_NULL: "W_CX2_NONFINITE_AS_NULL",
   /** A mutual pair is written as two directed edges without its mark. */
   MUTUAL_EXPANDED: LOSS.MUTUAL_EXPANDED,
-  /** A plain edge column named like the weight key reads back as THE weight (or is skipped when weights are written). */
+  /**
+   * An attribute without the weight role is named like the key weights are written under; it reads back as the edge
+   * weight, or is not written when the graph has weights of its own.
+   */
   WEIGHT_KEY_CLASH: LOSS.WEIGHT_KEY_CLASH,
   /** A parent / parents column: CX2 has no containment. */
   HIERARCHY_DROPPED: LOSS.HIERARCHY,
   /** A start / end / timestamp column: CX2 has no time. */
   TEMPORAL_DROPPED: LOSS.TEMPORAL,
-  /** A role column written as a plain attribute. */
+  /** An attribute with a role the format has no place for is written as a plain attribute; the role is lost. */
   ROLE_DROPPED: LOSS.ROLE,
-  /** A dtype CX2 declares as another (f32 as double, u32 as long, dict as string, ...). */
+  /**
+   * An attribute type CX2 stores as another (a 32-bit float as double, an unsigned integer as long, a dictionary as
+   * string); it reads back with that type.
+   */
   DTYPE_UNSUPPORTED: LOSS.DTYPE,
-  /** Node ids that are not integers under the default sanitizeIds "error": export() throws E_INVALID_ID. */
+  /**
+   * Node ids the format cannot write, under `sanitizeIds: "error"`; the save fails with E_INVALID_ID. Pass
+   * `sanitizeIds: "mangle"` to rewrite them.
+   */
   ID_CHARSET: LOSS.ID_CHARSET,
   /** Node ids that are not integers under sanitizeIds "mangle": renumbered, originals kept. */
   ID_MANGLED: LOSS.ID_MANGLED,
@@ -87,100 +97,12 @@ const CORE_ASPECTS = /* @__PURE__ */ new Set([
   "status"
 ]);
 const WEIGHT_ATTRIBUTE = "weight";
-const RAW = `${String.fromCharCode(0)}cx2:`;
-const RAW_JSON = /"\\u0000cx2:(-?[0-9]+)"/g;
-const BIG_INTEGER_TEXT = /^-?[1-9][0-9]{15,}$/;
-function writableId(id) {
-  return typeof id === "number" ? Number.isSafeInteger(id) : BIG_INTEGER_TEXT.test(id) && !Number.isSafeInteger(Number(id));
-}
-function writtenIds(snapshot, mode) {
-  const { ids } = snapshot;
-  const bad = [];
-  const used = /* @__PURE__ */ new Set();
-  for (let i = 0; i < ids.size; i++) {
-    const id = ids.idOf(i);
-    if (!writableId(id)) {
-      bad.push(i);
-    } else if (typeof id === "number") {
-      used.add(id);
-    }
-  }
-  if (bad.length > 0 && mode === "error") {
-    const first = ids.idOf(bad[0]);
-    throw new GraphFormatError(
-      "E_INVALID_ID",
-      `${bad.length} node id(s) cannot be written as CX2 integers (first: ${JSON.stringify(first)} at index ${bad[0]}); pass sanitizeIds: "mangle" to rewrite them`,
-      { reason: "charset", charset: "integer", count: bad.length, index: bad[0] }
-    );
-  }
-  const renumbered = /* @__PURE__ */ new Map();
-  let next = 0;
-  for (const i of bad) {
-    while (used.has(next)) {
-      next++;
-    }
-    used.add(next);
-    renumbered.set(i, next);
-  }
-  return {
-    changed: bad.length,
-    idAt: (i) => {
-      const id = renumbered.get(i) ?? ids.idOf(i);
-      return typeof id === "string" ? `${RAW}${id}` : id;
-    },
-    isChanged: (i) => renumbered.has(i),
-    originalAt: (i) => ids.idOf(i)
-  };
-}
-function unwritableIds(snapshot) {
-  let count = 0;
-  for (let i = 0; i < snapshot.ids.size; i++) {
-    if (!writableId(snapshot.ids.idOf(i))) {
-      count++;
-    }
-  }
-  return count;
-}
 function isBypass(column) {
   return column.meta.origin?.namespace === BYPASS_NAMESPACE;
 }
 function isZ(column) {
   return column.meta.extra.cytoscape === "z";
 }
-function scalarType(dtype, longOrigin) {
-  switch (dtype) {
-    case "f64":
-      return longOrigin ? "long" : "double";
-    case "f32":
-      return "double";
-    case "i32":
-    case "u8":
-      return "integer";
-    case "u32":
-      return "long";
-    case "bool":
-      return "boolean";
-    default:
-      return "string";
-  }
-}
-function allIntegral(column) {
-  for (let i = 0; i < column.length; i++) {
-    if (column.isSet(i) && !Number.isSafeInteger(column.value(i))) {
-      return false;
-    }
-  }
-  return true;
-}
-function declaredType(column) {
-  const { meta } = column;
-  const origin = meta.origin?.type ?? null;
-  const longOrigin = origin !== null && /long$/.test(origin) && (meta.dtype !== "f64" || allIntegral(column));
-  if (meta.dtype === "list") {
-    return meta.itemDtype === null || meta.itemDtype === "json" ? "string" : `list_of_${scalarType(meta.itemDtype, longOrigin)}`;
-  }
-  return meta.components > 1 ? `list_of_${scalarType(meta.dtype, false)}` : scalarType(meta.dtype, longOrigin);
-}
 function nonFiniteCount(column) {
   const { dtype, itemDtype } = column.meta;
   const numeric = dtype === "f32" || dtype === "f64" || dtype === "list" && (itemDtype === "f32" || itemDtype === "f64");
@@ -257,24 +179,11 @@ function plan(snapshot, common) {
     notes.push(gen);
   }
   const folding = pairFolding(snapshot);
-  directionNotes(snapshot, folding, common, note);
-  const unwritable = unwritableIds(snapshot);
-  if (unwritable > 0) {
-    note(
-      common.sanitizeIds === "mangle" ? LOSS.ID_MANGLED : LOSS.ID_CHARSET,
-      common.sanitizeIds === "mangle" ? `${unwritable} node id(s) that are not integers are renumbered; the originals are kept in the ${ORIGINAL_ID_ATTRIBUTE} attribute (restored by restoreMangledIds)` : `${unwritable} node id(s) that are not integers; export() will throw unless sanitizeIds is "mangle"`,
-      null,
-      unwritable
-    );
-  }
-  let ids = null;
-  try {
-    ids = writtenIds(snapshot, common.sanitizeIds);
-  } catch (err) {
-    if (!(err instanceof GraphFormatError)) {
-      throw err;
-    }
-    fatal ??= err;
+  directionNotes(snapshot, folding, common, CX2_LOSS.UNDIRECTED_AS_DIRECTED, note);
+  const planned = planNodeIds(snapshot, common, "CX2", ORIGINAL_ID_ATTRIBUTE, note);
+  const ids = planned instanceof GraphFormatError ? null : planned;
+  if (planned instanceof GraphFormatError) {
+    fatal ??= planned;
   }
   const weights = explicitWeights(snapshot);
   const label = snapshot.nodes.byRole("label");
@@ -321,21 +230,12 @@ function plan(snapshot, common) {
   if (nonfinite > 0) {
     note(
       CX2_LOSS.NONFINITE_AS_NULL,
-      `${nonfinite} NaN or infinite value(s) cannot be written in CX2; written as null, they read back unset`,
+      `${nonfinite} NaN or infinite value${plural(nonfinite)} cannot be written in CX2; written as null, they read back unset`,
       null,
       nonfinite
     );
   }
   const edgeIds = planEdgeIds(snapshot, note);
-  const idColumn = snapshot.edges.byRole("id");
-  if (idColumn !== null && idColumn.dtype !== "f64") {
-    note(
-      LOSS.DTYPE,
-      `edge id column "${idColumn.meta.name}" is ${idColumn.dtype}; CX2 edge ids are integers and read back as f64`,
-      idColumn.meta.name,
-      snapshot.edgeCount - idColumn.nullCount
-    );
-  }
   const z = [...snapshot.nodes].find(isZ) ?? null;
   const positionZ = position !== null && z === null && position.meta.extra.sourceDims === 3;
   return {
@@ -356,99 +256,6 @@ function plan(snapshot, common) {
     originalIds: ids !== null && ids.changed > 0
   };
 }
-function directionNotes(snapshot, folding, common, note) {
-  if (!snapshot.directed) {
-    note(
-      CX2_LOSS.UNDIRECTED_AS_DIRECTED,
-      `the snapshot is undirected; every edge is written as a directed CX2 edge (${snapshot.edgeCount} edge(s))`,
-      null,
-      snapshot.edgeCount
-    );
-  } else if (common.onMixedDirection !== "error") {
-    let undirected = 0;
-    for (let e = 0; e < snapshot.edgeCount; e++) {
-      if (!folding.folded(e) && !folding.sourceDirected(e)) {
-        undirected++;
-      }
-    }
-    if (undirected > 0) {
-      note(
-        CX2_LOSS.UNDIRECTED_AS_DIRECTED,
-        `${undirected} undirected edge(s) are written as one directed edge each (a pair folded to its primary); CX2 has no undirected edge`,
-        null,
-        undirected
-      );
-    }
-  }
-  if (folding.mutualCount > 0) {
-    note(
-      LOSS.MUTUAL_EXPANDED,
-      `${folding.mutualCount} mutual pair(s) are written as two directed edges; the mutual mark is lost`,
-      null,
-      folding.mutualCount
-    );
-  }
-}
-function nonFinitePositions(position) {
-  let count = 0;
-  for (let i = 0; i < position.length; i++) {
-    if (position.isSet(i)) {
-      const p = position.value(i);
-      if (!Number.isFinite(p[0]) || !Number.isFinite(p[1])) {
-        count++;
-      }
-    }
-  }
-  return count;
-}
-function planEdgeIds(snapshot, note) {
-  const column = snapshot.edges.byRole("id");
-  const ids = new Array(snapshot.edgeCount).fill(null);
-  const used = /* @__PURE__ */ new Set();
-  let generated = 0;
-  if (column !== null) {
-    for (let e = 0; e < snapshot.edgeCount; e++) {
-      const value = column.isSet(e) ? column.value(e) : void 0;
-      let n = NaN;
-      if (typeof value === "number") {
-        n = value;
-      } else if (typeof value === "string") {
-        n = Number(value);
-      }
-      if (Number.isSafeInteger(n) && !used.has(n)) {
-        ids[e] = n === 0 ? 0 : n;
-        used.add(n);
-      }
-    }
-  }
-  let next = 0;
-  const out = [];
-  for (let e = 0; e < snapshot.edgeCount; e++) {
-    let id = ids[e];
-    if (id === null) {
-      while (used.has(next)) {
-        next++;
-      }
-      id = next;
-      used.add(next);
-      generated++;
-    }
-    out.push(id);
-  }
-  if (column !== null && generated > 0) {
-    note(
-      LOSS.EDGE_IDS_GENERATED,
-      `${generated} edge(s) have no distinct integer id in "${column.meta.name}"; they are written with generated ids`,
-      column.meta.name,
-      generated
-    );
-  }
-  return out;
-}
-function stringify(value) {
-  const text = JSON.stringify(value, (_key, v) => Object.is(v, -0) ? `${RAW}-0` : v);
-  return text.includes("\\u0000cx2:") ? text.replace(RAW_JSON, "$1") : text;
-}
 function cellValue(p, row) {
   const { column } = p;
   if (!column.isSet(row)) {
@@ -638,14 +445,15 @@ function* write(snapshot, p) {
   }
   yield '{"status":[{"error":"","success":true}]}]\n';
 }
-function* block(aspect, count, element) {
-  yield `{${JSON.stringify(aspect)}:[`;
-  for (let k = 0; k < count; k++) {
-    yield k === 0 ? `
-${element(k)}` : `,
-${element(k)}`;
-  }
-  yield "]},\n";
+function block(aspect, count, element) {
+  return aspectBlock(
+    aspect,
+    (function* elements() {
+      for (let k = 0; k < count; k++) {
+        yield element(k);
+      }
+    })()
+  );
 }
 function nodeElement(p, ids, i) {
   const element = { id: ids.idAt(i) };
@@ -699,6 +507,7 @@ function bypassValues(columns, row) {
 }
 const cx2Exporter = Object.freeze({
   format: CX2_FORMAT,
+  options: Object.freeze([]),
   capabilities: CX2_CAPABILITIES,
   /**
    * Pre-flight: what export() would lose, without writing anything.
@@ -733,4 +542,4 @@ export {
   CX2_LOSS as a,
   cx2Exporter as c
 };
-//# sourceMappingURL=exporter-BGrsWamJ.js.map
+//# sourceMappingURL=exporter-Dxh231ZF.js.map

package/dist/chunks/exporter-Dxh231ZF.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"exporter-Dxh231ZF.js","sources":["../../src/formats/cx2/exporter.ts"],"sourcesContent":["/**\n * The CX2 exporter (design/graph-io/cytoscape-and-obo/design.md section 1.3; graphty issue #307):\n * writes a snapshot as one CX2 document -- the descriptor, the pre-metadata, one\n * `attributeDeclarations` block (aliases from `origin.id`, defaults from `meta.default`),\n * `networkAttributes`, `nodes` (x / y from the position with y flipped back to screen coordinates,\n * `z` from the `z` column), `edges`, the `cx2.bypass` columns as `nodeBypasses` / `edgeBypasses`,\n * the opaque aspects a CX2 import kept (which returns its own style rules) and `status`.\n *\n * What CX2 cannot hold is announced by check() before anything is written: every edge is\n * directed (W_CX2_UNDIRECTED_AS_DIRECTED, W_MUTUAL_EXPANDED), node ids are integers (E_ID_CHARSET\n * unless `sanitizeIds: \"mangle\"`, which keeps the original in the `graphty:originalId` attribute\n * the importer restores), nested values are written as JSON text (W_CX2_JSON_AS_STRING), NaN and\n * the infinities as null (W_CX2_NONFINITE_AS_NULL), and the generic notes of checkCapabilities().\n */\n\nimport { type Column, GraphFormatError, type GraphSnapshot } from \"@graphty/graph-format\";\n\nimport {\n    aspectBlock,\n    declaredType,\n    directionNotes,\n    nonFinitePositions,\n    planEdgeIds,\n    planNodeIds,\n    stringify,\n    type WrittenIds,\n} from \"../../common/cx-export.js\";\nimport { type PairFolding, pairFolding } from \"../../common/direction.js\";\nimport { capabilities, checkCapabilities, LOSS } from \"../../common/export.js\";\nimport { isRecord, POSITION_COLUMN } from \"../../common/json-elements.js\";\nimport { type ResolvedExportOptions, resolveExportOptions } from \"../../common/options.js\";\nimport { plural } from \"../../common/plural.js\";\nimport { type ExplicitWeights, explicitWeights } from \"../../common/weights.js\";\nimport { encodeChunks, joinText } from \"../../common/writer.js\";\nimport { type CommonExportOptions, type ExportCapabilities, type GraphExporter, type LossNote } from \"../../types.js\";\nimport { BYPASS_NAMESPACE, CX2_FORMAT, cx2Type, ORIGINAL_ID_ATTRIBUTE } from \"./importer.js\";\n\n/**\n * The options of the CX2 exporter: the common export options; it has none of its own.\n * @category Built-in formats\n */\nexport type Cx2ExportOptions = CommonExportOptions;\n\n/**\n * The loss notes the CX2 exporter's check() returns, by name. A key is the\n * code without its severity and format prefixes.\n * @category Built-in formats\n */\nexport const CX2_LOSS = Object.freeze({\n    /**\n     * Every edge is written as directed, so an undirected graph, or the undirected edges of a mixed graph, read back\n     * as directed.\n     */\n    UNDIRECTED_AS_DIRECTED: \"W_CX2_UNDIRECTED_AS_DIRECTED\",\n    /** A nested (json) column is written as a string attribute holding its JSON text. */\n    JSON_AS_STRING: \"W_CX2_JSON_AS_STRING\",\n    /** NaN and the infinities cannot be written; they are written as null and read back unset. */\n    NONFINITE_AS_NULL: \"W_CX2_NONFINITE_AS_NULL\",\n    /** A mutual pair is written as two directed edges without its mark. */\n    MUTUAL_EXPANDED: LOSS.MUTUAL_EXPANDED,\n    /**\n     * An attribute without the weight role is named like the key weights are written under; it reads back as the edge\n     * weight, or is not written when the graph has weights of its own.\n     */\n    WEIGHT_KEY_CLASH: LOSS.WEIGHT_KEY_CLASH,\n    /** A parent / parents column: CX2 has no containment. */\n    HIERARCHY_DROPPED: LOSS.HIERARCHY,\n    /** A start / end / timestamp column: CX2 has no time. */\n    TEMPORAL_DROPPED: LOSS.TEMPORAL,\n    /** An attribute with a role the format has no place for is written as a plain attribute; the role is lost. */\n    ROLE_DROPPED: LOSS.ROLE,\n    /**\n     * An attribute type CX2 stores as another (a 32-bit float as double, an unsigned integer as long, a dictionary as\n     * string); it reads back with that type.\n     */\n    DTYPE_UNSUPPORTED: LOSS.DTYPE,\n    /**\n     * Node ids the format cannot write, under `sanitizeIds: \"error\"`; the save fails with E_INVALID_ID. Pass\n     * `sanitizeIds: \"mangle\"` to rewrite them.\n     */\n    ID_CHARSET: LOSS.ID_CHARSET,\n    /** Node ids that are not integers under sanitizeIds \"mangle\": renumbered, originals kept. */\n    ID_MANGLED: LOSS.ID_MANGLED,\n    /** Edges without a usable id get generated integer ids. */\n    EDGE_IDS_GENERATED: LOSS.EDGE_IDS_GENERATED,\n});\n\n/**\n * What CX2 keeps: directed multigraphs with self-loops, integer node ids,\n * required integer edge ids, declared string / double / integer / boolean columns and lists of\n * them, declared defaults, network attributes and the position role. f32, u32, u8 and dict columns\n * are written as the nearest declared type and read back as it.\n * @category Built-in formats\n */\nexport const CX2_CAPABILITIES: ExportCapabilities = capabilities({\n    mixedDirection: false,\n    multiEdges: true,\n    selfLoops: true,\n    edgeIds: \"required\",\n    idCharset: \"integer\",\n    dtypes: [\"string\", \"f64\", \"i32\", \"bool\"],\n    components: false,\n    lists: true,\n    json: false,\n    defaults: true,\n    options: false,\n    hierarchy: false,\n    temporal: \"none\",\n    graphAttributes: true,\n    positions: true,\n    viz: false,\n});\n\n/** The roles CX2 has a slot for, and the column names its importer gives them. */\nconst SLOT_ROLES: ReadonlySet<string> = new Set([\"label\", \"position\", \"id\"]);\nconst ROLE_NAMES: Readonly<Record<string, string>> = Object.freeze({\n    label: \"name\",\n    position: POSITION_COLUMN,\n});\n\n/** Roles whose columns are never written as attributes. */\nconst SKIPPED_ROLES: ReadonlySet<string> = new Set([\n    \"directed\",\n    \"pair\",\n    \"mutual\",\n    \"weight\",\n    \"timeText\",\n    \"originalId\",\n    \"parent\",\n    \"parents\",\n    \"start\",\n    \"end\",\n    \"timestamp\",\n    \"timestamps\",\n    \"spells\",\n    \"open\",\n    \"spellsOpen\",\n    \"position\",\n    \"color\",\n    \"size\",\n    \"shape\",\n    \"thickness\",\n]);\n\n/** The aspects the exporter writes itself; an opaque aspect of the same name is not written again. */\nconst CORE_ASPECTS: ReadonlySet<string> = new Set([\n    \"nodes\",\n    \"edges\",\n    \"attributeDeclarations\",\n    \"networkAttributes\",\n    \"nodeBypasses\",\n    \"edgeBypasses\",\n    \"metaData\",\n    \"status\",\n]);\n\n/** The weight attribute name. */\nconst WEIGHT_ATTRIBUTE = \"weight\";\n\n/** One attribute column as it will be written. */\ninterface AttributePlan {\n    readonly column: Column;\n    /** The full attribute name. */\n    readonly name: string;\n    /** The key used in v (the alias, or the name). */\n    readonly key: string;\n    /** The declared type text. */\n    readonly d: string;\n    /** Whether values are written as their JSON text (a json column). */\n    readonly jsonText: boolean;\n}\n\n/** Everything export() and check() need, computed once. */\ninterface Plan {\n    readonly notes: LossNote[];\n    readonly fatal: GraphFormatError | null;\n    readonly ids: WrittenIds | null;\n    readonly folding: PairFolding;\n    readonly weights: ExplicitWeights;\n    readonly nodeAttrs: readonly AttributePlan[];\n    readonly edgeAttrs: readonly AttributePlan[];\n    readonly graphAttrs: readonly AttributePlan[];\n    readonly nodeBypasses: readonly Column[];\n    readonly edgeBypasses: readonly Column[];\n    readonly position: Column | null;\n    readonly positionZ: boolean;\n    readonly z: Column | null;\n    readonly edgeIds: readonly number[];\n    readonly originalIds: boolean;\n}\n\n/**\n * Whether a column is a bypass column of a CX2 import.\n * @param column - the column\n * @returns true for the cx2.bypass namespace\n */\nfunction isBypass(column: Column): boolean {\n    return column.meta.origin?.namespace === BYPASS_NAMESPACE;\n}\n\n/**\n * Whether a column is the z (stacking order) column.\n * @param column - the column\n * @returns true for the column marked by a Cytoscape-family importer\n */\nfunction isZ(column: Column): boolean {\n    return column.meta.extra.cytoscape === \"z\";\n}\n\n/**\n * Count the non-finite numbers of a column.\n * @param column - the column\n * @returns how many set cells (or list items) are NaN or infinite\n */\nfunction nonFiniteCount(column: Column): number {\n    const { dtype, itemDtype } = column.meta;\n    const numeric =\n        dtype === \"f32\" || dtype === \"f64\" || (dtype === \"list\" && (itemDtype === \"f32\" || itemDtype === \"f64\"));\n    if (!numeric) {\n        return 0;\n    }\n    let count = 0;\n    for (let i = 0; i < column.length; i++) {\n        if (!column.isSet(i)) {\n            continue;\n        }\n        const value = column.value(i);\n        if (dtype === \"list\") {\n            if ((value as readonly number[]).some((v) => !Number.isFinite(v))) {\n                count++;\n            }\n        } else if (!Number.isFinite(value as number)) {\n            count++;\n        }\n    }\n    return count;\n}\n\n/**\n * Plan the attribute columns of one table.\n * @param table - the table\n * @param skip - columns not written as attributes\n * @param rename - the written name of a column, when it differs (the label as `name`)\n * @param reserved - keys already used in v\n * @returns the plans\n */\nfunction planAttributes(\n    table: Iterable<Column>,\n    skip: (column: Column) => boolean,\n    rename: (column: Column) => string,\n    reserved: ReadonlySet<string> = new Set(),\n): AttributePlan[] {\n    const plans: AttributePlan[] = [];\n    const used = new Set<string>(reserved);\n    const candidates = [...table].filter((c) => !skip(c));\n    for (const column of candidates) {\n        used.add(rename(column));\n    }\n    for (const column of candidates) {\n        const name = rename(column);\n        const { origin } = column.meta;\n        let key = name;\n        const alias = origin?.format === CX2_FORMAT && typeof origin.id === \"string\" ? origin.id : null;\n        if (alias !== null && alias.length > 0 && alias !== name && !used.has(alias)) {\n            key = alias;\n            used.add(alias);\n        }\n        plans.push({ column, name, key, d: declaredType(column), jsonText: column.meta.dtype === \"json\" });\n    }\n    return plans;\n}\n\n/**\n * Plan an export: the notes, the fatal condition and what is written.\n * @param snapshot - the snapshot\n * @param common - the resolved common options\n * @returns the plan\n */\nfunction plan(snapshot: GraphSnapshot, common: ResolvedExportOptions): Plan {\n    const notes: LossNote[] = [];\n    let fatal: GraphFormatError | null = null;\n    const note = (code: string, message: string, column: string | null = null, count: number | null = null): void => {\n        notes.push(Object.freeze({ code, message, column, count }));\n    };\n    // bypass columns are written as bypasses, which hold any JSON value\n    const bypassNames = new Set(\n        [...snapshot.nodes, ...snapshot.edges].filter((c) => isBypass(c) || isZ(c)).map((c) => c.meta.name),\n    );\n    for (const gen of checkCapabilities(snapshot, CX2_CAPABILITIES, common, {\n        roles: SLOT_ROLES,\n        roleNames: ROLE_NAMES,\n    })) {\n        if (gen.column !== null && bypassNames.has(gen.column) && (gen.code === LOSS.JSON || gen.code === LOSS.DTYPE)) {\n            continue;\n        }\n        if (gen.code === LOSS.ID_CHARSET || gen.code === LOSS.ID_MANGLED) {\n            // counted below: CX2 also keeps integer ids beyond 2^53, which the generic rule refuses\n            continue;\n        }\n        if (gen.code === LOSS.JSON) {\n            note(\n                CX2_LOSS.JSON_AS_STRING,\n                `${gen.column === null ? \"a column\" : `column \"${gen.column}\"`} holds nested values; written as a string attribute holding their JSON text`,\n                gen.column,\n                gen.count,\n            );\n            continue;\n        }\n        if (gen.code === LOSS.MIXED_DIRECTION_ERROR && fatal === null) {\n            fatal = new GraphFormatError(\"E_DIRECTED\", gen.message, { reason: \"mixed direction\" });\n        }\n        notes.push(gen);\n    }\n\n    const folding = pairFolding(snapshot);\n    directionNotes(snapshot, folding, common, CX2_LOSS.UNDIRECTED_AS_DIRECTED, note);\n\n    const planned = planNodeIds(snapshot, common, \"CX2\", ORIGINAL_ID_ATTRIBUTE, note);\n    const ids = planned instanceof GraphFormatError ? null : planned;\n    if (planned instanceof GraphFormatError) {\n        fatal ??= planned;\n    }\n\n    const weights = explicitWeights(snapshot);\n    const label = snapshot.nodes.byRole(\"label\");\n    const nodeAttrs = planAttributes(\n        snapshot.nodes,\n        (c) => (c.meta.role !== null && SKIPPED_ROLES.has(c.meta.role)) || isBypass(c) || isZ(c),\n        (c) => (c === label && !snapshot.nodes.has(\"name\") ? \"name\" : c.meta.name),\n        ids !== null && ids.changed > 0 ? new Set([ORIGINAL_ID_ATTRIBUTE]) : new Set(),\n    );\n    const plainWeight = snapshot.edges.get(WEIGHT_ATTRIBUTE);\n    const weightColumnClash = plainWeight !== null && plainWeight.meta.role === null;\n    if (weightColumnClash) {\n        note(\n            LOSS.WEIGHT_KEY_CLASH,\n            weights.weighted\n                ? `edge column \"${WEIGHT_ATTRIBUTE}\" is not written: the explicit weights are written under that name`\n                : `edge column \"${WEIGHT_ATTRIBUTE}\" reads back as the edge weight`,\n            WEIGHT_ATTRIBUTE,\n            null,\n        );\n    }\n    const edgeAttrs = planAttributes(\n        snapshot.edges,\n        (c) =>\n            (c.meta.role !== null && (SKIPPED_ROLES.has(c.meta.role) || c.meta.role === \"id\")) ||\n            isBypass(c) ||\n            (weights.weighted && c === plainWeight),\n        (c) => c.meta.name,\n        weights.weighted ? new Set([WEIGHT_ATTRIBUTE]) : new Set(),\n    );\n    const graphAttrs = planAttributes(\n        snapshot.graph,\n        () => false,\n        (c) => c.meta.name,\n    ).map((p) => ({ ...p, key: p.name }));\n\n    let nonfinite = 0;\n    for (const p of [...nodeAttrs, ...edgeAttrs, ...graphAttrs]) {\n        nonfinite += nonFiniteCount(p.column);\n    }\n    for (let e = 0; e < snapshot.edgeCount; e++) {\n        if (weights.isExplicit(e) && !Number.isFinite(weights.value(e))) {\n            nonfinite++;\n        }\n    }\n    const position = snapshot.nodes.byRole(\"position\");\n    if (position !== null) {\n        nonfinite += nonFinitePositions(position);\n    }\n    if (nonfinite > 0) {\n        note(\n            CX2_LOSS.NONFINITE_AS_NULL,\n            `${nonfinite} NaN or infinite value${plural(nonfinite)} cannot be written in CX2; written as null, they read back unset`,\n            null,\n            nonfinite,\n        );\n    }\n\n    const edgeIds = planEdgeIds(snapshot, note);\n    const z = [...snapshot.nodes].find(isZ) ?? null;\n    const positionZ = position !== null && z === null && position.meta.extra.sourceDims === 3;\n    return {\n        notes,\n        fatal,\n        ids,\n        folding,\n        weights,\n        nodeAttrs,\n        edgeAttrs,\n        graphAttrs,\n        nodeBypasses: [...snapshot.nodes].filter(isBypass),\n        edgeBypasses: [...snapshot.edges].filter(isBypass),\n        position,\n        positionZ,\n        z,\n        edgeIds,\n        originalIds: ids !== null && ids.changed > 0,\n    };\n}\n\n// ============================================================ writing\n\n/**\n * The value written for one cell.\n * @param p - the attribute plan\n * @param row - the row\n * @returns the value, or undefined for an unset cell\n */\nfunction cellValue(p: AttributePlan, row: number): unknown {\n    const { column } = p;\n    if (!column.isSet(row)) {\n        return undefined;\n    }\n    const value = column.value(row);\n    if (p.jsonText) {\n        return JSON.stringify(value);\n    }\n    if (column.meta.dtype === \"list\" || column.meta.components > 1) {\n        const items = Array.from(value as ArrayLike<unknown>);\n        if (p.d === \"string\") {\n            return JSON.stringify(items);\n        }\n        return items.some((v) => typeof v === \"number\" && !Number.isFinite(v)) ? null : items;\n    }\n    if (typeof value === \"number\" && !Number.isFinite(value)) {\n        return null;\n    }\n    return value;\n}\n\n/**\n * The declarations of one table.\n * @param plans - the attribute plans\n * @param defaults - whether defaults and aliases may be written (not for network attributes)\n * @returns the declaration object\n */\nfunction declarations(plans: readonly AttributePlan[], defaults: boolean): Record<string, unknown> {\n    const out: Record<string, unknown> = {};\n    for (const p of plans) {\n        const decl: Record<string, unknown> = { d: p.d };\n        if (defaults && p.key !== p.name) {\n            decl.a = p.key;\n        }\n        const fallback = p.column.meta.default;\n        if (defaults && fallback !== undefined && fallback !== null) {\n            if (defaultFits(cx2Type(p.d), fallback)) {\n                decl.v = fallback;\n            }\n        }\n        out[p.name] = decl;\n    }\n    return out;\n}\n\n/**\n * Whether a declared default can be written as the value of a declared type.\n * @param type - the type\n * @param fallback - the default\n * @returns true when it matches\n */\nfunction defaultFits(type: ReturnType<typeof cx2Type>, fallback: unknown): boolean {\n    if (type === null) {\n        return false;\n    }\n    if (type.list) {\n        return Array.isArray(fallback);\n    }\n    switch (type.scalar) {\n        case \"string\":\n            return typeof fallback === \"string\";\n        case \"boolean\":\n            return typeof fallback === \"boolean\";\n        default:\n            return typeof fallback === \"number\" && Number.isFinite(fallback);\n    }\n}\n\n/**\n * The v object of one element.\n * @param plans - the attribute plans\n * @param row - the row\n * @returns the object, or null when empty\n */\nfunction attributesOf(plans: readonly AttributePlan[], row: number): Record<string, unknown> | null {\n    let out: Record<string, unknown> | null = null;\n    for (const p of plans) {\n        const value = cellValue(p, row);\n        if (value !== undefined) {\n            out ??= {};\n            out[p.key] = value;\n        }\n    }\n    return out;\n}\n\n/**\n * Write the document as text parts.\n * @param snapshot - the snapshot\n * @param p - the plan\n * @yields the document's text\n * @returns nothing\n */\nfunction* write(snapshot: GraphSnapshot, p: Plan): Generator<string, void, undefined> {\n    if (p.fatal !== null) {\n        throw p.fatal;\n    }\n    const { ids } = p;\n    if (ids === null) {\n        throw new GraphFormatError(\"E_INVALID_ID\", \"node ids cannot be written as CX2 integers\", { reason: \"charset\" });\n    }\n    const { src, dst } = snapshot.edgeList();\n    const edges: number[] = [];\n    for (let e = 0; e < snapshot.edgeCount; e++) {\n        if (!p.folding.folded(e)) {\n            edges.push(e);\n        }\n    }\n\n    const nodeDecls = declarations(p.nodeAttrs, true);\n    if (p.originalIds) {\n        nodeDecls[ORIGINAL_ID_ATTRIBUTE] = { d: \"string\" };\n    }\n    const edgeDecls = declarations(p.edgeAttrs, true);\n    if (p.weights.weighted) {\n        edgeDecls[WEIGHT_ATTRIBUTE] = { d: \"double\" };\n    }\n    const networkDecls = declarations(p.graphAttrs, false);\n    const network: Record<string, unknown> = {};\n    for (const a of p.graphAttrs) {\n        const value = cellValue(a, 0);\n        if (value !== undefined) {\n            network[a.name] = value;\n        }\n    }\n    const { meta } = snapshot;\n    for (const [key, value] of [\n        [\"name\", meta.name],\n        [\"description\", meta.description],\n    ] as const) {\n        if (value !== null && !(key in network) && !(key in networkDecls)) {\n            network[key] = value;\n            networkDecls[key] = { d: \"string\" };\n        }\n    }\n    const kept = isRecord(meta.extra.cx2) ? meta.extra.cx2 : {};\n    const otherDecls = isRecord(kept.declarations) ? kept.declarations : {};\n    const opaque = meta.sourceFormat === CX2_FORMAT && isRecord(kept.opaque) ? kept.opaque : {};\n    const declarationsElement: Record<string, unknown> = { ...otherDecls };\n    for (const [key, table] of [\n        [\"networkAttributes\", networkDecls],\n        [\"nodes\", nodeDecls],\n        [\"edges\", edgeDecls],\n    ] as const) {\n        if (Object.keys(table).length > 0) {\n            declarationsElement[key] = table;\n        }\n    }\n    const nodeBypassRows = bypassRows(p.nodeBypasses, snapshot.nodeCount);\n    const edgeBypassRows = bypassRows(p.edgeBypasses, snapshot.edgeCount).filter((e) => !p.folding.folded(e));\n    const opaqueAspects = Object.entries(opaque).filter(\n        (entry): entry is [string, unknown[]] => !CORE_ASPECTS.has(entry[0]) && Array.isArray(entry[1]),\n    );\n\n    const counts: [string, number][] = [];\n    const hasDeclarations = Object.keys(declarationsElement).length > 0;\n    if (hasDeclarations) {\n        counts.push([\"attributeDeclarations\", 1]);\n    }\n    if (Object.keys(network).length > 0) {\n        counts.push([\"networkAttributes\", 1]);\n    }\n    counts.push([\"nodes\", snapshot.nodeCount], [\"edges\", edges.length]);\n    if (nodeBypassRows.length > 0) {\n        counts.push([\"nodeBypasses\", nodeBypassRows.length]);\n    }\n    if (edgeBypassRows.length > 0) {\n        counts.push([\"edgeBypasses\", edgeBypassRows.length]);\n    }\n    for (const [name, elements] of opaqueAspects) {\n        counts.push([name, elements.length]);\n    }\n\n    yield '[{\"CXVersion\":\"2.0\",\"hasFragments\":false},\\n';\n    yield `{\"metaData\":${stringify(counts.map(([name, elementCount]) => ({ name, elementCount })))}},\\n`;\n    if (hasDeclarations) {\n        yield `{\"attributeDeclarations\":[${stringify(declarationsElement)}]},\\n`;\n    }\n    if (Object.keys(network).length > 0) {\n        yield `{\"networkAttributes\":[${stringify(network)}]},\\n`;\n    }\n    yield* block(\"nodes\", snapshot.nodeCount, (i) => stringify(nodeElement(p, ids, i)));\n    yield* block(\"edges\", edges.length, (k) => {\n        const e = edges[k];\n        const element: Record<string, unknown> = {\n            id: p.edgeIds[e],\n            s: ids.idAt(src[e]),\n            t: ids.idAt(dst[e]),\n        };\n        let v = attributesOf(p.edgeAttrs, e);\n        if (p.weights.isExplicit(e)) {\n            const w = p.weights.value(e);\n            v ??= {};\n            v[WEIGHT_ATTRIBUTE] = Number.isFinite(w) ? w : null;\n        }\n        if (v !== null) {\n            element.v = v;\n        }\n        return stringify(element);\n    });\n    if (nodeBypassRows.length > 0) {\n        yield* block(\"nodeBypasses\", nodeBypassRows.length, (k) => {\n            const i = nodeBypassRows[k];\n            return stringify({ id: ids.idAt(i), v: bypassValues(p.nodeBypasses, i) });\n        });\n    }\n    if (edgeBypassRows.length > 0) {\n        yield* block(\"edgeBypasses\", edgeBypassRows.length, (k) => {\n            const e = edgeBypassRows[k];\n            return stringify({ id: p.edgeIds[e], v: bypassValues(p.edgeBypasses, e) });\n        });\n    }\n    for (const [name, elements] of opaqueAspects) {\n        yield* block(name, elements.length, (k) => stringify(elements[k]));\n    }\n    yield '{\"status\":[{\"error\":\"\",\"success\":true}]}]\\n';\n}\n\n/**\n * The text of one aspect block, element by element.\n * @param aspect - the aspect name\n * @param count - its element count\n * @param element - the JSON text of element k\n * @returns the block's text parts\n */\nfunction block(aspect: string, count: number, element: (k: number) => string): Generator<string, void, undefined> {\n    return aspectBlock(\n        aspect,\n        (function* elements(): Generator<string, void, undefined> {\n            for (let k = 0; k < count; k++) {\n                yield element(k);\n            }\n        })(),\n    );\n}\n\n/**\n * The element of node i.\n * @param p - the plan\n * @param ids - the written ids\n * @param i - the node index\n * @returns the element\n */\nfunction nodeElement(p: Plan, ids: WrittenIds, i: number): Record<string, unknown> {\n    const element: Record<string, unknown> = { id: ids.idAt(i) };\n    if (p.position?.isSet(i) === true) {\n        const point = p.position.value(i) as ArrayLike<number>;\n        if (Number.isFinite(point[0]) && Number.isFinite(point[1])) {\n            element.x = point[0];\n            element.y = point[1] === 0 ? 0 : -point[1];\n            if (p.positionZ && Number.isFinite(point[2])) {\n                element.z = point[2];\n            }\n        }\n    }\n    if (p.z?.isSet(i) === true) {\n        const z = p.z.value(i);\n        if (typeof z === \"number\" && Number.isFinite(z)) {\n            element.z = z;\n        }\n    }\n    let v = attributesOf(p.nodeAttrs, i);\n    if (p.originalIds && ids.isChanged(i)) {\n        v ??= {};\n        v[ORIGINAL_ID_ATTRIBUTE] = String(ids.originalAt(i));\n    }\n    if (v !== null) {\n        element.v = v;\n    }\n    return element;\n}\n\n/**\n * The rows with at least one bypass value.\n * @param columns - the bypass columns\n * @param rows - the row count\n * @returns the rows, ascending\n */\nfunction bypassRows(columns: readonly Column[], rows: number): number[] {\n    const out: number[] = [];\n    if (columns.length === 0) {\n        return out;\n    }\n    for (let i = 0; i < rows; i++) {\n        if (columns.some((c) => c.isSet(i))) {\n            out.push(i);\n        }\n    }\n    return out;\n}\n\n/**\n * The bypass values of one row.\n * @param columns - the bypass columns\n * @param row - the row\n * @returns property -> value\n */\nfunction bypassValues(columns: readonly Column[], row: number): Record<string, unknown> {\n    const out: Record<string, unknown> = {};\n    for (const column of columns) {\n        if (column.isSet(row)) {\n            // the visual property's own name: a column renamed for a clash with an attribute keeps it in origin.id\n            const property = column.meta.origin?.id;\n            out[typeof property === \"string\" && property.length > 0 ? property : column.meta.name] = column.value(row);\n        }\n    }\n    return out;\n}\n\n/**\n * The CX2 exporter plugin.\n * @category Built-in formats\n */\nexport const cx2Exporter: GraphExporter<Cx2ExportOptions> = Object.freeze({\n    format: CX2_FORMAT,\n    options: Object.freeze([]),\n    capabilities: CX2_CAPABILITIES,\n\n    /**\n     * Pre-flight: what export() would lose, without writing anything.\n     * @param snapshot - the snapshot\n     * @param options - the common options\n     * @returns the notes, empty when the export is exact\n     */\n    check(snapshot: GraphSnapshot, options?: Cx2ExportOptions): readonly LossNote[] {\n        return Object.freeze([...plan(snapshot, resolveExportOptions(options)).notes]);\n    },\n\n    /**\n     * Write the document as UTF-8 chunks.\n     * @param snapshot - the snapshot\n     * @param options - the common options\n     * @returns the chunks\n     */\n    export(snapshot: GraphSnapshot, options?: Cx2ExportOptions): AsyncIterable<Uint8Array> {\n        return encodeChunks(write(snapshot, plan(snapshot, resolveExportOptions(options))));\n    },\n\n    /**\n     * Write the document as one string.\n     * @param snapshot - the snapshot\n     * @param options - the common options\n     * @returns the document\n     */\n    exportToString(snapshot: GraphSnapshot, options?: Cx2ExportOptions): Promise<string> {\n        return joinText(write(snapshot, plan(snapshot, resolveExportOptions(options))));\n    },\n});\n"],"names":[],"mappings":";;;;;AAgDO,MAAM,WAAW,OAAO,OAAO;AAAA;AAAA;AAAA;AAAA;AAAA,EAKlC,wBAAwB;AAAA;AAAA,EAExB,gBAAgB;AAAA;AAAA,EAEhB,mBAAmB;AAAA;AAAA,EAEnB,iBAAiB,KAAK;AAAA;AAAA;AAAA;AAAA;AAAA,EAKtB,kBAAkB,KAAK;AAAA;AAAA,EAEvB,mBAAmB,KAAK;AAAA;AAAA,EAExB,kBAAkB,KAAK;AAAA;AAAA,EAEvB,cAAc,KAAK;AAAA;AAAA;AAAA;AAAA;AAAA,EAKnB,mBAAmB,KAAK;AAAA;AAAA;AAAA;AAAA;AAAA,EAKxB,YAAY,KAAK;AAAA;AAAA,EAEjB,YAAY,KAAK;AAAA;AAAA,EAEjB,oBAAoB,KAAK;AAC7B,CAAC;AASM,MAAM,mBAAuC,aAAa;AAAA,EAC7D,gBAAgB;AAAA,EAChB,YAAY;AAAA,EACZ,WAAW;AAAA,EACX,SAAS;AAAA,EACT,WAAW;AAAA,EACX,QAAQ,CAAC,UAAU,OAAO,OAAO,MAAM;AAAA,EACvC,YAAY;AAAA,EACZ,OAAO;AAAA,EACP,MAAM;AAAA,EACN,UAAU;AAAA,EACV,SAAS;AAAA,EACT,WAAW;AAAA,EACX,UAAU;AAAA,EACV,iBAAiB;AAAA,EACjB,WAAW;AAAA,EACX,KAAK;AACT,CAAC;AAGD,MAAM,aAAkC,oBAAI,IAAI,CAAC,SAAS,YAAY,IAAI,CAAC;AAC3E,MAAM,aAA+C,OAAO,OAAO;AAAA,EAC/D,OAAO;AAAA,EACP,UAAU;AACd,CAAC;AAGD,MAAM,oCAAyC,IAAI;AAAA,EAC/C;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACJ,CAAC;AAGD,MAAM,mCAAwC,IAAI;AAAA,EAC9C;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACJ,CAAC;AAGD,MAAM,mBAAmB;AAuCzB,SAAS,SAAS,QAAyB;AACvC,SAAO,OAAO,KAAK,QAAQ,cAAc;AAC7C;AAOA,SAAS,IAAI,QAAyB;AAClC,SAAO,OAAO,KAAK,MAAM,cAAc;AAC3C;AAOA,SAAS,eAAe,QAAwB;AAC5C,QAAM,EAAE,OAAO,UAAA,IAAc,OAAO;AACpC,QAAM,UACF,UAAU,SAAS,UAAU,SAAU,UAAU,WAAW,cAAc,SAAS,cAAc;AACrG,MAAI,CAAC,SAAS;AACV,WAAO;AAAA,EACX;AACA,MAAI,QAAQ;AACZ,WAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;AACpC,QAAI,CAAC,OAAO,MAAM,CAAC,GAAG;AAClB;AAAA,IACJ;AACA,UAAM,QAAQ,OAAO,MAAM,CAAC;AAC5B,QAAI,UAAU,QAAQ;AAClB,UAAK,MAA4B,KAAK,CAAC,MAAM,CAAC,OAAO,SAAS,CAAC,CAAC,GAAG;AAC/D;AAAA,MACJ;AAAA,IACJ,WAAW,CAAC,OAAO,SAAS,KAAe,GAAG;AAC1C;AAAA,IACJ;AAAA,EACJ;AACA,SAAO;AACX;AAUA,SAAS,eACL,OACA,MACA,QACA,WAAgC,oBAAI,OACrB;AACf,QAAM,QAAyB,CAAA;AAC/B,QAAM,OAAO,IAAI,IAAY,QAAQ;AACrC,QAAM,aAAa,CAAC,GAAG,KAAK,EAAE,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AACpD,aAAW,UAAU,YAAY;AAC7B,SAAK,IAAI,OAAO,MAAM,CAAC;AAAA,EAC3B;AACA,aAAW,UAAU,YAAY;AAC7B,UAAM,OAAO,OAAO,MAAM;AAC1B,UAAM,EAAE,WAAW,OAAO;AAC1B,QAAI,MAAM;AACV,UAAM,QAAQ,QAAQ,WAAW,cAAc,OAAO,OAAO,OAAO,WAAW,OAAO,KAAK;AAC3F,QAAI,UAAU,QAAQ,MAAM,SAAS,KAAK,UAAU,QAAQ,CAAC,KAAK,IAAI,KAAK,GAAG;AAC1E,YAAM;AACN,WAAK,IAAI,KAAK;AAAA,IAClB;AACA,UAAM,KAAK,EAAE,QAAQ,MAAM,KAAK,GAAG,aAAa,MAAM,GAAG,UAAU,OAAO,KAAK,UAAU,QAAQ;AAAA,EACrG;AACA,SAAO;AACX;AAQA,SAAS,KAAK,UAAyB,QAAqC;AACxE,QAAM,QAAoB,CAAA;AAC1B,MAAI,QAAiC;AACrC,QAAM,OAAO,CAAC,MAAc,SAAiB,SAAwB,MAAM,QAAuB,SAAe;AAC7G,UAAM,KAAK,OAAO,OAAO,EAAE,MAAM,SAAS,QAAQ,MAAA,CAAO,CAAC;AAAA,EAC9D;AAEA,QAAM,cAAc,IAAI;AAAA,IACpB,CAAC,GAAG,SAAS,OAAO,GAAG,SAAS,KAAK,EAAE,OAAO,CAAC,MAAM,SAAS,CAAC,KAAK,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,MAAM,EAAE,KAAK,IAAI;AAAA,EAAA;AAEtG,aAAW,OAAO,kBAAkB,UAAU,kBAAkB,QAAQ;AAAA,IACpE,OAAO;AAAA,IACP,WAAW;AAAA,EAAA,CACd,GAAG;AACA,QAAI,IAAI,WAAW,QAAQ,YAAY,IAAI,IAAI,MAAM,MAAM,IAAI,SAAS,KAAK,QAAQ,IAAI,SAAS,KAAK,QAAQ;AAC3G;AAAA,IACJ;AACA,QAAI,IAAI,SAAS,KAAK,cAAc,IAAI,SAAS,KAAK,YAAY;AAE9D;AAAA,IACJ;AACA,QAAI,IAAI,SAAS,KAAK,MAAM;AACxB;AAAA,QACI,SAAS;AAAA,QACT,GAAG,IAAI,WAAW,OAAO,aAAa,WAAW,IAAI,MAAM,GAAG;AAAA,QAC9D,IAAI;AAAA,QACJ,IAAI;AAAA,MAAA;AAER;AAAA,IACJ;AACA,QAAI,IAAI,SAAS,KAAK,yBAAyB,UAAU,MAAM;AAC3D,cAAQ,IAAI,iBAAiB,cAAc,IAAI,SAAS,EAAE,QAAQ,mBAAmB;AAAA,IACzF;AACA,UAAM,KAAK,GAAG;AAAA,EAClB;AAEA,QAAM,UAAU,YAAY,QAAQ;AACpC,iBAAe,UAAU,SAAS,QAAQ,SAAS,wBAAwB,IAAI;AAE/E,QAAM,UAAU,YAAY,UAAU,QAAQ,OAAO,uBAAuB,IAAI;AAChF,QAAM,MAAM,mBAAmB,mBAAmB,OAAO;AACzD,MAAI,mBAAmB,kBAAkB;AACrC,cAAU;AAAA,EACd;AAEA,QAAM,UAAU,gBAAgB,QAAQ;AACxC,QAAM,QAAQ,SAAS,MAAM,OAAO,OAAO;AAC3C,QAAM,YAAY;AAAA,IACd,SAAS;AAAA,IACT,CAAC,MAAO,EAAE,KAAK,SAAS,QAAQ,cAAc,IAAI,EAAE,KAAK,IAAI,KAAM,SAAS,CAAC,KAAK,IAAI,CAAC;AAAA,IACvF,CAAC,MAAO,MAAM,SAAS,CAAC,SAAS,MAAM,IAAI,MAAM,IAAI,SAAS,EAAE,KAAK;AAAA,IACrE,QAAQ,QAAQ,IAAI,UAAU,IAAI,oBAAI,IAAI,CAAC,qBAAqB,CAAC,IAAI,oBAAI,IAAA;AAAA,EAAI;AAEjF,QAAM,cAAc,SAAS,MAAM,IAAI,gBAAgB;AACvD,QAAM,oBAAoB,gBAAgB,QAAQ,YAAY,KAAK,SAAS;AAC5E,MAAI,mBAAmB;AACnB;AAAA,MACI,KAAK;AAAA,MACL,QAAQ,WACF,gBAAgB,gBAAgB,uEAChC,gBAAgB,gBAAgB;AAAA,MACtC;AAAA,MACA;AAAA,IAAA;AAAA,EAER;AACA,QAAM,YAAY;AAAA,IACd,SAAS;AAAA,IACT,CAAC,MACI,EAAE,KAAK,SAAS,SAAS,cAAc,IAAI,EAAE,KAAK,IAAI,KAAK,EAAE,KAAK,SAAS,SAC5E,SAAS,CAAC,KACT,QAAQ,YAAY,MAAM;AAAA,IAC/B,CAAC,MAAM,EAAE,KAAK;AAAA,IACd,QAAQ,WAAW,oBAAI,IAAI,CAAC,gBAAgB,CAAC,IAAI,oBAAI,IAAA;AAAA,EAAI;AAE7D,QAAM,aAAa;AAAA,IACf,SAAS;AAAA,IACT,MAAM;AAAA,IACN,CAAC,MAAM,EAAE,KAAK;AAAA,EAAA,EAChB,IAAI,CAAC,OAAO,EAAE,GAAG,GAAG,KAAK,EAAE,KAAA,EAAO;AAEpC,MAAI,YAAY;AAChB,aAAW,KAAK,CAAC,GAAG,WAAW,GAAG,WAAW,GAAG,UAAU,GAAG;AACzD,iBAAa,eAAe,EAAE,MAAM;AAAA,EACxC;AACA,WAAS,IAAI,GAAG,IAAI,SAAS,WAAW,KAAK;AACzC,QAAI,QAAQ,WAAW,CAAC,KAAK,CAAC,OAAO,SAAS,QAAQ,MAAM,CAAC,CAAC,GAAG;AAC7D;AAAA,IACJ;AAAA,EACJ;AACA,QAAM,WAAW,SAAS,MAAM,OAAO,UAAU;AACjD,MAAI,aAAa,MAAM;AACnB,iBAAa,mBAAmB,QAAQ;AAAA,EAC5C;AACA,MAAI,YAAY,GAAG;AACf;AAAA,MACI,SAAS;AAAA,MACT,GAAG,SAAS,yBAAyB,OAAO,SAAS,CAAC;AAAA,MACtD;AAAA,MACA;AAAA,IAAA;AAAA,EAER;AAEA,QAAM,UAAU,YAAY,UAAU,IAAI;AAC1C,QAAM,IAAI,CAAC,GAAG,SAAS,KAAK,EAAE,KAAK,GAAG,KAAK;AAC3C,QAAM,YAAY,aAAa,QAAQ,MAAM,QAAQ,SAAS,KAAK,MAAM,eAAe;AACxF,SAAO;AAAA,IACH;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,cAAc,CAAC,GAAG,SAAS,KAAK,EAAE,OAAO,QAAQ;AAAA,IACjD,cAAc,CAAC,GAAG,SAAS,KAAK,EAAE,OAAO,QAAQ;AAAA,IACjD;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,aAAa,QAAQ,QAAQ,IAAI,UAAU;AAAA,EAAA;AAEnD;AAUA,SAAS,UAAU,GAAkB,KAAsB;AACvD,QAAM,EAAE,WAAW;AACnB,MAAI,CAAC,OAAO,MAAM,GAAG,GAAG;AACpB,WAAO;AAAA,EACX;AACA,QAAM,QAAQ,OAAO,MAAM,GAAG;AAC9B,MAAI,EAAE,UAAU;AACZ,WAAO,KAAK,UAAU,KAAK;AAAA,EAC/B;AACA,MAAI,OAAO,KAAK,UAAU,UAAU,OAAO,KAAK,aAAa,GAAG;AAC5D,UAAM,QAAQ,MAAM,KAAK,KAA2B;AACpD,QAAI,EAAE,MAAM,UAAU;AAClB,aAAO,KAAK,UAAU,KAAK;AAAA,IAC/B;AACA,WAAO,MAAM,KAAK,CAAC,MAAM,OAAO,MAAM,YAAY,CAAC,OAAO,SAAS,CAAC,CAAC,IAAI,OAAO;AAAA,EACpF;AACA,MAAI,OAAO,UAAU,YAAY,CAAC,OAAO,SAAS,KAAK,GAAG;AACtD,WAAO;AAAA,EACX;AACA,SAAO;AACX;AAQA,SAAS,aAAa,OAAiC,UAA4C;AAC/F,QAAM,MAA+B,CAAA;AACrC,aAAW,KAAK,OAAO;AACnB,UAAM,OAAgC,EAAE,GAAG,EAAE,EAAA;AAC7C,QAAI,YAAY,EAAE,QAAQ,EAAE,MAAM;AAC9B,WAAK,IAAI,EAAE;AAAA,IACf;AACA,UAAM,WAAW,EAAE,OAAO,KAAK;AAC/B,QAAI,YAAY,aAAa,UAAa,aAAa,MAAM;AACzD,UAAI,YAAY,QAAQ,EAAE,CAAC,GAAG,QAAQ,GAAG;AACrC,aAAK,IAAI;AAAA,MACb;AAAA,IACJ;AACA,QAAI,EAAE,IAAI,IAAI;AAAA,EAClB;AACA,SAAO;AACX;AAQA,SAAS,YAAY,MAAkC,UAA4B;AAC/E,MAAI,SAAS,MAAM;AACf,WAAO;AAAA,EACX;AACA,MAAI,KAAK,MAAM;AACX,WAAO,MAAM,QAAQ,QAAQ;AAAA,EACjC;AACA,UAAQ,KAAK,QAAA;AAAA,IACT,KAAK;AACD,aAAO,OAAO,aAAa;AAAA,IAC/B,KAAK;AACD,aAAO,OAAO,aAAa;AAAA,IAC/B;AACI,aAAO,OAAO,aAAa,YAAY,OAAO,SAAS,QAAQ;AAAA,EAAA;AAE3E;AAQA,SAAS,aAAa,OAAiC,KAA6C;AAChG,MAAI,MAAsC;AAC1C,aAAW,KAAK,OAAO;AACnB,UAAM,QAAQ,UAAU,GAAG,GAAG;AAC9B,QAAI,UAAU,QAAW;AACrB,cAAQ,CAAA;AACR,UAAI,EAAE,GAAG,IAAI;AAAA,IACjB;AAAA,EACJ;AACA,SAAO;AACX;AASA,UAAU,MAAM,UAAyB,GAA6C;AAClF,MAAI,EAAE,UAAU,MAAM;AAClB,UAAM,EAAE;AAAA,EACZ;AACA,QAAM,EAAE,QAAQ;AAChB,MAAI,QAAQ,MAAM;AACd,UAAM,IAAI,iBAAiB,gBAAgB,8CAA8C,EAAE,QAAQ,WAAW;AAAA,EAClH;AACA,QAAM,EAAE,KAAK,QAAQ,SAAS,SAAA;AAC9B,QAAM,QAAkB,CAAA;AACxB,WAAS,IAAI,GAAG,IAAI,SAAS,WAAW,KAAK;AACzC,QAAI,CAAC,EAAE,QAAQ,OAAO,CAAC,GAAG;AACtB,YAAM,KAAK,CAAC;AAAA,IAChB;AAAA,EACJ;AAEA,QAAM,YAAY,aAAa,EAAE,WAAW,IAAI;AAChD,MAAI,EAAE,aAAa;AACf,cAAU,qBAAqB,IAAI,EAAE,GAAG,SAAA;AAAA,EAC5C;AACA,QAAM,YAAY,aAAa,EAAE,WAAW,IAAI;AAChD,MAAI,EAAE,QAAQ,UAAU;AACpB,cAAU,gBAAgB,IAAI,EAAE,GAAG,SAAA;AAAA,EACvC;AACA,QAAM,eAAe,aAAa,EAAE,YAAY,KAAK;AACrD,QAAM,UAAmC,CAAA;AACzC,aAAW,KAAK,EAAE,YAAY;AAC1B,UAAM,QAAQ,UAAU,GAAG,CAAC;AAC5B,QAAI,UAAU,QAAW;AACrB,cAAQ,EAAE,IAAI,IAAI;AAAA,IACtB;AAAA,EACJ;AACA,QAAM,EAAE,SAAS;AACjB,aAAW,CAAC,KAAK,KAAK,KAAK;AAAA,IACvB,CAAC,QAAQ,KAAK,IAAI;AAAA,IAClB,CAAC,eAAe,KAAK,WAAW;AAAA,EAAA,GACxB;AACR,QAAI,UAAU,QAAQ,EAAE,OAAO,YAAY,EAAE,OAAO,eAAe;AAC/D,cAAQ,GAAG,IAAI;AACf,mBAAa,GAAG,IAAI,EAAE,GAAG,SAAA;AAAA,IAC7B;AAAA,EACJ;AACA,QAAM,OAAO,SAAS,KAAK,MAAM,GAAG,IAAI,KAAK,MAAM,MAAM,CAAA;AACzD,QAAM,aAAa,SAAS,KAAK,YAAY,IAAI,KAAK,eAAe,CAAA;AACrE,QAAM,SAAS,KAAK,iBAAiB,cAAc,SAAS,KAAK,MAAM,IAAI,KAAK,SAAS,CAAA;AACzF,QAAM,sBAA+C,EAAE,GAAG,WAAA;AAC1D,aAAW,CAAC,KAAK,KAAK,KAAK;AAAA,IACvB,CAAC,qBAAqB,YAAY;AAAA,IAClC,CAAC,SAAS,SAAS;AAAA,IACnB,CAAC,SAAS,SAAS;AAAA,EAAA,GACX;AACR,QAAI,OAAO,KAAK,KAAK,EAAE,SAAS,GAAG;AAC/B,0BAAoB,GAAG,IAAI;AAAA,IAC/B;AAAA,EACJ;AACA,QAAM,iBAAiB,WAAW,EAAE,cAAc,SAAS,SAAS;AACpE,QAAM,iBAAiB,WAAW,EAAE,cAAc,SAAS,SAAS,EAAE,OAAO,CAAC,MAAM,CAAC,EAAE,QAAQ,OAAO,CAAC,CAAC;AACxG,QAAM,gBAAgB,OAAO,QAAQ,MAAM,EAAE;AAAA,IACzC,CAAC,UAAwC,CAAC,aAAa,IAAI,MAAM,CAAC,CAAC,KAAK,MAAM,QAAQ,MAAM,CAAC,CAAC;AAAA,EAAA;AAGlG,QAAM,SAA6B,CAAA;AACnC,QAAM,kBAAkB,OAAO,KAAK,mBAAmB,EAAE,SAAS;AAClE,MAAI,iBAAiB;AACjB,WAAO,KAAK,CAAC,yBAAyB,CAAC,CAAC;AAAA,EAC5C;AACA,MAAI,OAAO,KAAK,OAAO,EAAE,SAAS,GAAG;AACjC,WAAO,KAAK,CAAC,qBAAqB,CAAC,CAAC;AAAA,EACxC;AACA,SAAO,KAAK,CAAC,SAAS,SAAS,SAAS,GAAG,CAAC,SAAS,MAAM,MAAM,CAAC;AAClE,MAAI,eAAe,SAAS,GAAG;AAC3B,WAAO,KAAK,CAAC,gBAAgB,eAAe,MAAM,CAAC;AAAA,EACvD;AACA,MAAI,eAAe,SAAS,GAAG;AAC3B,WAAO,KAAK,CAAC,gBAAgB,eAAe,MAAM,CAAC;AAAA,EACvD;AACA,aAAW,CAAC,MAAM,QAAQ,KAAK,eAAe;AAC1C,WAAO,KAAK,CAAC,MAAM,SAAS,MAAM,CAAC;AAAA,EACvC;AAEA,QAAM;AACN,QAAM,eAAe,UAAU,OAAO,IAAI,CAAC,CAAC,MAAM,YAAY,OAAO,EAAE,MAAM,aAAA,EAAe,CAAC,CAAC;AAAA;AAC9F,MAAI,iBAAiB;AACjB,UAAM,6BAA6B,UAAU,mBAAmB,CAAC;AAAA;AAAA,EACrE;AACA,MAAI,OAAO,KAAK,OAAO,EAAE,SAAS,GAAG;AACjC,UAAM,yBAAyB,UAAU,OAAO,CAAC;AAAA;AAAA,EACrD;AACA,SAAO,MAAM,SAAS,SAAS,WAAW,CAAC,MAAM,UAAU,YAAY,GAAG,KAAK,CAAC,CAAC,CAAC;AAClF,SAAO,MAAM,SAAS,MAAM,QAAQ,CAAC,MAAM;AACvC,UAAM,IAAI,MAAM,CAAC;AACjB,UAAM,UAAmC;AAAA,MACrC,IAAI,EAAE,QAAQ,CAAC;AAAA,MACf,GAAG,IAAI,KAAK,IAAI,CAAC,CAAC;AAAA,MAClB,GAAG,IAAI,KAAK,IAAI,CAAC,CAAC;AAAA,IAAA;AAEtB,QAAI,IAAI,aAAa,EAAE,WAAW,CAAC;AACnC,QAAI,EAAE,QAAQ,WAAW,CAAC,GAAG;AACzB,YAAM,IAAI,EAAE,QAAQ,MAAM,CAAC;AAC3B,YAAM,CAAA;AACN,QAAE,gBAAgB,IAAI,OAAO,SAAS,CAAC,IAAI,IAAI;AAAA,IACnD;AACA,QAAI,MAAM,MAAM;AACZ,cAAQ,IAAI;AAAA,IAChB;AACA,WAAO,UAAU,OAAO;AAAA,EAC5B,CAAC;AACD,MAAI,eAAe,SAAS,GAAG;AAC3B,WAAO,MAAM,gBAAgB,eAAe,QAAQ,CAAC,MAAM;AACvD,YAAM,IAAI,eAAe,CAAC;AAC1B,aAAO,UAAU,EAAE,IAAI,IAAI,KAAK,CAAC,GAAG,GAAG,aAAa,EAAE,cAAc,CAAC,GAAG;AAAA,IAC5E,CAAC;AAAA,EACL;AACA,MAAI,eAAe,SAAS,GAAG;AAC3B,WAAO,MAAM,gBAAgB,eAAe,QAAQ,CAAC,MAAM;AACvD,YAAM,IAAI,eAAe,CAAC;AAC1B,aAAO,UAAU,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,GAAG,aAAa,EAAE,cAAc,CAAC,GAAG;AAAA,IAC7E,CAAC;AAAA,EACL;AACA,aAAW,CAAC,MAAM,QAAQ,KAAK,eAAe;AAC1C,WAAO,MAAM,MAAM,SAAS,QAAQ,CAAC,MAAM,UAAU,SAAS,CAAC,CAAC,CAAC;AAAA,EACrE;AACA,QAAM;AACV;AASA,SAAS,MAAM,QAAgB,OAAe,SAAoE;AAC9G,SAAO;AAAA,IACH;AAAA,KACC,UAAU,WAA+C;AACtD,eAAS,IAAI,GAAG,IAAI,OAAO,KAAK;AAC5B,cAAM,QAAQ,CAAC;AAAA,MACnB;AAAA,IACJ,GAAA;AAAA,EAAG;AAEX;AASA,SAAS,YAAY,GAAS,KAAiB,GAAoC;AAC/E,QAAM,UAAmC,EAAE,IAAI,IAAI,KAAK,CAAC,EAAA;AACzD,MAAI,EAAE,UAAU,MAAM,CAAC,MAAM,MAAM;AAC/B,UAAM,QAAQ,EAAE,SAAS,MAAM,CAAC;AAChC,QAAI,OAAO,SAAS,MAAM,CAAC,CAAC,KAAK,OAAO,SAAS,MAAM,CAAC,CAAC,GAAG;AACxD,cAAQ,IAAI,MAAM,CAAC;AACnB,cAAQ,IAAI,MAAM,CAAC,MAAM,IAAI,IAAI,CAAC,MAAM,CAAC;AACzC,UAAI,EAAE,aAAa,OAAO,SAAS,MAAM,CAAC,CAAC,GAAG;AAC1C,gBAAQ,IAAI,MAAM,CAAC;AAAA,MACvB;AAAA,IACJ;AAAA,EACJ;AACA,MAAI,EAAE,GAAG,MAAM,CAAC,MAAM,MAAM;AACxB,UAAM,IAAI,EAAE,EAAE,MAAM,CAAC;AACrB,QAAI,OAAO,MAAM,YAAY,OAAO,SAAS,CAAC,GAAG;AAC7C,cAAQ,IAAI;AAAA,IAChB;AAAA,EACJ;AACA,MAAI,IAAI,aAAa,EAAE,WAAW,CAAC;AACnC,MAAI,EAAE,eAAe,IAAI,UAAU,CAAC,GAAG;AACnC,UAAM,CAAA;AACN,MAAE,qBAAqB,IAAI,OAAO,IAAI,WAAW,CAAC,CAAC;AAAA,EACvD;AACA,MAAI,MAAM,MAAM;AACZ,YAAQ,IAAI;AAAA,EAChB;AACA,SAAO;AACX;AAQA,SAAS,WAAW,SAA4B,MAAwB;AACpE,QAAM,MAAgB,CAAA;AACtB,MAAI,QAAQ,WAAW,GAAG;AACtB,WAAO;AAAA,EACX;AACA,WAAS,IAAI,GAAG,IAAI,MAAM,KAAK;AAC3B,QAAI,QAAQ,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG;AACjC,UAAI,KAAK,CAAC;AAAA,IACd;AAAA,EACJ;AACA,SAAO;AACX;AAQA,SAAS,aAAa,SAA4B,KAAsC;AACpF,QAAM,MAA+B,CAAA;AACrC,aAAW,UAAU,SAAS;AAC1B,QAAI,OAAO,MAAM,GAAG,GAAG;AAEnB,YAAM,WAAW,OAAO,KAAK,QAAQ;AACrC,UAAI,OAAO,aAAa,YAAY,SAAS,SAAS,IAAI,WAAW,OAAO,KAAK,IAAI,IAAI,OAAO,MAAM,GAAG;AAAA,IAC7G;AAAA,EACJ;AACA,SAAO;AACX;AAMO,MAAM,cAA+C,OAAO,OAAO;AAAA,EACtE,QAAQ;AAAA,EACR,SAAS,OAAO,OAAO,EAAE;AAAA,EACzB,cAAc;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQd,MAAM,UAAyB,SAAiD;AAC5E,WAAO,OAAO,OAAO,CAAC,GAAG,KAAK,UAAU,qBAAqB,OAAO,CAAC,EAAE,KAAK,CAAC;AAAA,EACjF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,OAAO,UAAyB,SAAuD;AACnF,WAAO,aAAa,MAAM,UAAU,KAAK,UAAU,qBAAqB,OAAO,CAAC,CAAC,CAAC;AAAA,EACtF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,eAAe,UAAyB,SAA6C;AACjF,WAAO,SAAS,MAAM,UAAU,KAAK,UAAU,qBAAqB,OAAO,CAAC,CAAC,CAAC;AAAA,EAClF;AACJ,CAAC;"}

package/dist/chunks/{exporter-DIeGJXAZ.js → exporter-tne475KK.js}

@@ -1,11 +1,10 @@
 import { GraphFormatError } from "@graphty/graph-format";
 import { c as childrenCsr } from "./children-CL3Cy0ez.js";
-import { V as resolveExportOptions, X as pairFolding, _ as DictHeuristic } from "./report-B1z4WT9e.js";
-import { e as escapeXmlAttribute, x as xmlIllegalTextNotes, a as escapeXmlText } from "./escape-B-tkk_Cl.js";
-import { c as capabilities, a as checkCapabilities, L as LOSS } from "./export-Bh60Dv-n.js";
-import { e as explicitWeights, f as formatF32, a as formatF64 } from "./weights-Dzba96G3.js";
-import { j as joinText, e as encodeChunks } from "./writer-C7flM-Ih.js";
-import { F as FORMAT, M as META_KEY, b as XLINK_NAMESPACE, C as CY_NAMESPACE, c as XGMML_NAMESPACE, a as XGMML_LOSS, Z as Z_COLUMN, L as LABEL_COLUMN, I as INTERACTION_COLUMN, d as aliasesOf, G as GRAPHICS_COLUMN, S as SUBGRAPH_COLUMN, N as NESTED_NETWORK_COLUMN, e as NETWORK_POINTER_COLUMN, f as NETWORKS_COLUMN, E as EDGE_ID_COLUMN, P as POSITION_COLUMN, g as PARENT_COLUMN, h as PARENTS_COLUMN, i as XGMML_ORIGIN_NAMESPACE, j as CYTOSCAPE_ORIGIN_NAMESPACE } from "./importer-D_e7e7LX.js";
+import { r as resolveExportOptions, c as capabilities, a as checkCapabilities, L as LOSS, p as pairFolding, b as plural, $ as agree, e as explicitWeights, a9 as idText, aa as formatF32, ab as formatF64, ac as DictHeuristic } from "./export-BTI4yQgy.js";
+import { e as escapeXmlAttribute, x as xmlIllegalTextNotes, a as escapeXmlText } from "./escape-D0g6NNUy.js";
+import { j as joinText, e as encodeChunks } from "./writer-DxjgHwSe.js";
+import { F as FORMAT, M as META_KEY, b as XLINK_NAMESPACE, C as CY_NAMESPACE, c as XGMML_NAMESPACE, a as XGMML_LOSS, Z as Z_COLUMN, L as LABEL_COLUMN, I as INTERACTION_COLUMN, d as aliasesOf, G as GRAPHICS_COLUMN, S as SUBGRAPH_COLUMN, N as NESTED_NETWORK_COLUMN, e as NETWORK_POINTER_COLUMN, f as NETWORKS_COLUMN, E as EDGE_ID_COLUMN, P as POSITION_COLUMN, g as PARENT_COLUMN, h as PARENTS_COLUMN, i as XGMML_ORIGIN_NAMESPACE, j as CYTOSCAPE_ORIGIN_NAMESPACE } from "./importer-Bcl1d4xH.js";
+const LITERAL_ESCAPES = String.raw`\n or \t`;
 const CAPABILITIES = capabilities({
   mixedDirection: true,
   multiEdges: true,
@@ -280,7 +279,7 @@ function attNotes(column, domain, note) {
     if (escapes > 0) {
       note(
         XGMML_LOSS.BACKSLASH_ESCAPE,
-        `${label}: ${escapes} value(s) hold a literal \\n or \\t, which Cytoscape's escape convention reads back as a newline or tab`,
+        `${label}: ${escapes} value${plural(escapes)} ${agree(escapes, "holds", "hold")} a literal ${LITERAL_ESCAPES}, which Cytoscape's escape convention reads back as a newline or tab`,
         meta.name,
         escapes
       );
@@ -297,7 +296,7 @@ function attNotes(column, domain, note) {
     if (readsAs !== meta.dtype) {
       note(
         XGMML_LOSS.STORAGE_CLASS_CHANGED,
-        `${label} reads back as ${readsAs} (the cardinality heuristic)`,
+        `${label} reads back as ${readsAs}: the importer stores text with few distinct values as dict and other text as string; the values are the same`,
         meta.name,
         null
       );
@@ -324,7 +323,7 @@ function planExport(snapshot, options, escapes) {
   if (folding.mutualCount > 0) {
     note(
       XGMML_LOSS.MUTUAL_EXPANDED,
-      `${folding.mutualCount} mutual pair(s) are written as two directed edges; the mutual mark is lost`,
+      `${folding.mutualCount} mutual pair${plural(folding.mutualCount)} ${agree(folding.mutualCount, "is", "are")} written as two directed edges; the mutual mark is lost`,
       null,
       folding.mutualCount
     );
@@ -333,7 +332,7 @@ function planExport(snapshot, options, escapes) {
   if (numericIds > 0) {
     note(
       XGMML_LOSS.ID_TEXT_TYPE,
-      `${numericIds} numeric node id(s) are written as text and read back as strings`,
+      `${numericIds} numeric node id${plural(numericIds)} ${agree(numericIds, "is", "are")} written as text and read back as strings`,
       null,
       numericIds
     );
@@ -351,7 +350,7 @@ function planExport(snapshot, options, escapes) {
   if (hierarchy.unreachable > 0) {
     note(
       XGMML_LOSS.PARENT_CYCLE,
-      `${hierarchy.unreachable} node(s) whose parent chain never reaches a root are written at the top level and lose their parent`,
+      `${hierarchy.unreachable} node${plural(hierarchy.unreachable)} whose parent chain never reaches a root ${agree(hierarchy.unreachable, "is", "are")} written at the top level and lose their parent`,
       null,
       hierarchy.unreachable
     );
@@ -380,7 +379,12 @@ function planExport(snapshot, options, escapes) {
   const weights = explicitWeights(snapshot);
   for (const column of snapshot.edges) {
     if (column.meta.name === "weight" && column.meta.role === null && !weights.weighted) {
-      note(LOSS.WEIGHT_KEY_CLASH, `edge column "weight" reads back as THE weight`, "weight", null);
+      note(
+        LOSS.WEIGHT_KEY_CLASH,
+        `edge column "weight" reads back as the edge weight, not as a column`,
+        "weight",
+        null
+      );
     }
   }
   return {
@@ -412,7 +416,7 @@ function interactionNote(snapshot, note) {
   if (shaped > 0) {
     note(
       XGMML_LOSS.INTERACTION_FROM_LABEL,
-      `${shaped} edge label(s) have Cytoscape's "a (i) b" shape and read back with an "${INTERACTION_COLUMN}" column`,
+      `${shaped} edge label${plural(shaped)} ${agree(shaped, "has", "have")} Cytoscape's "a (i) b" shape and read back with an "${INTERACTION_COLUMN}" column`,
       INTERACTION_COLUMN,
       shaped
     );
@@ -447,7 +451,7 @@ function positionNotes(position, snapshot, note) {
   if (meta.components !== 3) {
     note(
       XGMML_LOSS.POSITION,
-      `position column "${meta.name}" has ${meta.components} component(s) and reads back with 3`,
+      `position column "${meta.name}" has ${meta.components} component${plural(meta.components)} and reads back with 3`,
       meta.name,
       null
     );
@@ -468,7 +472,7 @@ function positionNotes(position, snapshot, note) {
   if (nonFinite > 0) {
     note(
       XGMML_LOSS.POSITION,
-      `${nonFinite} position(s) with a non-finite coordinate are not written`,
+      `${nonFinite} position${plural(nonFinite)} with a non-finite coordinate ${agree(nonFinite, "is", "are")} not written`,
       meta.name,
       nonFinite
     );
@@ -477,7 +481,7 @@ function positionNotes(position, snapshot, note) {
   if (depth > 0) {
     note(
       XGMML_LOSS.POSITION,
-      zColumn === null ? `${depth} position(s) have a z; it is written as graphics z and reads back in the z column (zAs: "position" reads it as a coordinate)` : `${depth} position(s) have a z, but graphics z holds the z column; the position z is lost`,
+      zColumn === null ? `${depth} position${plural(depth)} ${agree(depth, "has", "have")} a z; it is written as graphics z and reads back in the z column (zAs: "position" reads it as a coordinate)` : `${depth} position${plural(depth)} ${agree(depth, "has", "have")} a z, but graphics z holds the z column; the position z is lost`,
       meta.name,
       depth
     );
@@ -519,9 +523,6 @@ function scalarText(value) {
   }
   return JSON.stringify(value) ?? "";
 }
-function idText(id) {
-  return typeof id === "number" ? formatF64(id) : id;
-}
 function xmlAttributesOf(writes, row) {
   let out = "";
   for (const w of writes) {
@@ -823,6 +824,7 @@ function planFor(snapshot, options) {
 }
 const xgmmlExporter = Object.freeze({
   format: FORMAT,
+  options: Object.freeze(["cytoscapeEscapes"]),
   capabilities: CAPABILITIES,
   check: (snapshot, options) => Object.freeze(planExport(snapshot, resolveExportOptions(options), resolveEscapes(options)).notes),
   export: (snapshot, options) => encodeChunks(write(snapshot, options)),
@@ -831,4 +833,4 @@ const xgmmlExporter = Object.freeze({
 export {
   xgmmlExporter as x
 };
-//# sourceMappingURL=exporter-DIeGJXAZ.js.map
+//# sourceMappingURL=exporter-tne475KK.js.map