@graphty/graph-io 0.3.18 → 0.3.19

package/dist/chunks/exporter-CbMZyVt-.js

@@ -0,0 +1,735 @@
+import { GraphFormatError } from "@graphty/graph-format";
+import { aB as resolveExportOptions, ax as pairFolding } from "./report-BcWboivV.js";
+import { c as capabilities, L as LOSS, j as joinText, e as encodeChunks, a as checkCapabilities } from "./writer-DQiKgQJc.js";
+import { i as isRecord, P as POSITION_COLUMN } from "./json-elements-CZY1wiZh.js";
+import { e as explicitWeights } from "./weights-CwISIpCP.js";
+import { a as CX2_FORMAT, O as ORIGINAL_ID_ATTRIBUTE, b as cx2Type, B as BYPASS_NAMESPACE } from "./importer-DOepkgnG.js";
+const CX2_LOSS = Object.freeze({
+  /** Every edge is written directed: an undirected snapshot, or the undirected pairs of a mixed one. */
+  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",
+  /** NaN and the infinities cannot be written; they are written as null and read back unset. */
+  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). */
+  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. */
+  ROLE_DROPPED: LOSS.ROLE,
+  /** A dtype CX2 declares as another (f32 as double, u32 as long, dict as string, ...). */
+  DTYPE_UNSUPPORTED: LOSS.DTYPE,
+  /** Node ids that are not integers under the default sanitizeIds "error": export() throws E_INVALID_ID. */
+  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 id get generated integer ids. */
+  EDGE_IDS_GENERATED: LOSS.EDGE_IDS_GENERATED
+});
+const CX2_CAPABILITIES = capabilities({
+  mixedDirection: false,
+  multiEdges: true,
+  selfLoops: true,
+  edgeIds: "required",
+  idCharset: "integer",
+  dtypes: ["string", "f64", "i32", "bool"],
+  components: false,
+  lists: true,
+  json: false,
+  defaults: true,
+  options: false,
+  hierarchy: false,
+  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
+});
+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"
+]);
+const CORE_ASPECTS = /* @__PURE__ */ new Set([
+  "nodes",
+  "edges",
+  "attributeDeclarations",
+  "networkAttributes",
+  "nodeBypasses",
+  "edgeBypasses",
+  "metaData",
+  "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");
+  if (!numeric) {
+    return 0;
+  }
+  let count = 0;
+  for (let i = 0; i < column.length; i++) {
+    if (!column.isSet(i)) {
+      continue;
+    }
+    const value = column.value(i);
+    if (dtype === "list") {
+      if (value.some((v) => !Number.isFinite(v))) {
+        count++;
+      }
+    } else if (!Number.isFinite(value)) {
+      count++;
+    }
+  }
+  return count;
+}
+function planAttributes(table, skip, rename, reserved = /* @__PURE__ */ new Set()) {
+  const plans = [];
+  const used = new Set(reserved);
+  const candidates = [...table].filter((c) => !skip(c));
+  for (const column of candidates) {
+    used.add(rename(column));
+  }
+  for (const column of candidates) {
+    const name = rename(column);
+    const { origin } = column.meta;
+    let key = name;
+    const alias = origin?.format === CX2_FORMAT && typeof origin.id === "string" ? origin.id : null;
+    if (alias !== null && alias.length > 0 && alias !== name && !used.has(alias)) {
+      key = alias;
+      used.add(alias);
+    }
+    plans.push({ column, name, key, d: declaredType(column), jsonText: column.meta.dtype === "json" });
+  }
+  return plans;
+}
+function plan(snapshot, common) {
+  const notes = [];
+  let fatal = null;
+  const note = (code, message, column = null, count = null) => {
+    notes.push(Object.freeze({ code, message, column, count }));
+  };
+  const bypassNames = new Set(
+    [...snapshot.nodes, ...snapshot.edges].filter((c) => isBypass(c) || isZ(c)).map((c) => c.meta.name)
+  );
+  for (const gen of checkCapabilities(snapshot, CX2_CAPABILITIES, common, {
+    roles: SLOT_ROLES,
+    roleNames: ROLE_NAMES
+  })) {
+    if (gen.column !== null && bypassNames.has(gen.column) && (gen.code === LOSS.JSON || gen.code === LOSS.DTYPE)) {
+      continue;
+    }
+    if (gen.code === LOSS.ID_CHARSET || gen.code === LOSS.ID_MANGLED) {
+      continue;
+    }
+    if (gen.code === LOSS.JSON) {
+      note(
+        CX2_LOSS.JSON_AS_STRING,
+        `${gen.column === null ? "a column" : `column "${gen.column}"`} holds nested values; written as a string attribute holding their JSON text`,
+        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);
+  }
+  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;
+  }
+  const weights = explicitWeights(snapshot);
+  const label = snapshot.nodes.byRole("label");
+  const nodeAttrs = planAttributes(
+    snapshot.nodes,
+    (c) => c.meta.role !== null && SKIPPED_ROLES.has(c.meta.role) || isBypass(c) || isZ(c),
+    (c) => c === label && !snapshot.nodes.has("name") ? "name" : c.meta.name,
+    ids !== null && ids.changed > 0 ? /* @__PURE__ */ new Set([ORIGINAL_ID_ATTRIBUTE]) : /* @__PURE__ */ new Set()
+  );
+  const plainWeight = snapshot.edges.get(WEIGHT_ATTRIBUTE);
+  const weightColumnClash = plainWeight !== null && plainWeight.meta.role === null;
+  if (weightColumnClash) {
+    note(
+      LOSS.WEIGHT_KEY_CLASH,
+      weights.weighted ? `edge column "${WEIGHT_ATTRIBUTE}" is not written: the explicit weights are written under that name` : `edge column "${WEIGHT_ATTRIBUTE}" reads back as the edge weight`,
+      WEIGHT_ATTRIBUTE,
+      null
+    );
+  }
+  const edgeAttrs = planAttributes(
+    snapshot.edges,
+    (c) => c.meta.role !== null && (SKIPPED_ROLES.has(c.meta.role) || c.meta.role === "id") || isBypass(c) || weights.weighted && c === plainWeight,
+    (c) => c.meta.name,
+    weights.weighted ? /* @__PURE__ */ new Set([WEIGHT_ATTRIBUTE]) : /* @__PURE__ */ new Set()
+  );
+  const graphAttrs = planAttributes(
+    snapshot.graph,
+    () => false,
+    (c) => c.meta.name
+  ).map((p) => ({ ...p, key: p.name }));
+  let nonfinite = 0;
+  for (const p of [...nodeAttrs, ...edgeAttrs, ...graphAttrs]) {
+    nonfinite += nonFiniteCount(p.column);
+  }
+  for (let e = 0; e < snapshot.edgeCount; e++) {
+    if (weights.isExplicit(e) && !Number.isFinite(weights.value(e))) {
+      nonfinite++;
+    }
+  }
+  const position = snapshot.nodes.byRole("position");
+  if (position !== null) {
+    nonfinite += nonFinitePositions(position);
+  }
+  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`,
+      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 {
+    notes,
+    fatal,
+    ids,
+    folding,
+    weights,
+    nodeAttrs,
+    edgeAttrs,
+    graphAttrs,
+    nodeBypasses: [...snapshot.nodes].filter(isBypass),
+    edgeBypasses: [...snapshot.edges].filter(isBypass),
+    position,
+    positionZ,
+    z,
+    edgeIds,
+    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)) {
+    return void 0;
+  }
+  const value = column.value(row);
+  if (p.jsonText) {
+    return JSON.stringify(value);
+  }
+  if (column.meta.dtype === "list" || column.meta.components > 1) {
+    const items = Array.from(value);
+    if (p.d === "string") {
+      return JSON.stringify(items);
+    }
+    return items.some((v) => typeof v === "number" && !Number.isFinite(v)) ? null : items;
+  }
+  if (typeof value === "number" && !Number.isFinite(value)) {
+    return null;
+  }
+  return value;
+}
+function declarations(plans, defaults) {
+  const out = {};
+  for (const p of plans) {
+    const decl = { d: p.d };
+    if (defaults && p.key !== p.name) {
+      decl.a = p.key;
+    }
+    const fallback = p.column.meta.default;
+    if (defaults && fallback !== void 0 && fallback !== null) {
+      if (defaultFits(cx2Type(p.d), fallback)) {
+        decl.v = fallback;
+      }
+    }
+    out[p.name] = decl;
+  }
+  return out;
+}
+function defaultFits(type, fallback) {
+  if (type === null) {
+    return false;
+  }
+  if (type.list) {
+    return Array.isArray(fallback);
+  }
+  switch (type.scalar) {
+    case "string":
+      return typeof fallback === "string";
+    case "boolean":
+      return typeof fallback === "boolean";
+    default:
+      return typeof fallback === "number" && Number.isFinite(fallback);
+  }
+}
+function attributesOf(plans, row) {
+  let out = null;
+  for (const p of plans) {
+    const value = cellValue(p, row);
+    if (value !== void 0) {
+      out ??= {};
+      out[p.key] = value;
+    }
+  }
+  return out;
+}
+function* write(snapshot, p) {
+  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 CX2 integers", { reason: "charset" });
+  }
+  const { src, dst } = snapshot.edgeList();
+  const edges = [];
+  for (let e = 0; e < snapshot.edgeCount; e++) {
+    if (!p.folding.folded(e)) {
+      edges.push(e);
+    }
+  }
+  const nodeDecls = declarations(p.nodeAttrs, true);
+  if (p.originalIds) {
+    nodeDecls[ORIGINAL_ID_ATTRIBUTE] = { d: "string" };
+  }
+  const edgeDecls = declarations(p.edgeAttrs, true);
+  if (p.weights.weighted) {
+    edgeDecls[WEIGHT_ATTRIBUTE] = { d: "double" };
+  }
+  const networkDecls = declarations(p.graphAttrs, false);
+  const network = {};
+  for (const a of p.graphAttrs) {
+    const value = cellValue(a, 0);
+    if (value !== void 0) {
+      network[a.name] = value;
+    }
+  }
+  const { meta } = snapshot;
+  for (const [key, value] of [
+    ["name", meta.name],
+    ["description", meta.description]
+  ]) {
+    if (value !== null && !(key in network) && !(key in networkDecls)) {
+      network[key] = value;
+      networkDecls[key] = { d: "string" };
+    }
+  }
+  const kept = isRecord(meta.extra.cx2) ? meta.extra.cx2 : {};
+  const otherDecls = isRecord(kept.declarations) ? kept.declarations : {};
+  const opaque = meta.sourceFormat === CX2_FORMAT && isRecord(kept.opaque) ? kept.opaque : {};
+  const declarationsElement = { ...otherDecls };
+  for (const [key, table] of [
+    ["networkAttributes", networkDecls],
+    ["nodes", nodeDecls],
+    ["edges", edgeDecls]
+  ]) {
+    if (Object.keys(table).length > 0) {
+      declarationsElement[key] = table;
+    }
+  }
+  const nodeBypassRows = bypassRows(p.nodeBypasses, snapshot.nodeCount);
+  const edgeBypassRows = bypassRows(p.edgeBypasses, snapshot.edgeCount).filter((e) => !p.folding.folded(e));
+  const opaqueAspects = Object.entries(opaque).filter(
+    (entry) => !CORE_ASPECTS.has(entry[0]) && Array.isArray(entry[1])
+  );
+  const counts = [];
+  const hasDeclarations = Object.keys(declarationsElement).length > 0;
+  if (hasDeclarations) {
+    counts.push(["attributeDeclarations", 1]);
+  }
+  if (Object.keys(network).length > 0) {
+    counts.push(["networkAttributes", 1]);
+  }
+  counts.push(["nodes", snapshot.nodeCount], ["edges", edges.length]);
+  if (nodeBypassRows.length > 0) {
+    counts.push(["nodeBypasses", nodeBypassRows.length]);
+  }
+  if (edgeBypassRows.length > 0) {
+    counts.push(["edgeBypasses", edgeBypassRows.length]);
+  }
+  for (const [name, elements] of opaqueAspects) {
+    counts.push([name, elements.length]);
+  }
+  yield '[{"CXVersion":"2.0","hasFragments":false},\n';
+  yield `{"metaData":${stringify(counts.map(([name, elementCount]) => ({ name, elementCount })))}},
+`;
+  if (hasDeclarations) {
+    yield `{"attributeDeclarations":[${stringify(declarationsElement)}]},
+`;
+  }
+  if (Object.keys(network).length > 0) {
+    yield `{"networkAttributes":[${stringify(network)}]},
+`;
+  }
+  yield* block("nodes", snapshot.nodeCount, (i) => stringify(nodeElement(p, ids, i)));
+  yield* block("edges", edges.length, (k) => {
+    const e = edges[k];
+    const element = {
+      id: p.edgeIds[e],
+      s: ids.idAt(src[e]),
+      t: ids.idAt(dst[e])
+    };
+    let v = attributesOf(p.edgeAttrs, e);
+    if (p.weights.isExplicit(e)) {
+      const w = p.weights.value(e);
+      v ??= {};
+      v[WEIGHT_ATTRIBUTE] = Number.isFinite(w) ? w : null;
+    }
+    if (v !== null) {
+      element.v = v;
+    }
+    return stringify(element);
+  });
+  if (nodeBypassRows.length > 0) {
+    yield* block("nodeBypasses", nodeBypassRows.length, (k) => {
+      const i = nodeBypassRows[k];
+      return stringify({ id: ids.idAt(i), v: bypassValues(p.nodeBypasses, i) });
+    });
+  }
+  if (edgeBypassRows.length > 0) {
+    yield* block("edgeBypasses", edgeBypassRows.length, (k) => {
+      const e = edgeBypassRows[k];
+      return stringify({ id: p.edgeIds[e], v: bypassValues(p.edgeBypasses, e) });
+    });
+  }
+  for (const [name, elements] of opaqueAspects) {
+    yield* block(name, elements.length, (k) => stringify(elements[k]));
+  }
+  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 nodeElement(p, ids, i) {
+  const element = { id: ids.idAt(i) };
+  if (p.position?.isSet(i) === true) {
+    const point = p.position.value(i);
+    if (Number.isFinite(point[0]) && Number.isFinite(point[1])) {
+      element.x = point[0];
+      element.y = point[1] === 0 ? 0 : -point[1];
+      if (p.positionZ && Number.isFinite(point[2])) {
+        element.z = point[2];
+      }
+    }
+  }
+  if (p.z?.isSet(i) === true) {
+    const z = p.z.value(i);
+    if (typeof z === "number" && Number.isFinite(z)) {
+      element.z = z;
+    }
+  }
+  let v = attributesOf(p.nodeAttrs, i);
+  if (p.originalIds && ids.isChanged(i)) {
+    v ??= {};
+    v[ORIGINAL_ID_ATTRIBUTE] = String(ids.originalAt(i));
+  }
+  if (v !== null) {
+    element.v = v;
+  }
+  return element;
+}
+function bypassRows(columns, rows) {
+  const out = [];
+  if (columns.length === 0) {
+    return out;
+  }
+  for (let i = 0; i < rows; i++) {
+    if (columns.some((c) => c.isSet(i))) {
+      out.push(i);
+    }
+  }
+  return out;
+}
+function bypassValues(columns, row) {
+  const out = {};
+  for (const column of columns) {
+    if (column.isSet(row)) {
+      const property = column.meta.origin?.id;
+      out[typeof property === "string" && property.length > 0 ? property : column.meta.name] = column.value(row);
+    }
+  }
+  return out;
+}
+const cx2Exporter = Object.freeze({
+  format: CX2_FORMAT,
+  capabilities: CX2_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) {
+    return Object.freeze([...plan(snapshot, resolveExportOptions(options)).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(write(snapshot, plan(snapshot, resolveExportOptions(options))));
+  },
+  /**
+   * Write the document as one string.
+   * @param snapshot - the snapshot
+   * @param options - the common options
+   * @returns the document
+   */
+  exportToString(snapshot, options) {
+    return joinText(write(snapshot, plan(snapshot, resolveExportOptions(options))));
+  }
+});
+export {
+  CX2_CAPABILITIES as C,
+  CX2_LOSS as a,
+  cx2Exporter as c
+};
+//# sourceMappingURL=exporter-CbMZyVt-.js.map