@graphty/graph-io 0.3.47 → 0.3.49

package/dist/chunks/exporter-_jrBTnos.js

@@ -0,0 +1,1009 @@
+import { GraphFormatError } from "@graphty/graph-format";
+import { c as childrenCsr } from "./children-CA4coBi0.js";
+import { d as directionNotes, p as planNodeIds, a as planEdgeIds, s as stringify, b as aspectBlock, n as noteList, c as declaredType, e as nextNodeId } from "./cx-export-Bt6NoqTQ.js";
+import { p as pairFolding } from "./format-BXiAb-1h.js";
+import { c as capabilities, L as LOSS, r as resolveExportOptions, a as checkCapabilities, e as explicitWeights } from "./export-Cha4dRFz.js";
+import { i as isRecord, P as POSITION_COLUMN } from "./json-elements-Cq76WjnZ.js";
+import { p as plural } from "./report-CwMfYa9J.js";
+import { j as joinText, e as encodeChunks } from "./writer-DxjgHwSe.js";
+import { c as cytoscapeStyledExport, C as CX_STYLE_CAPABILITIES, s as snapshotBlock, b as blockAspect, d as cytoscapeCxAspect } from "./styles-CCs214_3.js";
+import { S as STYLE_BLOCK_NAME } from "./block-iptrlMBb.js";
+import { O as ORIGINAL_ID_ATTRIBUTE } from "./importer-B92x1xY5.js";
+const CX_FORMAT = "cx";
+const CX_LOSS = Object.freeze({
+  /**
+   * 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_CX_UNDIRECTED_AS_DIRECTED",
+  /** A nested (json) column is written as a string attribute holding its JSON text. */
+  JSON_AS_STRING: "W_CX_JSON_AS_STRING",
+  /** A mutual pair is written as two directed edges without its mark. */
+  MUTUAL_EXPANDED: LOSS.MUTUAL_EXPANDED,
+  /**
+   * An attribute named `weight` without the weight role 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 start / end / timestamp column: CX has no time. */
+  TEMPORAL_DROPPED: LOSS.TEMPORAL,
+  /** 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,
+  /**
+   * An attribute without a role is written where the format keeps a role (for example, a `name` column as the label), and
+   * reads back with that role.
+   */
+  ROLE_ASSUMED: LOSS.ROLE_ASSUMED,
+  /**
+   * An attribute type CX stores as another (a 32-bit float as double, an unsigned integer as long, a byte as
+   * integer, a dictionary as string); it reads back with that type.
+   */
+  DTYPE_UNSUPPORTED: LOSS.DTYPE,
+  /** A multi-component column (a second view's `position@2`, a vector) is written as a list of doubles. */
+  COMPONENTS_FLATTENED: LOSS.COMPONENTS,
+  /** A declared default: CX has none. */
+  DEFAULT_DROPPED: LOSS.DEFAULT,
+  /** Declared options: CX has no enumerations. */
+  OPTIONS_DROPPED: LOSS.OPTIONS,
+  /**
+   * 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,
+  /** Edges without a usable integer id get generated ids. */
+  EDGE_IDS_GENERATED: LOSS.EDGE_IDS_GENERATED,
+  /**
+   * An attribute with a role (for example, the label) is written where the format keeps that role, and reads back under the
+   * name the format's importer gives it.
+   */
+  COLUMN_NAME_CHANGED: LOSS.COLUMN_NAME_CHANGED,
+  /** An extension table other than the `cx:citations` / `cx:supports` tables a CX import creates. */
+  EXTENSION_TABLE_DROPPED: LOSS.EXTENSION_TABLE,
+  /** A position, stacking order or weight that is NaN or infinite: CX spells no such number there. */
+  NONFINITE_AS_NULL: LOSS.NONFINITE_AS_NULL,
+  /** Visual columns (color, size, shape, thickness roles): CX keeps style as visual properties, not roles. */
+  VIZ_DROPPED: LOSS.VIZ
+});
+const CX_CAPABILITIES = capabilities({
+  mixedDirection: false,
+  multiEdges: true,
+  selfLoops: true,
+  edgeIds: "required",
+  idCharset: "integer",
+  dtypes: ["string", "f64", "i32", "bool"],
+  components: false,
+  lists: true,
+  json: false,
+  defaults: false,
+  options: false,
+  hierarchy: true,
+  temporal: "none",
+  graphAttributes: true,
+  positions: true,
+  viz: false
+});
+const SLOT_ROLES = /* @__PURE__ */ new Set(["label", "position", "id"]);
+const ROLE_NAMES = Object.freeze({
+  label: "name",
+  position: POSITION_COLUMN,
+  id: "id",
+  parent: "parent"
+});
+const SKIPPED_ROLES = /* @__PURE__ */ new Set([
+  "directed",
+  "pair",
+  "mutual",
+  "weight",
+  "timeText",
+  "originalId",
+  "parent",
+  "parents",
+  "start",
+  "end",
+  "timestamp",
+  "timestamps",
+  "spells",
+  "open",
+  "spellsOpen",
+  "position",
+  "color",
+  "size",
+  "shape",
+  "thickness",
+  "id"
+]);
+const BYPASS_NAMESPACE = "cx.bypass";
+const PROVENANCE_TABLES = Object.freeze({
+  "cx:citations": "citations",
+  "cx:supports": "supports"
+});
+const NEVER_WRITTEN = /* @__PURE__ */ new Set([
+  "nodes",
+  "edges",
+  "nodeAttributes",
+  "edgeAttributes",
+  "networkAttributes",
+  "cartesianLayout",
+  "cyGroups",
+  "cyVisualProperties",
+  "cyTableColumn",
+  "cySubNetworks",
+  "cyNetworkRelations",
+  "cyViews",
+  "CX Element ID",
+  "citations",
+  "supports",
+  "nodeCitations",
+  "edgeCitations",
+  "nodeSupports",
+  "edgeSupports",
+  "functionTerms",
+  "reifiedEdges",
+  "numberVerification",
+  "metaData",
+  "status",
+  "groups",
+  "subnetwork",
+  STYLE_BLOCK_NAME
+]);
+const WEIGHT_ATTRIBUTE = "weight";
+const NUMERIC_DTYPES = /* @__PURE__ */ new Set(["f32", "f64", "i32", "u32", "u8"]);
+function fromCx(column, namespace) {
+  return column.meta.origin?.format === CX_FORMAT && column.meta.origin.namespace === namespace;
+}
+function isBypass(column) {
+  return column.meta.origin?.namespace === BYPASS_NAMESPACE;
+}
+function isZ(column) {
+  return column.meta.extra.cytoscape === "z";
+}
+function isLink(column) {
+  return fromCx(column, "provenance") && column.meta.dtype === "list" && (column.meta.name === "citations" || column.meta.name === "supports");
+}
+function coreNeedsText(column) {
+  const { dtype } = column.meta;
+  return dtype !== "string" && dtype !== "dict" && dtype !== "json";
+}
+function genericNotes(snapshot, common, several, own, notes, note) {
+  let fatal = null;
+  const edgeLabel = snapshot.edges.byRole("label")?.meta.name;
+  const ownNames = new Set(own.filter((c) => c !== null).map((c) => c.meta.name));
+  for (const gen of checkCapabilities(snapshot, CX_CAPABILITIES, common, {
+    roles: SLOT_ROLES,
+    // a parents column reads back as parents only when some node has several parents
+    roleNames: several ? { ...ROLE_NAMES, parents: "parents" } : ROLE_NAMES
+  })) {
+    if (writtenOtherwise(gen, ownNames)) {
+      continue;
+    }
+    if (gen.code === LOSS.JSON) {
+      const which = gen.column === null ? "a column" : `column "${gen.column}"`;
+      note(
+        CX_LOSS.JSON_AS_STRING,
+        `${which} holds nested values; written as a string attribute holding their JSON text`,
+        gen.column,
+        gen.count
+      );
+      continue;
+    }
+    if (isEdgeLabelRename(gen, edgeLabel)) {
+      note(
+        LOSS.ROLE,
+        `edge column "${edgeLabel ?? ""}" (label) is written as a plain attribute; CX edges have no label slot and the role is lost`,
+        gen.column,
+        gen.count
+      );
+      continue;
+    }
+    if (gen.code === LOSS.MIXED_DIRECTION_ERROR && fatal === null) {
+      fatal = new GraphFormatError("E_DIRECTED", gen.message, { reason: "mixed direction" });
+    }
+    notes.push(gen);
+  }
+  if (edgeLabel === "name") {
+    note(
+      LOSS.ROLE,
+      `edge column "name" (label) is written as a plain attribute; CX edges have no label slot and the role is lost`,
+      "name",
+      null
+    );
+  }
+  return fatal;
+}
+function writtenOtherwise(gen, ownNames) {
+  if (gen.column !== null && ownNames.has(gen.column) && (gen.code === LOSS.JSON || gen.code === LOSS.DTYPE)) {
+    return true;
+  }
+  if (gen.code === LOSS.ID_CHARSET || gen.code === LOSS.ID_MANGLED) {
+    return true;
+  }
+  return gen.code === LOSS.EXTENSION_TABLE && gen.column !== null && gen.column in PROVENANCE_TABLES;
+}
+function isEdgeLabelRename(gen, edgeLabel) {
+  return gen.code === LOSS.COLUMN_NAME_CHANGED && gen.column === edgeLabel && gen.message.startsWith("edge column");
+}
+function planPositions(snapshot, note) {
+  const position = snapshot.nodes.byRole("position");
+  const zColumn = [...snapshot.nodes].find(isZ) ?? null;
+  const z = zColumn !== null && zFitsLayout(zColumn, position) ? zColumn : null;
+  if (position === null) {
+    return { position, z, positionZ: false, nonfinite: 0 };
+  }
+  let nonfinite = nonFiniteCells(position, (v) => [v[0], v[1]]);
+  const depth = nonFiniteCells(position, (v) => v[2] === 0 ? [] : [Number.NaN]);
+  const positionZ = zColumn === null && (position.meta.extra.sourceDims === 3 || depth > 0);
+  if (positionZ) {
+    nonfinite += nonFiniteCells(position, (v) => Number.isFinite(v[0]) && Number.isFinite(v[1]) ? [v[2]] : []);
+    note(
+      LOSS.COMPONENTS,
+      `node column "${position.meta.name}" (position) has a third coordinate; CX writes it as the layout's z, which reads back in the z column (a stacking order), not in the position`,
+      position.meta.name,
+      depth
+    );
+  }
+  return { position, z, positionZ, nonfinite };
+}
+function graphColumnNotes(snapshot, note) {
+  for (const c of snapshot.graph) {
+    const named = c.meta.name === "name" || c.meta.name === "description";
+    if (!isBypass(c) && named && (c.dtype === "string" || c.dtype === "dict")) {
+      note(
+        LOSS.ROLE_ASSUMED,
+        `graph column "${c.meta.name}" is written as the network attribute ${c.meta.name}, which reads back as the graph's ${c.meta.name}, not as a column`,
+        c.meta.name,
+        null
+      );
+    }
+  }
+}
+function plan(snapshot, common) {
+  const { notes, note } = noteList();
+  const functionTerm = [...snapshot.nodes].find((c) => fromCx(c, "provenance") && c.meta.name === "functionTerm") ?? null;
+  const reifiedEdge = [...snapshot.nodes].find((c) => fromCx(c, "reifiedEdges") && c.dtype === "u32") ?? null;
+  const children = childrenCsr(snapshot);
+  const several = children.column?.meta.role === "parents" && severalParents(children.column);
+  let fatal = genericNotes(snapshot, common, several, [functionTerm, reifiedEdge], notes, note);
+  const folding = pairFolding(snapshot);
+  directionNotes(snapshot, folding, common, CX_LOSS.UNDIRECTED_AS_DIRECTED, note);
+  const planned = planNodeIds(snapshot, common, "CX", ORIGINAL_ID_ATTRIBUTE, note);
+  const ids = planned instanceof GraphFormatError ? null : planned;
+  if (planned instanceof GraphFormatError) {
+    fatal ??= planned;
+  }
+  const edgeIds = planEdgeIds(snapshot, note, ids);
+  if (snapshot.nodes.has(ORIGINAL_ID_ATTRIBUTE)) {
+    note(
+      LOSS.ROLE_ASSUMED,
+      `node column "${ORIGINAL_ID_ATTRIBUTE}" is the importer's record of mangled ids: it reads back as the node ids unless restoreMangledIds is false`,
+      ORIGINAL_ID_ATTRIBUTE,
+      null
+    );
+  }
+  const positions = planPositions(snapshot, note);
+  const { position, z, positionZ } = positions;
+  let { nonfinite } = positions;
+  const collapsed = [...snapshot.nodes].find((c) => fromCx(c, "cyGroups") && c.dtype === "bool") ?? null;
+  const nodeCore = corePlans(snapshot, note);
+  const edgeCore = [];
+  const interaction = snapshot.edges.get("interaction");
+  if (interaction !== null && (interaction.meta.role === null || !SKIPPED_ROLES.has(interaction.meta.role))) {
+    edgeCore.push({ key: "i", column: interaction });
+    coreTextNote(interaction, "edge", note);
+  }
+  const coreColumns = new Set([...nodeCore, ...edgeCore].map((c) => c.column));
+  const special = (c) => coreColumns.has(c) || isBypass(c) || isLink(c) || c === z || c === collapsed || c === functionTerm || c === reifiedEdge || c.meta.role !== null && SKIPPED_ROLES.has(c.meta.role);
+  const label = snapshot.nodes.byRole("label");
+  const renamedName = label !== null && label.meta.name !== "name" ? snapshot.nodes.get("name") : null;
+  if (renamedName !== null) {
+    note(
+      LOSS.COLUMN_NAME_CHANGED,
+      `node column "name" is written as the attribute "name#2" and reads back as "name#2", because the label column "${label?.meta.name ?? ""}" is written as n and takes the name "name"`,
+      "name",
+      renamedName.length - renamedName.nullCount
+    );
+  }
+  const nodeAttrs = attributePlans(snapshot.nodes, special, (c) => c === renamedName ? "name#2" : c.meta.name);
+  const weight = planWeight(snapshot, folding, note);
+  const plainWeight = snapshot.edges.get(WEIGHT_ATTRIBUTE);
+  const edgeAttrs = attributePlans(
+    snapshot.edges,
+    (c) => special(c) || c === plainWeight && c.meta.role === null,
+    (c) => c.meta.name
+  );
+  nonfinite += weight.nonfinite;
+  graphColumnNotes(snapshot, note);
+  const graphAttrs = attributePlans(
+    snapshot.graph,
+    (c) => isBypass(c) || c.meta.name === STYLE_BLOCK_NAME,
+    (c) => c.meta.name
+  );
+  if (children.column !== null && children.column.meta.role === "parents" && !several) {
+    note(
+      LOSS.COLUMN_NAME_CHANGED,
+      `node column "${children.column.meta.name}" (parents) holds at most one parent per node; it reads back as the single-parent column "parent"`,
+      children.column.meta.name,
+      children.column.length - children.column.nullCount
+    );
+  }
+  if (nonfinite > 0) {
+    note(
+      LOSS.NONFINITE_AS_NULL,
+      `${nonfinite} NaN or infinite position${plural(nonfinite)}, stacking orders or weights cannot be written in CX; they read back unset`,
+      null,
+      nonfinite
+    );
+  }
+  return {
+    notes,
+    fatal,
+    ids,
+    folding,
+    edgeIds,
+    weight: weight.plan,
+    nodeCore,
+    edgeCore,
+    nodeAttrs,
+    edgeAttrs,
+    graphAttrs,
+    position,
+    positionZ,
+    z,
+    bypass: {
+      node: [...snapshot.nodes].filter(isBypass),
+      edge: [...snapshot.edges].filter(isBypass),
+      graph: [...snapshot.graph].filter(isBypass)
+    },
+    collapsed,
+    links: linkPlans(snapshot),
+    functionTerm,
+    reifiedEdge
+  };
+}
+function corePlans(snapshot, note) {
+  const out = [];
+  const label = snapshot.nodes.byRole("label");
+  const plainName = snapshot.nodes.get("name");
+  const n = label ?? (plainName !== null && plainName.meta.role === null ? plainName : null);
+  if (n !== null) {
+    out.push({ key: "n", column: n });
+    coreTextNote(n, "node", note);
+    if (n !== label) {
+      note(
+        LOSS.ROLE_ASSUMED,
+        `node column "name" is written as n and reads back as the label`,
+        "name",
+        n.length - n.nullCount
+      );
+    }
+  }
+  const represents = snapshot.nodes.get("represents");
+  if (represents !== null && represents !== n && (represents.meta.role === null || !SKIPPED_ROLES.has(represents.meta.role))) {
+    out.push({ key: "r", column: represents });
+    coreTextNote(represents, "node", note);
+  }
+  return out;
+}
+function coreTextNote(column, domain, note) {
+  if (coreNeedsText(column)) {
+    note(
+      LOSS.DTYPE,
+      `${domain} column "${column.meta.name}" is ${column.dtype}; CX writes it as text and it reads back as string`,
+      column.meta.name,
+      column.length - column.nullCount
+    );
+  }
+}
+function attributePlans(table, skip, rename) {
+  return [...table].filter((c) => !skip(c)).map((column) => ({ column, name: rename(column), d: declaredType(column) }));
+}
+function planWeight(snapshot, folding, note) {
+  const weights = explicitWeights(snapshot);
+  const plain = snapshot.edges.get(WEIGHT_ATTRIBUTE);
+  const clash = plain !== null && plain.meta.role === null;
+  let plan2 = null;
+  if (weights.weighted) {
+    plan2 = { value: (e) => weights.isExplicit(e) ? weights.value(e) : void 0 };
+    if (clash) {
+      note(
+        LOSS.WEIGHT_KEY_CLASH,
+        `edge column "${WEIGHT_ATTRIBUTE}" is not written: the explicit weights are written under that name`,
+        WEIGHT_ATTRIBUTE,
+        null
+      );
+    }
+  } else if (clash) {
+    const numeric = NUMERIC_DTYPES.has(plain.dtype);
+    note(
+      LOSS.WEIGHT_KEY_CLASH,
+      numeric ? `edge column "${WEIGHT_ATTRIBUTE}" is written as the weight attribute and reads back as the edge weight` : `edge column "${WEIGHT_ATTRIBUTE}" is ${plain.dtype}, and CX reads that attribute as the edge weight; it is not written`,
+      WEIGHT_ATTRIBUTE,
+      null
+    );
+    if (numeric) {
+      plan2 = { value: (e) => plain.isSet(e) ? plain.value(e) : void 0 };
+    }
+  }
+  return { plan: plan2, nonfinite: plan2 === null ? 0 : nanWeights(snapshot.edgeCount, plan2, folding) };
+}
+function nanWeights(edgeCount, plan2, folding) {
+  let nan = 0;
+  for (let e = 0; e < edgeCount; e++) {
+    const w = plan2.value(e);
+    if (!folding.folded(e) && w !== void 0 && Number.isNaN(w)) {
+      nan++;
+    }
+  }
+  return nan;
+}
+function zFitsLayout(z, position) {
+  for (let i = 0; i < z.length; i++) {
+    if (!z.isSet(i)) {
+      continue;
+    }
+    const value = z.value(i);
+    const point = position?.isSet(i) === true ? position.value(i) : null;
+    if (typeof value !== "number" || !Number.isFinite(value) || point === null || !Number.isFinite(point[0]) || !Number.isFinite(point[1])) {
+      return false;
+    }
+  }
+  return true;
+}
+function nonFiniteCells(column, pick) {
+  let count = 0;
+  for (let i = 0; i < column.length; i++) {
+    if (column.isSet(i) && pick(column.value(i)).some((v) => !Number.isFinite(v))) {
+      count++;
+    }
+  }
+  return count;
+}
+function severalParents(column) {
+  for (let i = 0; i < column.length; i++) {
+    if (column.isSet(i) && column.value(i).length > 1) {
+      return true;
+    }
+  }
+  return false;
+}
+function linkPlans(snapshot) {
+  const out = [];
+  for (const [domain, table] of [
+    ["node", snapshot.nodes],
+    ["edge", snapshot.edges]
+  ]) {
+    for (const column of table) {
+      if (isLink(column)) {
+        const key = column.meta.name;
+        out.push({ aspect: `${domain}${key === "citations" ? "Citations" : "Supports"}`, key, domain, column });
+      }
+    }
+  }
+  return out;
+}
+function scalarText(value) {
+  if (typeof value === "number") {
+    return Object.is(value, -0) ? "-0" : String(value);
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  return typeof value === "boolean" ? String(value) : JSON.stringify(value);
+}
+function cellValue(column, d, row) {
+  if (!column.isSet(row)) {
+    return void 0;
+  }
+  const value = column.value(row);
+  if (column.meta.dtype === "json") {
+    return JSON.stringify(value);
+  }
+  if (column.meta.dtype === "list" || column.meta.components > 1) {
+    const items = Array.from(value);
+    return d === "string" ? JSON.stringify(items) : items.map(scalarText);
+  }
+  return scalarText(value);
+}
+function coreText(column, row) {
+  if (!column.isSet(row)) {
+    return void 0;
+  }
+  const value = column.value(row);
+  if (column.meta.dtype === "json" || column.meta.dtype === "list" || column.meta.components > 1) {
+    return JSON.stringify(column.meta.dtype === "json" ? value : Array.from(value));
+  }
+  return scalarText(value);
+}
+function writtenEdges(snapshot, folding) {
+  const out = [];
+  for (let e = 0; e < snapshot.edgeCount; e++) {
+    if (!folding.folded(e)) {
+      out.push(e);
+    }
+  }
+  return out;
+}
+function aspects(snapshot, p, ids, styled) {
+  const { src, dst } = snapshot.edgeList();
+  const edges = writtenEdges(snapshot, p.folding);
+  const nodeRange = () => Array.from({ length: snapshot.nodeCount }, (_, i2) => i2);
+  const nodeCore = (key) => p.nodeCore.find((c) => c.key === key)?.column ?? null;
+  const n = nodeCore("n");
+  const r = nodeCore("r");
+  const i = p.edgeCore[0]?.column ?? null;
+  const kept = snapshot.meta.sourceFormat === CX_FORMAT && isRecord(snapshot.meta.extra.cx) ? snapshot.meta.extra.cx : {};
+  const out = [
+    {
+      name: "nodes",
+      idCounter: nextNodeId(ids, snapshot.nodeCount),
+      *elements() {
+        for (let row = 0; row < snapshot.nodeCount; row++) {
+          const element = { "@id": ids.idAt(row) };
+          const name = n === null ? void 0 : coreText(n, row);
+          const represents = r === null ? void 0 : coreText(r, row);
+          if (name !== void 0) {
+            element.n = name;
+          }
+          if (represents !== void 0) {
+            element.r = represents;
+          }
+          yield element;
+        }
+      }
+    },
+    {
+      name: "edges",
+      idCounter: edges.reduce((max, e) => Math.max(max, p.edgeIds[e] + 1), 0),
+      *elements() {
+        for (const e of edges) {
+          const element = {
+            "@id": p.edgeIds[e],
+            s: ids.idAt(src[e]),
+            t: ids.idAt(dst[e])
+          };
+          const interaction = i === null ? void 0 : coreText(i, e);
+          if (interaction !== void 0) {
+            element.i = interaction;
+          }
+          yield element;
+        }
+      }
+    },
+    {
+      name: "nodeAttributes",
+      *elements() {
+        for (const a of p.nodeAttrs) {
+          for (let row = 0; row < snapshot.nodeCount; row++) {
+            const v = cellValue(a.column, a.d, row);
+            if (v !== void 0) {
+              yield { po: ids.idAt(row), n: a.name, v, d: a.d };
+            }
+          }
+        }
+        for (let row = 0; row < snapshot.nodeCount; row++) {
+          if (ids.isChanged(row)) {
+            yield {
+              po: ids.idAt(row),
+              n: ORIGINAL_ID_ATTRIBUTE,
+              v: String(ids.originalAt(row)),
+              d: "string"
+            };
+          }
+        }
+      }
+    },
+    {
+      name: "edgeAttributes",
+      *elements() {
+        for (const a of p.edgeAttrs) {
+          for (const e of edges) {
+            const v = cellValue(a.column, a.d, e);
+            if (v !== void 0) {
+              yield { po: p.edgeIds[e], n: a.name, v, d: a.d };
+            }
+          }
+        }
+        if (p.weight !== null) {
+          for (const e of edges) {
+            const w = p.weight.value(e);
+            if (w !== void 0 && !Number.isNaN(w)) {
+              yield { po: p.edgeIds[e], n: WEIGHT_ATTRIBUTE, v: scalarText(w), d: "double" };
+            }
+          }
+        }
+      }
+    },
+    {
+      name: "networkAttributes",
+      *elements() {
+        for (const a of p.graphAttrs) {
+          const v = cellValue(a.column, a.d, 0);
+          if (v !== void 0) {
+            yield { n: a.name, v, d: a.d };
+          }
+        }
+        const { meta } = snapshot;
+        for (const [key, value] of [
+          ["name", meta.name],
+          ["description", meta.description]
+        ]) {
+          if (value !== null && !p.graphAttrs.some((a) => a.name === key)) {
+            yield { n: key, v: value, d: "string" };
+          }
+        }
+      }
+    },
+    { name: "cyTableColumn", elements: () => tableColumns(p, ids) },
+    { name: "cartesianLayout", elements: () => layoutElements(p, ids, nodeRange()) },
+    { name: "cyGroups", elements: () => groupElements(snapshot, p, ids, edges) },
+    {
+      name: "cyVisualProperties",
+      elements: () => styled === null ? visualProperties(p, ids, nodeRange(), edges, kept) : styledVisualProperties(styled, ids, p.edgeIds, edges)
+    }
+  ];
+  const block = snapshotBlock(snapshot);
+  if (block !== null) {
+    out.push({ name: STYLE_BLOCK_NAME, elements: () => blockAspect(block) });
+  }
+  out.push(...provenanceAspects(snapshot, p, ids, edges));
+  for (const [name, value] of Object.entries(kept)) {
+    if (!NEVER_WRITTEN.has(name) && Array.isArray(value)) {
+      out.push({ name, elements: () => keptElements(value, kept.subnetwork, STYLE_ASPECTS.has(name)) });
+    }
+  }
+  return out;
+}
+function* tableColumns(p, ids) {
+  for (const { key, column } of [...p.nodeCore, ...p.edgeCore]) {
+    const n = { n: "name", r: "represents", i: "interaction" }[key];
+    if (n !== void 0 && column !== null) {
+      yield { applies_to: key === "i" ? "edge_table" : "node_table", n, d: "string" };
+    }
+  }
+  for (const a of p.nodeAttrs) {
+    yield { applies_to: "node_table", n: a.name, d: a.d };
+  }
+  if (ids.changed > 0) {
+    yield { applies_to: "node_table", n: ORIGINAL_ID_ATTRIBUTE, d: "string" };
+  }
+  for (const a of p.edgeAttrs) {
+    yield { applies_to: "edge_table", n: a.name, d: a.d };
+  }
+  if (p.weight !== null) {
+    yield { applies_to: "edge_table", n: WEIGHT_ATTRIBUTE, d: "double" };
+  }
+  for (const a of p.graphAttrs) {
+    yield { applies_to: "network_table", n: a.name, d: a.d };
+  }
+}
+const STYLE_ASPECTS = /* @__PURE__ */ new Set(["tableVisualProperties", "cyTableVisualProperties"]);
+function* keptElements(elements, subnetwork, style) {
+  for (const element of elements) {
+    if (!isRecord(element)) {
+      yield element;
+      continue;
+    }
+    if (element.s !== void 0 && element.s !== null && element.s !== subnetwork) {
+      continue;
+    }
+    const { s: _scope, ...rest } = element;
+    yield style ? rewriteView(rest) : rest;
+  }
+}
+function rewriteView(element) {
+  const out = { ...element };
+  if ("view" in out) {
+    out.view = 0;
+  }
+  if (typeof out.applies_to === "number") {
+    out.applies_to = 0;
+  }
+  return out;
+}
+function* layoutElements(p, ids, rows) {
+  const { position } = p;
+  if (position === null) {
+    return;
+  }
+  for (const row of rows) {
+    if (!position.isSet(row)) {
+      continue;
+    }
+    const point = position.value(row);
+    if (!Number.isFinite(point[0]) || !Number.isFinite(point[1])) {
+      continue;
+    }
+    const entry = { node: ids.idAt(row), x: point[0], y: point[1] === 0 ? 0 : -point[1] };
+    if (p.z?.isSet(row) === true) {
+      entry.z = p.z.value(row);
+    } else if (p.positionZ && Number.isFinite(point[2])) {
+      entry.z = point[2];
+    }
+    yield entry;
+  }
+}
+function* groupElements(snapshot, p, ids, edges) {
+  const children = childrenCsr(snapshot);
+  const groupsOf = /* @__PURE__ */ new Map();
+  const groups = [];
+  for (let g = 0; g < snapshot.nodeCount; g++) {
+    const members = children.childrenOf(g);
+    if (members.length > 0 || p.collapsed?.isSet(g) === true) {
+      groups.push(g);
+    }
+    for (const c of members) {
+      groupsOf.set(c, [...groupsOf.get(c) ?? [], g]);
+    }
+  }
+  if (groups.length === 0) {
+    return;
+  }
+  const { internal, external } = groupEdges(snapshot, p, groupsOf, edges);
+  const label = p.nodeCore.find((c) => c.key === "n")?.column ?? null;
+  for (const g of groups) {
+    const entry = { "@id": ids.idAt(g) };
+    const name = label === null ? void 0 : coreText(label, g);
+    if (name !== void 0) {
+      entry.n = name;
+    }
+    entry.nodes = Array.from(children.childrenOf(g), (c) => ids.idAt(c));
+    entry.internal_edges = internal.get(g) ?? [];
+    entry.external_edges = external.get(g) ?? [];
+    if (p.collapsed?.isSet(g) === true) {
+      entry.collapsed = p.collapsed.value(g);
+    }
+    yield entry;
+  }
+}
+function groupEdges(snapshot, p, groupsOf, edges) {
+  const internal = /* @__PURE__ */ new Map();
+  const external = /* @__PURE__ */ new Map();
+  const add = (table, g, id) => {
+    table.set(g, [...table.get(g) ?? [], id]);
+  };
+  const { src, dst } = snapshot.edgeList();
+  for (const e of edges) {
+    const ofSource = groupsOf.get(src[e]) ?? [];
+    const ofTarget = groupsOf.get(dst[e]) ?? [];
+    for (const g of ofSource) {
+      add(ofTarget.includes(g) ? internal : external, g, p.edgeIds[e]);
+    }
+    for (const g of ofTarget.filter((t) => !ofSource.includes(t))) {
+      add(external, g, p.edgeIds[e]);
+    }
+  }
+  return { internal, external };
+}
+function bypassValues(columns, row) {
+  let out = null;
+  for (const column of columns) {
+    if (column.isSet(row)) {
+      const property = column.meta.origin?.id;
+      out ??= {};
+      out[typeof property === "string" && property.length > 0 ? property : column.meta.name] = scalarText(
+        column.value(row)
+      );
+    }
+  }
+  return out;
+}
+function* visualProperties(p, ids, rows, edges, kept) {
+  const network = bypassValues(p.bypass.graph, 0);
+  if (network !== null) {
+    yield { properties_of: "network", properties: network };
+  }
+  const view = ownView(kept);
+  for (const entry of Array.isArray(kept.cyVisualProperties) ? kept.cyVisualProperties : []) {
+    if (isRecord(entry) && !["nodes", "edges", "network"].includes(String(entry.properties_of)) && (view === null || entry.view === void 0 || entry.view === null || entry.view === view)) {
+      yield rewriteView(entry);
+    }
+  }
+  for (const row of rows) {
+    const properties = bypassValues(p.bypass.node, row);
+    if (properties !== null) {
+      yield { properties_of: "nodes", applies_to: ids.idAt(row), properties };
+    }
+  }
+  for (const e of edges) {
+    const properties = bypassValues(p.bypass.edge, e);
+    if (properties !== null) {
+      yield { properties_of: "edges", applies_to: p.edgeIds[e], properties };
+    }
+  }
+}
+function* styledVisualProperties(styled, ids, edgeIds, edges) {
+  yield* cytoscapeCxAspect(styled.style);
+  const text = (m) => Object.fromEntries([...m].map(([k, v]) => [k, String(v)]));
+  for (let row = 0; row < styled.bypasses.node.length; row++) {
+    const m = styled.bypasses.node[row];
+    if (m !== null && m.size > 0) {
+      yield { properties_of: "nodes", applies_to: ids.idAt(row), properties: text(m) };
+    }
+  }
+  for (const e of edges) {
+    const m = styled.bypasses.edge[e];
+    if (m !== null && m.size > 0) {
+      yield { properties_of: "edges", applies_to: edgeIds[e], properties: text(m) };
+    }
+  }
+}
+function ownView(kept) {
+  const sub = kept.subnetwork;
+  for (const r of Array.isArray(kept.cyNetworkRelations) ? kept.cyNetworkRelations : []) {
+    if (isRecord(r) && r.r === "view" && (sub === void 0 || r.p === sub)) {
+      return r.c;
+    }
+  }
+  for (const v of Array.isArray(kept.cyViews) ? kept.cyViews : []) {
+    if (isRecord(v) && (sub === void 0 || v.s === sub)) {
+      return v["@id"];
+    }
+  }
+  return null;
+}
+function provenanceAspects(snapshot, p, ids, edges) {
+  const out = [];
+  for (const [table, aspect] of Object.entries(PROVENANCE_TABLES)) {
+    const ext = snapshot.extensions.get(table);
+    if (ext === void 0) {
+      continue;
+    }
+    const idColumn = ext.get("id");
+    const fields = [...ext].filter((c) => c !== idColumn);
+    let max = -1;
+    for (let row = 0; row < ext.rowCount; row++) {
+      if (idColumn?.isSet(row) === true) {
+        max = Math.max(max, Number(idColumn.value(row)));
+      }
+    }
+    out.push({
+      name: aspect,
+      idCounter: max + 1,
+      *elements() {
+        for (let row = 0; row < ext.rowCount; row++) {
+          const element = {};
+          if (idColumn?.isSet(row) === true) {
+            element["@id"] = idColumn.value(row);
+          }
+          for (const field of fields) {
+            if (field.isSet(row)) {
+              element[field.meta.name] = field.value(row);
+            }
+          }
+          yield element;
+        }
+      }
+    });
+  }
+  for (const link of p.links) {
+    out.push({
+      name: link.aspect,
+      *elements() {
+        const rows = link.domain === "node" ? Array.from({ length: snapshot.nodeCount }, (_, i) => i) : edges;
+        for (const row of rows) {
+          if (link.column.isSet(row)) {
+            const po = link.domain === "node" ? ids.idAt(row) : p.edgeIds[row];
+            yield { po: [po], [link.key]: Array.from(link.column.value(row)) };
+          }
+        }
+      }
+    });
+  }
+  const terms = p.functionTerm;
+  if (terms !== null) {
+    out.push({
+      name: "functionTerms",
+      *elements() {
+        for (let row = 0; row < snapshot.nodeCount; row++) {
+          const term = terms.isSet(row) ? terms.value(row) : null;
+          if (isRecord(term)) {
+            yield { po: ids.idAt(row), ...term };
+          }
+        }
+      }
+    });
+  }
+  const reified = p.reifiedEdge;
+  if (reified !== null) {
+    out.push({
+      name: "reifiedEdges",
+      *elements() {
+        for (let row = 0; row < snapshot.nodeCount; row++) {
+          const edge = reified.isSet(row) ? reified.value(row) : -1;
+          if (edge >= 0 && edge < snapshot.edgeCount) {
+            yield { node: ids.idAt(row), edge: p.edgeIds[edge] };
+          }
+        }
+      }
+    });
+  }
+  return out;
+}
+function* write(snapshot, p, styled = null) {
+  if (p.fatal !== null) {
+    throw p.fatal;
+  }
+  const { ids } = p;
+  if (ids === null) {
+    throw new GraphFormatError("E_INVALID_ID", "node ids cannot be written as CX integers", { reason: "charset" });
+  }
+  const all = aspects(snapshot, p, ids, styled);
+  const written2 = [];
+  for (const aspect of all) {
+    let count = 0;
+    for (const _ of aspect.elements()) {
+      count++;
+    }
+    if (count > 0 || aspect.name === "nodes") {
+      written2.push({ aspect, count });
+    }
+  }
+  const metaData = written2.map(({ aspect, count }) => ({
+    name: aspect.name,
+    version: "1.0",
+    ...aspect.idCounter === void 0 ? {} : { idCounter: aspect.idCounter },
+    elementCount: count,
+    consistencyGroup: 1
+  }));
+  yield '[{"numberVerification":[{"longNumber":281474976710655}]},\n';
+  yield `{"metaData":${stringify(metaData)}},
+`;
+  for (const { aspect } of written2) {
+    yield* aspectBlock(aspect.name, mapIterable(aspect.elements(), stringify));
+  }
+  yield '{"status":[{"error":"","success":true}]}]\n';
+}
+function* mapIterable(items, fn) {
+  for (const item of items) {
+    yield fn(item);
+  }
+}
+const cxExporter = Object.freeze({
+  format: CX_FORMAT,
+  options: Object.freeze([]),
+  capabilities: CX_CAPABILITIES,
+  styles: Object.freeze({ capabilities: CX_STYLE_CAPABILITIES }),
+  /**
+   * Pre-flight: what export() would lose, without writing anything.
+   * @param snapshot - the snapshot
+   * @param options - the common options
+   * @returns the notes, empty when the export is exact
+   */
+  check(snapshot, options) {
+    const styled = cytoscapeStyledExport(snapshot, options?.styles, "desktop");
+    return Object.freeze([
+      ...plan(styled?.snapshot ?? snapshot, resolveExportOptions(options)).notes,
+      ...styled?.notes ?? []
+    ]);
+  },
+  /**
+   * Write the document as UTF-8 chunks.
+   * @param snapshot - the snapshot
+   * @param options - the common options
+   * @returns the chunks
+   */
+  export(snapshot, options) {
+    return encodeChunks(written(snapshot, options));
+  },
+  /**
+   * Write the document as one string.
+   * @param snapshot - the snapshot
+   * @param options - the common options
+   * @returns the document
+   */
+  exportToString(snapshot, options) {
+    return joinText(written(snapshot, options));
+  }
+});
+function written(snapshot, options) {
+  const styled = cytoscapeStyledExport(snapshot, options?.styles, "desktop");
+  const target = styled?.snapshot ?? snapshot;
+  return write(target, plan(target, resolveExportOptions(options)), styled?.styled ?? null);
+}
+export {
+  CX_CAPABILITIES as C,
+  CX_LOSS as a,
+  cxExporter as c
+};
+//# sourceMappingURL=exporter-_jrBTnos.js.map