@graphty/graph-io 0.3.43 → 0.3.44

package/dist/chunks/{importer-WrGRZb0N.js → importer-B7r2owVf.js}

@@ -1,9 +1,12 @@
 import { GraphFormatError, INVALID_INDEX } from "@graphty/graph-format";
-import { ae as AMBIGUOUS_GRAPH_NAME_CODE, af as GRAPH_NOT_FOUND_CODE, l as MULTIPLE_GRAPHS_CODE, N as NO_GRAPH_CODE, E as EMPTY_INPUT_CODE, i as DANGLING_REFERENCE_CODE, ah as STYLES_NOT_IMPORTED_CODE, ad as TOO_LARGE_CODE, w as UNKNOWN_ENCODING_CODE, x as ENCODING_FALLBACK_CODE, F as ELEMENT_ISSUE, G as INPUT_ISSUE, bs as decodeEntryName, am as throwIfAborted, c as capabilities, L as LOSS, r as resolveExportOptions, a as checkCapabilities, p as pairFolding, b as plural, $ as agree, e as explicitWeights, aF as formatDecimal, ab as formatF64, aa as formatF32, ac as DictHeuristic, b$ as readBytes, a8 as ImportReportBuilder, a4 as textChunks, aS as ImportError, ao as reportSinkOptions, an as reportUnusedOptions, a7 as chooseGraph, ap as graphChosen, al as resolveImportOptions, c0 as elementCount, ar as IdCoercer, a1 as declareResolved } from "./export-rKLeGQMo.js";
-import { h as hasIllegalXmlChar, e as escapeXmlAttribute, o as quoteCsvCell, t as tokenizeXml, f as xmlDeclaredEncoding, X as XmlSyntaxError } from "./escape-B62ZGM_a.js";
-import { O as ORIGINAL_ID_ATTRIBUTE } from "./constants-fT3E8JYY.js";
-import { X as XGMML_ISSUE, Z as Z_COLUMN, b as XLINK_NAMESPACE, C as CY_NAMESPACE, c as XGMML_NAMESPACE, G as GRAPHICS_COLUMN, E as EDGE_ID_COLUMN, P as POSITION_COLUMN, e as PARENT_COLUMN, f as PARENTS_COLUMN, S as SUBGRAPH_COLUMN, N as NESTED_NETWORK_COLUMN, g as NETWORK_POINTER_COLUMN, h as NETWORKS_COLUMN, r as resolveSettings, m as membersOf, k as XgmmlEmitter, l as isCyTrue, p as parseXgmml, n as dialectOf, i as XGMML_ORIGIN_NAMESPACE, o as parseCoordinate } from "./importer-Ht7LNg8L.js";
-import { C as CsvRecordReader } from "./records-Cu4bxYOm.js";
+import { a4 as decodeEntryName, h as throwIfAborted, c as capabilities, L as LOSS, r as resolveExportOptions, a as checkCapabilities, p as pairFolding, e as explicitWeights, D as DictHeuristic, ak as readBytes, t as textChunks, j as reportSinkOptions, i as reportUnusedOptions, f as chooseGraph, k as graphChosen, g as resolveImportOptions, ab as readText, I as IdCoercer, d as declareResolved } from "./export-D7IGzTG4.js";
+import { h as hasIllegalXmlChar, e as escapeXmlAttribute, q as quoteCsvCell, t as tokenizeXml, b as xmlDeclaredEncoding, c as XmlSyntaxError } from "./escape-B1rMftd9.js";
+import { a2 as AMBIGUOUS_GRAPH_NAME_CODE, a3 as GRAPH_NOT_FOUND_CODE, h as MULTIPLE_GRAPHS_CODE, N as NO_GRAPH_CODE, E as EMPTY_INPUT_CODE, e as DANGLING_REFERENCE_CODE, a5 as STYLES_NOT_IMPORTED_CODE, a1 as TOO_LARGE_CODE, r as UNKNOWN_ENCODING_CODE, s as ENCODING_FALLBACK_CODE, x as ELEMENT_ISSUE, y as INPUT_ISSUE, p as plural, V as agree, aO as formatDecimal, a0 as formatF64, $ as formatF32, Z as ImportReportBuilder, an as ImportError, aS as elementCount } from "./format-GDmO6m6Q.js";
+import { X as XGMML_ISSUE, B as emitCytoscapeStyle, s as snapshotBlock, D as lossOf, f as XGMML_STYLE_CAPABILITIES, H as cytoscapeVizmapXml, Z as Z_COLUMN, g as XLINK_NAMESPACE, C as CY_NAMESPACE, h as XGMML_NAMESPACE, G as GRAPHICS_COLUMN, E as EDGE_ID_COLUMN, P as POSITION_COLUMN, k as PARENT_COLUMN, l as PARENTS_COLUMN, S as SUBGRAPH_COLUMN, N as NESTED_NETWORK_COLUMN, m as NETWORK_POINTER_COLUMN, n as NETWORKS_COLUMN, o as XGMML_ORIGIN_NAMESPACE, J as readXgmmlStyles, K as cytoscapeBackground, O as emptyCytoscapeStyle, Q as graphicsBypasses, R as resolveCytoscape, T as hiddenToVisible, U as exactFromBlock, V as cytoscapeRules, W as nonEmpty, Y as typedKey } from "./styles-_N-C8S-U.js";
+import { x as writeStyleBlock, y as styleBlockLosses, j as StyleNotes, S as STYLE_BLOCK_NAME, a as STYLE_ISSUE, Q as dataCell } from "./block-JQiwViEt.js";
+import { O as ORIGINAL_ID_ATTRIBUTE } from "./constants-BFUR_CtU.js";
+import { r as resolveSettings, m as membersOf, X as XgmmlEmitter, i as isCyTrue, p as parseXgmml, d as dialectOf, b as parseCoordinate } from "./importer-BFmOP96W.js";
+import { C as CsvRecordReader } from "./records-Nwz_rbNt.js";
 const FORMAT = "cys";
 const EXTENSIONS = Object.freeze([".cys"]);
 const MIME_TYPES = Object.freeze(["application/zip"]);
