@graphty/graph-io 0.3.47 → 0.3.49

package/dist/chunks/{importer-BSvfrX_h.js → importer-PqaaKKnY.js}

@@ -1,1005 +1,13 @@
-import { GraphFormatError, INVALID_INDEX } from "@graphty/graph-format";
-import { c as childrenCsr } from "./children-CA4coBi0.js";
-import { d as directionNotes, p as planNodeIds, e as planEdgeIds, O as ORIGINAL_ID_ATTRIBUTE, s as stringify, g as aspectBlock, i as noteList, f as declaredType, j as nextNodeId, z as zAsOption } from "./importer-CMmeMWlC.js";
-import { c as capabilities, L as LOSS, r as resolveExportOptions, p as pairFolding, a as checkCapabilities, e as explicitWeights, g as resolveImportOptions, t as textChunks, h as throwIfAborted, i as reportUnusedOptions, j as reportSinkOptions, f as chooseGraph, k as graphChosen, l as DirectionResolver, I as IdCoercer, d as declareResolved, u as uniqueColumnName, w as weightFromValue } from "./export-BvqAXCKh.js";
-import { i as isRecord, P as POSITION_COLUMN, h as headText, s as scanAspects, r as reportTooDeep, a as reportSharedBlock, C as CxStructure, J as JsonScanError, E as ExactInteger, c as cxId, p as plainJson, z as zDecl, b as positionDecl, d as declareFresh, e as inexactLiteral, k as keptPrecision } from "./json-elements-DJZRZ6jd.js";
-import { p as plural, a1 as TOO_LARGE_CODE, S as SINK_OPTION_CODE, O as OPTION_IGNORED_CODE, D as DIRECTION_FORCED_CODE, b as DIRECTION_REFUSED_CODE, R as ROLE_TAKEN_CODE, C as COLUMN_RENAMED_CODE, N as NO_GRAPH_CODE, a2 as AMBIGUOUS_GRAPH_NAME_CODE, a3 as GRAPH_NOT_FOUND_CODE, i as MULTIPLE_GRAPHS_CODE, I as ID_MERGED_CODE, P as PRECISION_CODE, A as ID_TEXT_TYPE_CODE, W as JSON_NONSTANDARD_NUMBER_CODE, a4 as SINGLE_OBJECT_ASPECT_CODE, L as MULTI_ASPECT_FRAGMENT_CODE, d as UNKNOWN_ELEMENT_CODE, j as DUPLICATE_EDGE_ID_CODE, k as DUPLICATE_NODE_CODE, n as MISSING_ENDPOINT_CODE, o as MISSING_ID_CODE, a5 as STYLES_NOT_IMPORTED_CODE, a6 as PARENT_CYCLE_CODE, m as UNKNOWN_PARENT_CODE, l as DUPLICATE_ATTRIBUTE_CODE, f as DANGLING_REFERENCE_CODE, U as UNKNOWN_ATTR_TYPE_CODE, a7 as WIDENED_CODE, Y as BAD_VALUE_CODE, g as COUNT_MISMATCH_CODE, Q as ASPECT_ORDER_CODE, K as BAD_ASPECT_BLOCK_CODE, V as STATUS_WARNING_CODE, T as STATUS_FAILED_CODE, s as UNKNOWN_ENCODING_CODE, t as ENCODING_FALLBACK_CODE, u as INVALID_ENCODING_CODE, v as INVALID_UTF8_CODE, a8 as SYNTAX_CODE, E as EMPTY_INPUT_CODE, y as ELEMENT_ISSUE, z as INPUT_ISSUE, Z as ImportReportBuilder, a as agree } from "./format-BpQBx8MZ.js";
-import { j as joinText, e as encodeChunks } from "./writer-DxjgHwSe.js";
-import { c as cytoscapeStyledExport, q as CX_STYLE_CAPABILITIES, s as snapshotBlock, d as blockAspect, r as cytoscapeCxAspect, t as readCxStyles, u as blockOfAspect } from "./styles-BQnsga7p.js";
-import { S as STYLE_BLOCK_NAME } from "./block-DiGq58c3.js";
-import { f as flipY } from "./convert-BcQ8_jMo.js";
-const CX_FORMAT$1 = "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$1 && 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$1 && 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, aspect2] 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: aspect2,
-      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 aspect2 of all) {
-    let count = 0;
-    for (const _ of aspect2.elements()) {
-      count++;
-    }
-    if (count > 0 || aspect2.name === "nodes") {
-      written2.push({ aspect: aspect2, count });
-    }
-  }
-  const metaData = written2.map(({ aspect: aspect2, count }) => ({
-    name: aspect2.name,
-    version: "1.0",
-    ...aspect2.idCounter === void 0 ? {} : { idCounter: aspect2.idCounter },
-    elementCount: count,
-    consistencyGroup: 1
-  }));
-  yield '[{"numberVerification":[{"longNumber":281474976710655}]},\n';
-  yield `{"metaData":${stringify(metaData)}},
-`;
-  for (const { aspect: aspect2 } of written2) {
-    yield* aspectBlock(aspect2.name, mapIterable(aspect2.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$1,
-  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);
-}
+import { INVALID_INDEX } from "@graphty/graph-format";
+import { b as resolveImportOptions, d as reportUnusedOptions, f as reportSinkOptions, g as chooseGraph, h as graphChosen, I as IdCoercer, i as declareResolved, u as uniqueColumnName, w as weightFromValue } from "./export-Cha4dRFz.js";
+import { K as ImportReportBuilder, L as BAD_ASPECT_BLOCK_CODE, E as EMPTY_INPUT_CODE, Q as SYNTAX_CODE, T as BAD_VALUE_CODE, i as MULTIPLE_GRAPHS_CODE, V as TOO_LARGE_CODE, S as SINK_OPTION_CODE, O as OPTION_IGNORED_CODE, D as DIRECTION_FORCED_CODE, b as DIRECTION_REFUSED_CODE, R as ROLE_TAKEN_CODE, C as COLUMN_RENAMED_CODE, N as NO_GRAPH_CODE, W as AMBIGUOUS_GRAPH_NAME_CODE, Y as GRAPH_NOT_FOUND_CODE, I as ID_MERGED_CODE, P as PRECISION_CODE, A as ID_TEXT_TYPE_CODE, Z as JSON_NONSTANDARD_NUMBER_CODE, _ as SINGLE_OBJECT_ASPECT_CODE, $ as MULTI_ASPECT_FRAGMENT_CODE, d as UNKNOWN_ELEMENT_CODE, j as DUPLICATE_EDGE_ID_CODE, k as DUPLICATE_NODE_CODE, n as MISSING_ENDPOINT_CODE, o as MISSING_ID_CODE, a0 as STYLES_NOT_IMPORTED_CODE, a1 as PARENT_CYCLE_CODE, m as UNKNOWN_PARENT_CODE, l as DUPLICATE_ATTRIBUTE_CODE, f as DANGLING_REFERENCE_CODE, U as UNKNOWN_ATTR_TYPE_CODE, a2 as WIDENED_CODE, g as COUNT_MISMATCH_CODE, a3 as ASPECT_ORDER_CODE, a4 as STATUS_WARNING_CODE, a5 as STATUS_FAILED_CODE, s as UNKNOWN_ENCODING_CODE, t as ENCODING_FALLBACK_CODE, u as INVALID_ENCODING_CODE, v as INVALID_UTF8_CODE, y as ELEMENT_ISSUE, z as INPUT_ISSUE, p as plural, a as agree } from "./report-CwMfYa9J.js";
+import { D as DirectionResolver } from "./format-BXiAb-1h.js";
+import { t as textChunks, b as throwIfAborted } from "./input-CAxt_aV-.js";
+import { h as headText, s as scanAspects, r as reportTooDeep, a as reportSharedBlock, C as CxStructure, i as isRecord, J as JsonScanError, E as ExactInteger, c as cxId, p as plainJson, z as zDecl, b as positionDecl, d as declareFresh, e as inexactLiteral, k as keptPrecision } from "./json-elements-Cq76WjnZ.js";
+import { S as STYLE_BLOCK_NAME } from "./block-iptrlMBb.js";
+import { z as zAsOption, O as ORIGINAL_ID_ATTRIBUTE } from "./importer-B92x1xY5.js";
+import { t as readCxStyles, u as blockOfAspect } from "./styles-CCs214_3.js";
+import { f as flipY } from "./convert-Ct2zelbQ.js";
 const CX_FORMAT = "cx";
 const CX_BYPASS_NAMESPACE = "cx.bypass";
 const CX_ISSUE = Object.freeze({
@@ -1869,7 +877,7 @@ class CxReader {
    * @param doc - the collected document
    * @param plan - the graph to read
    */
-  constructor(sink, report, options, zAs, doc, plan2) {
+  constructor(sink, report, options, zAs, doc, plan) {
     this.rootNodes = /* @__PURE__ */ new Set();
     this.rootEdges = /* @__PURE__ */ new Set();
     this.nodeRows = /* @__PURE__ */ new Map();
@@ -1892,7 +900,7 @@ class CxReader {
     this.options = options;
     this.zAs = zAs;
     this.doc = doc;
-    this.plan = plan2;
+    this.plan = plan;
     this.direction = new DirectionResolver(sink, report, options.onMixedDirection);
     this.coercer = new IdCoercer(options.ids);
     for (const { value } of aspect(doc, "nodes")) {
@@ -3234,7 +2242,9 @@ class CxReader {
       }
       return true;
     });
-    const source = others.size > 0 ? { entries: kept, otherViews: others.size } : { entries: kept };
+    const { weightFrom } = this.options;
+    const collection = aspect(this.doc, "cySubNetworks").length > 0;
+    const source = others.size > 0 ? { entries: kept, otherViews: others.size, weightFrom, collection } : { entries: kept, weightFrom, collection };
     this.report.keepForStyles(source);
   }
   /**
@@ -3671,20 +2681,17 @@ const cxImporter = Object.freeze({
     const nodes = aspect(doc, "nodes").length;
     const edges = aspect(doc, "edges").length;
     return graphPlans(doc, report).map(
-      (plan2) => Object.freeze({
-        index: plan2.index,
-        name: plan2.name,
-        nodes: memberCount(plan2.nodes, nodes),
-        edges: memberCount(plan2.edges, edges)
+      (plan) => Object.freeze({
+        index: plan.index,
+        name: plan.name,
+        nodes: memberCount(plan.nodes, nodes),
+        edges: memberCount(plan.edges, edges)
       })
     );
   }
 });
 export {
-  CX_CAPABILITIES as C,
-  CX_ISSUE as a,
-  CX_LOSS as b,
-  cxExporter as c,
-  cxImporter as d
+  CX_ISSUE as C,
+  cxImporter as c
 };
-//# sourceMappingURL=importer-BSvfrX_h.js.map
+//# sourceMappingURL=importer-PqaaKKnY.js.map