@graphty/graph-io 0.3.19 → 0.3.21

package/dist/chunks/exporter-DIeGJXAZ.js

@@ -0,0 +1,834 @@
+import { GraphFormatError } from "@graphty/graph-format";
+import { c as childrenCsr } from "./children-CL3Cy0ez.js";
+import { V as resolveExportOptions, X as pairFolding, _ as DictHeuristic } from "./report-B1z4WT9e.js";
+import { e as escapeXmlAttribute, x as xmlIllegalTextNotes, a as escapeXmlText } from "./escape-B-tkk_Cl.js";
+import { c as capabilities, a as checkCapabilities, L as LOSS } from "./export-Bh60Dv-n.js";
+import { e as explicitWeights, f as formatF32, a as formatF64 } from "./weights-Dzba96G3.js";
+import { j as joinText, e as encodeChunks } from "./writer-C7flM-Ih.js";
+import { F as FORMAT, M as META_KEY, b as XLINK_NAMESPACE, C as CY_NAMESPACE, c as XGMML_NAMESPACE, a as XGMML_LOSS, Z as Z_COLUMN, L as LABEL_COLUMN, I as INTERACTION_COLUMN, d as aliasesOf, G as GRAPHICS_COLUMN, S as SUBGRAPH_COLUMN, N as NESTED_NETWORK_COLUMN, e as NETWORK_POINTER_COLUMN, f as NETWORKS_COLUMN, E as EDGE_ID_COLUMN, P as POSITION_COLUMN, g as PARENT_COLUMN, h as PARENTS_COLUMN, i as XGMML_ORIGIN_NAMESPACE, j as CYTOSCAPE_ORIGIN_NAMESPACE } from "./importer-D_e7e7LX.js";
+const CAPABILITIES = capabilities({
+  mixedDirection: true,
+  multiEdges: true,
+  selfLoops: true,
+  edgeIds: "optional",
+  idCharset: "any",
+  dtypes: ["string", "dict", "f64", "f32", "i32", "u32", "u8", "bool", "list"],
+  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", "id", "parent", "parents", "position"]);
+const ROLE_NAMES = Object.freeze({
+  label: LABEL_COLUMN,
+  id: EDGE_ID_COLUMN,
+  parent: PARENT_COLUMN,
+  position: POSITION_COLUMN
+});
+const DROPPED_ROLES = /* @__PURE__ */ new Set([
+  "color",
+  "size",
+  "shape",
+  "thickness",
+  "start",
+  "end",
+  "timestamp",
+  "timestamps",
+  "spells",
+  "open",
+  "spellsOpen"
+]);
+const READ_ATTRIBUTES = {
+  node: /* @__PURE__ */ new Set(["id", "label", "name"]),
+  edge: /* @__PURE__ */ new Set(["id", "label", "name", "source", "target", "weight"])
+};
+const STRUCTURAL_ROLES = /* @__PURE__ */ new Set([
+  "directed",
+  "pair",
+  "mutual",
+  "weight",
+  "parent",
+  "parents",
+  "position"
+]);
+const RESERVED_NODE_NAMES = /* @__PURE__ */ new Set([
+  LABEL_COLUMN,
+  POSITION_COLUMN,
+  Z_COLUMN,
+  GRAPHICS_COLUMN,
+  PARENT_COLUMN,
+  PARENTS_COLUMN,
+  SUBGRAPH_COLUMN,
+  NESTED_NETWORK_COLUMN,
+  NETWORK_POINTER_COLUMN,
+  NETWORKS_COLUMN
+]);
+const RESERVED_EDGE_NAMES = /* @__PURE__ */ new Set([EDGE_ID_COLUMN, LABEL_COLUMN, GRAPHICS_COLUMN]);
+const RESERVED_NAMES = {
+  graph: /* @__PURE__ */ new Set([GRAPHICS_COLUMN]),
+  node: RESERVED_NODE_NAMES,
+  edge: RESERVED_EDGE_NAMES
+};
+const GRAPHICS_ATTRIBUTES = /* @__PURE__ */ new Set([
+  "type",
+  "w",
+  "h",
+  "d",
+  "image",
+  "bitmap",
+  "width",
+  "arrow",
+  "capstyle",
+  "joinstyle",
+  "smooth",
+  "splinesteps",
+  "justify",
+  "font",
+  "background",
+  "foreground",
+  "extent",
+  "start",
+  "style",
+  "stipple",
+  "visible",
+  "fill",
+  "outline",
+  "anchor"
+]);
+const I32_MAX = 2147483647;
+function typesOf(column, dtype) {
+  if (column.meta.components > 1) {
+    return ["string", "String"];
+  }
+  switch (dtype) {
+    case "bool":
+      return ["boolean", "Boolean"];
+    case "i32":
+    case "u8":
+      return ["integer", "Integer"];
+    case "u32":
+      return maxValue(column) > I32_MAX ? ["integer", "Long"] : ["integer", "Integer"];
+    case "f32":
+    case "f64":
+      return column.meta.origin?.type === "long" && allSafeIntegers(column) ? ["integer", "Long"] : ["real", "Double"];
+    default:
+      return ["string", "String"];
+  }
+}
+function allSafeIntegers(column) {
+  for (let r = 0; r < column.length; r++) {
+    if (!column.isSet(r)) {
+      continue;
+    }
+    const items = column.dtype === "list" ? [...column.sliceOf(r)] : [column.value(r)];
+    if (!items.every((item) => typeof item === "number" && Number.isSafeInteger(item))) {
+      return false;
+    }
+  }
+  return true;
+}
+function maxValue(column) {
+  let max = 0;
+  for (let r = 0; r < column.length; r++) {
+    if (!column.isSet(r)) {
+      continue;
+    }
+    const value = column.value(r);
+    const items = column.dtype === "list" ? [...column.sliceOf(r)] : [value];
+    for (const item of items) {
+      if (typeof item === "number" && item > max) {
+        max = item;
+      }
+    }
+  }
+  return max;
+}
+function owned(column, namespace) {
+  const { origin } = column.meta;
+  return origin !== null && origin.namespace === namespace;
+}
+function planTable(table, domain, snapshot, note) {
+  const writes = [];
+  const reserved = RESERVED_NAMES[domain];
+  const hasLabelRole = domain !== "graph" && (domain === "node" ? snapshot.nodes : snapshot.edges).byRole("label") !== null;
+  for (const column of table) {
+    const { meta } = column;
+    if (meta.role !== null && (STRUCTURAL_ROLES.has(meta.role) || DROPPED_ROLES.has(meta.role) || meta.role === "id" || meta.role === "timeText")) {
+      continue;
+    }
+    const kind = slotOf(column, domain, hasLabelRole);
+    const set = column.length - column.nullCount;
+    if (kind === "att" && reserved.has(meta.name)) {
+      note(
+        LOSS.COLUMN_NAME_CHANGED,
+        `${domain} column "${meta.name}" is named like a column the XGMML importer owns and reads back renamed`,
+        meta.name,
+        set
+      );
+    } else if (kind === "label" && meta.dtype !== "string" && meta.dtype !== "dict") {
+      note(
+        LOSS.DTYPE,
+        `${domain} label column "${meta.name}" (${meta.dtype}) is written as text and reads back as string`,
+        meta.name,
+        set
+      );
+    } else if (kind === "label" && meta.role === null) {
+      note(
+        LOSS.ROLE_ASSUMED,
+        `${domain} column "${meta.name}" is written as the label and reads back with the label role`,
+        meta.name,
+        set
+      );
+    }
+    if (kind === "att") {
+      attNotes(column, domain, note);
+    }
+    const item = meta.dtype === "list" ? meta.itemDtype : meta.dtype;
+    const [type, cyType] = meta.dtype === "list" ? ["list", "List"] : declaredTypes(column, typesOf(column, item));
+    writes.push({
+      column,
+      name: meta.name,
+      kind,
+      type,
+      cyType,
+      elementType: meta.dtype === "list" ? typesOf(column, item)[1] : null
+    });
+  }
+  return writes;
+}
+function slotOf(column, domain, hasLabelRole) {
+  const { meta } = column;
+  if (domain !== "graph" && untypedAttribute(column, domain)) {
+    return "xml";
+  }
+  if (meta.role === "label" || !hasLabelRole && domain !== "graph" && meta.role === null && meta.name === LABEL_COLUMN && (meta.dtype === "string" || meta.dtype === "dict")) {
+    return "label";
+  }
+  if (meta.dtype === "json" && meta.name === GRAPHICS_COLUMN && owned(column, XGMML_ORIGIN_NAMESPACE)) {
+    return "graphics";
+  }
+  if (domain !== "node") {
+    return "att";
+  }
+  if (meta.name === Z_COLUMN && meta.dtype === "f64" && meta.role === null) {
+    return "z";
+  }
+  if (meta.name === SUBGRAPH_COLUMN && meta.dtype === "json" && owned(column, XGMML_ORIGIN_NAMESPACE)) {
+    return "subgraph";
+  }
+  if (meta.name === NESTED_NETWORK_COLUMN && meta.dtype === "string" && owned(column, CYTOSCAPE_ORIGIN_NAMESPACE)) {
+    return "nested";
+  }
+  if (meta.name === NETWORK_POINTER_COLUMN && meta.dtype === "string" && owned(column, XGMML_ORIGIN_NAMESPACE)) {
+    return "pointer";
+  }
+  if (meta.name === NETWORKS_COLUMN && meta.dtype === "list" && owned(column, XGMML_ORIGIN_NAMESPACE)) {
+    return "networks";
+  }
+  return "att";
+}
+function untypedAttribute(column, domain) {
+  const { meta } = column;
+  const { origin } = meta;
+  return origin !== null && origin.format === FORMAT && origin.type === null && origin.namespace === null && meta.role === null && meta.components === 1 && (meta.dtype === "string" || meta.dtype === "bool" || meta.dtype === "i32" || meta.dtype === "f64") && /^[A-Za-z_][A-Za-z0-9_.-]*$/.test(meta.name) && !READ_ATTRIBUTES[domain].has(meta.name);
+}
+function declaredTypes(column, types) {
+  const { origin } = column.meta;
+  if (origin !== null && origin.format === FORMAT && origin.type === types[0] && column.meta.components === 1) {
+    return [types[0], null];
+  }
+  return types;
+}
+function attNotes(column, domain, note) {
+  const { meta } = column;
+  const set = column.length - column.nullCount;
+  const label = `${domain} column "${meta.name}"`;
+  const item = meta.dtype === "list" ? meta.itemDtype : meta.dtype;
+  if (meta.dtype === "json") {
+    note(
+      XGMML_LOSS.JSON_AS_STRING,
+      `${label} holds nested values; they are written as JSON text and read back as strings`,
+      meta.name,
+      set
+    );
+    return;
+  }
+  if (item === "f32" || item === "u8" || item === "u32") {
+    note(
+      XGMML_LOSS.WIDENED_TYPE,
+      `${label} (${item}) is written as a wider Cytoscape type and reads back as ${readBackDtype(column, item)}`,
+      meta.name,
+      set
+    );
+  }
+  if (item === "string" || item === "dict") {
+    let escapes = 0;
+    for (let r = 0; r < column.length; r++) {
+      if (column.isSet(r)) {
+        const values = column.dtype === "list" ? [...column.sliceOf(r)] : [column.value(r)];
+        if (values.some((v) => typeof v === "string" && /\\[nt]/.test(v))) {
+          escapes++;
+        }
+      }
+    }
+    if (escapes > 0) {
+      note(
+        XGMML_LOSS.BACKSLASH_ESCAPE,
+        `${label}: ${escapes} value(s) hold a literal \\n or \\t, which Cytoscape's escape convention reads back as a newline or tab`,
+        meta.name,
+        escapes
+      );
+    }
+  }
+  if (meta.dtype === "string" || meta.dtype === "dict") {
+    const heuristic = new DictHeuristic();
+    for (let r = 0; r < column.length && !heuristic.decided; r++) {
+      if (column.isSet(r)) {
+        heuristic.observe(column.value(r));
+      }
+    }
+    const readsAs = heuristic.decide();
+    if (readsAs !== meta.dtype) {
+      note(
+        XGMML_LOSS.STORAGE_CLASS_CHANGED,
+        `${label} reads back as ${readsAs} (the cardinality heuristic)`,
+        meta.name,
+        null
+      );
+    }
+  }
+}
+function readBackDtype(column, item) {
+  if (item === "u8" || item === "u32" && maxValue(column) <= I32_MAX) {
+    return "i32";
+  }
+  return "f64";
+}
+function planExport(snapshot, options, escapes) {
+  const notes = checkCapabilities(snapshot, CAPABILITIES, options, {
+    roles: SLOT_ROLES,
+    roleNames: ROLE_NAMES,
+    positionDtype: "f32"
+  }).filter((n) => n.code !== LOSS.JSON);
+  const note = (code, message, column = null, count = null) => {
+    notes.push(Object.freeze({ code, message, column, count }));
+  };
+  notes.push(...xmlIllegalTextNotes(snapshot));
+  const folding = pairFolding(snapshot);
+  if (folding.mutualCount > 0) {
+    note(
+      XGMML_LOSS.MUTUAL_EXPANDED,
+      `${folding.mutualCount} mutual pair(s) are written as two directed edges; the mutual mark is lost`,
+      null,
+      folding.mutualCount
+    );
+  }
+  const numericIds = countNumericIds(snapshot);
+  if (numericIds > 0) {
+    note(
+      XGMML_LOSS.ID_TEXT_TYPE,
+      `${numericIds} numeric node id(s) are written as text and read back as strings`,
+      null,
+      numericIds
+    );
+  }
+  const edgeId = snapshot.edges.byRole("id");
+  if (edgeId !== null && edgeId.dtype !== "string" && edgeId.dtype !== "dict") {
+    note(
+      XGMML_LOSS.EDGE_ID_TEXT,
+      `edge id column "${edgeId.meta.name}" (${edgeId.dtype}) is written as text and reads back as strings`,
+      edgeId.meta.name,
+      null
+    );
+  }
+  const hierarchy = childrenCsr(snapshot);
+  if (hierarchy.unreachable > 0) {
+    note(
+      XGMML_LOSS.PARENT_CYCLE,
+      `${hierarchy.unreachable} node(s) whose parent chain never reaches a root are written at the top level and lose their parent`,
+      null,
+      hierarchy.unreachable
+    );
+  }
+  const parents = snapshot.nodes.byRole("parents");
+  if (parents !== null && snapshot.nodes.byRole("parent") !== null) {
+    note(
+      XGMML_LOSS.PARENTS_DROPPED,
+      `parents column "${parents.meta.name}" is not written: the "parent" column is the containment written`,
+      parents.meta.name,
+      parents.length - parents.nullCount
+    );
+  } else if (parents !== null && !multiParent(parents)) {
+    note(
+      LOSS.COLUMN_NAME_CHANGED,
+      `parents column "${parents.meta.name}" holds one parent per node and reads back as the "parent" column`,
+      parents.meta.name,
+      null
+    );
+  }
+  const position = snapshot.nodes.byRole("position");
+  if (position !== null) {
+    positionNotes(position, snapshot, note);
+  }
+  interactionNote(snapshot, note);
+  const weights = explicitWeights(snapshot);
+  for (const column of snapshot.edges) {
+    if (column.meta.name === "weight" && column.meta.role === null && !weights.weighted) {
+      note(LOSS.WEIGHT_KEY_CLASH, `edge column "weight" reads back as THE weight`, "weight", null);
+    }
+  }
+  return {
+    options,
+    escapes,
+    notes,
+    graph: planTable(snapshot.graph, "graph", snapshot, note),
+    nodes: planTable(snapshot.nodes, "node", snapshot, note),
+    edges: planTable(snapshot.edges, "edge", snapshot, note),
+    folding,
+    weights,
+    hierarchy,
+    reachable: reachableNodes(snapshot.nodeCount, hierarchy),
+    position,
+    edgeId
+  };
+}
+function interactionNote(snapshot, note) {
+  const label = snapshot.edges.byRole("label") ?? snapshot.edges.get(LABEL_COLUMN);
+  if (label === null || snapshot.edges.get(INTERACTION_COLUMN) !== null) {
+    return;
+  }
+  let shaped = 0;
+  for (let e = 0; e < label.length; e++) {
+    if (label.isSet(e) && aliasesOf(scalarText(label.value(e))) !== null) {
+      shaped++;
+    }
+  }
+  if (shaped > 0) {
+    note(
+      XGMML_LOSS.INTERACTION_FROM_LABEL,
+      `${shaped} edge label(s) have Cytoscape's "a (i) b" shape and read back with an "${INTERACTION_COLUMN}" column`,
+      INTERACTION_COLUMN,
+      shaped
+    );
+  }
+}
+function reachableNodes(nodeCount, hierarchy) {
+  const reached = new Uint8Array(nodeCount);
+  const stack = Array.from(hierarchy.roots);
+  for (const root of stack) {
+    reached[root] = 1;
+  }
+  while (stack.length > 0) {
+    for (const child of hierarchy.childrenOf(stack.pop())) {
+      if (reached[child] === 0) {
+        reached[child] = 1;
+        stack.push(child);
+      }
+    }
+  }
+  return reached;
+}
+function multiParent(column) {
+  for (let r = 0; r < column.length; r++) {
+    if (column.isSet(r) && column.dtype === "list" && column.sliceOf(r).length > 1) {
+      return true;
+    }
+  }
+  return false;
+}
+function positionNotes(position, snapshot, note) {
+  const { meta } = position;
+  if (meta.components !== 3) {
+    note(
+      XGMML_LOSS.POSITION,
+      `position column "${meta.name}" has ${meta.components} component(s) and reads back with 3`,
+      meta.name,
+      null
+    );
+  }
+  let nonFinite = 0;
+  let depth = 0;
+  for (let r = 0; r < position.length; r++) {
+    if (!position.isSet(r)) {
+      continue;
+    }
+    const xyz = Array.from(position.value(r));
+    if (xyz.slice(0, 2).some((v) => !Number.isFinite(v))) {
+      nonFinite++;
+    } else if ((xyz[2] ?? 0) !== 0) {
+      depth++;
+    }
+  }
+  if (nonFinite > 0) {
+    note(
+      XGMML_LOSS.POSITION,
+      `${nonFinite} position(s) with a non-finite coordinate are not written`,
+      meta.name,
+      nonFinite
+    );
+  }
+  const zColumn = snapshot.nodes.get(Z_COLUMN);
+  if (depth > 0) {
+    note(
+      XGMML_LOSS.POSITION,
+      zColumn === null ? `${depth} position(s) have a z; it is written as graphics z and reads back in the z column (zAs: "position" reads it as a coordinate)` : `${depth} position(s) have a z, but graphics z holds the z column; the position z is lost`,
+      meta.name,
+      depth
+    );
+  }
+}
+function countNumericIds(snapshot) {
+  let n = 0;
+  for (let i = 0; i < snapshot.nodeCount; i++) {
+    if (typeof snapshot.ids.idOf(i) === "number") {
+      n++;
+    }
+  }
+  return n;
+}
+function valueText(value, dtype, escapes) {
+  let text;
+  if (typeof value === "boolean") {
+    text = value ? "1" : "0";
+  } else if (typeof value === "number") {
+    text = dtype === "f32" ? formatF32(value) : formatF64(value);
+  } else if (typeof value === "string") {
+    text = escapes ? value.replace(/\n/g, "\\n").replace(/\t/g, "\\t") : value;
+  } else if (ArrayBuffer.isView(value)) {
+    text = JSON.stringify(Array.from(value));
+  } else {
+    text = JSON.stringify(value) ?? "";
+  }
+  return escapeXmlAttribute(text);
+}
+function scalarText(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number") {
+    return formatF64(value);
+  }
+  if (typeof value === "boolean") {
+    return value ? "true" : "false";
+  }
+  return JSON.stringify(value) ?? "";
+}
+function idText(id) {
+  return typeof id === "number" ? formatF64(id) : id;
+}
+function xmlAttributesOf(writes, row) {
+  let out = "";
+  for (const w of writes) {
+    if (w.kind === "xml" && w.column.isSet(row)) {
+      out += ` ${w.name}="${escapeXmlAttribute(scalarText(w.column.value(row)))}"`;
+    }
+  }
+  return out;
+}
+function* attsOf(writes, row, first, plan, indent) {
+  for (const w of writes) {
+    if (w.kind !== "att") {
+      continue;
+    }
+    const { column } = w;
+    const isSet = column.isSet(row);
+    if (!isSet && !(first && column.nullCount === column.length)) {
+      continue;
+    }
+    const name = `${indent}<att name="${escapeXmlAttribute(w.name)}"`;
+    const types = `${w.type === null ? "" : ` type="${w.type}"`}${w.cyType === null ? "" : ` cy:type="${w.cyType}"`}`;
+    const extra = `${column.meta.extra.hidden === true ? ' cy:hidden="1"' : ""}${column.meta.extra.equation === true ? ' cy:equation="1"' : ""}`;
+    if (!isSet) {
+      yield `${name}${types}${w.elementType === null ? "" : ` cy:elementType="${w.elementType}"`}${extra}/>
+`;
+      continue;
+    }
+    if (column.dtype === "list") {
+      const items = [...column.sliceOf(row)];
+      const [itemType, itemCy] = typesOf(column, column.meta.itemDtype);
+      yield `${name}${types} cy:elementType="${w.elementType ?? "String"}"${extra}${items.length === 0 ? "/>" : ">"}
+`;
+      if (items.length > 0) {
+        for (const item of items) {
+          yield `${indent}    <att name="${escapeXmlAttribute(w.name)}" value="${valueText(item, column.meta.itemDtype, plan.escapes)}" type="${itemType}" cy:type="${itemCy}"/>
+`;
+        }
+        yield `${indent}</att>
+`;
+      }
+      continue;
+    }
+    yield `${name} value="${valueText(column.value(row), column.dtype, plan.escapes)}"${types}${extra}/>
+`;
+  }
+}
+function* graphicsOf(record, coords, indent) {
+  const attrs = [...coords];
+  const nested = [];
+  for (const [key, value] of Object.entries(record ?? {})) {
+    if (key === "Line") {
+      nested.push([key, value]);
+    } else if (typeof value === "string" && (GRAPHICS_ATTRIBUTES.has(key) || key.startsWith("cy:"))) {
+      attrs.push([key, value]);
+    } else {
+      nested.push([key, value]);
+    }
+  }
+  if (attrs.length === 0 && nested.length === 0) {
+    return;
+  }
+  const head = `${indent}<graphics${attrs.map(([k, v]) => ` ${k}="${escapeXmlAttribute(v)}"`).join("")}`;
+  if (nested.length === 0) {
+    yield `${head}/>
+`;
+    return;
+  }
+  yield `${head}>
+`;
+  for (const [key, value] of nested) {
+    if (key === "Line" && Array.isArray(value)) {
+      yield `${indent}    <Line>
+`;
+      for (const point of value) {
+        const entries = typeof point === "object" && point !== null ? Object.entries(point) : [];
+        yield `${indent}        <point${entries.map(([k, v]) => ` ${k}="${escapeXmlAttribute(String(v))}"`).join("")}/>
+`;
+      }
+      yield `${indent}    </Line>
+`;
+    } else {
+      yield* jsonAtt(key, value, `${indent}    `);
+    }
+  }
+  yield `${indent}</graphics>
+`;
+}
+function* jsonAtt(name, value, indent) {
+  const nameAttr = name === null ? "" : ` name="${escapeXmlAttribute(name)}"`;
+  if (Array.isArray(value)) {
+    yield `${indent}<att${nameAttr} type="list">
+`;
+    for (const item of value) {
+      yield* jsonAtt(name, item, `${indent}    `);
+    }
+    yield `${indent}</att>
+`;
+  } else if (typeof value === "object" && value !== null) {
+    const entries = Object.entries(value);
+    if (name !== null && entries.every(([, v]) => typeof v === "string") && entries.length <= 3 && entries.every(([k]) => /^[a-z]$/.test(k))) {
+      yield `${indent}<att${nameAttr}${entries.map(([k, v]) => ` ${k}="${escapeXmlAttribute(v)}"`).join("")}/>
+`;
+      return;
+    }
+    yield `${indent}<att${nameAttr}>
+`;
+    for (const [key, item] of entries) {
+      yield* jsonAtt(key, item, `${indent}    `);
+    }
+    yield `${indent}</att>
+`;
+  } else if (value === null || value === void 0) {
+    yield `${indent}<att${nameAttr} type="string"/>
+`;
+  } else {
+    yield `${indent}<att${nameAttr} value="${escapeXmlAttribute(scalarText(value))}" type="string"/>
+`;
+  }
+}
+function slot(writes, kind) {
+  return writes.find((w) => w.kind === kind)?.column ?? null;
+}
+function cellOf(column, row) {
+  return column !== null && column.isSet(row) ? column.value(row) : null;
+}
+function coordsOf(plan, zColumn, node) {
+  const out = [];
+  const xyz = cellOf(plan.position, node);
+  if (xyz !== null) {
+    const [x, y, z2] = Array.from(xyz);
+    if (Number.isFinite(x) && Number.isFinite(y)) {
+      out.push(["x", formatF32(x)], ["y", formatF32(y === 0 ? 0 : -y)]);
+      if (zColumn === null && z2 !== void 0 && z2 !== 0 && Number.isFinite(z2)) {
+        out.push(["z", formatF32(z2)]);
+      }
+    }
+  }
+  const z = cellOf(zColumn, node);
+  if (typeof z === "number") {
+    out.push(["z", formatF64(z)]);
+  }
+  return out;
+}
+function* nodeOf(snapshot, plan, node, indent) {
+  const labelCol = slot(plan.nodes, "label");
+  const label = cellOf(labelCol, node);
+  yield `${indent}<node id="${escapeXmlAttribute(idText(snapshot.ids.idOf(node)))}"${label === null ? "" : ` label="${escapeXmlAttribute(scalarText(label))}"`}${xmlAttributesOf(plan.nodes, node)}>
+`;
+  const inner = `${indent}    `;
+  yield* attsOf(plan.nodes, node, node === 0, plan, inner);
+  const children = plan.reachable[node] === 1 ? plan.hierarchy.childrenOf(node) : [];
+  const nested = cellOf(slot(plan.nodes, "nested"), node);
+  const pointer = cellOf(slot(plan.nodes, "pointer"), node);
+  const subgraph = cellOf(slot(plan.nodes, "subgraph"), node);
+  if (children.length > 0 || subgraph !== null) {
+    const sub = subgraph ?? {};
+    yield `${inner}<att name="__isGroup" value="1" type="boolean" cy:type="Boolean" cy:hidden="1"/>
+`;
+    const id = typeof sub.id === "string" ? ` id="${escapeXmlAttribute(sub.id)}"` : "";
+    const lbl = typeof sub.label === "string" ? ` label="${escapeXmlAttribute(sub.label)}"` : "";
+    yield `${inner}<att>
+${inner}    <graph${id}${lbl}>
+`;
+    const atts = typeof sub.atts === "object" && sub.atts !== null ? Object.entries(sub.atts) : [];
+    for (const [key, value] of atts) {
+      yield* jsonAtt(key, value, `${inner}        `);
+    }
+    for (const child of children) {
+      yield `${inner}        <node xlink:href="#${escapeXmlAttribute(idText(snapshot.ids.idOf(child)))}"/>
+`;
+    }
+    yield `${inner}    </graph>
+${inner}</att>
+`;
+  } else if (typeof nested === "string") {
+    yield `${inner}<att>
+${inner}    <graph label="${escapeXmlAttribute(nested)}"/>
+${inner}</att>
+`;
+  } else if (typeof pointer === "string") {
+    yield `${inner}<att>
+${inner}    <graph xlink:href="${escapeXmlAttribute(pointer)}"/>
+${inner}</att>
+`;
+  }
+  const graphics = cellOf(slot(plan.nodes, "graphics"), node);
+  yield* graphicsOf(graphics, coordsOf(plan, slot(plan.nodes, "z"), node), inner);
+  yield `${indent}</node>
+`;
+}
+function* write(snapshot, options) {
+  const plan = planFor(snapshot, options);
+  const meta = snapshot.meta.extra[META_KEY];
+  const graphId = typeof meta?.graphId === "string" ? ` id="${escapeXmlAttribute(meta.graphId)}"` : "";
+  const keep = (meta?.directed === "0" || meta?.directed === "1") && snapshot.edgeCount > 0 && snapshot.edges.byRole("directed") === null;
+  let directed = snapshot.directed ? "1" : "0";
+  if (keep) {
+    directed = meta?.directed;
+  }
+  const name = snapshot.meta.name === null ? "" : ` label="${escapeXmlAttribute(snapshot.meta.name)}"`;
+  yield '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n';
+  yield `<graph${graphId}${name} directed="${directed}" cy:documentVersion="3.0" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:xlink="${XLINK_NAMESPACE}" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:cy="${CY_NAMESPACE}" xmlns="${XGMML_NAMESPACE}">
+`;
+  yield* metadataOf(snapshot);
+  yield* attsOf(plan.graph, 0, true, plan, "    ");
+  yield* graphicsOf(cellOf(slot(plan.graph, "graphics"), 0), [], "    ");
+  for (let u = 0; u < snapshot.nodeCount; u++) {
+    yield* nodeOf(snapshot, plan, u, "    ");
+  }
+  yield* networksOf(snapshot, plan);
+  yield* edgesOf(snapshot, plan);
+  yield "</graph>\n";
+}
+function* metadataOf(snapshot) {
+  const { name, description, created } = snapshot.meta;
+  if (description === null && created === null) {
+    return;
+  }
+  yield '    <att name="networkMetadata">\n        <rdf:RDF>\n            <rdf:Description rdf:about="http://www.cytoscape.org/">\n';
+  if (name !== null) {
+    yield `                <dc:title>${escapeXmlText(name)}</dc:title>
+`;
+  }
+  if (description !== null) {
+    yield `                <dc:description>${escapeXmlText(description)}</dc:description>
+`;
+  }
+  if (created !== null) {
+    yield `                <dc:date>${escapeXmlText(created)}</dc:date>
+`;
+  }
+  yield "            </rdf:Description>\n        </rdf:RDF>\n    </att>\n";
+}
+function* networksOf(snapshot, plan) {
+  const column = slot(plan.nodes, "networks");
+  if (column?.dtype !== "list") {
+    return;
+  }
+  const members = /* @__PURE__ */ new Map();
+  for (let u = 0; u < snapshot.nodeCount; u++) {
+    for (const id of column.isSet(u) ? column.sliceOf(u) : []) {
+      const list = members.get(String(id)) ?? [];
+      list.push(u);
+      members.set(String(id), list);
+    }
+  }
+  for (const [id, nodes] of members) {
+    yield `    <att>
+        <graph id="${escapeXmlAttribute(id)}">
+`;
+    for (const u of nodes) {
+      yield `            <node xlink:href="#${escapeXmlAttribute(idText(snapshot.ids.idOf(u)))}"/>
+`;
+    }
+    yield "        </graph>\n    </att>\n";
+  }
+}
+function* edgesOf(snapshot, plan) {
+  const { folding, weights } = plan;
+  const labelCol = slot(plan.edges, "label");
+  const graphicsCol = slot(plan.edges, "graphics");
+  const list = snapshot.edgeList();
+  let first = true;
+  for (let e = 0; e < snapshot.edgeCount; e++) {
+    if (folding.folded(e)) {
+      continue;
+    }
+    const u = list.src[e];
+    const v = list.dst[e];
+    const directed = snapshot.directed && folding.sourceDirected(e);
+    const id = cellOf(plan.edgeId, e);
+    const label = cellOf(labelCol, e);
+    const weight = weights.text(e);
+    yield `    <edge${id === null ? "" : ` id="${escapeXmlAttribute(scalarText(id))}"`}${label === null ? "" : ` label="${escapeXmlAttribute(scalarText(label))}"`} source="${escapeXmlAttribute(idText(snapshot.ids.idOf(u)))}" target="${escapeXmlAttribute(idText(snapshot.ids.idOf(v)))}" cy:directed="${directed ? "1" : "0"}"${weight === null ? "" : ` weight="${weight}"`}${xmlAttributesOf(plan.edges, e)}>
+`;
+    yield* attsOf(plan.edges, e, first, plan, "        ");
+    yield* graphicsOf(cellOf(graphicsCol, e), [], "        ");
+    yield "    </edge>\n";
+    first = false;
+  }
+}
+function resolveEscapes(options) {
+  const value = options?.cytoscapeEscapes ?? false;
+  if (typeof value !== "boolean") {
+    throw new GraphFormatError("E_UNSUPPORTED", "option cytoscapeEscapes must be a boolean", {
+      option: "cytoscapeEscapes",
+      found: typeof value
+    });
+  }
+  return value;
+}
+function planFor(snapshot, options) {
+  const plan = planExport(snapshot, resolveExportOptions(options), resolveEscapes(options));
+  const illegal = plan.notes.find((n) => n.code === XGMML_LOSS.XML_ILLEGAL_CHAR);
+  if (illegal !== void 0) {
+    throw new GraphFormatError("E_COLUMN_TYPE", illegal.message, { code: illegal.code, column: illegal.column });
+  }
+  return plan;
+}
+const xgmmlExporter = Object.freeze({
+  format: FORMAT,
+  capabilities: CAPABILITIES,
+  check: (snapshot, options) => Object.freeze(planExport(snapshot, resolveExportOptions(options), resolveEscapes(options)).notes),
+  export: (snapshot, options) => encodeChunks(write(snapshot, options)),
+  exportToString: (snapshot, options) => joinText(write(snapshot, options))
+});
+export {
+  xgmmlExporter as x
+};
+//# sourceMappingURL=exporter-DIeGJXAZ.js.map