@@ -67,6 +70,7 @@ const CYS_ISSUE = Object.freeze({
   /** `graphName` matches several networks in the session. The import stops. */
   AMBIGUOUS_GRAPH_NAME: AMBIGUOUS_GRAPH_NAME_CODE
 });
+const STYLE_COLUMN_PREFIX = "graphty.style.";
 class ZipError extends Error {
   /**
    * Create the error.
@@ -644,6 +648,7 @@ const INTEGER = "java.lang.Integer";
 const LONG = "java.lang.Long";
 const BOOLEAN = "java.lang.Boolean";
 const I32_MAX = 2147483647;
+const CYS_STYLE_CAPABILITIES = Object.freeze({ ...XGMML_STYLE_CAPABILITIES, block: "native" });
 const ROOT_FOLDER = "CytoscapeSession/";
 const DEFAULT_NAME = "Network";
 const SUID_TEXT = /^[1-9]\d*$/;
@@ -1066,85 +1071,97 @@ function networkCandidates(snapshot, name) {
     out.push({ name: "description", source: null, javaClass: STRING, cell: () => description });
   }
   for (const column of snapshot.graph) {
-    out.push(candidateOf(column, column.meta.name));
+    if (column.meta.name !== STYLE_BLOCK_NAME) {
+      out.push(candidateOf(column, column.meta.name));
+    }
   }
   return out;
 }
-function plan(snapshot, common) {
+function addedCandidates(table, added) {
+  const out = [];
+  for (const [name, values] of added) {
+    if (table.has(name)) {
+      continue;
+    }
+    const kinds = new Set(values.filter((v) => v !== null).map((v) => typeof v));
+    const [kind] = kinds;
+    let javaClass = STRING;
+    if (kinds.size === 1 && kind === "number") {
+      javaClass = DOUBLE;
+    } else if (kinds.size === 1 && kind === "boolean") {
+      javaClass = BOOLEAN;
+    }
+    out.push({
+      name,
+      source: null,
+      javaClass,
+      cell: (row) => {
+        const v = values[row] ?? null;
+        if (v === null) {
+          return null;
+        }
+        return typeof v === "number" ? formatDecimal(v) : String(v);
+      }
+    });
+  }
+  return out;
+}
+function plan(snapshot, common, styles) {
   const notes = [];
   const note = (code, message, column = null, count = null) => {
     notes.push(Object.freeze({ code, message, column, count }));
   };
-  for (const gen of checkCapabilities(snapshot, CYS_CAPABILITIES, common, {
+  const generic = checkCapabilities(snapshot, CYS_CAPABILITIES, common, {
     roles: SLOT_ROLES,
     roleNames: ROLE_NAMES,
     positionDtype: "f64"
-  })) {
-    if (gen.code !== LOSS.JSON && gen.code !== LOSS.ID_CHARSET && gen.code !== LOSS.ID_MANGLED) {
-      notes.push(gen);
-    }
-  }
+  });
+  notes.push(...generic.filter((gen) => !SESSION_OWN_CODES.has(gen.code)));
   const ids = planIds(snapshot, common, note);
   const { nodeSuids, edgeSuids, mangled, fatal } = ids;
   let { next } = ids;
   const rootSuid = next++;
   const subSuid = next++;
   const folding = pairFolding(snapshot);
-  if (folding.mutualCount > 0) {
-    note(
-      LOSS.MUTUAL_EXPANDED,
-      `${folding.mutualCount} mutual pair${plural(folding.mutualCount)} ${agree(folding.mutualCount, "is", "are")} written as two directed edges; the mutual mark is lost`,
-      null,
-      folding.mutualCount
-    );
-  }
+  noteMutualPairs(folding.mutualCount, note);
   const position = snapshot.nodes.byRole("position");
   const z = [...snapshot.nodes].find(isZ) ?? null;
   const positionZ = position !== null && z === null;
   if (position !== null) {
     positionNotes(position, z, note);
   }
-  const placed = position !== null && position.nullCount < position.length || z !== null && z.nullCount < z.length;
-  const viewSuid = placed ? next++ : null;
+  const placed = holdsValues(position) || holdsValues(z);
+  const emitNotes = new StyleNotes();
+  const styled = styles === void 0 ? null : emitCytoscapeStyle(styles.rules, snapshot, { dialect: "desktop", notes: emitNotes });
+  const superseded = (c) => styled !== null && isKeptGraphics(c);
+  const viewSuid = placed || styled !== null ? next++ : null;
   const viewNodeBase = next;
-  const nodeOwn = mangled ? [
-    {
-      name: ORIGINAL_ID_ATTRIBUTE,
-      source: null,
-      javaClass: STRING,
-      // every node carries its original, so an empty id ("") is told apart from an unset cell
-      cell: (row) => String(snapshot.ids.idOf(row))
-    }
-  ] : [];
+  const nodeOwn = mangled ? [originalIdCandidate(snapshot)] : [];
   const nodeTable = planTable(
     "node",
-    elementCandidates(snapshot, "node", nodeOwn, (c) => placed && c === z, note),
+    [
+      ...elementCandidates(snapshot, "node", nodeOwn, (c) => placed && c === z || superseded(c), note),
+      ...styled === null ? [] : addedCandidates(snapshot.nodes, styled.columns.node)
+    ],
     snapshot.nodeCount,
     note
   );
-  const weights = explicitWeights(snapshot);
-  const plainWeight = snapshot.edges.get("weight");
-  if (plainWeight !== null && plainWeight.meta.role === null && !weights.weighted) {
-    note(LOSS.WEIGHT_KEY_CLASH, `edge column "weight" reads back as the edge weight`, "weight", null);
-  }
-  const edgeOwn = weights.weighted ? [
-    {
-      name: "weight",
-      source: null,
-      javaClass: DOUBLE,
-      cell: (e) => weights.isExplicit(e) ? formatDecimal(weights.value(e)) : null
-    }
-  ] : [];
+  const edgeOwn = weightCandidates(snapshot, note);
   const edgeRows = snapshot.edgeCount;
   const edgeTable = planTable(
     "edge",
-    elementCandidates(snapshot, "edge", edgeOwn, () => false, note),
+    [
+      ...elementCandidates(snapshot, "edge", edgeOwn, superseded, note),
+      ...styled === null ? [] : addedCandidates(snapshot.edges, styled.columns.edge)
+    ],
     edgeRows,
     note
   );
   const name = snapshot.meta.name ?? DEFAULT_NAME;
   const networkTable = planTable("network", networkCandidates(snapshot, name), 1, note);
   const rootTable = [{ name: "name", javaClass: STRING, cell: () => name }];
+  const inlineBlock = styles === void 0 ? null : writeStyleBlock(styles.rules, { inlineColumns: true, snapshot });
+  const blockNotes = inlineBlock === null ? [] : styleBlockLosses(inlineBlock, styles?.rules.styles.rules.length ?? 0, "size");
   return {
     notes,
     fatal,
@@ -1162,9 +1179,56 @@ function plan(snapshot, common) {
     rootTable,
     position,
     z: placed ? z : null,
-    positionZ
+    positionZ,
+    styled,
+    styleNotes: [...emitNotes.list().map(lossOf), ...blockNotes],
+    block: styles === void 0 ? snapshotBlock(snapshot) : inlineBlock
   };
 }
+const SESSION_OWN_CODES = /* @__PURE__ */ new Set([LOSS.JSON, LOSS.ID_CHARSET, LOSS.ID_MANGLED]);
+function noteMutualPairs(mutualCount, note) {
+  if (mutualCount > 0) {
+    note(
+      LOSS.MUTUAL_EXPANDED,
+      `${mutualCount} mutual pair${plural(mutualCount)} ${agree(mutualCount, "is", "are")} written as two directed edges; the mutual mark is lost`,
+      null,
+      mutualCount
+    );
+  }
+}
+function holdsValues(column) {
+  return column !== null && column.nullCount < column.length;
+}
+function isKeptGraphics(c) {
+  return c.dtype === "json" && c.meta.origin?.type === "graphics" && c.meta.origin.namespace === XGMML_ORIGIN_NAMESPACE;
+}
+function originalIdCandidate(snapshot) {
+  return {
+    name: ORIGINAL_ID_ATTRIBUTE,
+    source: null,
+    javaClass: STRING,
+    // every node carries its original, so an empty id ("") is told apart from an unset cell
+    cell: (row) => String(snapshot.ids.idOf(row))
+  };
+}
+function weightCandidates(snapshot, note) {
+  const weights = explicitWeights(snapshot);
+  const plainWeight = snapshot.edges.get("weight");
+  if (plainWeight !== null && plainWeight.meta.role === null && !weights.weighted) {
+    note(LOSS.WEIGHT_KEY_CLASH, `edge column "weight" reads back as the edge weight`, "weight", null);
+  }
+  if (!weights.weighted) {
+    return [];
+  }
+  return [
+    {
+      name: "weight",
+      source: null,
+      javaClass: DOUBLE,
+      cell: (e) => weights.isExplicit(e) ? formatDecimal(weights.value(e)) : null
+    }
+  ];
+}
 function positionNotes(position, z, note) {
   const { name, components } = position.meta;
   if (components !== 3) {
@@ -1210,7 +1274,7 @@ function sessionEscape(text) {
   return encodeURIComponent(wellFormed).replaceAll(/[!~'()]/g, (c) => `%${(c.codePointAt(0) ?? 0).toString(16).toUpperCase()}`).replaceAll("%20", "+").replaceAll("-", "%2D");
 }
 function* cyTable(title, columns, rows) {
-  const line = (cells) => `${cells.map((c) => quoteCsvCell(c)).join(",")}
+  const line = (cells) => `${cells.map((c) => c === null ? "" : quoteCsvCell(c)).join(",")}
 `;
   yield line(["CyCSV-Version", "1"]);
   yield line(["SUID", ...columns.map((c) => c.name)]);
@@ -1218,7 +1282,10 @@ function* cyTable(title, columns, rows) {
   yield line(["", ...columns.map(() => "mutable")]);
   yield line([title, ""]);
   for (const [suid, row] of rows) {
-    yield line([String(suid), ...columns.map((c) => c.cell(row) ?? "")]);
+    yield line([
+      String(suid),
+      ...columns.map((c) => c.cell(row) ?? (c.name.startsWith(STYLE_COLUMN_PREFIX) ? null : ""))
+    ]);
   }
 }
 const XML_DECLARATION = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n';
@@ -1247,21 +1314,48 @@ function* networkFile(snapshot, p) {
   yield "    </graph>\n  </att>\n</graph>\n";
 }
 function* viewFile(snapshot, p, viewSuid) {
+  const style = p.styled === null ? "default" : p.name;
   yield XML_DECLARATION;
-  yield `<graph id="${viewSuid}" label="${viewSuid}" cy:view="1" cy:networkId="${p.subSuid}" cy:visualStyle="default" cy:rendererId="org.cytoscape.ding" cy:documentVersion="3.0" ${NAMESPACES}>
+  yield `<graph id="${viewSuid}" label="${viewSuid}" cy:view="1" cy:networkId="${p.subSuid}" cy:visualStyle="${escapeXmlAttribute(style)}" cy:rendererId="org.cytoscape.ding" cy:documentVersion="3.0" ${NAMESPACES}>
 `;
   let view = p.viewNodeBase;
   for (let i = 0; i < snapshot.nodeCount; i++) {
     const coords = viewCoords(p, i);
-    if (coords.length > 0) {
+    const locked = p.styled?.bypasses.node[i] ?? null;
+    if (coords.length > 0 || locked !== null) {
       yield `  <node id="${view++}" cy:nodeId="${p.nodeSuids[i]}">
-    <graphics ${coords.join(" ")}/>
-  </node>
 `;
+      yield* viewGraphics(coords, locked);
+      yield "  </node>\n";
+    }
+  }
+  for (let e = 0; e < snapshot.edgeCount; e++) {
+    const locked = p.styled?.bypasses.edge[e] ?? null;
+    if (locked !== null && !p.folding.folded(e)) {
+      yield `  <edge id="${view++}" cy:edgeId="${p.edgeSuids[e]}">
+`;
+      yield* viewGraphics([], locked);
+      yield "  </edge>\n";
     }
   }
   yield "</graph>\n";
 }
+function* viewGraphics(coords, locked) {
+  const head = coords.length === 0 ? "    <graphics" : `    <graphics ${coords.join(" ")}`;
+  if (locked === null) {
+    yield `${head}/>
+`;
+    return;
+  }
+  yield `${head}>
+      <att name="lockedVisualProperties">
+`;
+  for (const [vp, value] of locked) {
+    yield `        <att name="${escapeXmlAttribute(vp)}" value="${escapeXmlAttribute(String(value))}" type="string" cy:type="String"/>
+`;
+  }
+  yield "      </att>\n    </graphics>\n";
+}
 function viewCoords(p, i) {
   const coords = [];
   if (p.position?.isSet(i) === true) {
@@ -1326,9 +1420,23 @@ function* entries(snapshot, p) {
       data: encode(viewFile(snapshot, p, p.viewSuid))
     };
   }
+  if (p.styled !== null) {
+    yield {
+      name: `${ROOT_FOLDER}session_vizmap.xml`,
+      data: encode([
+        XML_DECLARATION,
+        '<vizmap documentVersion="3.0" id="VizMap-graphty">\n',
+        cytoscapeVizmapXml(p.styled.style, p.name),
+        "\n</vizmap>\n"
+      ])
+    };
+  }
+  if (p.block !== null) {
+    yield { name: `${ROOT_FOLDER}${STYLE_BLOCK_NAME}`, data: new TextEncoder().encode(p.block) };
+  }
 }
 async function* write(snapshot, options) {
-  const p = plan(snapshot, resolveExportOptions(options));
+  const p = plan(snapshot, resolveExportOptions(options), options?.styles);
   await Promise.resolve();
   yield* writeZip(entries(snapshot, p));
 }
@@ -1336,6 +1444,7 @@ const cysExporter = Object.freeze({
   format: FORMAT,
   options: Object.freeze([]),
   capabilities: CYS_CAPABILITIES,
+  styles: Object.freeze({ capabilities: CYS_STYLE_CAPABILITIES }),
   /**
    * Pre-flight: what export() would lose, without writing anything.
    * @param snapshot - the snapshot
@@ -1343,7 +1452,8 @@ const cysExporter = Object.freeze({
    * @returns the notes, empty when the export is exact
    */
   check(snapshot, options) {
-    return Object.freeze([...plan(snapshot, resolveExportOptions(options)).notes]);
+    const p = plan(snapshot, resolveExportOptions(options), options?.styles);
+    return Object.freeze([...p.notes, ...p.styleNotes]);
   },
   /**
    * Write the session as zip bytes (stored entries, one at a time).
@@ -1528,6 +1638,7 @@ function layoutOf(zipEntries, report) {
     cysession: null,
     files: /* @__PURE__ */ new Map(),
     styles: [],
+    block: null,
     skipped: []
   };
   for (const [name, zip] of byName) {
@@ -1579,6 +1690,8 @@ function classify3(entry, layout) {
     layout.networkList = entry;
   } else if (/(^|\/)session_vizmap\.(xml|props)$/.test(path)) {
     layout.styles.push(entry);
+  } else if (path === STYLE_BLOCK_NAME) {
+    layout.block = entry;
   } else {
     layout.skipped.push(entry.name);
   }
@@ -1656,6 +1769,147 @@ function elementsNamed(node, name) {
   }
   return out;
 }
+function readSessionStyles(snapshot, context) {
+  const kept = context.kept;
+  if (kept?.era === "2") {
+    return readXgmmlStyles(snapshot, context, { tool: "cytoscape-fallbacks", hiddenColumn: HIDDEN_COLUMN });
+  }
+  const notes = new StyleNotes();
+  const style = sessionStyle(kept, notes);
+  const out = { node: { values: {} }, edge: { values: {} } };
+  for (const target of ["node", "edge"]) {
+    context.signal?.throwIfAborted();
+    out[target] = sessionTargetStyles(snapshot, target, style, { notes, budget: context.budget });
+  }
+  const background = cytoscapeBackground(style, notes);
+  return {
+    canonical: true,
+    dialect: "cytoscape",
+    tool: "cytoscape-fallbacks",
+    units: "px",
+    node: out.node,
+    edge: out.edge,
+    graph: background === null ? {} : { background },
+    notes: notes.list()
+  };
+}
+function sessionStyle(kept, notes) {
+  if (kept?.vizmap === null || kept?.vizmap === void 0) {
+    const problem = kept?.problem ?? null;
+    notes.add(problem === null ? STYLE_ISSUE.NO_VIZMAP : STYLE_ISSUE.UNREADABLE, null, "session_vizmap.xml", {
+      sample: problem ?? "absent"
+    });
+    return emptyCytoscapeStyle();
+  }
+  return cytoscapeStyleFromVizmap(kept.vizmap, kept.visualStyle, notes);
+}
+function sessionTargetStyles(snapshot, target, style, work) {
+  const { notes } = work;
+  const table = target === "node" ? snapshot.nodes : snapshot.edges;
+  const n = target === "node" ? snapshot.nodeCount : snapshot.edgeCount;
+  for (const m of style[target].mappings.values()) {
+    if (!table.has(m.column)) {
+      notes.add(STYLE_ISSUE.MAPPING_COLUMN_MISSING, target, m.column, { sample: m.kind });
+    }
+  }
+  const elements = {
+    count: n,
+    value: (column, i) => table.has(column) ? dataCell(table, column, i) : null,
+    bypasses: graphicsBypasses(table, target, n, notes)
+  };
+  const values = resolveCytoscape(target, style, elements, work);
+  hiddenToVisible(table, HIDDEN_COLUMN, n, values);
+  exactFromBlock(snapshot, target, values);
+  const { rules, columns } = cytoscapeRules(target, style, elements, work);
+  return { values: nonEmpty(values), rules, columns };
+}
+function cytoscapeStyleFromVizmap(root, name, notes) {
+  const style = emptyCytoscapeStyle();
+  const styles = root.children.filter((c) => c.name === "visualStyle");
+  let chosen = styles.find((s) => s.attrs.get("name") === name);
+  if (chosen === void 0) {
+    chosen = styles.at(0);
+    if (chosen === void 0) {
+      notes.add(STYLE_ISSUE.NO_VIZMAP, null, "visualStyle", { sample: "no visualStyle" });
+      return style;
+    }
+    notes.add(STYLE_ISSUE.VIEW_STYLE_MISSING, null, "visualStyle", { sample: String(name) });
+  }
+  if (styles.length > 1) {
+    notes.add(STYLE_ISSUE.OTHER_STYLES, null, "visualStyle", {
+      sample: `${styles.length - 1} unused`,
+      count: styles.length - 1
+    });
+  }
+  for (const kind of ["network", "node", "edge"]) {
+    const section = chosen.children.find((c) => c.name === kind);
+    for (const child of section?.children ?? []) {
+      readVizmapEntry(style, kind, child);
+    }
+  }
+  return style;
+}
+function readVizmapEntry(style, kind, child) {
+  const childName = child.attrs.get("name");
+  if (childName === void 0) {
+    return;
+  }
+  if (child.name === "dependency" && kind !== "network") {
+    style[kind].dependencies.set(childName, child.attrs.get("value")?.trim().toLowerCase() === "true");
+    return;
+  }
+  if (child.name !== "visualProperty") {
+    return;
+  }
+  const d = child.attrs.get("default");
+  if (d !== void 0) {
+    style[kind].defaults.set(childName, d);
+  }
+  if (kind !== "network") {
+    const mapping = vizmapMapping(child);
+    if (mapping !== null) {
+      style[kind].mappings.set(childName, mapping);
+    }
+  }
+}
+function vizmapMapping(vp) {
+  for (const m of vp.children) {
+    const column = m.attrs.get("attributeName");
+    if (column === void 0) {
+      continue;
+    }
+    const type = m.attrs.get("attributeType") ?? null;
+    if (m.name === "passthroughMapping") {
+      return { kind: "passthrough", column, type };
+    }
+    if (m.name === "discreteMapping") {
+      return { kind: "discrete", column, type, table: discreteTable(m, type) };
+    }
+    if (m.name === "continuousMapping") {
+      return { kind: "continuous", column, type, points: continuousPoints(m) };
+    }
+  }
+  return null;
+}
+function discreteTable(m, type) {
+  const table = [];
+  for (const e of m.children) {
+    const key = typedKey(e.attrs.get("attributeValue"), type);
+    const value = e.attrs.get("value");
+    if (e.name === "discreteMappingEntry" && key !== null && value !== void 0) {
+      table.push([key, value]);
+    }
+  }
+  return table;
+}
+function continuousPoints(m) {
+  return m.children.filter((p) => p.name === "continuousMappingPoint" && Number.isFinite(Number(p.attrs.get("attrValue")))).map((p) => ({
+    at: Number(p.attrs.get("attrValue")),
+    below: p.attrs.get("lesserValue"),
+    value: p.attrs.get("equalValue"),
+    above: p.attrs.get("greaterValue")
+  }));
+}
 const JAVA_TYPES = {
   "java.lang.String": "String",
   "java.lang.Long": "Long",
@@ -1665,70 +1919,92 @@ const JAVA_TYPES = {
 };
 const LIST_CLASS = /^java\.util\.List<\s*([\w.]+)\s*>$/;
 async function readCyTable(bytes, path, entry, report, common) {
+  const records = await tableRecords(bytes, common);
+  if (typeof records === "string") {
+    return tableError(report, entry, records);
+  }
+  const header = tableHeader(records);
+  if (typeof header === "string") {
+    return tableError(report, entry, header);
+  }
+  const columns = tableColumns(records[header.at].cells, records[header.at + 1].cells);
+  if (typeof columns === "string") {
+    return tableError(report, entry, columns);
+  }
+  const { rows, lines, quotedEmpty, problems } = tableRows(records.slice(header.at + header.lines), columns.length);
+  if (problems.short + problems.long + problems.repeated > 0) {
+    report.warning(
+      "parse-error",
+      CYS_ISSUE.TABLE_ROW,
+      `${entryLabel(entry)}: ${problems.short} row${plural(problems.short)} with too few cells (the rest are unset), ${problems.long} with too many (the extra cells are ignored), ${problems.repeated} repeating a key (the first row is read)`
+    );
+  }
+  return { path, entry, columns, rows, lines, quotedEmpty };
+}
+async function tableRecords(bytes, common) {
   const scratch = new ImportReportBuilder(FORMAT, 0);
   const reader = new CsvRecordReader(bytes, scratch, { delimiter: ",", encoding: "utf-8", signal: common.signal });
   const records = [];
   try {
     for await (const cells of reader) {
-      records.push({ cells, line: reader.line });
+      const empty = cells.flatMap((cell, i) => cell.length === 0 && reader.quoted[i] ? [i] : []);
+      records.push({ cells, line: reader.line, quotedEmpty: empty.length === 0 ? void 0 : new Set(empty) });
     }
   } catch (err) {
     if (err instanceof ImportError) {
-      return tableError(report, entry, scratch.issues.at(-1)?.message ?? err.message);
+      return scratch.issues.at(-1)?.message ?? err.message;
     }
     throw err;
   }
+  return records;
+}
+function tableHeader(records) {
   let at = 0;
   let version = 0;
   if (records[0]?.cells[0] === "CyCSV-Version") {
     const { cells } = records[0];
     if (cells.length !== 2 || !/^\d+$/.test(cells[1].trim())) {
-      return tableError(report, entry, `the version row ${JSON.stringify(cells)} does not parse`);
+      return `the version row ${JSON.stringify(cells)} does not parse`;
     }
     version = Number(cells[1]);
     at = 1;
   }
   if (version !== 0 && version !== 1) {
-    return tableError(report, entry, `CyCSV version "${records[0].cells[1]}" is not 0 or 1`);
+    return `CyCSV version "${records[0].cells[1]}" is not 0 or 1`;
   }
-  let headerLines = version === 1 ? 4 : 3;
-  if (records.length < at + headerLines - 1) {
-    return tableError(report, entry, "the table header is incomplete");
+  const lines = version === 1 ? 4 : 3;
+  if (records.length < at + lines - 1) {
+    return "the table header is incomplete";
   }
-  const beforeTitle = records[at + headerLines - 2];
-  const title = records.at(at + headerLines - 1);
-  if (title === void 0 || title.line > beforeTitle.line + 1 && !beforeTitle.cells.some((c) => /[\r\n]/.test(c))) {
-    headerLines--;
-  }
-  const names = records[at].cells;
-  const classes = records[at + 1].cells;
+  const beforeTitle = records[at + lines - 2];
+  const title = records.at(at + lines - 1);
+  const titleBlank = title === void 0 || title.line > beforeTitle.line + 1 && !beforeTitle.cells.some((c) => /[\r\n]/.test(c));
+  return { at, lines: titleBlank ? lines - 1 : lines };
+}
+function tableColumns(names, classes) {
   if (names.length === 0 || classes.length !== names.length) {
-    return tableError(
-      report,
-      entry,
-      `${names.length} column name${plural(names.length)} but ${classes.length} column class(es)`
-    );
+    return `${names.length} column name${plural(names.length)} but ${classes.length} column class(es)`;
   }
   const columns = [];
   for (let i = 0; i < names.length; i++) {
     const column = columnOf(names[i], classes[i]);
     if (column === null) {
-      return tableError(
-        report,
-        entry,
-        `column "${names[i]}" has the class "${classes[i]}", which graph-io cannot read`
-      );
+      return `column "${names[i]}" has the class "${classes[i]}", which graph-io cannot read`;
     }
     columns.push(column);
   }
+  return columns;
+}
+function tableRows(records, width) {
   const rows = /* @__PURE__ */ new Map();
   const lines = /* @__PURE__ */ new Map();
+  const quotedEmpty = /* @__PURE__ */ new Map();
   const problems = { short: 0, long: 0, repeated: 0 };
-  for (const record of records.slice(at + headerLines)) {
+  for (const record of records) {
     const { cells } = record;
-    if (cells.length < columns.length) {
+    if (cells.length < width) {
       problems.short++;
-    } else if (cells.length > columns.length) {
+    } else if (cells.length > width) {
       problems.long++;
     }
     const key = cells[0];
@@ -1736,17 +2012,13 @@ async function readCyTable(bytes, path, entry, report, common) {
       problems.repeated++;
       continue;
     }
-    rows.set(key, cells.slice(0, columns.length));
+    rows.set(key, cells.slice(0, width));
     lines.set(key, record.line);
+    if (record.quotedEmpty !== void 0) {
+      quotedEmpty.set(key, record.quotedEmpty);
+    }
   }
-  if (problems.short + problems.long + problems.repeated > 0) {
-    report.warning(
-      "parse-error",
-      CYS_ISSUE.TABLE_ROW,
-      `${entryLabel(entry)}: ${problems.short} row${plural(problems.short)} with too few cells (the rest are unset), ${problems.long} with too many (the extra cells are ignored), ${problems.repeated} repeating a key (the first row is read)`
-    );
-  }
-  return { path, entry, columns, rows, lines };
+  return { rows, lines, quotedEmpty, problems };
 }
 function columnOf(name, javaClass) {
   const scalar = JAVA_TYPES[javaClass.trim()];
@@ -1761,13 +2033,13 @@ function tableError(report, entry, reason) {
   report.error("parse-error", CYS_ISSUE.TABLE, `${entryLabel(entry)}: ${reason}; the table is not read`);
   return null;
 }
-function cellAtt(column, text, line, namespace, hidden) {
+function cellAtt(column, text, line, namespace, hidden, quoted = false) {
   const cell = { line, namespace, hidden };
   if (text.startsWith("=")) {
     return att(column.name, column.list ? "List" : column.type, null, text, true, cell);
   }
   if (!column.list) {
-    if (text.length === 0 && column.type !== "String") {
+    if (text.length === 0 && (column.type !== "String" || !quoted && column.name.startsWith(STYLE_COLUMN_PREFIX))) {
       return null;
     }
     return att(column.name, column.type, null, text, false, cell);
@@ -1785,10 +2057,10 @@ function cellAtt(column, text, line, namespace, hidden) {
   return list;
 }
 function javaSplitLines(text) {
-  if (!text.includes("\n")) {
+  if (!text.includes("\n") && !text.includes("\r")) {
     return [text];
   }
-  const items = text.split("\n");
+  const items = text.split(/\r\n|\r|\n/);
   while (items.at(-1)?.length === 0) {
     items.pop();
   }
@@ -2096,7 +2368,7 @@ async function import3(prepared, choice, sink, parsed) {
   const edges = byId(members.edges);
   const restore = saveRecords(graph, nodes, edges);
   try {
-    await fill3(prepared, choice, sink, parsed, nodes, edges);
+    return await fill3(prepared, choice, sink, parsed, nodes, edges);
   } finally {
     restore();
   }
@@ -2141,6 +2413,10 @@ async function fill3(prepared, choice, sink, parsed, nodes, edges) {
   }
   const restoredIds = inner.restoreMangledIds ? restoreIds(members.nodes) : /* @__PURE__ */ new Map();
   const { visualStyle, extraViews, extraIds } = await readViews(prepared, choice, nodes, edges);
+  const block = prepared.session.layout.block === null ? null : await entryText(prepared, prepared.session.layout.block);
+  if (block !== null) {
+    graph.atts.push(textAtt(STYLE_BLOCK_NAME, block));
+  }
   const cyMeta = sessionMeta(prepared, {
     collection: doc.root.label ?? choice.network.title,
     network: choice.graphId,
@@ -2174,6 +2450,7 @@ async function fill3(prepared, choice, sink, parsed, nodes, edges) {
   }
   reportRootOnly(parsed, report, choice.network.name);
   writeViewPositions(sink, extraViews, extraIds, report, prepared.inner, restoredIds);
+  return visualStyle;
 }
 function groupNodeIds(nodes) {
   return new Set(
@@ -2261,7 +2538,8 @@ function rowAtts(table, key, cells, namespace, hidden) {
   const line = table.lines.get(key) ?? 0;
   const out = [];
   for (let i = 1; i < table.columns.length && i < cells.length; i++) {
-    pushAtt(out, cellAtt(table.columns[i], cells[i], line, namespace, hidden));
+    const quoted = table.quotedEmpty?.get(key)?.has(i) === true;
+    pushAtt(out, cellAtt(table.columns[i], cells[i], line, namespace, hidden, quoted));
   }
   return out;
 }
@@ -2667,6 +2945,7 @@ async function import2(prepared, choice, sink) {
   };
   const settings = { labelAliases: true, cytoscapeEscapes: true, zAs: prepared.zAs };
   new XgmmlEmitter(doc, dialect, sink, report, inner, settings, extras).emit(null);
+  return cyMeta.visualStyle;
 }
 function idsIn(record, list) {
   const out = /* @__PURE__ */ new Set();
@@ -2738,15 +3017,82 @@ function sessionMeta(prepared, facts) {
 }
 async function importChoice(prepared, index, sink) {
   const choice = prepared.choices[index];
+  let visualStyle;
   if (choice.era === "3") {
     const parsed = prepared.docs.get(choice.network.name);
-    await import3(prepared, choice, sink, parsed);
+    visualStyle = await import3(prepared, choice, sink, parsed);
   } else {
-    await import2(prepared, choice, sink);
+    visualStyle = await import2(prepared, choice, sink);
   }
+  await keepStyleSource(prepared, index, visualStyle);
   throwIfAborted(prepared.common.signal);
   return prepared.report.finish();
 }
+async function keepStyleSource(prepared, index, visualStyle) {
+  const { layout } = prepared.session;
+  const entry = layout.styles.find((e) => e.path.endsWith("session_vizmap.xml"));
+  let vizmap = null;
+  let problem = null;
+  if (layout.era === "3" && entry !== void 0) {
+    const bytes = await entryBytes(prepared, entry);
+    const tree = typeof bytes === "string" ? bytes : await parseXmlTree(bytes, entry.name, new ImportReportBuilder(FORMAT, 0), prepared.inner);
+    if (typeof tree === "string") {
+      problem = tree;
+    } else {
+      vizmap = tree;
+    }
+  }
+  const source = {
+    era: layout.era,
+    vizmap,
+    problem,
+    visualStyle,
+    network: { index, name: prepared.choices[index].name }
+  };
+  prepared.report.keepForStyles(source);
+}
+async function entryBytes(prepared, entry) {
+  try {
+    return await prepared.session.read(entry, new ImportReportBuilder(FORMAT, 0));
+  } catch (err) {
+    if (err instanceof ImportError) {
+      return err.message;
+    }
+    throw err;
+  }
+}
+async function entryText(prepared, entry) {
+  const bytes = await entryBytes(prepared, entry);
+  if (typeof bytes === "string") {
+    return null;
+  }
+  try {
+    return await readText(bytes, new ImportReportBuilder(FORMAT, 0), { signal: prepared.common.signal });
+  } catch (err) {
+    if (err instanceof ImportError) {
+      return null;
+    }
+    throw err;
+  }
+}
+function textAtt(name, value) {
+  return {
+    name,
+    type: "string",
+    cyType: "String",
+    elementType: null,
+    value,
+    hidden: false,
+    equation: false,
+    children: [],
+    extra: {},
+    xml: null,
+    hasGraph: false,
+    text: "",
+    line: 0,
+    namespace: null
+  };
+}
 async function importCys(input, sink, options) {
   const prepared = await prepare(input, sink, options);
   const index = chooseGraph(
@@ -2813,7 +3159,8 @@ const cysImporter = Object.freeze({
   sniff: sniffCys,
   import: importCys,
   importAll: importAllCys,
-  listGraphs: listCysGraphs
+  listGraphs: listCysGraphs,
+  styles: readSessionStyles
 });
 export {
   CYS_CAPABILITIES as C,
@@ -2822,4 +3169,4 @@ export {
   cysExporter as c,
   cysImporter as d
 };
-//# sourceMappingURL=importer-WrGRZb0N.js.map
+//# sourceMappingURL=importer-B7r2owVf.js.map