@graphty/graph-io 0.3.16 → 0.3.18

package/dist/graph-io.js

@@ -1,25 +1,28 @@
-import { I as ImportReportBuilder, a as throwIfAborted } from "./chunks/writer-BtWpUaiH.js";
-import { B, b, C, c, d, D, e, f, g, h, i, j, k, l, E, m, n, H, o, p, q, r, s, u, v, w, L, x, M, y, z, A, F, G, J, N, K, O, P, Q, R, S, T, U, V, W, X, Y, Z, _, $, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, aa, ab, ac, ad, ae, af, ag, ah, ai, aj, ak, al, am, an, ao, ap, aq, ar, as, at, au, av, aw, ax, ay, az, aA, aB, aC, aD, aE, aF, aG, t, aH } from "./chunks/writer-BtWpUaiH.js";
+import { I as ImportReportBuilder, a as throwIfAborted } from "./chunks/report-BOk0p5y8.js";
+import { A, b, B, c, d, e, C, f, g, h, D, i, j, k, l, m, n, o, p, q, E, r, s, u, G, H, v, w, x, y, z, F, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, _, $, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, aa, ab, ac, ad, ae, af, ag, ah, ai, aj, ak, al, am, an, ao, ap, aq, ar, as, at, au, av, aw, ax, ay, az, aA, aB, aC, aD, t } from "./chunks/report-BOk0p5y8.js";
 import { C as C2, c as c2, a } from "./chunks/children-CL3Cy0ez.js";
 import { GraphFormatError, GraphBuilder } from "@graphty/graph-format";
 import { csvImporter, csvExporter } from "./csv.js";
 import { CSV_CAPABILITIES, CSV_ISSUE, CSV_LOSS } from "./csv.js";
-import { b as dotImporter, d as dotExporter } from "./chunks/importer-D7ZcGCeb.js";
-import { D as D2, a as a10 } from "./chunks/importer-D7ZcGCeb.js";
+import { b as dotImporter, d as dotExporter } from "./chunks/importer-Br_QeAeE.js";
+import { D as D2, a as a10 } from "./chunks/importer-Br_QeAeE.js";
 import { gexfImporter, gexfExporter } from "./gexf.js";
 import { GEXF_1_2_CAPABILITIES, GEXF_ISSUE, GEXF_LOSS } from "./gexf.js";
 import { gmlImporter, gmlExporter } from "./gml.js";
 import { GML_ISSUE, GML_LOSS } from "./gml.js";
-import { b as graphmlImporter, g as graphmlExporter } from "./chunks/importer-CXEiicAN.js";
-import { G as G2, a as a11 } from "./chunks/importer-CXEiicAN.js";
-import { s as sniffJsonDialect, e as jsonImporter, c as jsonExporter } from "./chunks/importer-C7mnGdr_.js";
-import { J as J2, a as a12, b as b2, d as d2, j as j2 } from "./chunks/importer-C7mnGdr_.js";
+import { b as graphmlImporter, g as graphmlExporter } from "./chunks/importer-DHagxvDD.js";
+import { G as G2, a as a11 } from "./chunks/importer-DHagxvDD.js";
+import { s as sniffJsonDialect, e as jsonImporter, c as jsonExporter } from "./chunks/importer-Du5crN9l.js";
+import { J as J2, a as a12, b as b2, d as d2, j as j2 } from "./chunks/importer-Du5crN9l.js";
 import { neo4jImporter, neo4jExporter } from "./neo4j.js";
 import { ID_SPACE_COLUMN, LABELS_COLUMN, NEO4J_CAPABILITIES, NEO4J_ISSUE, NEO4J_LOSS, ORIGINAL_ID_COLUMN, TYPE_COLUMN } from "./neo4j.js";
