@graphty/graph-io 0.3.18 → 0.3.19

package/dist/chunks/{importer-Du5crN9l.js → importer-Bm1_5vPS.js}

@@ -1,6 +1,8 @@
 import { GraphFormatError, INVALID_INDEX } from "@graphty/graph-format";
-import { aC as resolveExportOptions, ay as pairFolding, as as declareResolved, ag as UNKNOWN_ENCODING_CODE, s as ENCODING_FALLBACK_CODE, z as INVALID_ENCODING_CODE, F as INVALID_UTF8_CODE, V as OPTION_IGNORED_CODE, a3 as SINK_OPTION_CODE, H as HYPEREDGE_CODE, ad as TOO_LARGE_CODE, D as DANGLING_REFERENCE_CODE, A as AMBIGUOUS_GRAPH_NAME_CODE, G as GRAPH_NOT_FOUND_CODE, P as MULTIPLE_GRAPHS_CODE, v as ID_MERGED_CODE, n as DUPLICATE_EDGE_ID_CODE, p as DUPLICATE_NODE_CODE, ah as UNKNOWN_PARENT_CODE, e as BAD_VALUE_CODE, M as MISSING_ENDPOINT_CODE, N as MISSING_ID_CODE, a9 as SYNTAX_CODE, r as EMPTY_INPUT_CODE, aD as resolveImportOptions, I as ImportReportBuilder, az as readText, t as textChunks, aA as reportSinkOptions, aB as reportUnusedOptions, a as throwIfAborted, J as IdCoercer, q as DirectionResolver, aE as uniqueColumnName, ao as chooseGraph } from "./report-BOk0p5y8.js";
-import { c as capabilities, L as LOSS, n as joinText, e as encodeChunks, a as checkCapabilities, r as countMixedEdges, f as explicitWeights, h as formatF32, i as formatF64, w as weightFromValue } from "./writer-GAdltGmC.js";
+import { aB as resolveExportOptions, ax as pairFolding, ar as declareResolved, af as UNKNOWN_ENCODING_CODE, r as ENCODING_FALLBACK_CODE, y as INVALID_ENCODING_CODE, z as INVALID_UTF8_CODE, U as OPTION_IGNORED_CODE, a2 as SINK_OPTION_CODE, H as HYPEREDGE_CODE, ac as TOO_LARGE_CODE, D as DANGLING_REFERENCE_CODE, A as AMBIGUOUS_GRAPH_NAME_CODE, G as GRAPH_NOT_FOUND_CODE, O as MULTIPLE_GRAPHS_CODE, u as ID_MERGED_CODE, m as DUPLICATE_EDGE_ID_CODE, o as DUPLICATE_NODE_CODE, ag as UNKNOWN_PARENT_CODE, d as BAD_VALUE_CODE, M as MISSING_ENDPOINT_CODE, K as MISSING_ID_CODE, a8 as SYNTAX_CODE, q as EMPTY_INPUT_CODE, aC as resolveImportOptions, I as ImportReportBuilder, ay as readText, aD as textChunks, az as reportSinkOptions, aA as reportUnusedOptions, t as throwIfAborted, F as IdCoercer, p as DirectionResolver, aE as uniqueColumnName, an as chooseGraph } from "./report-BcWboivV.js";
+import { c as capabilities, L as LOSS, j as joinText, e as encodeChunks, a as checkCapabilities, g as countMixedEdges } from "./writer-DQiKgQJc.js";
+import { e as explicitWeights, a as formatF32, b as formatF64, w as weightFromValue } from "./weights-CwISIpCP.js";
+import { M as MAYBE_UNSAFE_INTEGER, e as rewriteNumbers, g as reviveNonstandard } from "./json-elements-CZY1wiZh.js";
 import { a as OBOGRAPHS_PREDICATE_TAGS, c as compactOboIri, o as oboColumnDecl, P as PLACEHOLDER_COLUMN, s as synonymScopeOf, O as OBO_NODE_COLUMNS } from "./ontology-BnrJ4I98.js";
 const JSON_DIALECTS = Object.freeze([
   "node-link",
@@ -1370,6 +1372,266 @@ const jsonExporter = Object.freeze({
 function jsonCapabilities(dialect) {
   return dialectCapabilities(dialect);
 }
+const GRAPH_FORMATS = Object.freeze([
+  "json",
+  "graphml",
+  "gexf",
+  "csv",
+  "gml",
+  "dot",
+  "pajek",
+  "neo4j",
+  "cx2",
+  "cx",
+  "obo"
+]);
+const SNIFF_HEAD_BYTES = 8192;
+function extensionOf(filename) {
+  const base = filename.slice(Math.max(filename.lastIndexOf("/"), filename.lastIndexOf("\\")) + 1);
+  const dot = base.lastIndexOf(".");
+  if (dot <= 0 || dot === base.length - 1) {
+    return null;
+  }
+  return base.slice(dot).toLowerCase();
+}
+function normalizeMimeType(mimeType) {
+  const semicolon = mimeType.indexOf(";");
+  return (semicolon < 0 ? mimeType : mimeType.slice(0, semicolon)).trim().toLowerCase();
+}
+function headBytes(head) {
+  if (typeof head === "string") {
+    return new TextEncoder().encode(head.slice(0, SNIFF_HEAD_BYTES)).subarray(0, SNIFF_HEAD_BYTES);
+  }
+  if (head.byteLength >= 2 && (head[0] === 255 && head[1] === 254 || head[0] === 254 && head[1] === 255)) {
+    const encoding = head[0] === 255 ? "utf-16le" : "utf-16be";
+    return headBytes(new TextDecoder(encoding).decode(head.subarray(0, SNIFF_HEAD_BYTES)));
+  }
+  return head.byteLength > SNIFF_HEAD_BYTES ? head.subarray(0, SNIFF_HEAD_BYTES) : head;
+}
+function rankFormats(hints, importers) {
+  const extension = typeof hints.filename === "string" ? extensionOf(hints.filename) : null;
+  const mime = typeof hints.mimeType === "string" ? normalizeMimeType(hints.mimeType) : null;
+  const head = hints.head === void 0 || hints.head === null ? null : headBytes(hints.head);
+  const candidates = [];
+  let rank = 0;
+  for (const importer of importers) {
+    const extensionMatch = extension !== null && importer.extensions.some((e) => e.toLowerCase() === extension);
+    const mimeMatch = mime !== null && importer.mimeTypes.some((m) => m.toLowerCase() === mime);
+    let content = 0;
+    if (head !== null && head.byteLength > 0 && typeof importer.sniff === "function") {
+      content = clamp(importer.sniff(head));
+    }
+    let confidence;
+    if (content > 0) {
+      confidence = 0.5 + 0.35 * content + (extensionMatch ? 0.1 : 0) + (mimeMatch ? 0.05 : 0);
+    } else if (extensionMatch || mimeMatch) {
+      confidence = (extensionMatch ? 0.3 : 0) + (mimeMatch ? 0.1 : 0);
+    } else {
+      continue;
+    }
+    const dialect = importer.format === "json" && head !== null ? sniffJsonDialectHead(head) : null;
+    const result = Object.freeze({
+      format: importer.format,
+      confidence: Math.min(1, confidence),
+      content,
+      extension: extensionMatch,
+      mimeType: mimeMatch,
+      dialect
+    });
+    candidates.push({ result, rank: rank++ });
+  }
+  candidates.sort((a, b) => b.result.confidence - a.result.confidence || a.rank - b.rank);
+  return candidates.map((c) => c.result);
+}
+function sniffFormat(hints, importers) {
+  const ranked = rankFormats(hints, importers);
+  return ranked.length > 0 ? ranked[0] : null;
+}
+function sniffJsonDialectHead(head) {
+  const text = typeof head === "string" ? head : new TextDecoder("utf-8", { fatal: false }).decode(head);
+  const body = text.charCodeAt(0) === 65279 ? text.slice(1) : text;
+  const trimmed = body.trimStart();
+  if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) {
+    return null;
+  }
+  let root;
+  try {
+    root = JSON.parse(trimmed);
+  } catch {
+    root = skeletonOf(trimmed);
+  }
+  return sniffJsonDialect(root);
+}
+function skeletonOf(text) {
+  const keys = scanKeys(text);
+  if (text.startsWith("[")) {
+    const first = keys.get("nodes[0]");
+    return first === void 0 ? null : [objectOf(first)];
+  }
+  const rootKeys = keys.get("");
+  if (rootKeys === void 0) {
+    return null;
+  }
+  const root = {};
+  for (const key of rootKeys) {
+    switch (key) {
+      case "graph":
+      case "options":
+        root[key] = objectOf(keys.get(key));
+        break;
+      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": {
+        const first = keys.get(`${key}[0]`);
+        root[key] = first === void 0 ? [] : [objectOf(first)];
+        break;
+      }
+      default:
+        root[key] = true;
+        break;
+    }
+  }
+  return root;
+}
+function objectOf(names) {
+  const out = {};
+  if (names !== void 0) {
+    for (const name of names) {
+      out[name] = name === "attributes" || name === "data" ? {} : true;
+    }
+  }
+  return out;
+}
+function scanKeys(text) {
+  const found = /* @__PURE__ */ new Map();
+  const kinds = [];
+  const labels = [];
+  const counts = [];
+  let pendingKey = null;
+  let expectingKey = false;
+  const pathOf = () => {
+    const depth = kinds.length;
+    if (depth === 1) {
+      return kinds[0] === "object" ? "" : null;
+    }
+    if (depth === 2 && kinds[0] === "array" && kinds[1] === "object" && labels[1] === "0") {
+      return "nodes[0]";
+    }
+    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") {
+        return `${section}[0]`;
+      }
+    }
+    return null;
+  };
+  let i = 0;
+  const n = text.length;
+  while (i < n) {
+    const ch = text[i];
+    if (ch === '"') {
+      const end = scanString(text, i + 1);
+      if (end < 0) {
+        break;
+      }
+      const literal = text.slice(i + 1, end);
+      i = end + 1;
+      if (expectingKey) {
+        pendingKey = decodeKey(literal);
+        expectingKey = false;
+      }
+      continue;
+    }
+    if (ch === "{" || ch === "[") {
+      let label = "";
+      if (kinds.length > 0) {
+        label = kinds[kinds.length - 1] === "object" ? pendingKey ?? "" : String(counts[counts.length - 1]);
+      }
+      kinds.push(ch === "{" ? "object" : "array");
+      labels.push(label);
+      counts.push(0);
+      expectingKey = ch === "{";
+      pendingKey = null;
+    } else if (ch === "}" || ch === "]") {
+      kinds.pop();
+      labels.pop();
+      counts.pop();
+      expectingKey = false;
+      pendingKey = null;
+    } else if (ch === ":") {
+      if (pendingKey !== null) {
+        const path = pathOf();
+        if (path !== null) {
+          let set = found.get(path);
+          if (set === void 0) {
+            set = /* @__PURE__ */ new Set();
+            found.set(path, set);
+          }
+          set.add(pendingKey);
+        }
+      }
+    } else if (ch === ",") {
+      const top = kinds.length - 1;
+      if (top >= 0) {
+        counts[top]++;
+        expectingKey = kinds[top] === "object";
+      }
+      pendingKey = null;
+    }
+    i++;
+  }
+  return found;
+}
+function scanString(text, from) {
+  let i = from;
+  while (i < text.length) {
+    const ch = text[i];
+    if (ch === "\\") {
+      i += 2;
+      continue;
+    }
+    if (ch === '"') {
+      return i;
+    }
+    i++;
+  }
+  return -1;
+}
+function decodeKey(literal) {
+  if (!literal.includes("\\")) {
+    return literal;
+  }
+  try {
+    return JSON.parse(`"${literal}"`);
+  } catch {
+    return literal;
+  }
+}
+function clamp(value) {
+  if (!(value > 0)) {
+    return 0;
+  }
+  return value > 1 ? 1 : value;
+}
 const NODE_KEYS = /* @__PURE__ */ new Set(["id", "lbl", "type", "propertyType", "meta"]);
 const META_KEYS = /* @__PURE__ */ new Set([
   "definition",
@@ -2592,84 +2854,7 @@ function parseDocument(text, report) {
   }
   return root;
 }
-const MAYBE_UNSAFE_INTEGER = new RegExp("(?<![0-9.])[0-9]{16}");
 const BIG_INTEGERS_SHOWN = 10;
-const NONSTANDARD_SENTINEL = `${String.fromCharCode(0)}graph-io:`;
-const NONSTANDARD_TOKENS = [
-  ["-Infinity", -Infinity],
-  ["Infinity", Infinity],
-  ["NaN", NaN]
-];
-const INTEGER_LITERAL = /^-?(0|[1-9][0-9]*)$/;
-function rewriteNumbers(text) {
-  const parts = [];
-  const tokens = /* @__PURE__ */ new Set();
-  const bigIntegers = [];
-  const arrays = [];
-  let expectValue = true;
-  let copied = 0;
-  let i = 0;
-  const n = text.length;
-  while (i < n) {
-    const ch = text[i];
-    if (ch === '"') {
-      i++;
-      while (i < n && text[i] !== '"') {
-        i += text[i] === "\\" ? 2 : 1;
-      }
-      i++;
-      expectValue = false;
-      continue;
-    }
-    if (ch === "{" || ch === "[") {
-      arrays.push(ch === "[");
-      expectValue = ch === "[";
-    } else if (ch === "}" || ch === "]") {
-      arrays.pop();
-      expectValue = false;
-    } else if (ch === ":") {
-      expectValue = true;
-    } else if (ch === ",") {
-      expectValue = arrays.length > 0 && arrays[arrays.length - 1];
-    } else if (expectValue && ch !== " " && ch !== "	" && ch !== "\n" && ch !== "\r") {
-      expectValue = false;
-      const token = NONSTANDARD_TOKENS.find(([word]) => text.startsWith(word, i));
-      let end = i;
-      let replacement = null;
-      if (token !== void 0) {
-        end = i + token[0].length;
-        tokens.add(token[0]);
-        replacement = JSON.stringify(`${NONSTANDARD_SENTINEL}${token[0]}`);
-      } else if (ch === "-" || ch >= "0" && ch <= "9") {
-        end = i + 1;
-        while (end < n && "0123456789+-.eE".includes(text[end])) {
-          end++;
-        }
-        const literal = text.slice(i, end);
-        if (INTEGER_LITERAL.test(literal) && !Number.isSafeInteger(Number(literal))) {
-          bigIntegers.push(literal);
-          replacement = `"${literal}"`;
-        }
-      }
-      if (replacement !== null) {
-        parts.push(text.slice(copied, i), replacement);
-        copied = end;
-      }
-      i = Math.max(end, i + 1);
-      continue;
-    }
-    i++;
-  }
-  parts.push(text.slice(copied));
-  return { text: parts.join(""), tokens, bigIntegers };
-}
-function reviveNonstandard(_key, value) {
-  if (typeof value === "string" && value.startsWith(NONSTANDARD_SENTINEL)) {
-    const found = NONSTANDARD_TOKENS.find(([word]) => word === value.slice(NONSTANDARD_SENTINEL.length));
-    return found === void 0 ? value : found[1];
-  }
-  return value;
-}
 function detectDialect(root, forced, report) {
   if (forced !== "auto") {
     return forced;
@@ -3860,7 +4045,8 @@ const jsonImporter = Object.freeze({
     if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) {
       return 0;
     }
-    return SNIFF_KEYS.some((key) => trimmed.includes(key)) ? 0.9 : 0.5;
+    const score = SNIFF_KEYS.some((key) => trimmed.includes(key)) ? 0.9 : 0.5;
+    return trimmed.startsWith("[") && sniffJsonDialectHead(trimmed) !== "cytoscape" ? Math.min(score, 0.3) : score;
   },
   /**
    * Read a JSON graph document into the sink.
@@ -3962,13 +4148,20 @@ function readGraph(root, dialect, sink, report, resolved, json, options) {
   throwIfAborted(resolved.signal);
 }
 export {
+  GRAPH_FORMATS as G,
   JSON_DIALECTS as J,
+  SNIFF_HEAD_BYTES as S,
   JSON_ISSUE as a,
   JSON_LOSS as b,
   jsonExporter as c,
   dialectCapabilities as d,
   jsonImporter as e,
+  extensionOf as f,
+  sniffJsonDialectHead as g,
+  headBytes as h,
   jsonCapabilities as j,
-  sniffJsonDialect as s
+  normalizeMimeType as n,
+  rankFormats as r,
+  sniffFormat as s
 };
-//# sourceMappingURL=importer-Du5crN9l.js.map
+//# sourceMappingURL=importer-Bm1_5vPS.js.map