@graphty/graph-io 0.3.25 → 0.3.26

package/dist/chunks/importer-90YWhJoF.js

@@ -0,0 +1,2811 @@
+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, bt 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, c0 as readBytes, a8 as ImportReportBuilder, a4 as textChunks, aT as ImportError, ao as reportSinkOptions, an as reportUnusedOptions, a7 as chooseGraph, ap as graphChosen, al as resolveImportOptions, c1 as elementCount, ar as IdCoercer, a1 as declareResolved } from "./export-BTI4yQgy.js";
+import { h as hasIllegalXmlChar, e as escapeXmlAttribute, o as quoteCsvCell, t as tokenizeXml, f as xmlDeclaredEncoding, X as XmlSyntaxError } from "./escape-D0g6NNUy.js";
+import { O as ORIGINAL_ID_ATTRIBUTE } from "./constants-BCsFsMj4.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, g as PARENT_COLUMN, h as PARENTS_COLUMN, S as SUBGRAPH_COLUMN, N as NESTED_NETWORK_COLUMN, e as NETWORK_POINTER_COLUMN, f 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-Bcl1d4xH.js";
+import { C as CsvRecordReader } from "./records-CQXT__mY.js";
+const FORMAT = "cys";
+const EXTENSIONS = Object.freeze([".cys"]);
+const MIME_TYPES = Object.freeze(["application/zip"]);
+const META_KEY = "cytoscape";
+const CYTOSCAPE_NAMESPACE = "cytoscape";
+const SELECTED_COLUMN = "cytoscape.selected";
+const HIDDEN_COLUMN = "cytoscape.hidden";
+const VIEW_POSITION_PREFIX = "position@";
+const DEFAULT_MAX_UNCOMPRESSED = 2 * 1024 * 1024 * 1024;
+const MAX_RATIO = 1e3;
+const RELAYED = Object.fromEntries(
+  Object.values(XGMML_ISSUE).map((code) => [code.replace(/^[EW]_/, ""), code])
+);
+const CYS_ISSUE = Object.freeze({
+  ...INPUT_ISSUE,
+  ...ELEMENT_ISSUE,
+  /** A session XML entry that is not UTF-8 and declares no encoding was read as windows-1252. */
+  ENCODING_FALLBACK: ENCODING_FALLBACK_CODE,
+  /** A session XML entry declares an encoding the platform cannot decode; read as UTF-8. */
+  UNKNOWN_ENCODING: UNKNOWN_ENCODING_CODE,
+  ...RELAYED,
+  /** The input is not a zip archive (or is text). */
+  NOT_ZIP: "E_CYS_NOT_ZIP",
+  /** The archive is damaged: no end record, offsets outside the file, a bad CRC, truncated data. */
+  CORRUPT: "E_CYS_CORRUPT",
+  /** A zip without a session marker (`<x.y.z>.version` or `cysession.xml`). */
+  NOT_SESSION: "E_CYS_NOT_SESSION",
+  /** A zip feature the reader does not support: encryption, a compression method, split archives. */
+  UNSUPPORTED: "E_CYS_UNSUPPORTED",
+  /** A session version graph-io cannot read: a major above 3, or the 2011 3.0 pre-release layout. */
+  VERSION: "E_CYS_VERSION",
+  /** A table or a virtual column that cannot be read at all; it is skipped. */
+  TABLE: "E_CYS_TABLE",
+  /** Table rows with too few or too many cells, a repeated key, or a key matching no element. */
+  TABLE_ROW: "W_CYS_TABLE_ROW",
+  /** The members of a collapsed group are not in the network itself; they are listed in `snapshot.meta.extra`. */
+  COLLAPSED_GROUP: "W_CYS_COLLAPSED_GROUP",
+  /** Entries the importer does not read (apps, global tables, properties, images, thumbnails). */
+  ENTRY_SKIPPED: "W_CYS_ENTRY_SKIPPED",
+  /** Two entries with one name; the first is read. */
+  DUPLICATE_ENTRY: "W_CYS_DUPLICATE_ENTRY",
+  /** A cysession.xml network record without an id, or naming a file an earlier record names. */
+  SESSION_RECORD: "W_CYS_SESSION_RECORD",
+  /** The archive inflates beyond maxUncompressedBytes, or an entry beyond the ratio limit. */
+  TOO_LARGE: TOO_LARGE_CODE,
+  /** The session's styles are not applied. */
+  STYLES_NOT_IMPORTED: STYLES_NOT_IMPORTED_CODE,
+  /** A view, table or network the session names but does not hold. */
+  DANGLING_REFERENCE: DANGLING_REFERENCE_CODE,
+  /** The input is empty. */
+  EMPTY_INPUT: EMPTY_INPUT_CODE,
+  /** The session holds no network. */
+  NO_GRAPH: NO_GRAPH_CODE,
+  /**
+   * The file holds several graphs and only the first was read. It is not added when `graphIndex` or `graphName` chose the graph.
+   * `importAllGraphs()` reads every one.
+   */
+  MULTIPLE_GRAPHS: MULTIPLE_GRAPHS_CODE,
+  /** `graphIndex` or `graphName` matches no network in the session. The import stops. */
+  GRAPH_NOT_FOUND: GRAPH_NOT_FOUND_CODE,
+  /** `graphName` matches several networks in the session. The import stops. */
+  AMBIGUOUS_GRAPH_NAME: AMBIGUOUS_GRAPH_NAME_CODE
+});
+class ZipError extends Error {
+  /**
+   * Create the error.
+   * @param kind - what went wrong
+   * @param message - a plain-ASCII message
+   */
+  constructor(kind, message) {
+    super(message);
+    this.name = "ZipError";
+    this.kind = kind;
+  }
+}
+const RATIO_FLOOR = 1024 * 1024;
+const EOCD_SIGNATURE = 101010256;
+const ZIP64_LOCATOR_SIGNATURE = 117853008;
+const ZIP64_EOCD_SIGNATURE = 101075792;
+const CENTRAL_SIGNATURE = 33639248;
+const LOCAL_SIGNATURE = 67324752;
+const EOCD_SIZE = 22;
+const MAX_COMMENT = 65535;
+const CENTRAL_SIZE = 46;
+const LOCAL_SIZE = 30;
+const ZIP64_EOCD_SIZE = 56;
+const ZIP64_LOCATOR_SIZE = 20;
+const U16_MAX = 65535;
+const U32_MAX = 4294967295;
+const UTF8_FLAG = 2048;
+const CRC_SLICE = 1024 * 1024;
+const METHOD_NAMES = {
+  1: "shrink",
+  6: "implode",
+  9: "deflate64",
+  12: "bzip2",
+  14: "LZMA",
+  93: "zstd",
+  95: "xz",
+  96: "JPEG",
+  97: "WavPack",
+  98: "PPMd",
+  99: "AES encryption"
+};
+function startsLikeZip(bytes) {
+  return bytes.byteLength >= 4 && bytes[0] === 80 && bytes[1] === 75 && bytes[2] === 3 && bytes[3] === 4;
+}
+function readZipDirectory(bytes) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const eocd = findEndRecord(bytes, view);
+  if (eocd < 0) {
+    throw startsLikeZip(bytes) ? new ZipError("corrupt", "the archive has no end of central directory record (truncated?)") : new ZipError("not-zip", "the input is not a zip archive");
+  }
+  let disk = view.getUint16(eocd + 4, true);
+  let directoryDisk = view.getUint16(eocd + 6, true);
+  let count = view.getUint16(eocd + 10, true);
+  let directorySize = view.getUint32(eocd + 12, true);
+  let directoryOffset = view.getUint32(eocd + 16, true);
+  let directoryEnd = eocd;
+  const locator = eocd - ZIP64_LOCATOR_SIZE;
+  if (locator >= 0 && view.getUint32(locator, true) === ZIP64_LOCATOR_SIGNATURE) {
+    const record = zip64EndRecord(view, locator);
+    disk = view.getUint32(record + 16, true);
+    directoryDisk = view.getUint32(record + 20, true);
+    count = readU64(view, record + 32);
+    directorySize = readU64(view, record + 40);
+    directoryOffset = readU64(view, record + 48);
+    directoryEnd = record;
+  } else if (count === U16_MAX || directorySize === U32_MAX || directoryOffset === U32_MAX) {
+    throw new ZipError("corrupt", "the end record needs a zip64 record the archive does not have");
+  }
+  if (disk !== 0 || directoryDisk !== 0) {
+    throw new ZipError("unsupported", "a split (multi-disk) archive cannot be read");
+  }
+  const start = directoryEnd - directorySize;
+  if (start < 0 || directoryOffset > bytes.byteLength) {
+    throw new ZipError("corrupt", "the central directory lies outside the archive");
+  }
+  const shift = start - directoryOffset;
+  if (shift < 0) {
+    throw new ZipError("corrupt", "the central directory offset does not match its position");
+  }
+  const entries2 = [];
+  let at = start;
+  for (let i = 0; i < count; i++) {
+    if (at + CENTRAL_SIZE > directoryEnd || view.getUint32(at, true) !== CENTRAL_SIGNATURE) {
+      throw new ZipError("corrupt", `central directory entry ${i + 1} of ${count} is damaged`);
+    }
+    const nameLength = view.getUint16(at + 28, true);
+    const extraLength = view.getUint16(at + 30, true);
+    const commentLength = view.getUint16(at + 32, true);
+    const next = at + CENTRAL_SIZE + nameLength + extraLength + commentLength;
+    if (next > directoryEnd) {
+      throw new ZipError("corrupt", `central directory entry ${i + 1} runs past the directory`);
+    }
+    const flags = view.getUint16(at + 8, true);
+    const name = decodeEntryName(
+      bytes.subarray(at + CENTRAL_SIZE, at + CENTRAL_SIZE + nameLength),
+      (flags & UTF8_FLAG) === 0
+    );
+    let compressedSize = view.getUint32(at + 20, true);
+    let size = view.getUint32(at + 24, true);
+    let localOffset = view.getUint32(at + 42, true);
+    if (compressedSize === U32_MAX || size === U32_MAX || localOffset === U32_MAX) {
+      ({ compressedSize, size, localOffset } = zip64Extra(view, at + CENTRAL_SIZE + nameLength, extraLength, {
+        compressedSize,
+        size,
+        localOffset
+      }));
+    }
+    entries2.push(
+      Object.freeze({
+        name,
+        method: view.getUint16(at + 10, true),
+        flags,
+        crc32: view.getUint32(at + 16, true),
+        compressedSize,
+        size,
+        localOffset: localOffset + shift,
+        directory: name.endsWith("/")
+      })
+    );
+    at = next;
+  }
+  if (at + 4 <= directoryEnd && view.getUint32(at, true) === CENTRAL_SIGNATURE) {
+    throw new ZipError(
+      "corrupt",
+      `the end record counts ${count} entries but the central directory holds more; entries would go unread`
+    );
+  }
+  checkOverlap(entries2, view);
+  return entries2;
+}
+function checkOverlap(entries2, view) {
+  const sorted = [...entries2].sort((a, b) => a.localOffset - b.localOffset);
+  const end = (entry) => {
+    const at = entry.localOffset;
+    const intact = at + LOCAL_SIZE <= view.byteLength && view.getUint32(at, true) === LOCAL_SIGNATURE;
+    const lengths = intact ? view.getUint16(at + 26, true) + view.getUint16(at + 28, true) : 0;
+    return at + LOCAL_SIZE + lengths + entry.compressedSize;
+  };
+  for (let i = 1; i < sorted.length; i++) {
+    const before = sorted[i - 1];
+    if (sorted[i].localOffset < end(before)) {
+      throw new ZipError("corrupt", `the entries ${before.name} and ${sorted[i].name} overlap`);
+    }
+  }
+}
+function findEndRecord(bytes, view) {
+  const lowest = Math.max(0, bytes.byteLength - EOCD_SIZE - MAX_COMMENT);
+  let fallback = -1;
+  for (let at = bytes.byteLength - EOCD_SIZE; at >= lowest; at--) {
+    if (view.getUint32(at, true) !== EOCD_SIGNATURE) {
+      continue;
+    }
+    if (at + EOCD_SIZE + view.getUint16(at + 20, true) === bytes.byteLength) {
+      return at;
+    }
+    if (fallback < 0) {
+      fallback = at;
+    }
+  }
+  return fallback;
+}
+function zip64EndRecord(view, locator) {
+  const stated = readU64(view, locator + 8);
+  for (const at of [stated, locator - ZIP64_EOCD_SIZE]) {
+    if (at >= 0 && at + ZIP64_EOCD_SIZE <= locator && view.getUint32(at, true) === ZIP64_EOCD_SIGNATURE) {
+      return at;
+    }
+  }
+  throw new ZipError("corrupt", "the zip64 end record the locator names is missing");
+}
+function zip64Extra(view, at, length, fields) {
+  const out = { ...fields };
+  for (let p = at; p + 4 <= at + length; ) {
+    const id = view.getUint16(p, true);
+    const dataLength = view.getUint16(p + 2, true);
+    if (id === 1) {
+      let q = p + 4;
+      const end = q + dataLength;
+      for (const key of ["size", "compressedSize", "localOffset"]) {
+        if (fields[key] === U32_MAX) {
+          if (q + 8 > end) {
+            throw new ZipError("corrupt", "a zip64 extra field is too short");
+          }
+          out[key] = readU64(view, q);
+          q += 8;
+        }
+      }
+      return out;
+    }
+    p += 4 + dataLength;
+  }
+  throw new ZipError("corrupt", "an entry needs a zip64 extra field it does not have");
+}
+function readU64(view, at) {
+  const high = view.getUint32(at + 4, true);
+  if (high >= 2097152) {
+    throw new ZipError("unsupported", "a zip64 size or offset beyond 2^53 cannot be read");
+  }
+  return high * 4294967296 + view.getUint32(at, true);
+}
+async function readZipEntry(bytes, entry, options) {
+  if ((entry.flags & 1) !== 0 || entry.method === 99) {
+    throw new ZipError("unsupported", `${entry.name}: the entry is encrypted`);
+  }
+  if (entry.method !== 0 && entry.method !== 8) {
+    const name = METHOD_NAMES[entry.method] ?? `method ${entry.method}`;
+    throw new ZipError(
+      "unsupported",
+      `${entry.name}: compression ${name} is not supported (only stored and deflate)`
+    );
+  }
+  if (entry.size > options.maxBytes) {
+    throw new ZipError(
+      "too-large",
+      `${entry.name}: ${entry.size} uncompressed bytes exceed the limit of ${options.maxBytes}`
+    );
+  }
+  if (entry.size > RATIO_FLOOR && entry.size > options.maxRatio * Math.max(entry.compressedSize, 1)) {
+    throw new ZipError(
+      "too-large",
+      `${entry.name}: ${entry.size} bytes from ${entry.compressedSize} is a compression ratio above ${options.maxRatio}:1`
+    );
+  }
+  const data = entryData(bytes, entry);
+  if (entry.method === 0) {
+    if (data.byteLength !== entry.size) {
+      throw new ZipError("corrupt", `${entry.name}: a stored entry's sizes disagree`);
+    }
+    let crc = 4294967295;
+    for (let at = 0; at < data.byteLength; at += CRC_SLICE) {
+      throwIfAborted(options.signal);
+      crc = crcUpdate(crc, data.subarray(at, Math.min(at + CRC_SLICE, data.byteLength)));
+      options.onBytes?.(Math.min(at + CRC_SLICE, data.byteLength));
+    }
+    if ((crc ^ 4294967295) >>> 0 !== entry.crc32) {
+      throw new ZipError("corrupt", `${entry.name}: the data does not match its CRC-32`);
+    }
+    return data;
+  }
+  return inflate(data, entry, options);
+}
+function entryData(bytes, entry) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const at = entry.localOffset;
+  if (at + LOCAL_SIZE > bytes.byteLength || view.getUint32(at, true) !== LOCAL_SIGNATURE) {
+    throw new ZipError("corrupt", `${entry.name}: the local header is missing`);
+  }
+  const nameLength = view.getUint16(at + 26, true);
+  const localName2 = decodeEntryName(
+    bytes.subarray(at + LOCAL_SIZE, Math.min(bytes.byteLength, at + LOCAL_SIZE + nameLength)),
+    (entry.flags & UTF8_FLAG) === 0
+  );
+  if (localName2 !== entry.name) {
+    throw new ZipError(
+      "corrupt",
+      `${entry.name}: the local header names the entry ${JSON.stringify(localName2)}, the central directory ${JSON.stringify(entry.name)}`
+    );
+  }
+  const start = at + LOCAL_SIZE + nameLength + view.getUint16(at + 28, true);
+  const end = start + entry.compressedSize;
+  if (end > bytes.byteLength) {
+    throw new ZipError("corrupt", `${entry.name}: the entry's data runs past the end of the archive (truncated?)`);
+  }
+  return bytes.subarray(start, end);
+}
+async function inflate(data, entry, options) {
+  if (typeof DecompressionStream !== "function") {
+    throw new ZipError(
+      "unsupported",
+      "this runtime has no DecompressionStream, so deflated entries cannot be read"
+    );
+  }
+  const member = new Uint8Array(10 + data.byteLength + 8);
+  member.set([31, 139, 8, 0, 0, 0, 0, 0, 0, 255]);
+  member.set(data, 10);
+  const trailer = new DataView(member.buffer, 10 + data.byteLength, 8);
+  trailer.setUint32(0, entry.crc32, true);
+  trailer.setUint32(4, entry.size % 4294967296, true);
+  const source = new ReadableStream({
+    start(controller) {
+      controller.enqueue(member);
+      controller.close();
+    }
+  });
+  const reader = source.pipeThrough(new DecompressionStream("gzip")).getReader();
+  const parts = [];
+  let total = 0;
+  try {
+    for (; ; ) {
+      throwIfAborted(options.signal);
+      let chunk;
+      try {
+        chunk = await reader.read();
+      } catch {
+        throw new ZipError(
+          "corrupt",
+          `${entry.name}: the deflate data is damaged or does not match its CRC-32 and size`
+        );
+      }
+      if (chunk.done) {
+        break;
+      }
+      total += chunk.value.byteLength;
+      if (total > entry.size) {
+        throw new ZipError("corrupt", `${entry.name}: the data is longer than its directory size`);
+      }
+      parts.push(chunk.value);
+      options.onBytes?.(total);
+    }
+  } finally {
+    await reader.cancel().catch(() => void 0);
+  }
+  if (total !== entry.size) {
+    throw new ZipError("corrupt", `${entry.name}: the data is shorter than its directory size`);
+  }
+  if (parts.length === 1) {
+    return parts[0];
+  }
+  const out = new Uint8Array(total);
+  let at = 0;
+  for (const part of parts) {
+    out.set(part, at);
+    at += part.byteLength;
+  }
+  return out;
+}
+const CRC_TABLE = (() => {
+  const table = new Uint32Array(256);
+  for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++) {
+      c = (c & 1) === 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+    }
+    table[n] = c >>> 0;
+  }
+  return table;
+})();
+function crcUpdate(crc, bytes) {
+  let c = crc;
+  for (const byte of bytes) {
+    c = CRC_TABLE[(c ^ byte) & 255] ^ c >>> 8;
+  }
+  return c >>> 0;
+}
+function crc32(bytes) {
+  return (crcUpdate(4294967295, bytes) ^ 4294967295) >>> 0;
+}
+const DOS_DATE = 0 << 9 | 1 << 5 | 1;
+const STORED_VERSION = 10;
+function* writeZip(entries2) {
+  const encoder = new TextEncoder();
+  const central = [];
+  let offset = 0;
+  let count = 0;
+  for (const entry of entries2) {
+    const name = encoder.encode(entry.name);
+    const { data } = entry;
+    if (offset + LOCAL_SIZE + name.byteLength + data.byteLength >= U32_MAX || count === U16_MAX) {
+      throw new GraphFormatError("E_TOO_LARGE", "the archive needs zip64, which graph-io does not write", {
+        entry: entry.name
+      });
+    }
+    const crc = crc32(data);
+    const local = new Uint8Array(LOCAL_SIZE + name.byteLength);
+    const lv = new DataView(local.buffer);
+    lv.setUint32(0, LOCAL_SIGNATURE, true);
+    lv.setUint16(4, STORED_VERSION, true);
+    lv.setUint16(6, UTF8_FLAG, true);
+    lv.setUint16(8, 0, true);
+    lv.setUint16(10, 0, true);
+    lv.setUint16(12, DOS_DATE, true);
+    lv.setUint32(14, crc, true);
+    lv.setUint32(18, data.byteLength, true);
+    lv.setUint32(22, data.byteLength, true);
+    lv.setUint16(26, name.byteLength, true);
+    lv.setUint16(28, 0, true);
+    local.set(name, LOCAL_SIZE);
+    const record = new Uint8Array(CENTRAL_SIZE + name.byteLength);
+    const cv = new DataView(record.buffer);
+    cv.setUint32(0, CENTRAL_SIGNATURE, true);
+    cv.setUint16(4, STORED_VERSION, true);
+    cv.setUint16(6, STORED_VERSION, true);
+    cv.setUint16(8, UTF8_FLAG, true);
+    cv.setUint16(10, 0, true);
+    cv.setUint16(12, 0, true);
+    cv.setUint16(14, DOS_DATE, true);
+    cv.setUint32(16, crc, true);
+    cv.setUint32(20, data.byteLength, true);
+    cv.setUint32(24, data.byteLength, true);
+    cv.setUint16(28, name.byteLength, true);
+    cv.setUint32(42, offset, true);
+    record.set(name, CENTRAL_SIZE);
+    central.push(record);
+    yield local;
+    if (data.byteLength > 0) {
+      yield data;
+    }
+    offset += local.byteLength + data.byteLength;
+    count++;
+  }
+  let size = 0;
+  for (const record of central) {
+    size += record.byteLength;
+    yield record;
+  }
+  const end = new Uint8Array(EOCD_SIZE);
+  const ev = new DataView(end.buffer);
+  ev.setUint32(0, EOCD_SIGNATURE, true);
+  ev.setUint16(8, count, true);
+  ev.setUint16(10, count, true);
+  ev.setUint32(12, size, true);
+  ev.setUint32(16, offset, true);
+  yield end;
+}
+const CYS_LOSS = Object.freeze({
+  /** CyCSV has no unset text cell: an unset cell of a text column reads back as "". */
+  UNSET_AS_EMPTY_STRING: "W_CYS_UNSET_AS_EMPTY_STRING",
+  /**
+   * List cells CyCSV cannot hold exactly: an unset or empty list of text reads back as [""], an
+   * empty list of numbers or booleans reads back unset, trailing empty text items vanish, and an
+   * item holding a newline splits in two.
+   */
+  LIST_ITEMS: "W_CYS_LIST_ITEMS",
+  /** A text cell starting with "=" is a formula to Cytoscape (an error cell there); graph-io reads it back as text. */
+  TEXT_AS_EQUATION: "W_CYS_TEXT_AS_EQUATION",
+  /** A nested (json) column is written as a text column holding its JSON text. */
+  JSON_AS_STRING: "W_CYS_JSON_AS_STRING",
+  /** A position that cannot be written as it is: another shape, a non-finite coordinate, a z read back in the z column. */
+  POSITION: "W_CYS_POSITION",
+  /**
+   * 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 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,
+  /** A mutual pair is written as two directed edges without its mark. */
+  MUTUAL_EXPANDED: LOSS.MUTUAL_EXPANDED,
+  /** Node ids that are numbers read back as their text. */
+  ID_TEXT_TYPE: LOSS.ID_TEXT_TYPE,
+  /**
+   * Two node ids would be written as the same text (the number 5 and the text "5"); the save fails with
+   * E_INVALID_ID.
+   */
+  ID_TEXT_COLLISION: LOSS.ID_TEXT_COLLISION,
+  /**
+   * 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 positive integers under sanitizeIds "mangle": renumbered, originals kept. */
+  ID_MANGLED: LOSS.ID_MANGLED,
+  /** Edges without a usable id get generated SUIDs. */
+  EDGE_IDS_GENERATED: LOSS.EDGE_IDS_GENERATED,
+  /**
+   * An attribute type Cytoscape stores as a wider one (a 32-bit float as Double, a byte as Integer), or a label that
+   * is not text and is written as text; it reads back with the Cytoscape type.
+   */
+  DTYPE_UNSUPPORTED: LOSS.DTYPE,
+  /** A column whose every cell is unset (and which is not text) vanishes. */
+  EMPTY_COLUMN_DROPPED: LOSS.EMPTY_COLUMN,
+  /**
+   * A text attribute reads back as a dictionary attribute, or the reverse, because the importer chooses by how often
+   * its values repeat. The values are the same.
+   */
+  STORAGE_CLASS_CHANGED: LOSS.STORAGE_CLASS,
+  /** A plain `weight` edge column reads back as the edge weight. */
+  WEIGHT_KEY_CLASH: LOSS.WEIGHT_KEY_CLASH,
+  /** A parent / parents column: groups are not written. */
+  HIERARCHY_DROPPED: LOSS.HIERARCHY,
+  /** A start / end / timestamp column: sessions have 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 extension table the session cannot carry. */
+  EXTENSION_TABLE_DROPPED: LOSS.EXTENSION_TABLE
+});
+const CYS_CAPABILITIES = capabilities({
+  mixedDirection: true,
+  multiEdges: true,
+  selfLoops: true,
+  edgeIds: "required",
+  idCharset: "integer",
+  dtypes: ["string", "dict", "f64", "i32", "bool", "list"],
+  components: false,
+  lists: true,
+  json: false,
+  defaults: false,
+  options: false,
+  hierarchy: false,
+  temporal: "none",
+  graphAttributes: true,
+  positions: true,
+  viz: false
+});
+const SLOT_ROLES = /* @__PURE__ */ new Set(["label", "id", "position"]);
+const ROLE_NAMES = Object.freeze({
+  label: "name",
+  id: EDGE_ID_COLUMN,
+  position: POSITION_COLUMN
+});
+const SKIPPED_ROLES = /* @__PURE__ */ new Set([
+  "directed",
+  "pair",
+  "mutual",
+  "weight",
+  "timeText",
+  "parent",
+  "parents",
+  "start",
+  "end",
+  "timestamp",
+  "timestamps",
+  "spells",
+  "open",
+  "spellsOpen",
+  "position",
+  "color",
+  "size",
+  "shape",
+  "thickness"
+]);
+const BUILT_IN = {
+  node: /* @__PURE__ */ new Map([
+    ["name", "java.lang.String"],
+    ["shared name", "java.lang.String"],
+    ["selected", "java.lang.Boolean"]
+  ]),
+  edge: /* @__PURE__ */ new Map([
+    ["name", "java.lang.String"],
+    ["shared name", "java.lang.String"],
+    ["interaction", "java.lang.String"],
+    ["shared interaction", "java.lang.String"],
+    ["selected", "java.lang.Boolean"]
+  ]),
+  network: /* @__PURE__ */ new Map([
+    ["name", "java.lang.String"],
+    ["shared name", "java.lang.String"],
+    ["selected", "java.lang.Boolean"],
+    ["__annotations", "java.util.List<java.lang.String>"]
+  ])
+};
+const IMPORTER_NAMES = {
+  node: /* @__PURE__ */ new Set([
+    POSITION_COLUMN,
+    Z_COLUMN,
+    GRAPHICS_COLUMN,
+    PARENT_COLUMN,
+    PARENTS_COLUMN,
+    SUBGRAPH_COLUMN,
+    NESTED_NETWORK_COLUMN,
+    NETWORK_POINTER_COLUMN,
+    NETWORKS_COLUMN
+  ]),
+  edge: /* @__PURE__ */ new Set([EDGE_ID_COLUMN, GRAPHICS_COLUMN]),
+  network: /* @__PURE__ */ new Set([GRAPHICS_COLUMN])
+};
+const STRING = "java.lang.String";
+const DOUBLE = "java.lang.Double";
+const INTEGER = "java.lang.Integer";
+const LONG = "java.lang.Long";
+const BOOLEAN = "java.lang.Boolean";
+const I32_MAX = 2147483647;
+const ROOT_FOLDER = "CytoscapeSession/";
+const DEFAULT_NAME = "Network";
+const SUID_TEXT = /^[1-9]\d*$/;
+function suidOf(id) {
+  if (typeof id === "number") {
+    return Number.isSafeInteger(id) && id > 0 ? id : null;
+  }
+  if (SUID_TEXT.test(id)) {
+    const n = Number(id);
+    return Number.isSafeInteger(n) ? n : null;
+  }
+  return null;
+}
+function keptNodeSuids(snapshot) {
+  const kept = [];
+  const bad = [];
+  const used = /* @__PURE__ */ new Set();
+  for (let i = 0; i < snapshot.nodeCount; i++) {
+    const suid = suidOf(snapshot.ids.idOf(i));
+    if (suid === null || used.has(suid)) {
+      kept.push(0);
+      bad.push(i);
+    } else {
+      used.add(suid);
+      kept.push(suid);
+    }
+  }
+  return { kept, bad };
+}
+function keptEdgeSuids(snapshot, nodeSuids) {
+  const column = snapshot.edges.byRole("id");
+  const out = new Array(snapshot.edgeCount).fill(0);
+  if (column === null) {
+    return out;
+  }
+  const used = /* @__PURE__ */ new Set();
+  for (let e = 0; e < snapshot.edgeCount; e++) {
+    const value = column.isSet(e) ? column.value(e) : null;
+    const suid = typeof value === "number" || typeof value === "string" ? suidOf(value) : null;
+    if (suid !== null && !used.has(suid) && !nodeSuids.has(suid)) {
+      used.add(suid);
+      out[e] = suid;
+    }
+  }
+  return out;
+}
+function scalarClass(column, dtype) {
+  switch (dtype) {
+    case "bool":
+      return BOOLEAN;
+    case "i32":
+    case "u8":
+      return INTEGER;
+    case "u32":
+      return maxValue(column) > I32_MAX ? LONG : INTEGER;
+    case "f32":
+    case "f64":
+      return /long$/i.test(column.meta.origin?.type ?? "") && allSafeIntegers(column) ? LONG : DOUBLE;
+    default:
+      return STRING;
+  }
+}
+function itemsOf(column, row) {
+  return column.dtype === "list" ? [...column.sliceOf(row)] : [column.value(row)];
+}
+function allSafeIntegers(column) {
+  for (let r = 0; r < column.length; r++) {
+    if (column.isSet(r) && !itemsOf(column, r).every((v) => typeof v === "number" && Number.isSafeInteger(v))) {
+      return false;
+    }
+  }
+  return true;
+}
+function maxValue(column) {
+  let max = 0;
+  for (let r = 0; r < column.length; r++) {
+    if (column.isSet(r)) {
+      for (const v of itemsOf(column, r)) {
+        if (typeof v === "number" && v > max) {
+          max = v;
+        }
+      }
+    }
+  }
+  return max;
+}
+function valueText(value, javaClass, dtype) {
+  if (javaClass === BOOLEAN) {
+    return value === true ? "true" : "false";
+  }
+  if (javaClass === DOUBLE) {
+    return formatDecimal(value, dtype === "f32" ? "f32" : "f64");
+  }
+  if (javaClass === INTEGER || javaClass === LONG) {
+    return String(value);
+  }
+  return textOf(value);
+}
+function textOf(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number") {
+    return formatF64(value);
+  }
+  if (typeof value === "boolean") {
+    return value ? "true" : "false";
+  }
+  if (ArrayBuffer.isView(value)) {
+    return JSON.stringify(Array.from(value).map(finiteOrText));
+  }
+  return JSON.stringify(value) ?? "";
+}
+function finiteOrText(v) {
+  return Number.isFinite(v) ? v : String(v);
+}
+function candidateOf(column, name) {
+  const { meta } = column;
+  if (column.dtype === "list") {
+    const item = meta.itemDtype;
+    const itemClass = scalarClass(column, item === "json" ? null : item);
+    return {
+      name,
+      source: column,
+      javaClass: `java.util.List<${itemClass}>`,
+      cell: (row) => column.isSet(row) ? [...column.sliceOf(row)].map((v) => valueText(v, itemClass, item)).join("\n") : null
+    };
+  }
+  const javaClass = meta.dtype === "json" || meta.components > 1 ? STRING : scalarClass(column, meta.dtype);
+  return {
+    name,
+    source: column,
+    javaClass,
+    cell: (row) => column.isSet(row) ? valueText(column.value(row), javaClass, meta.dtype) : null
+  };
+}
+function settleNames(domain, candidates, note) {
+  const taken = /* @__PURE__ */ new Set(["suid"]);
+  const out = [];
+  for (const c of candidates) {
+    const lower = c.name.toLowerCase();
+    const builtIn = BUILT_IN[domain].get(lower);
+    let { name } = c;
+    const clash = builtIn !== void 0 && builtIn !== c.javaClass ? builtIn : null;
+    if (taken.has(lower) || clash !== null) {
+      let k = 2;
+      while (taken.has(`${lower}#${k}`)) {
+        k++;
+      }
+      name = `${c.name}#${k}`;
+      const why = renameReason(lower, clash);
+      const set = c.source === null ? null : c.source.length - c.source.nullCount;
+      note(LOSS.COLUMN_NAME_CHANGED, `${domain} column "${c.name}" is written as "${name}": ${why}`, c.name, set);
+    } else if (c.source !== null && IMPORTER_NAMES[domain].has(c.name)) {
+      note(
+        LOSS.COLUMN_NAME_CHANGED,
+        `${domain} column "${c.name}" is written to the session's table and reads back as "${c.name}#2": graph-io's session reader makes a "${c.name}" column of its own`,
+        c.name,
+        c.source.length - c.source.nullCount
+      );
+    }
+    taken.add(name.toLowerCase());
+    out.push({ name, javaClass: c.javaClass, cell: c.cell });
+  }
+  return out;
+}
+function renameReason(lower, clash) {
+  if (lower === "suid") {
+    return "SUID is Cytoscape's key column";
+  }
+  if (clash !== null) {
+    return `Cytoscape's own "${lower}" column holds ${clash}`;
+  }
+  return "its name is taken (Cytoscape column names ignore case)";
+}
+function javaSplit(text) {
+  if (!text.includes("\n")) {
+    return [text];
+  }
+  const items = text.split("\n");
+  while (items.at(-1) === "") {
+    items.pop();
+  }
+  return items;
+}
+function cellNotes(domain, c, rows, note) {
+  const { source } = c;
+  if (source === null) {
+    return;
+  }
+  const label = `${domain} column "${source.meta.name}"`;
+  const { name } = source.meta;
+  const text = c.javaClass === STRING;
+  const { unset, equations, lists, set, heuristic } = cellCounts(c, source, rows);
+  if (source.dtype === "json") {
+    note(CYS_LOSS.JSON_AS_STRING, `${label} holds nested values; written as their JSON text`, name, set);
+  }
+  if (set === 0 && (!text || rows === 0)) {
+    note(LOSS.EMPTY_COLUMN, `${label} has no value; it is not in the re-import`, name, null);
+    return;
+  }
+  if (text && unset > 0) {
+    note(
+      CYS_LOSS.UNSET_AS_EMPTY_STRING,
+      `${label}: ${unset} unset cell${plural(unset)} ${agree(unset, "is", "are")} written empty and read back as ""`,
+      name,
+      unset
+    );
+  }
+  if (lists > 0) {
+    note(
+      CYS_LOSS.LIST_ITEMS,
+      `${label}: ${lists} list cell${plural(lists)} ${agree(lists, "reads", "read")} back changed (an unset or empty list of text as [""], an empty list of numbers unset, trailing empty items dropped, items holding a newline split)`,
+      name,
+      lists
+    );
+  }
+  if (equations > 0) {
+    note(
+      CYS_LOSS.TEXT_AS_EQUATION,
+      `${label}: ${equations} cell${plural(equations)} start with "=", which Cytoscape reads as a formula (an error cell); graph-io reads them back as text`,
+      name,
+      equations
+    );
+  }
+  if (text && (source.dtype === "string" || source.dtype === "dict")) {
+    const readsAs = heuristic.decide();
+    if (readsAs !== source.dtype) {
+      note(LOSS.STORAGE_CLASS, `${label} reads back as ${readsAs} (the cardinality heuristic)`, name, null);
+    }
+  }
+}
+function cellCounts(c, source, rows) {
+  const text = c.javaClass === STRING;
+  const stringList = c.javaClass === `java.util.List<${STRING}>`;
+  const counts = { unset: 0, equations: 0, lists: 0, set: 0, heuristic: new DictHeuristic() };
+  for (let r = 0; r < rows; r++) {
+    const cell = c.cell(r);
+    if (cell === null) {
+      counts.unset++;
+    } else {
+      counts.set++;
+    }
+    const written = cell ?? "";
+    if (text && !counts.heuristic.decided) {
+      counts.heuristic.observe(written);
+    }
+    if (written.startsWith("=")) {
+      counts.equations++;
+    } else if (source.dtype === "list" && listChanges(source, r, cell, stringList)) {
+      counts.lists++;
+    }
+  }
+  return counts;
+}
+function listChanges(source, r, cell, stringList) {
+  const written = cell ?? "";
+  let back = null;
+  if (stringList) {
+    back = written.length === 0 ? [""] : javaSplit(written);
+  } else if (written.length > 0) {
+    back = javaSplit(written).filter((item) => item.length > 0);
+  }
+  const items = cell === null ? null : [...source.sliceOf(r)].map((v) => valueText(v, "", null));
+  if (back === null || items === null) {
+    return back !== items;
+  }
+  return back.length !== items.length || stringList && back.some((b, i) => b !== items[i]);
+}
+function isZ(column) {
+  return column.meta.name === Z_COLUMN && column.meta.dtype === "f64" && column.meta.role === null;
+}
+function elementCandidates(snapshot, domain, own, skip, note) {
+  const table = domain === "node" ? snapshot.nodes : snapshot.edges;
+  const label = table.byRole("label");
+  const out = [];
+  if (label !== null) {
+    const c = candidateOf(label, "name");
+    out.push({ ...c, javaClass: STRING, cell: (row) => label.isSet(row) ? textOf(label.value(row)) : null });
+    if (label.dtype !== "string" && label.dtype !== "dict") {
+      note(
+        LOSS.DTYPE,
+        `${domain} label column "${label.meta.name}" (${label.dtype}) is written as text and reads back as string`,
+        label.meta.name,
+        label.length - label.nullCount
+      );
+    }
+  }
+  out.push(...own);
+  for (const column of table) {
+    const { role } = column.meta;
+    if (column === label || role !== null && (SKIPPED_ROLES.has(role) || role === "id") || skip(column)) {
+      continue;
+    }
+    out.push(candidateOf(column, column.meta.name));
+    if (label === null && role === null && column.meta.name === "name" && scalarClass(column, column.dtype) === STRING) {
+      note(
+        LOSS.ROLE_ASSUMED,
+        `${domain} column "name" is Cytoscape's name and reads back as the label`,
+        "name",
+        column.length - column.nullCount
+      );
+    }
+  }
+  return out;
+}
+function planTable(domain, candidates, rows, note) {
+  for (const c of candidates) {
+    cellNotes(domain, c, rows, note);
+  }
+  return settleNames(domain, candidates, note);
+}
+function idTextNotes(snapshot, note) {
+  let collisions = 0;
+  let numeric = 0;
+  const texts = /* @__PURE__ */ new Set();
+  for (let i = 0; i < snapshot.nodeCount; i++) {
+    const id = snapshot.ids.idOf(i);
+    numeric += typeof id === "number" ? 1 : 0;
+    const text = String(id);
+    if (texts.has(text)) {
+      collisions++;
+    }
+    texts.add(text);
+  }
+  let fatal = null;
+  if (collisions > 0) {
+    note(
+      LOSS.ID_TEXT_COLLISION,
+      `${collisions} node id${plural(collisions)} ${agree(collisions, "shares", "share")} their text with another id (a number and a string); the save fails with E_INVALID_ID`,
+      null,
+      collisions
+    );
+    fatal = new GraphFormatError(
+      "E_INVALID_ID",
+      `${collisions} node id${plural(collisions)} ${agree(collisions, "shares", "share")} their text with another id`,
+      { reason: "collision", count: collisions }
+    );
+  }
+  if (numeric > 0) {
+    note(
+      LOSS.ID_TEXT_TYPE,
+      `${numeric} numeric node id${plural(numeric)} ${agree(numeric, "reads", "read")} back as their text`,
+      null,
+      numeric
+    );
+  }
+  return fatal;
+}
+function badIdNotes(snapshot, bad, mangle, note) {
+  if (mangle) {
+    note(
+      LOSS.ID_MANGLED,
+      `${bad.length} node id${plural(bad.length)} that ${agree(bad.length, "is", "are")} not positive integers ${agree(bad.length, "is", "are")} renumbered, since Cytoscape ids are positive integers; the originals are kept in the "${ORIGINAL_ID_ATTRIBUTE}" column (restored by restoreMangledIds)`,
+      null,
+      bad.length
+    );
+    return null;
+  }
+  note(
+    LOSS.ID_CHARSET,
+    `${bad.length} node id${plural(bad.length)} ${agree(bad.length, "is", "are")} not positive integers, which Cytoscape requires; the save fails unless sanitizeIds is "mangle"`,
+    null,
+    bad.length
+  );
+  const first = snapshot.ids.idOf(bad[0]);
+  return new GraphFormatError(
+    "E_INVALID_ID",
+    `${bad.length} node id${plural(bad.length)} cannot be written as Cytoscape ids, which are positive integers (first: ${JSON.stringify(first)} at index ${bad[0]}); pass sanitizeIds: "mangle" to rewrite them`,
+    { reason: "charset", charset: "integer", count: bad.length, index: bad[0] }
+  );
+}
+function planIds(snapshot, common, note) {
+  const { kept, bad } = keptNodeSuids(snapshot);
+  const collision = idTextNotes(snapshot, note);
+  const charset = bad.length > 0 ? badIdNotes(snapshot, bad, common.sanitizeIds === "mangle", note) : null;
+  const fatal = collision ?? charset;
+  const nodeSet = new Set(kept.filter((s) => s > 0));
+  const edgeKept = keptEdgeSuids(snapshot, nodeSet);
+  let next = 1;
+  for (const s of [...nodeSet, ...edgeKept]) {
+    next = Math.max(next, s + 1);
+  }
+  const nodeSuids = kept.map((s) => s > 0 ? s : next++);
+  const idColumn = snapshot.edges.byRole("id");
+  let generated = 0;
+  const edgeSuids = edgeKept.map((s) => {
+    if (s > 0) {
+      return s;
+    }
+    generated++;
+    return next++;
+  });
+  if (idColumn !== null && generated > 0) {
+    note(
+      LOSS.EDGE_IDS_GENERATED,
+      `${generated} edge${plural(generated)} ${agree(generated, "has", "have")} no distinct positive integer id in "${idColumn.meta.name}"; they are written with new positive integer ids`,
+      idColumn.meta.name,
+      generated
+    );
+  }
+  if (idColumn !== null && idColumn.dtype !== "string") {
+    note(
+      LOSS.DTYPE,
+      `edge id column "${idColumn.meta.name}" is ${idColumn.dtype}; edge ids read back as text`,
+      idColumn.meta.name,
+      snapshot.edgeCount - idColumn.nullCount
+    );
+  }
+  return { nodeSuids, edgeSuids, next, fatal, mangled: common.sanitizeIds === "mangle" && bad.length > 0 };
+}
+function networkCandidates(snapshot, name) {
+  const out = [];
+  const graphName = snapshot.graph.get("name");
+  if (graphName === null || graphName.dtype !== "string" && graphName.dtype !== "dict") {
+    out.push({ name: "name", source: null, javaClass: STRING, cell: () => name });
+  }
+  const { description } = snapshot.meta;
+  if (description !== null && snapshot.graph.get("description") === null) {
+    out.push({ name: "description", source: null, javaClass: STRING, cell: () => description });
+  }
+  for (const column of snapshot.graph) {
+    out.push(candidateOf(column, column.meta.name));
+  }
+  return out;
+}
+function plan(snapshot, common) {
+  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, {
+    roles: SLOT_ROLES,
+    roleNames: ROLE_NAMES,
+    positionDtype: "f32"
+  })) {
+    if (gen.code !== LOSS.JSON && gen.code !== LOSS.ID_CHARSET && gen.code !== LOSS.ID_MANGLED) {
+      notes.push(gen);
+    }
+  }
+  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
+    );
+  }
+  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 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 nodeTable = planTable(
+    "node",
+    elementCandidates(snapshot, "node", nodeOwn, (c) => placed && c === z, note),
+    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 edgeRows = snapshot.edgeCount;
+  const edgeTable = planTable(
+    "edge",
+    elementCandidates(snapshot, "edge", edgeOwn, () => false, note),
+    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 }];
+  return {
+    notes,
+    fatal,
+    nodeSuids,
+    edgeSuids,
+    rootSuid,
+    subSuid,
+    viewSuid,
+    viewNodeBase,
+    name,
+    folding,
+    nodeTable,
+    edgeTable,
+    networkTable,
+    rootTable,
+    position,
+    z: placed ? z : null,
+    positionZ
+  };
+}
+function positionNotes(position, z, note) {
+  const { name, components } = position.meta;
+  if (components !== 3) {
+    note(
+      CYS_LOSS.POSITION,
+      `position column "${name}" has ${components} component${plural(components)} and reads back with 3`,
+      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(
+      CYS_LOSS.POSITION,
+      `${nonFinite} position${plural(nonFinite)} with a non-finite coordinate ${agree(nonFinite, "is", "are")} not written`,
+      name,
+      nonFinite
+    );
+  }
+  if (depth > 0) {
+    note(
+      CYS_LOSS.POSITION,
+      z === null ? `${depth} position${plural(depth)} ${agree(depth, "has", "have")} a z; it is written as the view's z and reads back in the z column` : `${depth} position${plural(depth)} ${agree(depth, "has", "have")} a z, but the view's z holds the z column; the position z is lost`,
+      name,
+      depth
+    );
+  }
+}
+function sessionEscape(text) {
+  const wellFormed = text.replaceAll(new RegExp("[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?<![\\uD800-\\uDBFF])[\\uDC00-\\uDFFF]", "g"), "�");
+  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(",")}
+`;
+  yield line(["CyCSV-Version", "1"]);
+  yield line(["SUID", ...columns.map((c) => c.name)]);
+  yield line([LONG, ...columns.map((c) => c.javaClass)]);
+  yield line(["", ...columns.map(() => "mutable")]);
+  yield line([title, ""]);
+  for (const [suid, row] of rows) {
+    yield line([String(suid), ...columns.map((c) => c.cell(row) ?? "")]);
+  }
+}
+const XML_DECLARATION = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n';
+const NAMESPACES = `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}"`;
+function* networkFile(snapshot, p) {
+  const label = !hasIllegalXmlChar(p.name) ? ` label="${escapeXmlAttribute(p.name)}"` : "";
+  yield XML_DECLARATION;
+  yield `<graph id="${p.rootSuid}"${label} directed="${snapshot.directed ? "1" : "0"}" cy:view="0" cy:registered="0" cy:documentVersion="3.0" ${NAMESPACES}>
+`;
+  yield `  <att>
+    <graph id="${p.subSuid}"${label} cy:registered="1">
+`;
+  for (let i = 0; i < snapshot.nodeCount; i++) {
+    yield `      <node id="${p.nodeSuids[i]}"/>
+`;
+  }
+  const { src, dst } = snapshot.edgeList();
+  for (let e = 0; e < snapshot.edgeCount; e++) {
+    if (p.folding.folded(e)) {
+      continue;
+    }
+    const directed = snapshot.directed && p.folding.sourceDirected(e);
+    yield `      <edge id="${p.edgeSuids[e]}" source="${p.nodeSuids[src[e]]}" target="${p.nodeSuids[dst[e]]}" cy:directed="${directed ? "1" : "0"}"/>
+`;
+  }
+  yield "    </graph>\n  </att>\n</graph>\n";
+}
+function* viewFile(snapshot, p, viewSuid) {
+  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}>
+`;
+  let view = p.viewNodeBase;
+  for (let i = 0; i < snapshot.nodeCount; i++) {
+    const coords = viewCoords(p, i);
+    if (coords.length > 0) {
+      yield `  <node id="${view++}" cy:nodeId="${p.nodeSuids[i]}">
+    <graphics ${coords.join(" ")}/>
+  </node>
+`;
+    }
+  }
+  yield "</graph>\n";
+}
+function viewCoords(p, i) {
+  const coords = [];
+  if (p.position?.isSet(i) === true) {
+    const [x, y, z] = Array.from(p.position.value(i));
+    if (Number.isFinite(x) && Number.isFinite(y)) {
+      coords.push(`x="${formatF32(x)}"`, `y="${formatF32(y === 0 ? 0 : -y)}"`);
+    }
+    if (Number.isFinite(x) && Number.isFinite(y) && p.positionZ && z !== void 0 && z !== 0 && Number.isFinite(z)) {
+      coords.push(`z="${formatF32(z)}"`);
+    }
+  }
+  if (p.z?.isSet(i) === true) {
+    coords.push(`z="${formatDecimal(p.z.value(i))}"`);
+  }
+  return coords;
+}
+function encode(parts) {
+  let text = "";
+  for (const part of parts) {
+    text += part;
+  }
+  return new TextEncoder().encode(text);
+}
+function* entries(snapshot, p) {
+  if (p.fatal !== null) {
+    throw p.fatal;
+  }
+  const name = sessionEscape(p.name);
+  const tables = `${ROOT_FOLDER}tables/${p.subSuid}-${name}/LOCAL_ATTRS-org.cytoscape.model.`;
+  const rowsOf = (suids, skip) => suids.flatMap((suid, row) => skip?.(row) === true ? [] : [[suid, row]]);
+  const nodeTable = `${p.name} default node`;
+  const edgeTable = `${p.name} default edge`;
+  const networkTable = `${p.name} default network`;
+  yield { name: `${ROOT_FOLDER}3.0.0.version`, data: new Uint8Array(0) };
+  yield { name: `${ROOT_FOLDER}networks/${p.rootSuid}-${name}.xgmml`, data: encode(networkFile(snapshot, p)) };
+  yield {
+    name: `${tables}CyNode-${sessionEscape(nodeTable)}.cytable`,
+    data: encode(cyTable(nodeTable, p.nodeTable, rowsOf(p.nodeSuids)))
+  };
+  yield {
+    name: `${tables}CyEdge-${sessionEscape(edgeTable)}.cytable`,
+    data: encode(
+      cyTable(
+        edgeTable,
+        p.edgeTable,
+        rowsOf(p.edgeSuids, (e) => p.folding.folded(e))
+      )
+    )
+  };
+  yield {
+    name: `${tables}CyNetwork-${sessionEscape(networkTable)}.cytable`,
+    data: encode(cyTable(networkTable, p.networkTable, [[p.subSuid, 0]]))
+  };
+  yield {
+    name: `${ROOT_FOLDER}tables/${p.rootSuid}-${name}/LOCAL_ATTRS-org.cytoscape.model.CyNetwork-${p.rootSuid}+default+network.cytable`,
+    data: encode(cyTable(`${p.rootSuid} default network`, p.rootTable, [[p.rootSuid, 0]]))
+  };
+  if (p.viewSuid !== null) {
+    yield {
+      name: `${ROOT_FOLDER}views/${p.subSuid}-${p.viewSuid}-${name}.xgmml`,
+      data: encode(viewFile(snapshot, p, p.viewSuid))
+    };
+  }
+}
+async function* write(snapshot, options) {
+  const p = plan(snapshot, resolveExportOptions(options));
+  await Promise.resolve();
+  yield* writeZip(entries(snapshot, p));
+}
+const cysExporter = Object.freeze({
+  format: FORMAT,
+  options: Object.freeze([]),
+  capabilities: CYS_CAPABILITIES,
+  /**
+   * Pre-flight: what export() would lose, without writing anything.
+   * @param snapshot - the snapshot
+   * @param options - the common options
+   * @returns the notes, empty when the export is exact
+   */
+  check(snapshot, options) {
+    return Object.freeze([...plan(snapshot, resolveExportOptions(options)).notes]);
+  },
+  /**
+   * Write the session as zip bytes (stored entries, one at a time).
+   * @param snapshot - the snapshot
+   * @param options - the common options
+   * @returns the bytes
+   */
+  export(snapshot, options) {
+    return write(snapshot, options);
+  },
+  /**
+   * A session is a zip archive, not text: always rejects with E_UNSUPPORTED (use exportGraphToBytes() or exportGraphToBlob()).
+   * @returns never
+   */
+  exportToString() {
+    return Promise.reject(
+      new GraphFormatError(
+        "E_UNSUPPORTED",
+        "a Cytoscape session is a zip file, not text; use exportGraphToBytes() or exportGraphToBlob()",
+        { reason: "binary" }
+      )
+    );
+  }
+});
+function urlDecode(text) {
+  const plus = text.replace(/\+/g, " ");
+  try {
+    return decodeURIComponent(plus);
+  } catch {
+    return plus;
+  }
+}
+async function openSession(input, report, common, maxBytes) {
+  const bytes = await readBytes(input, common);
+  if (bytes === null) {
+    report.fail(
+      CYS_ISSUE.NOT_ZIP,
+      "a Cytoscape session is a zip archive; text input cannot hold one (pass the bytes)"
+    );
+  }
+  if (bytes.byteLength === 0) {
+    report.fail(CYS_ISSUE.EMPTY_INPUT, "the input is empty");
+  }
+  let zipEntries;
+  try {
+    zipEntries = readZipDirectory(bytes);
+  } catch (err) {
+    return zipFailure(err, report);
+  }
+  const layout = layoutOf(zipEntries, report);
+  let budget = maxBytes;
+  let inflated = 0;
+  const total = [
+    ...layout.networks,
+    ...layout.views,
+    ...layout.tables,
+    ...layout.files.values(),
+    ...[layout.cytables, layout.networkList, layout.cysession].filter((e) => e !== null)
+  ].reduce((sum, e) => sum + e.zip.size, 0);
+  const charged = /* @__PURE__ */ new Set();
+  return {
+    layout,
+    read: async (entry, into) => {
+      const first = !charged.has(entry.name);
+      const before = inflated;
+      try {
+        const data = await readZipEntry(bytes, entry.zip, {
+          signal: common.signal,
+          maxBytes: first ? budget : entry.zip.size,
+          maxRatio: MAX_RATIO,
+          onBytes: first ? (n) => common.onProgress?.(Math.min(before + n, total), total) : void 0
+        });
+        if (first) {
+          charged.add(entry.name);
+          budget -= data.byteLength;
+          inflated += data.byteLength;
+        }
+        return data;
+      } catch (err) {
+        return zipFailure(err, into);
+      }
+    },
+    done: () => {
+      common.onProgress?.(total, total);
+    }
+  };
+}
+function zipFailure(err, report) {
+  if (!(err instanceof ZipError)) {
+    throw err;
+  }
+  const code = {
+    "not-zip": CYS_ISSUE.NOT_ZIP,
+    corrupt: CYS_ISSUE.CORRUPT,
+    unsupported: CYS_ISSUE.UNSUPPORTED,
+    "too-large": CYS_ISSUE.TOO_LARGE
+  }[err.kind];
+  if (err.kind === "too-large") {
+    report.error("unsupported", code, err.message);
+    throw report.abort(err.message, { code });
+  }
+  report.fail(code, err.message);
+}
+function shallowest(names, suffix) {
+  const depth = (name) => name.split("/").length;
+  const found = names.filter((n) => suffix.test(n));
+  const least = Math.min(...found.map(depth));
+  return found.filter((n) => depth(n) === least);
+}
+const NETWORK_FILE = /^networks\/(\d+)(?:-([^/]*))?\.xgmml$/;
+const VIEW_FILE = /^views\/(\d+)-(\d+)(?:-[^/]*)?\.xgmml$/;
+const TABLE_FILE = /^tables\/((\d+)(?:-[^/]*)?\/([^/-]+)-([^/-]+)-[^/]*\.cytable)$/;
+const NOISE = /(^|\/)(__MACOSX\/|\.DS_Store$)/;
+function layoutOf(zipEntries, report) {
+  const byName = /* @__PURE__ */ new Map();
+  const repeated = [];
+  for (const entry of zipEntries) {
+    const name = entry.name.replaceAll("\\", "/");
+    if (name.endsWith("/") || NOISE.test(name)) {
+      continue;
+    }
+    if (byName.has(name)) {
+      repeated.push(name);
+      continue;
+    }
+    byName.set(name, entry);
+  }
+  if (repeated.length > 0) {
+    report.warning(
+      "unsupported",
+      CYS_ISSUE.DUPLICATE_ENTRY,
+      `${repeated.length} entry name${plural(repeated.length)} appear more than once; the first of each is read: ${listed(repeated)}`
+    );
+  }
+  const names = [...byName.keys()];
+  const markers = shallowest(names, /(^|\/)[^/]+\.version$/);
+  const marker = markers.at(0);
+  const cysession = shallowest(names, /(^|\/)cysession\.xml$/).at(0);
+  if (markers.length > 1) {
+    report.warning(
+      "validation-error",
+      CYS_ISSUE.ENTRY_SKIPPED,
+      `the session has ${markers.length} version markers (${listed(markers)}); ${markers[0]} is used and the others are not read`
+    );
+  }
+  if (marker === void 0 && cysession === void 0) {
+    report.fail(
+      CYS_ISSUE.NOT_SESSION,
+      "the zip holds neither a session version marker (<x.y.z>.version) nor cysession.xml: it is not a Cytoscape session"
+    );
+  }
+  const anchor = marker ?? cysession;
+  const root = anchor.slice(0, anchor.lastIndexOf("/") + 1);
+  let era = "2";
+  let version = "2.0.0";
+  if (marker !== void 0) {
+    version = marker.slice(root.length, -".version".length);
+    if (!/^\d+(\.\d+)*$/.test(version)) {
+      report.fail(
+        CYS_ISSUE.VERSION,
+        `the session version marker ${marker} does not parse as a version (<major>.<minor>.<patch>.version)`
+      );
+    }
+    const major = Number(version.split(".")[0]);
+    if (major > 3) {
+      report.fail(
+        CYS_ISSUE.VERSION,
+        `the session version ${version} is newer than the Cytoscape 3 sessions graph-io reads`
+      );
+    }
+    era = major === 3 ? "3" : "2";
+  }
+  const layout = {
+    era,
+    version,
+    root,
+    networks: [],
+    views: [],
+    tables: [],
+    cytables: null,
+    networkList: null,
+    cysession: null,
+    files: /* @__PURE__ */ new Map(),
+    styles: [],
+    skipped: []
+  };
+  for (const [name, zip] of byName) {
+    if (!name.startsWith(root) || name === marker) {
+      if (name !== marker && !markers.includes(name)) {
+        layout.skipped.push(name);
+      }
+      continue;
+    }
+    const path = name.slice(root.length);
+    const entry = { path, name, zip };
+    if (era === "3") {
+      classify3(entry, layout);
+    } else {
+      classify2(entry, layout);
+    }
+  }
+  return layout;
+}
+function classify3(entry, layout) {
+  const { path } = entry;
+  const network = NETWORK_FILE.exec(path);
+  const view = VIEW_FILE.exec(path);
+  const table = TABLE_FILE.exec(path);
+  if (network !== null) {
+    layout.networks.push({ ...entry, suid: network[1], title: urlDecode(network[2] ?? "") });
+  } else if (view !== null) {
+    layout.views.push({ ...entry, network: view[1], view: view[2] });
+  } else if (path === "tables/cytables.xml") {
+    layout.cytables = entry;
+  } else if (table !== null) {
+    const element = {
+      "org.cytoscape.model.CyNode": "node",
+      "org.cytoscape.model.CyEdge": "edge",
+      "org.cytoscape.model.CyNetwork": "network"
+    }[urlDecode(table[4])];
+    if (element === void 0) {
+      layout.skipped.push(entry.name);
+      return;
+    }
+    layout.tables.push({
+      ...entry,
+      tablePath: table[1],
+      network: table[2],
+      namespace: urlDecode(table[3]),
+      element
+    });
+  } else if (path === "apps/org.cytoscape.swing-application/network_list.xml") {
+    layout.networkList = entry;
+  } else if (/(^|\/)session_vizmap\.(xml|props)$/.test(path)) {
+    layout.styles.push(entry);
+  } else {
+    layout.skipped.push(entry.name);
+  }
+}
+function classify2(entry, layout) {
+  const { path } = entry;
+  if (path === "cysession.xml") {
+    layout.cysession = entry;
+  } else if (/^[^/]+\.xgmml$/.test(path)) {
+    layout.files.set(path, entry);
+  } else if (/^session_vizmap\.(props|xml)$/.test(path)) {
+    layout.styles.push(entry);
+  } else {
+    layout.skipped.push(entry.name);
+  }
+}
+function listed(names) {
+  const head = names.slice(0, 10).map(entryLabel).join(", ");
+  return names.length > 10 ? `${head} and ${names.length - 10} more` : head;
+}
+function entryLabel(name) {
+  return name.replace(/^[^/]*CytoscapeSession[^/]*\//, "");
+}
+async function readXmlTree(bytes, entry, report, common) {
+  const tree = await parseXmlTree(bytes, entry, report, common);
+  return typeof tree === "string" ? report.fail(CYS_ISSUE.CORRUPT, `${entry}: ${tree}`) : tree;
+}
+async function parseXmlTree(bytes, entry, report, common) {
+  const scratch = new ImportReportBuilder(FORMAT, 0);
+  const stack = [{ name: "", attrs: /* @__PURE__ */ new Map(), children: [] }];
+  try {
+    await tokenizeXml(
+      textChunks(bytes, scratch, { signal: common.signal, declaredEncoding: xmlDeclaredEncoding, xml: true }),
+      {
+        start(name, attrs) {
+          const node = { name: name.slice(name.lastIndexOf(":") + 1), attrs, children: [] };
+          stack[stack.length - 1].children.push(node);
+          stack.push(node);
+        },
+        end() {
+          stack.pop();
+        },
+        text() {
+        }
+      }
+    );
+  } catch (err) {
+    if (err instanceof XmlSyntaxError || err instanceof ImportError) {
+      return err.message;
+    }
+    throw err;
+  }
+  for (const issue of scratch.issues) {
+    if (issue.severity === "warning") {
+      report.warning(issue.category, issue.code, `${entry}: ${issue.message}`, {
+        line: issue.line,
+        element: entry
+      });
+    }
+  }
+  const [root] = stack[0].children;
+  return root ?? "the document is empty";
+}
+function elementsNamed(node, name) {
+  const out = [];
+  const stack = [node];
+  while (stack.length > 0) {
+    const n = stack.pop();
+    if (n.name === name) {
+      out.push(n);
+    }
+    for (let i = n.children.length - 1; i >= 0; i--) {
+      stack.push(n.children[i]);
+    }
+  }
+  return out;
+}
+const JAVA_TYPES = {
+  "java.lang.String": "String",
+  "java.lang.Long": "Long",
+  "java.lang.Integer": "Integer",
+  "java.lang.Double": "Double",
+  "java.lang.Boolean": "Boolean"
+};
+const LIST_CLASS = /^java\.util\.List<\s*([\w.]+)\s*>$/;
+async function readCyTable(bytes, path, entry, report, 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 });
+    }
+  } catch (err) {
+    if (err instanceof ImportError) {
+      return tableError(report, entry, scratch.issues.at(-1)?.message ?? err.message);
+    }
+    throw err;
+  }
+  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`);
+    }
+    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`);
+  }
+  let headerLines = version === 1 ? 4 : 3;
+  if (records.length < at + headerLines - 1) {
+    return tableError(report, entry, "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;
+  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)`
+    );
+  }
+  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`
+      );
+    }
+    columns.push(column);
+  }
+  const rows = /* @__PURE__ */ new Map();
+  const lines = /* @__PURE__ */ new Map();
+  const problems = { short: 0, long: 0, repeated: 0 };
+  for (const record of records.slice(at + headerLines)) {
+    const { cells } = record;
+    if (cells.length < columns.length) {
+      problems.short++;
+    } else if (cells.length > columns.length) {
+      problems.long++;
+    }
+    const key = cells[0];
+    if (rows.has(key)) {
+      problems.repeated++;
+      continue;
+    }
+    rows.set(key, cells.slice(0, columns.length));
+    lines.set(key, record.line);
+  }
+  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 };
+}
+function columnOf(name, javaClass) {
+  const scalar = JAVA_TYPES[javaClass.trim()];
+  if (scalar !== void 0) {
+    return { name, type: scalar, list: false };
+  }
+  const list = LIST_CLASS.exec(javaClass.trim());
+  const item = list === null ? void 0 : JAVA_TYPES[list[1]];
+  return item === void 0 ? null : { name, type: item, list: true };
+}
+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) {
+  if (text.startsWith("=")) {
+    return att(column.name, column.list ? "List" : column.type, null, text, line, namespace, hidden, true);
+  }
+  if (!column.list) {
+    if (text.length === 0 && column.type !== "String") {
+      return null;
+    }
+    return att(column.name, column.type, null, text, line, namespace, hidden, false);
+  }
+  if (text.length === 0 && column.type !== "String") {
+    return null;
+  }
+  const list = att(column.name, "List", column.type, null, line, namespace, hidden, false);
+  for (const item of javaSplitLines(text)) {
+    if (item.length === 0 && column.type !== "String") {
+      continue;
+    }
+    list.children.push(att(column.name, column.type, null, item, line, namespace, hidden, false));
+  }
+  return list;
+}
+function javaSplitLines(text) {
+  if (!text.includes("\n")) {
+    return [text];
+  }
+  const items = text.split("\n");
+  while (items.length > 0 && items[items.length - 1].length === 0) {
+    items.pop();
+  }
+  return items;
+}
+function att(name, cyType, elementType, value, line, namespace, hidden, equation) {
+  return {
+    name,
+    type: null,
+    cyType,
+    elementType,
+    value,
+    hidden,
+    equation,
+    children: [],
+    extra: {},
+    xml: null,
+    hasGraph: false,
+    text: "",
+    line,
+    namespace
+  };
+}
+async function virtualColumnsOf(target, virtuals, tableOf, report) {
+  const out = [];
+  for (const virtual of virtuals) {
+    if (virtual.targetTable !== target.path) {
+      continue;
+    }
+    const resolved = await resolve(virtual, virtuals, tableOf, /* @__PURE__ */ new Set());
+    if (typeof resolved === "string") {
+      report.error(
+        "parse-error",
+        CYS_ISSUE.TABLE,
+        `${target.entry}: the virtual column "${virtual.name}" ${resolved}; the column is not read`
+      );
+      continue;
+    }
+    const targetKey = target.columns.findIndex((c) => c.name === virtual.targetJoinKey);
+    if (targetKey < 0) {
+      report.error(
+        "parse-error",
+        CYS_ISSUE.TABLE,
+        `${target.entry}: the virtual column "${virtual.name}" joins on the column "${virtual.targetJoinKey}", which the table does not have; the column is not read`
+      );
+      continue;
+    }
+    const values = /* @__PURE__ */ new Map();
+    for (const [key, cells] of target.rows) {
+      const join = targetKey <= 0 ? key : cells[targetKey];
+      const value = join === void 0 ? void 0 : resolved.values.get(join);
+      if (value !== void 0) {
+        values.set(key, value);
+      }
+    }
+    out.push({ column: { ...resolved.column, name: virtual.name }, values });
+  }
+  return out;
+}
+async function resolve(virtual, virtuals, tableOf, seen) {
+  if (seen.has(virtual)) {
+    return "is part of a cycle of virtual columns";
+  }
+  seen.add(virtual);
+  const source = await tableOf(virtual.sourceTable);
+  if (source === null) {
+    return `names the source table "${virtual.sourceTable}", which the session does not hold or cannot read`;
+  }
+  const joinIndex = source.columns.findIndex((c) => c.name === virtual.sourceJoinKey);
+  if (joinIndex < 0) {
+    return `joins on the column "${virtual.sourceJoinKey}", which its source table does not have`;
+  }
+  const joinOf = (key, cells) => joinIndex === 0 ? key : cells[joinIndex];
+  const own = source.columns.findIndex((c) => c.name === virtual.sourceColumn);
+  if (own >= 0) {
+    const values2 = /* @__PURE__ */ new Map();
+    for (const [key, cells] of source.rows) {
+      const join = joinOf(key, cells);
+      if (join !== void 0 && cells[own] !== void 0) {
+        values2.set(join, cells[own]);
+      }
+    }
+    return { column: source.columns[own], values: values2 };
+  }
+  const chained = virtuals.find((v) => v.targetTable === source.path && v.name === virtual.sourceColumn);
+  if (chained === void 0) {
+    return `names the source column "${virtual.sourceColumn}", which its source table does not have`;
+  }
+  const inner = await resolve(chained, virtuals, tableOf, seen);
+  if (typeof inner === "string") {
+    return inner;
+  }
+  const values = /* @__PURE__ */ new Map();
+  const chainedJoin = source.columns.findIndex((c) => c.name === chained.targetJoinKey);
+  if (chainedJoin < 0) {
+    return `reads the virtual column "${chained.name}", which joins on the column "${chained.targetJoinKey}" its table does not have`;
+  }
+  for (const [key, cells] of source.rows) {
+    const lookup = chainedJoin <= 0 ? key : cells[chainedJoin];
+    const value = lookup === void 0 ? void 0 : inner.values.get(lookup);
+    const join = joinOf(key, cells);
+    if (value !== void 0 && join !== void 0) {
+      values.set(join, value);
+    }
+  }
+  return { column: inner.column, values };
+}
+const FORMAT_DEFAULTS = {
+  ids: "keep",
+  defaultDirected: true,
+  weightFrom: "weight",
+  addMissingNodes: false
+};
+const USED_OPTIONS = /* @__PURE__ */ new Set([
+  "ids",
+  "addMissingNodes",
+  "duplicateEdges",
+  "selfLoops",
+  "onMixedDirection",
+  "defaultDirected",
+  "weightFrom",
+  "weightDtype",
+  "long",
+  "restoreMangledIds",
+  "errorLimit",
+  "signal",
+  "onProgress"
+]);
+function budgetOption(value) {
+  if (value === void 0) {
+    return DEFAULT_MAX_UNCOMPRESSED;
+  }
+  if (typeof value !== "number" || !(value > 0)) {
+    throw new GraphFormatError(
+      "E_UNSUPPORTED",
+      `option maxUncompressedBytes: ${JSON.stringify(value)} is not a positive number`,
+      {
+        option: "maxUncompressedBytes",
+        found: value
+      }
+    );
+  }
+  return value;
+}
+async function prepare(input, sink, options) {
+  const common = resolveImportOptions(options, FORMAT_DEFAULTS);
+  const report = new ImportReportBuilder(FORMAT, common.errorLimit);
+  if (sink !== null) {
+    reportSinkOptions(sink, options, report, true);
+    reportUnusedOptions(options, report, USED_OPTIONS);
+  }
+  const { zAs } = resolveSettings({ zAs: options?.zAs }, false);
+  const maxBytes = budgetOption(options?.maxUncompressedBytes);
+  const session = await openSession(input, report, common, maxBytes);
+  const inner = Object.freeze({ ...common, onProgress: null, encoding: null });
+  const docs = /* @__PURE__ */ new Map();
+  const choices = session.layout.era === "3" ? await networks3(session, report, inner, docs) : await networks2(session, report, inner);
+  return { report, common, inner, zAs, session, choices, docs };
+}
+async function parseEntry(session, entry, report, inner) {
+  return await parseOptionalEntry(session, entry, report, inner, false);
+}
+async function parseOptionalEntry(session, entry, report, inner, optional) {
+  const scratch = new ImportReportBuilder(FORMAT, Math.max(0, report.errorLimit - report.errorCount));
+  try {
+    const bytes = await session.read(entry, scratch);
+    const doc = await parseXgmml(bytes, scratch, inner, void 0);
+    const dialect = dialectOf(doc, scratch);
+    relay(scratch.issues, report, entry.name);
+    addCounts(scratch, report);
+    return { doc, dialect };
+  } catch (err) {
+    if (!(err instanceof ImportError)) {
+      throw err;
+    }
+    addCounts(scratch, report);
+    const { issues } = scratch;
+    if (scratch.truncated) {
+      relay(issues, report, entry.name);
+    }
+    const fatal = issues.at(-1);
+    relay(issues.slice(0, -1), report, entry.name);
+    const message = `${entryLabel(entry.name)}: ${fatal?.message ?? err.message}`;
+    const where = { line: fatal?.line ?? null };
+    if (fatal?.code === CYS_ISSUE.TOO_LARGE) {
+      report.error("unsupported", fatal.code, message);
+      throw report.abort(message, { code: fatal.code });
+    }
+    if (optional) {
+      report.error("parse-error", fatal?.code ?? CYS_ISSUE.CORRUPT, `${message}; the entry is not read`, where);
+      return null;
+    }
+    return report.fail(fatal?.code ?? CYS_ISSUE.CORRUPT, message, where);
+  }
+}
+function addCounts(from, to) {
+  for (const key of Object.keys(from.counts)) {
+    to.counts[key] += from.counts[key];
+  }
+}
+function relay(issues, report, entry) {
+  for (const issue of issues) {
+    const where = { line: issue.line, element: issue.element };
+    if (issue.severity === "error") {
+      report.error(issue.category, issue.code, `${entryLabel(entry)}: ${issue.message}`, where);
+    } else {
+      report.warning(issue.category, issue.code, `${entryLabel(entry)}: ${issue.message}`, where);
+    }
+  }
+}
+async function networks3(session, report, inner, docs) {
+  const { layout } = session;
+  const choices = [];
+  for (const network of layout.networks) {
+    const parsed = await parseEntry(session, network, report, inner);
+    if (parsed.dialect.view) {
+      report.fail(
+        XGMML_ISSUE.VIEW_DOCUMENT,
+        `${network.name}: this is a session view file (cy:view), not a network file; it holds no topology`,
+        { line: parsed.doc.root.line }
+      );
+    }
+    docs.set(network.name, parsed);
+    for (const graph of registeredGraphs(parsed)) {
+      if (graph.id === null) {
+        const label = graph.label === null ? "" : ` ("${graph.label}")`;
+        report.error(
+          "missing-value",
+          XGMML_ISSUE.MISSING_ID,
+          `${network.name}: a registered subnetwork${label} has no id; its tables and views cannot be found and it is skipped`,
+          { line: graph.line }
+        );
+        continue;
+      }
+      const members = membersOf(parsed.doc, graph);
+      choices.push({
+        era: "3",
+        network,
+        graph,
+        graphId: graph.id,
+        name: graph.label ?? graph.id,
+        nodes: new Set(members.nodes).size,
+        edges: members.edges.length
+      });
+    }
+  }
+  const known = new Set(choices.map((c) => c.graphId));
+  const strayViews = layout.views.filter((v) => !known.has(v.network)).map((v) => v.name);
+  const strayTables = layout.tables.filter(
+    (t) => !known.has(t.network) && !layout.networks.some((n) => n.suid === t.network) && !isGroupTable(t, session, docs)
+  );
+  if (strayViews.length > 0 || strayTables.length > 0) {
+    report.warning(
+      "validation-error",
+      CYS_ISSUE.DANGLING_REFERENCE,
+      `${strayViews.length + strayTables.length} view${plural(strayViews.length + strayTables.length)} or table${plural(strayViews.length + strayTables.length)} ${agree(strayViews.length + strayTables.length, "belongs", "belong")} to a network the session does not hold and were not read: ${listed([...strayViews, ...strayTables.map((t) => t.name)])}`
+    );
+  }
+  if (layout.networkList === null) {
+    return choices;
+  }
+  const tree = await parseXmlTree(
+    await session.read(layout.networkList, report),
+    layout.networkList.name,
+    report,
+    inner
+  );
+  if (typeof tree === "string") {
+    report.warning(
+      "unsupported",
+      CYS_ISSUE.ENTRY_SKIPPED,
+      `${layout.networkList.name}: ${tree}; it is not read and the networks are listed in entry order`
+    );
+    return choices;
+  }
+  const order = /* @__PURE__ */ new Map();
+  for (const node of elementsNamed(tree, "network")) {
+    const id = node.attrs.get("id");
+    const position = Number(node.attrs.get("order"));
+    if (id !== void 0 && Number.isFinite(position)) {
+      order.set(id, position);
+    }
+  }
+  return choices.map((choice, index) => ({ choice, index })).sort(
+    (a, b) => (order.get(a.choice.graphId) ?? Infinity) - (order.get(b.choice.graphId) ?? Infinity) || a.index - b.index
+  ).map((c) => c.choice);
+}
+function isGroupTable(table, session, docs) {
+  for (const network of session.layout.networks) {
+    if (docs.get(network.name)?.doc.graphs.some((g) => g.id === table.network) === true) {
+      return true;
+    }
+  }
+  return false;
+}
+function registeredGraphs(parsed) {
+  const subnetworks = parsed.doc.root.subgraphs.filter((g) => isCyTrue(g.registered));
+  return subnetworks.length === 0 && isCyTrue(parsed.doc.root.registered) ? [parsed.doc.root] : subnetworks;
+}
+async function import3(prepared, choice, sink, parsed) {
+  const { graph } = choice;
+  const members = membersOf(parsed.doc, graph);
+  const nodes = byId(members.nodes);
+  const edges = byId(members.edges);
+  const restore = saveRecords(graph, nodes, edges);
+  try {
+    await fill3(prepared, choice, sink, parsed, nodes, edges);
+  } finally {
+    restore();
+  }
+}
+function saveRecords(graph, nodes, edges) {
+  const saved = [...nodes.values()].map((n) => ({
+    n,
+    atts: n.atts.length,
+    x: n.x,
+    y: n.y,
+    z: n.z,
+    graphics: n.graphics
+  }));
+  const savedEdges = [...edges.values()].map((e) => ({ e, atts: e.atts.length, graphics: e.graphics }));
+  const graphAtts = graph.atts.length;
+  const graphGraphics = graph.graphics;
+  return () => {
+    for (const { n, atts, x, y, z, graphics } of saved) {
+      n.atts.length = atts;
+      Object.assign(n, { x, y, z, graphics });
+    }
+    for (const { e, atts, graphics } of savedEdges) {
+      e.atts.length = atts;
+      e.graphics = graphics;
+    }
+    graph.atts.length = graphAtts;
+    graph.graphics = graphGraphics;
+  };
+}
+async function fill3(prepared, choice, sink, parsed, nodes, edges) {
+  const { report, inner } = prepared;
+  const { doc, dialect } = parsed;
+  const { graph } = choice;
+  const members = membersOf(doc, graph);
+  const unmatched = await applyTables(prepared, choice, doc, nodes, edges);
+  if (unmatched > 0) {
+    report.warning(
+      "parse-error",
+      CYS_ISSUE.TABLE_ROW,
+      `${unmatched} table row${plural(unmatched)} of network ${choice.graphId} ${agree(unmatched, "names", "name")} no node, edge or network in it (left over from deleted elements) and ${agree(unmatched, "is", "are")} not read`
+    );
+  }
+  const restoredIds = inner.restoreMangledIds ? restoreIds(members.nodes) : /* @__PURE__ */ new Map();
+  const { visualStyle, extraViews, extraIds } = await readViews(prepared, choice, nodes, edges);
+  const cyMeta = sessionMeta(prepared, {
+    collection: doc.root.label ?? choice.network.title,
+    network: choice.graphId,
+    parentNetwork: parentNetwork(graph, prepared.choices),
+    visualStyle
+  });
+  const groups = [];
+  cyMeta.groups = groups;
+  const extras = {
+    sourceFormat: FORMAT,
+    entry: choice.network.name,
+    graphName: localName(graph) ?? choice.name,
+    metaExtra: { [META_KEY]: cyMeta },
+    labelFromName: true,
+    restoredIds,
+    groupNodes: groupNodeIds(members.nodes),
+    resolvePointer: pointerResolver(prepared, doc),
+    onMissingMember: (group, member) => {
+      addMissingMember(groups, group, member);
+    }
+  };
+  const settings = { labelAliases: false, cytoscapeEscapes: false, zAs: prepared.zAs };
+  new XgmmlEmitter(doc, dialect, sink, report, prepared.inner, settings, extras).emit(graph);
+  if (groups.length > 0) {
+    const missing = groups.reduce((n, g) => n + g.members.length, 0);
+    report.warning(
+      "unsupported",
+      CYS_ISSUE.COLLAPSED_GROUP,
+      `${groups.length} collapsed group${plural(groups.length)} ${agree(groups.length, "holds", "hold")} ${missing} member${plural(missing)} that are not in the network; they are listed in meta.extra.cytoscape.groups`
+    );
+  }
+  reportRootOnly(parsed, report, choice.network.name);
+  writeViewPositions(sink, extraViews, extraIds, report, prepared.inner, restoredIds);
+}
+function groupNodeIds(nodes) {
+  return new Set(
+    nodes.filter((n) => n.atts.some((a) => a.name === "__isGroup" && isCyTrue(a.value))).flatMap((n) => n.id === null ? [] : [n.id])
+  );
+}
+function addMissingMember(groups, group, member) {
+  const record = groups.find((g) => g.group === group);
+  if (record === void 0) {
+    groups.push({ group, members: [member] });
+  } else if (!record.members.includes(member)) {
+    record.members.push(member);
+  }
+}
+async function applyTables(prepared, choice, doc, nodes, edges) {
+  const { report, inner, session } = prepared;
+  const { layout } = session;
+  const tables = /* @__PURE__ */ new Map();
+  const tableOf = (path) => {
+    let pending = tables.get(path);
+    if (pending === void 0) {
+      const entry = layout.tables.find((t) => t.tablePath === path);
+      pending = entry === void 0 ? Promise.resolve(null) : session.read(entry, report).then((bytes) => readCyTable(bytes, path, entry.name, report, inner));
+      tables.set(path, pending);
+    }
+    return pending;
+  };
+  const ctx = {
+    choice,
+    graph: choice.graph,
+    nodes,
+    edges,
+    // a row of an element the file declares outside this network (a collapsed group's member, a
+    // meta-edge) is Cytoscape's bookkeeping, not a stale row
+    declared: /* @__PURE__ */ new Set([
+      ...doc.nodes.flatMap((n) => n.id === null ? [] : [n.id]),
+      ...doc.edges.flatMap((e) => e.id === null ? [] : [e.id])
+    ]),
+    virtuals: layout.cytables === null ? [] : await readVirtuals(session, layout.cytables, report, inner),
+    tableOf,
+    report
+  };
+  let unmatched = 0;
+  for (const entry of layout.tables.filter((t) => t.network === choice.graphId && t.element !== null)) {
+    throwIfAborted(inner.signal);
+    const table = await tableOf(entry.tablePath);
+    if (table !== null) {
+      unmatched += await applyTable(ctx, entry, table);
+    }
+  }
+  return unmatched;
+}
+async function applyTable(ctx, entry, table) {
+  const local = entry.namespace === "LOCAL_ATTRS";
+  const namespace = local ? null : entry.namespace;
+  const hidden = !local && entry.namespace !== "SHARED_ATTRS";
+  const target = (key) => {
+    if (entry.element === "network") {
+      return key === ctx.choice.graphId ? ctx.graph.atts : void 0;
+    }
+    return (entry.element === "node" ? ctx.nodes : ctx.edges).get(key)?.atts;
+  };
+  let unmatched = 0;
+  for (const [key, cells] of table.rows) {
+    const atts = target(key);
+    if (atts !== void 0) {
+      atts.push(...rowAtts(table, key, cells, namespace, hidden));
+    } else if (!ctx.declared.has(key)) {
+      unmatched++;
+    }
+  }
+  for (const virtual of await virtualColumnsOf(table, ctx.virtuals, ctx.tableOf, ctx.report)) {
+    const owned = table.columns.some((c) => c.name === virtual.column.name);
+    const ns = local ? sharedNamespace(owned) : namespace;
+    for (const [key, text] of virtual.values) {
+      const atts = target(key);
+      if (atts !== void 0) {
+        pushAtt(atts, cellAtt(virtual.column, text, table.lines.get(key) ?? 0, ns, hidden));
+      }
+    }
+  }
+  return unmatched;
+}
+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));
+  }
+  return out;
+}
+function sharedNamespace(owned) {
+  return owned ? "SHARED_ATTRS" : null;
+}
+function pushAtt(atts, att2) {
+  if (att2 !== null) {
+    atts.push(att2);
+  }
+}
+async function readViews(prepared, choice, nodes, edges) {
+  const { report, inner, session } = prepared;
+  const views = session.layout.views.filter((v) => v.network === choice.graphId).sort((a, b) => a.view.length - b.view.length || (a.view < b.view ? -1 : Number(a.view > b.view)));
+  let visualStyle = null;
+  const extraViews = [];
+  const extraIds = [];
+  let first = true;
+  for (const view of views) {
+    const viewDoc = (await parseOptionalEntry(session, view, report, inner, true))?.doc;
+    if (viewDoc === void 0) {
+      continue;
+    }
+    if (first) {
+      first = false;
+      visualStyle = viewDoc.root.attrs.get("cy:visualStyle") ?? null;
+      applyView(viewDoc, choice.graph, nodes, edges, report, view.name);
+    } else {
+      extraViews.push(viewPositions(viewDoc, prepared.zAs, nodes, report, view.name));
+      extraIds.push(view.view);
+    }
+  }
+  return { visualStyle, extraViews, extraIds };
+}
+async function readVirtuals(session, entry, report, inner) {
+  const tree = await parseXmlTree(await session.read(entry, report), entry.name, report, inner);
+  if (typeof tree === "string") {
+    report.error(
+      "parse-error",
+      CYS_ISSUE.TABLE,
+      `${entryLabel(entry.name)}: ${tree}; its virtual columns are not read`
+    );
+    return [];
+  }
+  const out = [];
+  for (const node of elementsNamed(tree, "virtualColumn")) {
+    const missing = ["name", "targetTable", "sourceTable", "sourceColumn"].filter((k) => !node.attrs.has(k));
+    if (missing.length > 0) {
+      const named = node.attrs.has("name") ? ` "${node.attrs.get("name") ?? ""}"` : "";
+      report.error(
+        "parse-error",
+        CYS_ISSUE.TABLE,
+        `${entryLabel(entry.name)}: a virtual column${named} has no ${missing.join(", ")}; the column is not read`
+      );
+      continue;
+    }
+    const a = (key) => node.attrs.get(key) ?? "";
+    out.push({
+      name: a("name"),
+      targetTable: a("targetTable"),
+      sourceTable: a("sourceTable"),
+      sourceColumn: a("sourceColumn"),
+      sourceJoinKey: node.attrs.get("sourceJoinKey") ?? "SUID",
+      targetJoinKey: node.attrs.get("targetJoinKey") ?? "SUID"
+    });
+  }
+  return out;
+}
+function byId(records) {
+  const out = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    if (record.id !== null && !out.has(record.id)) {
+      out.set(record.id, record);
+    }
+  }
+  return out;
+}
+function applyView(view, graph, nodes, edges, report, entry) {
+  let dangling = 0;
+  const seen = /* @__PURE__ */ new Set();
+  for (const node of view.nodes) {
+    const target = node.viewId === null ? void 0 : nodes.get(node.viewId);
+    if (target === void 0) {
+      dangling++;
+      continue;
+    }
+    duplicateViewNode(seen, node, report, entry);
+    target.x = node.x;
+    target.y = node.y;
+    target.z = node.z;
+    if (node.graphics !== null) {
+      target.graphics = { ...target.graphics ?? {}, ...node.graphics };
+    }
+  }
+  for (const edge of view.edges) {
+    const target = edge.viewId === null ? void 0 : edges.get(edge.viewId);
+    if (target === void 0) {
+      dangling++;
+      continue;
+    }
+    if (edge.graphics !== null) {
+      target.graphics = { ...target.graphics ?? {}, ...edge.graphics };
+    }
+  }
+  if (view.root.graphics !== null) {
+    graph.graphics = { ...graph.graphics ?? {}, ...view.root.graphics };
+  }
+  if (dangling > 0) {
+    report.warning(
+      "validation-error",
+      CYS_ISSUE.DANGLING_REFERENCE,
+      `${entryLabel(entry)}: ${dangling} view element${plural(dangling)} ${agree(dangling, "names", "name")} no node or edge of the network; they are not read`
+    );
+  }
+}
+function duplicateViewNode(seen, node, report, entry) {
+  const id = node.viewId;
+  if (seen.has(id)) {
+    report.warning(
+      "validation-error",
+      XGMML_ISSUE.DUPLICATE_NODE,
+      `${entryLabel(entry)}: the view gives node "${id}" twice; the later element is used`,
+      { line: node.line, element: id }
+    );
+  }
+  seen.add(id);
+}
+function viewPositions(view, zAs, nodes, report, entry) {
+  const out = /* @__PURE__ */ new Map();
+  const seen = /* @__PURE__ */ new Set();
+  let dangling = 0;
+  const coordinate = (text, node) => {
+    if (text === null) {
+      return null;
+    }
+    const n = parseCoordinate(text);
+    if (n === null) {
+      report.error(
+        "validation-error",
+        XGMML_ISSUE.BAD_VALUE,
+        `${entryLabel(entry)}: graphics coordinate "${text}" is not a number`,
+        {
+          line: node.line,
+          element: node.viewId
+        }
+      );
+    }
+    return n;
+  };
+  for (const node of view.nodes) {
+    if (node.viewId === null || !nodes.has(node.viewId)) {
+      dangling++;
+      continue;
+    }
+    duplicateViewNode(seen, node, report, entry);
+    const x = coordinate(node.x, node);
+    const y = coordinate(node.y, node);
+    const z = zAs === "position" ? coordinate(node.z, node) : null;
+    if (x !== null && y !== null) {
+      out.set(node.viewId, [x, y === 0 ? 0 : -y, z ?? 0]);
+    } else {
+      out.delete(node.viewId);
+    }
+  }
+  if (dangling > 0) {
+    report.warning(
+      "validation-error",
+      CYS_ISSUE.DANGLING_REFERENCE,
+      `${entryLabel(entry)}: ${dangling} view element${plural(dangling)} ${agree(dangling, "names", "name")} no node of the network; they are not read`
+    );
+  }
+  return out;
+}
+function writeViewPositions(sink, views, viewIds, report, common, restoredIds) {
+  const coercer = new IdCoercer(common.ids);
+  views.forEach((positions, i) => {
+    const name = `${VIEW_POSITION_PREFIX}${i + 2}`;
+    const { handle } = declareResolved(
+      sink,
+      "node",
+      {
+        name,
+        dtype: "f32",
+        components: 3,
+        nullable: true,
+        origin: {
+          format: FORMAT,
+          id: viewIds[i],
+          title: null,
+          type: "graphics",
+          namespace: XGMML_ORIGIN_NAMESPACE
+        },
+        extra: { sourceDims: 2, units: "file" }
+      },
+      report,
+      { element: name }
+    );
+    for (const [id, xyz] of positions) {
+      let index;
+      try {
+        index = sink.indexOf(coercer.text(restoredIds.get(id) ?? id));
+      } catch {
+        continue;
+      }
+      if (index !== INVALID_INDEX) {
+        sink.setNodeValue(handle, index, xyz);
+      }
+    }
+  });
+}
+function restoreIds(nodes) {
+  const out = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    const at = node.atts.findIndex(
+      (a) => a.name === ORIGINAL_ID_ATTRIBUTE && (a.namespace ?? null) === null && a.value !== null && a.children.length === 0
+    );
+    if (node.id !== null && at >= 0) {
+      out.set(node.id, node.atts[at].value);
+      node.atts.splice(at, 1);
+    }
+  }
+  return out;
+}
+function localName(graph) {
+  const att2 = graph.atts.find((a) => a.name === "name" && (a.namespace ?? null) === null);
+  return att2?.value ?? null;
+}
+function parentNetwork(graph, choices) {
+  const att2 = graph.atts.find((a) => a.name === "__parentNetwork.SUID" || a.name === "Cy2 Parent Network.SUID");
+  if (att2?.value === void 0 || att2.value === null || att2.value.length === 0) {
+    return null;
+  }
+  const suid = att2.value;
+  const named = choices.find((c) => c.era === "3" && c.graphId === suid);
+  return named?.name ?? suid;
+}
+function pointerResolver(prepared, doc) {
+  const names = /* @__PURE__ */ new Map();
+  for (const graph of doc.graphs) {
+    const { href } = graph;
+    const hash = href?.indexOf("#") ?? -1;
+    if (href === null || hash <= 0 || names.has(href)) {
+      continue;
+    }
+    const file = urlDecode(href.slice(0, hash));
+    const id = href.slice(hash + 1);
+    const network = prepared.session.layout.networks.find(
+      (n) => urlDecode(n.path.slice("networks/".length)) === file
+    );
+    const parsed = network === void 0 ? void 0 : prepared.docs.get(network.name);
+    const target = parsed?.doc.graphs.find((g) => g.id === id);
+    if (target !== void 0) {
+      names.set(href, target.label ?? id);
+    }
+  }
+  return (href) => names.get(href) ?? null;
+}
+function reportRootOnly(parsed, report, entry) {
+  const held = /* @__PURE__ */ new Set();
+  for (const graph of registeredGraphs(parsed)) {
+    const members = membersOf(parsed.doc, graph);
+    members.nodes.forEach((n) => held.add(n));
+    members.edges.forEach((e) => held.add(e));
+  }
+  const nodes = parsed.doc.nodes.filter((n) => !held.has(n)).length;
+  const edges = parsed.doc.edges.filter((e) => !held.has(e)).length;
+  if (nodes + edges > 0) {
+    report.warning(
+      "unsupported",
+      XGMML_ISSUE.ROOT_ONLY_ELEMENTS,
+      `${entryLabel(entry)}: ${elementCount(nodes, edges)} ${agree(nodes + edges, "belongs", "belong")} to none of the session's networks (group meta-edges or collapsed group members) and ${agree(nodes + edges, "was", "were")} not read`
+    );
+  }
+}
+async function networks2(session, report, inner) {
+  const { layout } = session;
+  if (layout.cysession === null) {
+    return report.fail(CYS_ISSUE.NOT_SESSION, "the session has no cysession.xml");
+  }
+  const tree = await readXmlTree(await session.read(layout.cysession, report), layout.cysession.name, report, inner);
+  const documentVersion = tree.attrs.get("documentVersion") ?? "";
+  if (documentVersion.length > 0 && !/^\d+(\.\d+)*$/.test(documentVersion.trim())) {
+    report.warning(
+      "validation-error",
+      XGMML_ISSUE.DOCUMENT_VERSION,
+      `${layout.cysession.name}: documentVersion "${documentVersion}" does not parse; the session is read as Cytoscape 2.x`
+    );
+  }
+  if (documentVersion.startsWith("3")) {
+    report.fail(
+      CYS_ISSUE.VERSION,
+      `cysession.xml has documentVersion ${documentVersion} and no version marker: the 2011 Cytoscape 3.0 pre-release layout, which no released Cytoscape reads`
+    );
+  }
+  const byDecoded = /* @__PURE__ */ new Map();
+  for (const [path, entry] of layout.files) {
+    byDecoded.set(path, entry);
+    byDecoded.set(urlDecode(path), entry);
+  }
+  const order = [...layout.files.values()];
+  const choices = [];
+  const missing = [];
+  const named = /* @__PURE__ */ new Set();
+  for (const record of elementsNamed(tree, "network")) {
+    const given = record.attrs.get("id");
+    const filename = record.attrs.get("filename") ?? (given === void 0 ? void 0 : `${given}.xgmml`);
+    if (given === "Network Root") {
+      continue;
+    }
+    if (filename === void 0) {
+      sessionRecord(
+        report,
+        layout.cysession.name,
+        "a <network> has neither an id nor a filename; it is not read"
+      );
+      continue;
+    }
+    const id = given ?? urlDecode(filename.replace(/\.xgmml$/i, ""));
+    if (given === void 0) {
+      sessionRecord(
+        report,
+        layout.cysession.name,
+        `a <network> for ${filename} has no id; it is named "${id}" after its file`
+      );
+    }
+    const file = byDecoded.get(filename);
+    if (file === void 0) {
+      missing.push(filename);
+      continue;
+    }
+    if (named.has(file)) {
+      sessionRecord(
+        report,
+        layout.cysession.name,
+        `the <network> "${id}" names ${filename}, which an earlier record already names; it is not read a second time`
+      );
+      continue;
+    }
+    named.add(file);
+    const parent = record.children.find((c) => c.name === "parent")?.attrs.get("id") ?? null;
+    choices.push({
+      era: "2",
+      file,
+      name: id,
+      record,
+      parent: parent === "Network Root" || parent === "NULL" ? null : parent
+    });
+  }
+  if (missing.length > 0) {
+    report.warning(
+      "validation-error",
+      CYS_ISSUE.DANGLING_REFERENCE,
+      `cysession.xml names ${missing.length} network file${plural(missing.length)} the session does not hold: ${listed(missing)}`
+    );
+  }
+  const unnamed = order.filter((e) => !named.has(e)).map((e) => e.name);
+  if (unnamed.length > 0) {
+    report.warning(
+      "unsupported",
+      CYS_ISSUE.ENTRY_SKIPPED,
+      `${unnamed.length} network file${plural(unnamed.length)} ${agree(unnamed.length, "is", "are")} not in cysession.xml's network tree and were not read: ${listed(unnamed)}`
+    );
+  }
+  return choices.sort((a, b) => order.indexOf(a.file) - order.indexOf(b.file));
+}
+function sessionRecord(report, entry, message) {
+  report.warning("validation-error", CYS_ISSUE.SESSION_RECORD, `${entryLabel(entry)}: ${message}`);
+}
+async function import2(prepared, choice, sink) {
+  const { report, inner, session } = prepared;
+  const { doc, dialect } = await parseEntry(session, choice.file, report, inner);
+  let unmatched = 0;
+  for (const [list, column] of [
+    ["selectedNodes", SELECTED_COLUMN],
+    ["hiddenNodes", HIDDEN_COLUMN]
+  ]) {
+    unmatched += mark(doc.nodes, idsIn(choice.record, list), column);
+  }
+  for (const [list, column] of [
+    ["selectedEdges", SELECTED_COLUMN],
+    ["hiddenEdges", HIDDEN_COLUMN]
+  ]) {
+    unmatched += mark(doc.edges, idsIn(choice.record, list), column);
+  }
+  if (unmatched > 0) {
+    report.warning(
+      "validation-error",
+      CYS_ISSUE.DANGLING_REFERENCE,
+      `cysession.xml lists ${unmatched} selected or hidden name${plural(unmatched)} that ${choice.file.name} does not hold; they are not read`
+    );
+  }
+  const cyMeta = sessionMeta(prepared, {
+    collection: null,
+    network: choice.name,
+    parentNetwork: choice.parent,
+    visualStyle: choice.record.attrs.get("visualStyle") ?? null
+  });
+  const extras = {
+    sourceFormat: FORMAT,
+    entry: choice.file.name,
+    graphName: choice.name,
+    metaExtra: { [META_KEY]: cyMeta }
+  };
+  const settings = { labelAliases: true, cytoscapeEscapes: true, zAs: prepared.zAs };
+  new XgmmlEmitter(doc, dialect, sink, report, inner, settings, extras).emit(null);
+}
+function idsIn(record, list) {
+  const out = /* @__PURE__ */ new Set();
+  for (const holder of record.children.filter((c) => c.name === list)) {
+    for (const item of holder.children) {
+      const id = item.attrs.get("id");
+      if (id !== void 0) {
+        out.add(id);
+      }
+    }
+  }
+  return out;
+}
+function mark(records, ids, column) {
+  if (ids.size === 0) {
+    return 0;
+  }
+  const matched = /* @__PURE__ */ new Set();
+  for (const record of records) {
+    if (record.id !== null && ids.has(record.id)) {
+      matched.add(record.id);
+    }
+    if (record.label !== null && ids.has(record.label)) {
+      matched.add(record.label);
+    }
+    if (record.id !== null && ids.has(record.id) || record.label !== null && ids.has(record.label)) {
+      record.atts.push({
+        name: column,
+        type: null,
+        cyType: "Boolean",
+        elementType: null,
+        value: "true",
+        hidden: false,
+        equation: false,
+        children: [],
+        extra: {},
+        xml: null,
+        hasGraph: false,
+        text: "",
+        line: record.line,
+        namespace: CYTOSCAPE_NAMESPACE
+      });
+    }
+  }
+  return ids.size - matched.size;
+}
+function sessionMeta(prepared, facts) {
+  const { layout } = prepared.session;
+  const { report } = prepared;
+  if (layout.styles.length > 0) {
+    report.warning(
+      "unsupported",
+      CYS_ISSUE.STYLES_NOT_IMPORTED,
+      `the session's styles (${layout.styles.map((s) => s.path).join(", ")}) are not applied`
+    );
+  }
+  if (layout.skipped.length > 0) {
+    report.warning(
+      "unsupported",
+      CYS_ISSUE.ENTRY_SKIPPED,
+      `${layout.skipped.length} ${layout.skipped.length === 1 ? "entry holds" : "entries hold"} no graph data and ${agree(layout.skipped.length, "was", "were")} not read (apps, global tables, properties, images): ${listed(layout.skipped)}`
+    );
+  }
+  return {
+    sessionVersion: layout.version,
+    ...facts,
+    skippedEntries: [...layout.skipped]
+  };
+}
+async function importChoice(prepared, index, sink) {
+  const choice = prepared.choices[index];
+  if (choice.era === "3") {
+    const parsed = prepared.docs.get(choice.network.name);
+    await import3(prepared, choice, sink, parsed);
+  } else {
+    await import2(prepared, choice, sink);
+  }
+  throwIfAborted(prepared.common.signal);
+  return prepared.report.finish();
+}
+async function importCys(input, sink, options) {
+  const prepared = await prepare(input, sink, options);
+  const index = chooseGraph(
+    prepared.choices.map((c) => c.name),
+    options,
+    prepared.report
+  );
+  if (prepared.choices.length > 1 && !graphChosen(options)) {
+    prepared.report.warning(
+      "unsupported",
+      CYS_ISSUE.MULTIPLE_GRAPHS,
+      `the session holds ${prepared.choices.length} networks; only the first is read (importAllGraphs() reads every one; graphIndex or graphName chooses one)`
+    );
+  }
+  const report = await importChoice(prepared, index, sink);
+  prepared.session.done();
+  return report;
+}
+async function importAllCys(input, sinkFor, options) {
+  const first = await prepare(input, null, options);
+  const opened = first.report.fork();
+  const reports = [];
+  for (let i = 0; i < first.choices.length; i++) {
+    const sink = sinkFor(i);
+    const prepared = i === 0 ? first : { ...first, report: opened.fork() };
+    reportSinkOptions(sink, options, prepared.report, true);
+    reportUnusedOptions(options, prepared.report, USED_OPTIONS);
+    reports.push(await importChoice(prepared, i, sink));
+  }
+  first.session.done();
+  return reports;
+}
+async function listCysGraphs(input, options) {
+  const prepared = await prepare(input, null, options);
+  return prepared.choices.map(
+    (choice, index) => Object.freeze({
+      index,
+      name: choice.name,
+      nodes: choice.era === "3" ? choice.nodes : null,
+      edges: choice.era === "3" ? choice.edges : null
+    })
+  );
+}
+const SESSION_NAMES = [
+  /CytoscapeSession|cysession\.xml/,
+  new RegExp("(?<!\\d)\\d+\\.\\d+\\.\\d+\\.version"),
+  /(?:^|\/)apps\/org\.cytoscape\./,
+  /(?:^|\/)(?:networks|views)\/\d+-[^/]*\.xgmml/,
+  /(?:^|\/)tables\/\d+-[^/]*\/[^/]+\.cytable/
+];
+function sniffCys(head) {
+  for (let at = 0; at + 4 <= head.byteLength; at++) {
+    if (startsLikeZip(head.subarray(at))) {
+      return SESSION_NAMES.some((r) => r.test(decodeEntryName(head.subarray(at)))) ? 0.95 : 0;
+    }
+  }
+  return 0;
+}
+const cysImporter = Object.freeze({
+  format: FORMAT,
+  options: Object.freeze(["maxUncompressedBytes", "zAs"]),
+  extensions: EXTENSIONS,
+  mimeTypes: MIME_TYPES,
+  sniff: sniffCys,
+  import: importCys,
+  importAll: importAllCys,
+  listGraphs: listCysGraphs
+});
+export {
+  CYS_CAPABILITIES as C,
+  CYS_ISSUE as a,
+  CYS_LOSS as b,
+  cysExporter as c,
+  cysImporter as d
+};
+//# sourceMappingURL=importer-90YWhJoF.js.map