@graphty/graph-io 0.3.18 → 0.3.20

package/dist/chunks/importer-DD-xv9_Y.js

@@ -0,0 +1,1471 @@
+import { GraphFormatError, INVALID_INDEX } from "@graphty/graph-format";
+import { A as AMBIGUOUS_GRAPH_NAME_CODE, G as GRAPH_NOT_FOUND_CODE, M as MULTIPLE_GRAPHS_CODE, N as NO_GRAPH_CODE, u as EMPTY_INPUT_CODE, j as DANGLING_REFERENCE_CODE, g as STYLES_NOT_IMPORTED_CODE, T as TOO_LARGE_CODE, aB as decodeEntryName, y as throwIfAborted, aY as readBytes, w as ImportReportBuilder, x as textChunks, ao as ImportError, F as reportSinkOptions, z as reportUnusedOptions, H as chooseGraph, v as resolveImportOptions, K as IdCoercer, L as declareResolved } from "./report-B1z4WT9e.js";
+import { X as XGMML_ISSUE, r as resolveSettings, m as membersOf, k as isCyTrue, l as XgmmlEmitter, p as parseXgmml, n as dialectOf, i as XGMML_ORIGIN_NAMESPACE } from "./importer-D_e7e7LX.js";
+import { t as tokenizeXml, f as xmlDeclaredEncoding, X as XmlSyntaxError } from "./escape-B-tkk_Cl.js";
+import { C as CsvRecordReader } from "./records-dbRkxwaq.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({
+  ...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",
+  /** A collapsed group's members are not in the network; they are recorded in 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",
+  /** The archive inflates beyond maxUncompressedBytes, or an entry beyond the ratio limit. */
+  TOO_LARGE: TOO_LARGE_CODE,
+  /** The session's styles are not applied (issue #706). */
+  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 session holds several networks; one was read. */
+  MULTIPLE_GRAPHS: MULTIPLE_GRAPHS_CODE,
+  /** graphIndex / graphName names no network (fatal). */
+  GRAPH_NOT_FOUND: GRAPH_NOT_FOUND_CODE,
+  /** graphName names several networks (fatal). */
+  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 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 entries = [];
+  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 name = decodeEntryName(bytes.subarray(at + CENTRAL_SIZE, at + CENTRAL_SIZE + nameLength));
+    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
+      }));
+    }
+    entries.push(
+      Object.freeze({
+        name,
+        method: view.getUint16(at + 10, true),
+        flags: view.getUint16(at + 8, true),
+        crc32: view.getUint32(at + 16, true),
+        compressedSize,
+        size,
+        localOffset: localOffset + shift,
+        directory: name.endsWith("/")
+      })
+    );
+    at = next;
+  }
+  return entries;
+}
+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 start = at + LOCAL_SIZE + view.getUint16(at + 26, true) + 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 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 = zipEntries.reduce((sum, e) => sum + e.size, 0);
+  return {
+    layout,
+    read: async (entry) => {
+      const before = inflated;
+      try {
+        const data = await readZipEntry(bytes, entry.zip, {
+          signal: common.signal,
+          maxBytes: budget,
+          maxRatio: MAX_RATIO,
+          onBytes: (n) => common.onProgress?.(before + n, total)
+        });
+        budget -= data.byteLength;
+        inflated += data.byteLength;
+        return data;
+      } catch (err) {
+        return zipFailure(err, report);
+      }
+    }
+  };
+}
+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);
+}
+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) {
+    if (entry.directory || NOISE.test(entry.name)) {
+      continue;
+    }
+    if (byName.has(entry.name)) {
+      repeated.push(entry.name);
+      continue;
+    }
+    byName.set(entry.name, entry);
+  }
+  if (repeated.length > 0) {
+    report.warning(
+      "unsupported",
+      CYS_ISSUE.DUPLICATE_ENTRY,
+      `${repeated.length} entry name(s) appear more than once; the first of each is read: ${listed(repeated)}`
+    );
+  }
+  const names = [...byName.keys()];
+  const marker = names.find((n) => /^([^/]*\/)?[^/]+\.version$/.test(n));
+  const cysession = names.find((n) => /^([^/]*\/)?cysession\.xml$/.test(n));
+  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);
+    const major = Number(version.split(".")[0]);
+    if (!Number.isInteger(major) || 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) {
+        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])];
+    layout.tables.push({
+      ...entry,
+      tablePath: table[1],
+      network: table[2],
+      namespace: urlDecode(table[3]),
+      element: element ?? null
+    });
+  } 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).join(", ");
+  return names.length > 10 ? `${head} and ${names.length - 10} more` : head;
+}
+async function readXmlTree(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 }),
+      {
+        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) {
+      report.fail(CYS_ISSUE.CORRUPT, `${entry}: ${err.message}`);
+    }
+    throw err;
+  }
+  const [root] = stack[0].children;
+  if (root === void 0) {
+    report.fail(CYS_ISSUE.CORRUPT, `${entry}: the document is empty`);
+  }
+  return root;
+}
+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.length === 2 && records[0].cells[0] === "CyCSV-Version") {
+    version = Number(records[0].cells[1]);
+    at = 1;
+  }
+  if (version !== 0 && version !== 1) {
+    return tableError(report, entry, `CyCSV version "${records[0].cells[1]}" is not 0 or 1`);
+  }
+  const headerLines = version === 1 ? 4 : 3;
+  if (records.length < at + headerLines) {
+    return tableError(report, entry, "the table header is incomplete");
+  }
+  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(s) 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,
+      `${entry}: ${problems.short} row(s) 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, `${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);
+    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);
+  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: null,
+  addMissingNodes: false
+};
+const USED_OPTIONS = /* @__PURE__ */ new Set([
+  "ids",
+  "addMissingNodes",
+  "duplicateEdges",
+  "selfLoops",
+  "onMixedDirection",
+  "defaultDirected",
+  "weightFrom",
+  "weightDtype",
+  "long",
+  "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) {
+  const bytes = await session.read(entry);
+  const scratch = new ImportReportBuilder(FORMAT, Number.MAX_SAFE_INTEGER);
+  try {
+    const doc = await parseXgmml(bytes, scratch, inner, void 0);
+    const dialect = dialectOf(doc, scratch);
+    relay(scratch.issues, report, entry.name);
+    return { doc, dialect };
+  } catch (err) {
+    if (!(err instanceof ImportError)) {
+      throw err;
+    }
+    const { issues } = scratch;
+    const fatal = issues.at(-1);
+    relay(issues.slice(0, -1), report, entry.name);
+    return report.fail(fatal?.code ?? CYS_ISSUE.CORRUPT, `${entry.name}: ${fatal?.message ?? err.message}`, {
+      line: fatal?.line ?? null
+    });
+  }
+}
+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, `${entry}: ${issue.message}`, where);
+    } else {
+      report.warning(issue.category, issue.code, `${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);
+    docs.set(network.name, parsed);
+    for (const graph of registeredGraphs(parsed)) {
+      const members = membersOf(parsed.doc, graph);
+      choices.push({
+        era: "3",
+        network,
+        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(s) or table(s) 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 readXmlTree(await session.read(layout.networkList), layout.networkList.name, report, inner);
+  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) {
+  return parsed.doc.root.subgraphs.filter((g) => isCyTrue(g.registered));
+}
+async function import3(prepared, choice, sink, parsed) {
+  const { report, inner, session } = prepared;
+  const { layout } = session;
+  const { doc, dialect } = parsed;
+  const graph = doc.root.subgraphs.find((g) => g.id === choice.graphId);
+  const members = membersOf(doc, graph);
+  const nodes = byId(members.nodes);
+  const edges = byId(members.edges);
+  const cache = /* @__PURE__ */ new Map();
+  const tableOf = (path) => {
+    let pending = cache.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).then((bytes) => readCyTable(bytes, path, entry.name, report, inner));
+      cache.set(path, pending);
+    }
+    return pending;
+  };
+  const virtuals = layout.cytables === null ? [] : await readVirtuals(session, layout.cytables, report, inner);
+  const declared = /* @__PURE__ */ new Set([
+    ...doc.nodes.flatMap((n) => n.id === null ? [] : [n.id]),
+    ...doc.edges.flatMap((e) => e.id === null ? [] : [e.id])
+  ]);
+  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) {
+      continue;
+    }
+    const local = entry.namespace === "LOCAL_ATTRS";
+    const shared = entry.namespace === "SHARED_ATTRS";
+    const namespace = local ? null : entry.namespace;
+    const hidden = !local && !shared;
+    const target = (key) => {
+      if (entry.element === "network") {
+        return key === choice.graphId ? graph.atts : void 0;
+      }
+      return (entry.element === "node" ? nodes : edges).get(key)?.atts;
+    };
+    for (const [key, cells] of table.rows) {
+      const atts = target(key);
+      if (atts === void 0) {
+        if (!declared.has(key)) {
+          unmatched++;
+        }
+        continue;
+      }
+      const line = table.lines.get(key) ?? 0;
+      for (let i = 1; i < table.columns.length && i < cells.length; i++) {
+        const att2 = cellAtt(table.columns[i], cells[i], line, namespace, hidden);
+        if (att2 !== null) {
+          atts.push(att2);
+        }
+      }
+    }
+    for (const virtual of await virtualColumnsOf(table, virtuals, tableOf, report)) {
+      const owned = table.columns.some((c) => c.name === virtual.column.name);
+      let ns = namespace;
+      if (local) {
+        ns = owned ? "SHARED_ATTRS" : null;
+      }
+      for (const [key, text] of virtual.values) {
+        const att2 = cellAtt(virtual.column, text, table.lines.get(key) ?? 0, ns, hidden);
+        if (att2 !== null) {
+          target(key)?.push(att2);
+        }
+      }
+    }
+  }
+  if (unmatched > 0) {
+    report.warning(
+      "parse-error",
+      CYS_ISSUE.TABLE_ROW,
+      `${unmatched} table row(s) of network ${choice.graphId} name no node, edge or network of it (stale rows); they are not read`
+    );
+  }
+  const views = layout.views.filter((v) => v.network === choice.graphId);
+  let visualStyle = null;
+  const extraViews = [];
+  for (const [i, view] of views.entries()) {
+    const viewDoc = (await parseEntry(session, view, report, inner)).doc;
+    if (i === 0) {
+      visualStyle = viewDoc.root.attrs.get("cy:visualStyle") ?? null;
+      applyView(viewDoc, graph, nodes, edges, report, view.name);
+    } else {
+      extraViews.push(viewPositions(viewDoc, prepared.zAs));
+    }
+  }
+  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 },
+    groupNodes: new Set(
+      members.nodes.filter((n) => n.atts.some((a) => a.name === "__isGroup" && isCyTrue(a.value))).flatMap((n) => n.id === null ? [] : [n.id])
+    ),
+    resolvePointer: pointerResolver(prepared, doc),
+    onMissingMember: (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);
+      }
+    }
+  };
+  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) {
+    report.warning(
+      "unsupported",
+      CYS_ISSUE.COLLAPSED_GROUP,
+      `${groups.length} collapsed group(s) hold ${groups.reduce((n, g) => n + g.members.length, 0)} member(s) that are not in the network; they are listed in meta.extra.cytoscape.groups`
+    );
+  }
+  reportRootOnly(parsed, report, choice.network.name);
+  writeViewPositions(
+    sink,
+    extraViews,
+    views.slice(1).map((v) => v.view),
+    report,
+    prepared.inner
+  );
+}
+async function readVirtuals(session, entry, report, inner) {
+  const tree = await readXmlTree(await session.read(entry), entry.name, report, inner);
+  const out = [];
+  for (const node of elementsNamed(tree, "virtualColumn")) {
+    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;
+  for (const node of view.nodes) {
+    const target = node.viewId === null ? void 0 : nodes.get(node.viewId);
+    if (target === void 0) {
+      dangling++;
+      continue;
+    }
+    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,
+      `${entry}: ${dangling} view element(s) name no node or edge of the network; they are not read`
+    );
+  }
+}
+function viewPositions(view, zAs) {
+  const out = /* @__PURE__ */ new Map();
+  for (const node of view.nodes) {
+    const x = Number(node.x);
+    const y = Number(node.y);
+    const z = zAs === "position" ? Number(node.z ?? 0) : 0;
+    if (node.viewId !== null && node.x !== null && node.y !== null && Number.isFinite(x) && Number.isFinite(y)) {
+      out.set(node.viewId, [x, y === 0 ? 0 : -y, Number.isFinite(z) ? z : 0]);
+    }
+  }
+  return out;
+}
+function writeViewPositions(sink, views, viewIds, report, common) {
+  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(id));
+      } catch {
+        continue;
+      }
+      if (index !== INVALID_INDEX) {
+        sink.setNodeValue(handle, index, xyz);
+      }
+    }
+  });
+}
+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,
+      `${entry}: ${nodes} node(s) and ${edges} edge(s) belong to no registered network (group meta-edges, collapsed group members) and 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), layout.cysession.name, report, inner);
+  const documentVersion = tree.attrs.get("documentVersion") ?? "";
+  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 id = record.attrs.get("id") ?? "";
+    const filename = record.attrs.get("filename") ?? `${id}.xgmml`;
+    if (id === "Network Root") {
+      continue;
+    }
+    const file = byDecoded.get(filename);
+    if (file === void 0) {
+      missing.push(filename);
+      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(s) 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(s) 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));
+}
+async function import2(prepared, choice, sink) {
+  const { report, inner, session } = prepared;
+  const { doc, dialect } = await parseEntry(session, choice.file, report, inner);
+  for (const [list, column] of [
+    ["selectedNodes", SELECTED_COLUMN],
+    ["hiddenNodes", HIDDEN_COLUMN]
+  ]) {
+    mark(doc.nodes, idsIn(choice.record, list), column);
+  }
+  for (const [list, column] of [
+    ["selectedEdges", SELECTED_COLUMN],
+    ["hiddenEdges", HIDDEN_COLUMN]
+  ]) {
+    mark(doc.edges, idsIn(choice.record, list), column);
+  }
+  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;
+  }
+  for (const record of records) {
+    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
+      });
+    }
+  }
+}
+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: style import is issue #706`
+    );
+  }
+  if (layout.skipped.length > 0) {
+    report.warning(
+      "unsupported",
+      CYS_ISSUE.ENTRY_SKIPPED,
+      `${layout.skipped.length} entries hold no graph data and 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) {
+    prepared.report.warning(
+      "unsupported",
+      CYS_ISSUE.MULTIPLE_GRAPHS,
+      `the session holds ${prepared.choices.length} networks; ${prepared.choices.length - 1} were not read (use importAll, graphIndex or graphName)`
+    );
+  }
+  return importChoice(prepared, index, sink);
+}
+async function importAllCys(input, sinkFor, options) {
+  const bytes = await readBytes(input, { signal: options?.signal ?? null }) ?? input;
+  const first = await prepare(bytes, null, options);
+  const reports = [];
+  for (let i = 0; i < first.choices.length; i++) {
+    const sink = sinkFor(i);
+    const prepared = i === 0 ? first : await prepare(bytes, null, options);
+    reportSinkOptions(sink, options, prepared.report, true);
+    reportUnusedOptions(options, prepared.report, USED_OPTIONS);
+    reports.push(await importChoice(prepared, i, sink));
+  }
+  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_NAME = /CytoscapeSession|cysession\.xml|\d+\.\d+\.\d+\.version/;
+function sniffCys(head) {
+  for (let at = 0; at + 4 <= head.byteLength; at++) {
+    if (startsLikeZip(head.subarray(at))) {
+      return SESSION_NAME.test(decodeEntryName(head.subarray(at))) ? 0.95 : 0;
+    }
+  }
+  return 0;
+}
+const cysImporter = Object.freeze({
+  format: FORMAT,
+  extensions: EXTENSIONS,
+  mimeTypes: MIME_TYPES,
+  sniff: sniffCys,
+  import: importCys,
+  importAll: importAllCys,
+  listGraphs: listCysGraphs
+});
+export {
+  CYS_ISSUE as C,
+  cysImporter as c
+};
+//# sourceMappingURL=importer-DD-xv9_Y.js.map