-import { b as pajekImporter, p as pajekExporter } from "./chunks/importer-B8lsjFWx.js";
-import { P as P2, a as a13 } from "./chunks/importer-B8lsjFWx.js";
-import { T as T2, W as W2, i as i2, a as a14, p as p2 } from "./chunks/text-Dr0Ifpag.js";
-import { X as X2, a as a15, h as h2, t as t2, x as x2 } from "./chunks/escape-D1f9-cwf.js";
+import { o as oboImporter } from "./chunks/importer-aNJfe0qu.js";
+import { O as O2 } from "./chunks/importer-aNJfe0qu.js";
+import { b as pajekImporter, p as pajekExporter } from "./chunks/importer-d0uQxFp6.js";
+import { P as P2, a as a13 } from "./chunks/importer-d0uQxFp6.js";
+import { D as D3, L as L2, N as N2, c as c3, a as a14, b as b3, d as d3, e as e2, f as f2, g as g2, h as h2, i as i2, j as j3, k as k2, l as l2, m as m2, n as n2, o as o2, p as p2, s as s2, t as t2 } from "./chunks/writer-GAdltGmC.js";
+import { T as T2, W as W2, i as i3, a as a15, p as p3 } from "./chunks/text-Dr0Ifpag.js";
+import { X as X2, a as a16, h as h3, t as t3, x as x2 } from "./chunks/escape-D-gZWO26.js";
 const GRAPH_FORMATS = Object.freeze([
   "json",
   "graphml",
@@ -28,7 +31,8 @@ const GRAPH_FORMATS = Object.freeze([
   "gml",
   "dot",
   "pajek",
-  "neo4j"
+  "neo4j",
+  "obo"
 ]);
 const SNIFF_HEAD_BYTES = 8192;
 function extensionOf(filename) {
@@ -60,8 +64,8 @@ function rankFormats(hints, importers) {
   const candidates = [];
   let rank = 0;
   for (const importer of importers) {
-    const extensionMatch = extension !== null && importer.extensions.some((e2) => e2.toLowerCase() === extension);
-    const mimeMatch = mime !== null && importer.mimeTypes.some((m2) => m2.toLowerCase() === mime);
+    const extensionMatch = extension !== null && importer.extensions.some((e3) => e3.toLowerCase() === extension);
+    const mimeMatch = mime !== null && importer.mimeTypes.some((m3) => m3.toLowerCase() === mime);
     let content = 0;
     if (head !== null && head.byteLength > 0 && typeof importer.sniff === "function") {
       content = clamp(importer.sniff(head));
@@ -85,8 +89,8 @@ function rankFormats(hints, importers) {
     });
     candidates.push({ result: result2, rank: rank++ });
   }
-  candidates.sort((a16, b3) => b3.result.confidence - a16.result.confidence || a16.rank - b3.rank);
-  return candidates.map((c3) => c3.result);
+  candidates.sort((a17, b4) => b4.result.confidence - a17.result.confidence || a17.rank - b4.rank);
+  return candidates.map((c4) => c4.result);
 }
 function sniffFormat(hints, importers) {
   const ranked = rankFormats(hints, importers);
@@ -124,9 +128,19 @@ function skeletonOf(text) {
       case "options":
         root[key] = objectOf(keys.get(key));
         break;
-      case "graphs":
-        root[key] = [];
+      case "graphs": {
+        const nodes = keys.get("graphs[0].nodes[]");
+        const edges = keys.get("graphs[0].edges[]");
+        const graph = {};
+        if (nodes !== void 0) {
+          graph.nodes = [objectOf(nodes)];
+        }
+        if (edges !== void 0) {
+          graph.edges = [objectOf(edges)];
+        }
+        root[key] = nodes === void 0 && edges === void 0 ? [] : [graph];
         break;
+      }
       case "nodes":
       case "edges":
       case "links": {
@@ -168,6 +182,9 @@ function scanKeys(text) {
     if (depth === 2 && kinds[0] === "object" && kinds[1] === "object") {
       return labels[1] === "graph" || labels[1] === "options" ? labels[1] : null;
     }
+    if (depth === 5 && kinds.join() === "object,array,object,array,object" && labels[1] === "graphs" && labels[2] === "0" && (labels[3] === "nodes" || labels[3] === "edges")) {
+      return labels[3] === "nodes" ? "graphs[0].nodes[]" : "graphs[0].edges[]";
+    }
     if (depth === 3 && kinds[0] === "object" && kinds[1] === "array" && kinds[2] === "object") {
       const section = labels[1];
       if ((section === "nodes" || section === "edges" || section === "links") && labels[2] === "0") {
@@ -176,17 +193,17 @@ function scanKeys(text) {
     }
     return null;
   };
-  let i3 = 0;
-  const n2 = text.length;
-  while (i3 < n2) {
-    const ch = text[i3];
+  let i4 = 0;
+  const n3 = text.length;
+  while (i4 < n3) {
+    const ch = text[i4];
     if (ch === '"') {
-      const end = scanString(text, i3 + 1);
+      const end = scanString(text, i4 + 1);
       if (end < 0) {
         break;
       }
-      const literal = text.slice(i3 + 1, end);
-      i3 = end + 1;
+      const literal = text.slice(i4 + 1, end);
+      i4 = end + 1;
       if (expectingKey) {
         pendingKey = decodeKey(literal);
         expectingKey = false;
@@ -229,22 +246,22 @@ function scanKeys(text) {
       }
       pendingKey = null;
     }
-    i3++;
+    i4++;
   }
   return found;
 }
 function scanString(text, from) {
-  let i3 = from;
-  while (i3 < text.length) {
-    const ch = text[i3];
+  let i4 = from;
+  while (i4 < text.length) {
+    const ch = text[i4];
     if (ch === "\\") {
-      i3 += 2;
+      i4 += 2;
       continue;
     }
     if (ch === '"') {
-      return i3;
+      return i4;
     }
-    i3++;
+    i4++;
   }
   return -1;
 }
@@ -425,7 +442,24 @@ class FormatRegistry {
       await chosen.peeked?.close();
       throw err;
     }
-    return reports.map((report, i3) => result(chosen, builders[i3], report, options));
+    return reports.map((report, i4) => result(chosen, builders[i4], report, options));
+  }
+  /**
+   * The graphs of an input that can hold several, without importing them (a Cytoscape session's
+   * networks, a JGF `graphs` array), so a caller can offer a choice and then pass `graphIndex`
+   * or `graphName` to importGraph(). The format is named or sniffed as by importGraph().
+   * @param input - the text, bytes, stream or chunks to read
+   * @param options - the format, hints, common and format-specific import options
+   * @returns one listing per graph, in document order; null when the format's importer does not
+   * list its graphs (importGraph() then reads the first)
+   */
+  async listGraphs(input, options = {}) {
+    const chosen = await this.choose(input, options);
+    try {
+      return chosen.importer.listGraphs === void 0 ? null : await chosen.importer.listGraphs(chosen.source, importerOptions(options));
+    } finally {
+      await chosen.peeked?.close();
+    }
   }
   /**
    * The importer for an input: the named format, or the sniffed one.
@@ -483,7 +517,7 @@ class FormatRegistry {
   }
 }
 function createRegistry() {
-  return new FormatRegistry().registerImporter(jsonImporter).registerExporter(jsonExporter).registerImporter(graphmlImporter).registerExporter(graphmlExporter).registerImporter(gexfImporter).registerExporter(gexfExporter).registerImporter(csvImporter).registerExporter(csvExporter).registerImporter(gmlImporter).registerExporter(gmlExporter).registerImporter(dotImporter).registerExporter(dotExporter).registerImporter(pajekImporter).registerExporter(pajekExporter).registerImporter(neo4jImporter).registerExporter(neo4jExporter);
+  return new FormatRegistry().registerImporter(jsonImporter).registerExporter(jsonExporter).registerImporter(graphmlImporter).registerExporter(graphmlExporter).registerImporter(gexfImporter).registerExporter(gexfExporter).registerImporter(csvImporter).registerExporter(csvExporter).registerImporter(gmlImporter).registerExporter(gmlExporter).registerImporter(dotImporter).registerExporter(dotExporter).registerImporter(pajekImporter).registerExporter(pajekExporter).registerImporter(neo4jImporter).registerExporter(neo4jExporter).registerImporter(oboImporter);
 }
 const registry = createRegistry();
 function importGraph(input, options) {
@@ -492,6 +526,9 @@ function importGraph(input, options) {
 function importAllGraphs(input, options) {
   return registry.importAllGraphs(input, options);
 }
+function listGraphs(input, options) {
+  return registry.listGraphs(input, options);
+}
 function exportGraph(snapshot, format, options) {
   return registry.exportGraph(snapshot, format, options);
 }
@@ -584,10 +621,10 @@ async function peekHead(input, bytes, signal) {
   return { head: joinHead(buffered, bytes), input: replayed, close: () => replayed.close() };
 }
 function joinHead(chunks, bytes) {
-  if (chunks.every((c3) => c3 instanceof Uint8Array)) {
+  if (chunks.every((c4) => c4 instanceof Uint8Array)) {
     const total = Math.min(
       bytes,
-      chunks.reduce((sum, c3) => sum + c3.byteLength, 0)
+      chunks.reduce((sum, c4) => sum + c4.byteLength, 0)
     );
     const head = new Uint8Array(total);
     let offset = 0;
@@ -673,29 +710,37 @@ function readerIterator(stream) {
   };
 }
 export {
-  B as BAD_DEFAULT_CODE,
-  b as BAD_OPTIONS_CODE,
+  A as AMBIGUOUS_GRAPH_NAME_CODE,
+  b as ASPECT_ORDER_CODE,
+  B as BAD_ASPECT_BLOCK_CODE,
+  c as BAD_DEFAULT_CODE,
+  d as BAD_OPTIONS_CODE,
+  e as BAD_VALUE_CODE,
   C as COLUMN_RENAMED_CODE,
-  c as COLUMN_RENAMED_LOSS_CODE,
-  d as COUNT_HINT_CODE,
+  f as COLUMN_RENAMED_LOSS_CODE,
+  g as COUNT_HINT_CODE,
+  h as COUNT_MISMATCH_CODE,
   CSV_CAPABILITIES,
   CSV_ISSUE,
   CSV_LOSS,
   C2 as ChildrenCsr,
-  D as DEFAULT_CHUNK_BYTES,
-  e as DEFAULT_ERROR_LIMIT,
-  f as DIRECTED_COLUMN,
-  g as DIRECTION_FORCED_CODE,
-  h as DIRECTION_REFUSED_CODE,
+  D as DANGLING_REFERENCE_CODE,
+  D3 as DEFAULT_CHUNK_BYTES,
+  i as DEFAULT_ERROR_LIMIT,
+  j as DIRECTED_COLUMN,
+  k as DIRECTION_FORCED_CODE,
+  l as DIRECTION_REFUSED_CODE,
   D2 as DOT_ISSUE,
   a10 as DOT_LOSS,
-  i as DUPLICATE_EDGE_ID_CODE,
-  j as DUPLICATE_KEY_CODE,
-  k as DUPLICATE_NODE_CODE,
-  l as DirectionResolver,
+  m as DUPLICATE_ATTRIBUTE_CODE,
+  n as DUPLICATE_EDGE_ID_CODE,
+  o as DUPLICATE_KEY_CODE,
+  p as DUPLICATE_NODE_CODE,
+  q as DirectionResolver,
   E as EMPTY_COLUMN_DROPPED_CODE,
-  m as EMPTY_INPUT_CODE,
-  n as ENCODING_FALLBACK_CODE,
+  r as EMPTY_INPUT_CODE,
+  s as ENCODING_FALLBACK_CODE,
+  u as EQUATION_AS_TEXT_CODE,
   FormatRegistry,
   GEXF_1_2_CAPABILITIES,
   GEXF_ISSUE,
@@ -705,144 +750,156 @@ export {
   G2 as GRAPHML_ISSUE,
   a11 as GRAPHML_LOSS,
   GRAPH_FORMATS,
+  G as GRAPH_NOT_FOUND_CODE,
   H as HYPEREDGE_CODE,
-  o as ID_MERGED_CODE,
+  v as ID_MERGED_CODE,
   ID_SPACE_COLUMN,
-  p as ID_TEXT_COLLISION_CODE,
-  q as ID_TEXT_TYPE_CODE,
-  r as INTEGRAL_F64_CODE,
-  s as INVALID_ENCODING_CODE,
-  u as INVALID_UTF8_CODE,
-  v as IdCoercer,
-  w as ImportError,
+  w as ID_TEXT_COLLISION_CODE,
+  x as ID_TEXT_TYPE_CODE,
+  y as INTEGRAL_F64_CODE,
+  z as INVALID_ENCODING_CODE,
+  F as INVALID_UTF8_CODE,
+  J as IdCoercer,
+  K as ImportError,
   ImportReportBuilder,
   J2 as JSON_DIALECTS,
   a12 as JSON_ISSUE,
   b2 as JSON_LOSS,
   LABELS_COLUMN,
-  L as LOSS,
-  x as LineReader,
+  L2 as LOSS,
+  L as LineReader,
   M as MISSING_ENDPOINT_CODE,
-  y as MISSING_ID_CODE,
-  z as MIXED_DIRECTION_CODE,
-  A as MULTIPLE_GRAPHS_CODE,
-  F as MUTUAL_AS_UNDIRECTED_CODE,
-  G as MUTUAL_COLUMN,
-  J as MUTUAL_EXPANDED_CODE,
+  N as MISSING_ID_CODE,
+  O as MIXED_DIRECTION_CODE,
+  P as MULTIPLE_GRAPHS_CODE,
+  Q as MUTUAL_AS_UNDIRECTED_CODE,
+  R as MUTUAL_COLUMN,
+  S as MUTUAL_EXPANDED_CODE,
   NEO4J_CAPABILITIES,
   NEO4J_ISSUE,
   NEO4J_LOSS,
-  N as NO_CAPABILITIES,
-  K as NO_GRAPH_CODE,
-  O as OPTIONS_GAINED_CODE,
-  P as OPTION_IGNORED_CODE,
+  N2 as NO_CAPABILITIES,
+  T as NO_GRAPH_CODE,
+  O2 as OBO_ISSUE,
+  U as OPTIONS_GAINED_CODE,
+  V as OPTION_IGNORED_CODE,
   ORIGINAL_ID_COLUMN,
-  Q as PAIR_COLUMN,
+  W as PAIR_COLUMN,
   P2 as PAJEK_ISSUE,
   a13 as PAJEK_LOSS,
-  R as PARENTS_DROPPED_CODE,
-  S as PARSE_ERROR_CODE,
-  T as PRECISION_CODE,
-  U as RENAMED_CODE,
-  V as ROLE_ASSUMED_CODE,
-  W as ROLE_DROPPED_CODE,
-  X as ROLE_TAKEN_CODE,
-  Y as SINK_OPTION_CODE,
+  X as PARENTS_DROPPED_CODE,
+  Y as PARENT_CYCLE_CODE,
+  Z as PARSE_ERROR_CODE,
+  _ as PRECISION_CODE,
+  $ as RENAMED_CODE,
+  a0 as ROLE_ASSUMED_CODE,
+  a1 as ROLE_DROPPED_CODE,
+  a2 as ROLE_TAKEN_CODE,
+  a3 as SINK_OPTION_CODE,
   SNIFF_HEAD_BYTES,
-  Z as STORAGE_CLASS_CODE,
-  _ as STRAY_TEXT_CODE,
-  $ as SYNTAX_CODE,
-  a0 as TEMPORAL_DROPPED_CODE,
-  a1 as TEMPORAL_TEXT_DROPPED_CODE,
-  a2 as TEXT_INFERRED_CODE,
+  a4 as STATUS_FAILED_CODE,
+  a5 as STATUS_WARNING_CODE,
+  a6 as STORAGE_CLASS_CODE,
+  a7 as STRAY_TEXT_CODE,
+  a8 as STYLES_NOT_IMPORTED_CODE,
+  a9 as SYNTAX_CODE,
+  aa as TEMPORAL_DROPPED_CODE,
+  ab as TEMPORAL_TEXT_DROPPED_CODE,
+  ac as TEXT_INFERRED_CODE,
+  ad as TOO_LARGE_CODE,
   TYPE_COLUMN,
   T2 as TextCellWriter,
-  a3 as UNKNOWN_ATTR_TYPE_CODE,
-  a4 as UNKNOWN_ELEMENT_CODE,
-  a5 as UNKNOWN_ENCODING_CODE,
+  ae as UNKNOWN_ATTR_TYPE_CODE,
+  af as UNKNOWN_ELEMENT_CODE,
+  ag as UNKNOWN_ENCODING_CODE,
   UNKNOWN_FORMAT_CODE,
-  a6 as UNKNOWN_PARENT_CODE,
-  a7 as UNKNOWN_TYPE_CODE,
-  a8 as WEIGHT_KEY_CLASH_CODE,
+  ah as UNKNOWN_PARENT_CODE,
+  ai as UNKNOWN_TYPE_CODE,
+  aj as WEIGHT_KEY_CLASH_CODE,
+  ak as WIDENED_CODE,
   W2 as WIDENING_UNSUPPORTED_CODE,
-  a9 as XML_ILLEGAL_CHAR_CODE,
-  aa as XML_SYNTAX_CODE,
+  al as XML_ILLEGAL_CHAR_CODE,
+  am as XML_SYNTAX_CODE,
   X2 as XmlSyntaxError,
-  a15 as XmlTokenizer,
-  ab as canonicalId,
-  ac as capabilities,
-  ad as checkCapabilities,
+  a16 as XmlTokenizer,
+  an as canonicalId,
+  c3 as capabilities,
+  a14 as checkCapabilities,
   checkExport,
   c2 as childrenCsr,
   a as childrenFromColumn,
-  ae as coerceId,
-  af as coerceIdText,
-  ag as collectBytes,
+  ao as chooseGraph,
+  ap as coerceId,
+  aq as coerceIdText,
+  b3 as collectBytes,
   createRegistry,
   csvExporter,
   csvImporter,
-  ah as declareCompanion,
-  ai as declareResolved,
-  aj as decodeChunks,
+  ar as declareCompanion,
+  as as declareResolved,
+  d3 as decodeChunks,
+  at as decodeEntryName,
   d2 as dialectCapabilities,
   dotExporter,
   dotImporter,
-  ak as encodeChunks,
-  al as explicitWeights,
+  e2 as encodeChunks,
+  f2 as explicitWeights,
   exportGraph,
   exportGraphToString,
   extensionOf,
-  am as formatDecimal,
-  an as formatF32,
-  ao as formatF64,
-  ap as formatGmlReal,
-  aq as formatInteger,
+  g2 as formatDecimal,
+  h2 as formatF32,
+  i2 as formatF64,
+  j3 as formatGmlReal,
+  k2 as formatInteger,
   gexfExporter,
   gexfImporter,
   gmlExporter,
   gmlImporter,
   graphmlExporter,
   graphmlImporter,
-  h2 as hasIllegalXmlChar,
+  h3 as hasIllegalXmlChar,
   headBytes,
   importAllGraphs,
   importGraph,
-  i2 as inferTextDtype,
-  ar as inputLength,
-  as as isAbortError,
-  at as isCanonicalIntegerText,
-  au as isImportInput,
-  av as isNmtoken,
-  a14 as isNumericText,
-  aw as isWeightField,
-  ax as joinText,
+  i3 as inferTextDtype,
+  au as inputLength,
+  av as isAbortError,
+  aw as isCanonicalIntegerText,
+  ax as isImportInput,
+  l2 as isNmtoken,
+  a15 as isNumericText,
+  m2 as isWeightField,
+  n2 as joinText,
   j2 as jsonCapabilities,
   jsonExporter,
   jsonImporter,
-  ay as mangleNmtoken,
+  listGraphs,
+  o2 as mangleNmtoken,
   neo4jExporter,
   neo4jImporter,
   normalizeMimeType,
-  az as pairFolding,
+  oboImporter,
+  ay as pairFolding,
   pajekExporter,
   pajekImporter,
-  p2 as parseTextCell,
-  aA as parseWeightText,
+  p3 as parseTextCell,
+  p2 as parseWeightText,
   rankFormats,
-  aB as readText,
+  az as readText,
   registry,
-  aC as reportSinkOptions,
-  aD as reportUnusedOptions,
-  aE as resolveExportOptions,
-  aF as resolveImportOptions,
-  aG as sanitizeIds,
+  aA as reportSinkOptions,
+  aB as reportUnusedOptions,
+  aC as resolveExportOptions,
+  aD as resolveImportOptions,
+  s2 as sanitizeIds,
   sniff,
   sniffFormat,
   sniffJsonDialectHead,
   t as textChunks,
   throwIfAborted,
-  aH as toReadableStream,
-  t2 as tokenizeXml,
+  t2 as toReadableStream,
+  t3 as tokenizeXml,
   x2 as xmlIllegalTextNotes
 };
 //# sourceMappingURL=graph-io.js.map