@graphty/graph-io 0.3.24 → 0.3.26

package/dist/chunks/json-elements-3tnyt5uZ.js

@@ -0,0 +1,1225 @@
+import { GraphFormatError, INVALID_INDEX } from "@graphty/graph-format";
+import { V as BAD_ASPECT_BLOCK_CODE, W as MULTI_ASPECT_FRAGMENT_CODE, Y as ASPECT_ORDER_CODE, j as COUNT_MISMATCH_CODE, Z as STATUS_FAILED_CODE, _ as STATUS_WARNING_CODE, b as plural, $ as agree, a0 as uniqueColumnName, C as COLUMN_RENAMED_CODE, a1 as declareResolved, a2 as JSON_NONSTANDARD_NUMBER_CODE, o as DUPLICATE_ATTRIBUTE_CODE, P as PRECISION_CODE, a3 as BAD_VALUE_CODE } from "./export-BTI4yQgy.js";
+import { t as trimTrailingZeros } from "./text-DmcUs5_Q.js";
+const MAYBE_UNSAFE_INTEGER = new RegExp("(?<![0-9.])[0-9]{16}");
+const MAYBE_INEXACT_EXPONENT = new RegExp(
+  [
+    /\d[eE]\+?0*(?:1[5-9]|[2-9]\d|[1-9]\d{2,})/,
+    // an exponent of 15 or more
+    /\d[eE]-0*(?:[3-9]\d{2}|[1-9]\d{3,})/,
+    // an exponent of -300 or less
+    new RegExp("(?<![\\d.])(?=(?:\\d\\.?){16})\\d+\\.\\d+[eE]")
+    // 16 or more digits split by a decimal point
+  ].map((r) => r.source).join("|")
+);
+const SENTINEL = `${String.fromCodePoint(0)}graph-io`;
+const NONSTANDARD_TOKENS = [
+  ["-Infinity", -Infinity],
+  ["Infinity", Infinity],
+  ["NaN", NaN]
+];
+const INTEGER_LITERAL = /^-?(0|[1-9][0-9]*)$/;
+const NUMBER_PARTS = /^(-?)(\d+)(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/;
+function sentinelFor(text) {
+  let haystack = text;
+  if (/\\u0000/i.test(text)) {
+    const decoded = [];
+    for (const [literal] of text.matchAll(/"(?:[^"\\]|\\.)*"/g)) {
+      if (literal.includes("\\")) {
+        decoded.push(decodeString(literal));
+      }
+    }
+    haystack = `${decoded.join("\n")}
+${text}`;
+  }
+  let k = 0;
+  while (haystack.includes(`graph-io${k === 0 ? "" : String(k)}:`)) {
+    k++;
+  }
+  return `${SENTINEL}${k === 0 ? "" : String(k)}:`;
+}
+function decodeString(literal) {
+  try {
+    return String(JSON.parse(literal));
+  } catch {
+    return literal;
+  }
+}
+function isInexactLiteral(literal) {
+  const value = Number(literal);
+  if (!Number.isFinite(value)) {
+    return true;
+  }
+  if (value === 0) {
+    return /[1-9]/.test(literal.split(/[eE]/)[0]);
+  }
+  if (Number.isSafeInteger(value) || !Number.isInteger(value)) {
+    return false;
+  }
+  const m = NUMBER_PARTS.exec(literal);
+  if (m === null) {
+    return false;
+  }
+  const digits = trimTrailingZeros(m[2] + (m[3] ?? ""));
+  const exponent = Number(m[4] ?? "0") - (m[3] ?? "").length + ((m[2] + (m[3] ?? "")).length - digits.length);
+  if (digits.replace(/^0+/, "").length <= 15 || exponent < 0) {
+    return false;
+  }
+  const exact = BigInt(digits) * 10n ** BigInt(exponent);
+  return exact !== BigInt(Math.abs(value));
+}
+function rewriteNumbers(text, options = {}) {
+  const nonstandard = options.nonstandard ?? true;
+  const exactSentinel = options.exactSentinel ?? false;
+  const sentinel = sentinelFor(text);
+  const exactPrefix = `${sentinel}exact:`;
+  const parts = [];
+  const tokens = /* @__PURE__ */ new Set();
+  const bigIntegers = [];
+  const inexact = [];
+  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 ? NONSTANDARD_TOKENS.find(([word]) => text.startsWith(word, i)) : void 0;
+      let end = i;
+      let replacement = null;
+      if (token !== void 0) {
+        end = i + token[0].length;
+        tokens.add(token[0]);
+        replacement = JSON.stringify(`${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)) {
+          if (!Number.isSafeInteger(Number(literal))) {
+            bigIntegers.push(literal);
+            replacement = exactSentinel ? JSON.stringify(`${exactPrefix}${literal}`) : `"${literal}"`;
+          }
+        } else if (isInexactLiteral(literal)) {
+          inexact.push(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));
+  const revive = (_key, value) => {
+    if (typeof value === "string" && value.startsWith(sentinel)) {
+      const found = NONSTANDARD_TOKENS.find(([word]) => word === value.slice(sentinel.length));
+      return found === void 0 ? value : found[1];
+    }
+    return value;
+  };
+  const reviveExact = (_key, value) => typeof value === "string" && value.startsWith(exactPrefix) ? new ExactInteger(value.slice(exactPrefix.length)) : value;
+  return { text: parts.join(""), tokens, bigIntegers, inexact, revive, reviveExact };
+}
+const LINEAR_KEYS = 32;
+function findDuplicateKeys(text) {
+  const found = [];
+  const spans = [];
+  const wide = [];
+  let depth = 0;
+  const n = text.length;
+  let at = 0;
+  while (at < n) {
+    const c = text.codePointAt(at);
+    if (c === 123 || c === 91) {
+      openContainer(spans, wide, depth, c === 91);
+      depth++;
+    } else if (c === 125 || c === 93) {
+      depth--;
+    } else if (c === 34) {
+      const end = closingQuote(text, at + 1);
+      const keys = depth > 0 ? spans[depth - 1] : null;
+      const isObjectKey = keys !== null && keys[0] !== -1 && isKey(text, end + 1);
+      if (isObjectKey && isRepeated(text, at + 1, end, keys, wide, depth - 1)) {
+        found.push({ key: text.slice(at + 1, end), offset: at });
+      }
+      at = end;
+    }
+    at++;
+  }
+  return found;
+}
+function openContainer(spans, wide, depth, isArray) {
+  if (spans.length === depth) {
+    spans.push([]);
+    wide.push(null);
+  }
+  spans[depth].length = 0;
+  if (isArray) {
+    spans[depth].push(-1);
+  }
+  wide[depth] = null;
+}
+function isRepeated(text, start, end, keys, wide, level) {
+  const set = wide[level];
+  if (set !== null) {
+    const key = text.slice(start, end);
+    return set.has(key) || (set.add(key), false);
+  }
+  const length = end - start;
+  for (let k = 0; k < keys.length; k += 2) {
+    if (keys[k + 1] - keys[k] === length && sameText(text, keys[k], start, length)) {
+      return true;
+    }
+  }
+  keys.push(start, end);
+  if (keys.length > 2 * LINEAR_KEYS) {
+    const all = /* @__PURE__ */ new Set();
+    for (let k = 0; k < keys.length; k += 2) {
+      all.add(text.slice(keys[k], keys[k + 1]));
+    }
+    wide[level] = all;
+  }
+  return false;
+}
+function sameText(text, a, b, length) {
+  for (let i = 0; i < length; i++) {
+    if (text.codePointAt(a + i) !== text.codePointAt(b + i)) {
+      return false;
+    }
+  }
+  return true;
+}
+function closingQuote(text, from) {
+  for (let q = text.indexOf('"', from); q >= 0; q = text.indexOf('"', q + 1)) {
+    let backslashes = 0;
+    while (text.codePointAt(q - 1 - backslashes) === 92) {
+      backslashes++;
+    }
+    if (backslashes % 2 === 0) {
+      return q;
+    }
+  }
+  return text.length;
+}
+function isKey(text, from) {
+  let i = from;
+  while (i < text.length && isSpace(text.codePointAt(i))) {
+    i++;
+  }
+  return text.codePointAt(i) === 58;
+}
+class ExactInteger {
+  /**
+   * Wrap the digits of an integer literal.
+   * @param digits - the literal
+   */
+  constructor(digits) {
+    this.digits = digits;
+  }
+  /**
+   * The nearest number (JSON.stringify writes it as such).
+   * @returns the number
+   */
+  toJSON() {
+    return Number(this.digits);
+  }
+}
+function parseExact(text) {
+  if (!MAYBE_UNSAFE_INTEGER.test(text)) {
+    return { value: JSON.parse(text), exact: false };
+  }
+  const scan = rewriteNumbers(text, { nonstandard: false, exactSentinel: true });
+  if (scan.bigIntegers.length === 0) {
+    return { value: JSON.parse(text), exact: false };
+  }
+  return { value: JSON.parse(scan.text, scan.reviveExact), exact: true };
+}
+function plainJson(value, onPrecision) {
+  if (value instanceof ExactInteger) {
+    onPrecision?.(value.digits);
+    return Number(value.digits);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => plainJson(item, onPrecision));
+  }
+  if (typeof value === "object" && value !== null) {
+    const out = {};
+    for (const [key, item] of Object.entries(value)) {
+      setOwn(out, key, plainJson(item, onPrecision));
+    }
+    return out;
+  }
+  return value;
+}
+function setOwn(target, key, value) {
+  if (key === "__proto__") {
+    Object.defineProperty(target, key, { value, enumerable: true, writable: true, configurable: true });
+  } else {
+    target[key] = value;
+  }
+}
+function parseNonstandard(text) {
+  if (!/NaN|Infinity/.test(text)) {
+    return null;
+  }
+  const scan = rewriteNumbers(text, { nonstandard: true, exactSentinel: true });
+  if (scan.tokens.size === 0) {
+    return null;
+  }
+  try {
+    const value = JSON.parse(scan.text, (key, raw) => scan.reviveExact(key, scan.revive(key, raw)));
+    return { value, exact: scan.bigIntegers.length > 0, tokens: scan.tokens };
+  } catch {
+    return null;
+  }
+}
+const SURROGATE_ESCAPES = String.raw`\uD800-\uDFFF`;
+const LONE_SURROGATE = new RegExp("[\\ud800-\\udbff](?![\\udc00-\\udfff])|(?<![\\ud800-\\udbff])[\\udc00-\\udfff]", "g");
+const MAYBE_SURROGATE = /\\u[dD][89a-fA-F]|[\ud800-\udfff]/;
+function repairSurrogates(value, fixed) {
+  if (typeof value === "string") {
+    const repaired = value.replaceAll(LONE_SURROGATE, "�");
+    if (repaired !== value) {
+      fixed.count++;
+    }
+    return repaired;
+  }
+  if (Array.isArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      value[i] = repairSurrogates(value[i], fixed);
+    }
+    return value;
+  }
+  if (isRecord(value)) {
+    const keys = Object.keys(value);
+    const repairedKeys = keys.map((key) => key.replaceAll(LONE_SURROGATE, "�"));
+    const renamed = repairedKeys.some((key, i) => key !== keys[i]);
+    const out = renamed ? {} : value;
+    keys.forEach((key, i) => {
+      if (repairedKeys[i] !== key) {
+        fixed.count++;
+      }
+      if (renamed && Object.hasOwn(out, repairedKeys[i])) {
+        fixed.collisions.push(repairedKeys[i]);
+      }
+      setOwn(out, repairedKeys[i], repairSurrogates(value[key], fixed));
+    });
+    return out;
+  }
+  return value;
+}
+function keyCount(value) {
+  if (Array.isArray(value)) {
+    return value.reduce((n, item) => n + keyCount(item), 0);
+  }
+  if (isRecord(value)) {
+    return Object.keys(value).reduce((n, key) => n + 1 + keyCount(value[key]), 0);
+  }
+  return 0;
+}
+function duplicateKey(text) {
+  const stack = [];
+  let i = 0;
+  while (i < text.length) {
+    const c = text[i];
+    if (c === "{") {
+      stack.push(/* @__PURE__ */ new Set());
+    } else if (c === "[") {
+      stack.push(null);
+    } else if (c === "}" || c === "]") {
+      stack.pop();
+    } else if (c === '"') {
+      const start = i;
+      i = stringEnd(text, i + 1);
+      const keys = stack.at(-1) ?? null;
+      if (keys !== null && text[skipSpace(text, i + 1)] === ":") {
+        const key = JSON.parse(text.slice(start, i + 1));
+        if (keys.has(key)) {
+          return key;
+        }
+        keys.add(key);
+      }
+    }
+    i++;
+  }
+  return null;
+}
+function stringEnd(text, from) {
+  let i = from;
+  while (i < text.length && text[i] !== '"') {
+    i += text[i] === "\\" ? 2 : 1;
+  }
+  return i;
+}
+function skipSpace(text, from) {
+  let i = from;
+  while (i < text.length && isSpace(text.codePointAt(i))) {
+    i++;
+  }
+  return i;
+}
+const KEY_COLON = /"\s*:/g;
+function checkParsed(text, parsed, line, report) {
+  let value = parsed;
+  if (MAYBE_SURROGATE.test(text)) {
+    const fixed = { count: 0, collisions: [] };
+    value = repairSurrogates(value, fixed);
+    for (const key of fixed.collisions) {
+      report.warnOnce(
+        "validation-error",
+        DUPLICATE_ATTRIBUTE_CODE,
+        `an object holds two keys that are the same key ${JSON.stringify(key)} once their lone surrogates are replaced with U+FFFD; the later value is read`,
+        { line, element: key },
+        `${DUPLICATE_ATTRIBUTE_CODE}:json:${key}`
+      );
+    }
+    if (fixed.count > 0) {
+      report.error(
+        "validation-error",
+        BAD_VALUE_CODE,
+        `${fixed.count} string${plural(fixed.count)} ${agree(fixed.count, "holds", "hold")} a lone surrogate (an unpaired ${SURROGATE_ESCAPES} escape); each is read with U+FFFD in its place`,
+        { line }
+      );
+    }
+  }
+  if (typeof value === "object" && value !== null && (text.match(KEY_COLON)?.length ?? 0) > keyCount(value)) {
+    const key = duplicateKey(text);
+    if (key !== null) {
+      report.warnOnce(
+        "validation-error",
+        DUPLICATE_ATTRIBUTE_CODE,
+        `an object holds the key ${JSON.stringify(key)} twice; the later value is read`,
+        { line, element: key },
+        `${DUPLICATE_ATTRIBUTE_CODE}:json:${key}`
+      );
+    }
+  }
+  return value;
+}
+class JsonScanError extends Error {
+  /**
+   * Create the error.
+   * @param message - what is wrong
+   * @param line - the 1-based line
+   * @param empty - whether the input is empty
+   */
+  constructor(message, line, empty = false) {
+    super(message);
+    this.name = "JsonScanError";
+    this.line = line;
+    this.empty = empty;
+  }
+}
+const isSpace = (c) => c === 32 || c === 10 || c === 13 || c === 9;
+const endsScalar = (c) => isSpace(c) || c === 44 || c === 93 || c === 125 || c === 58;
+const QUOTE_OR_BACKSLASH = /["\\]/g;
+const MAX_ELEMENT_DEPTH = 200;
+class ChunkCursor {
+  /**
+   * Wrap text chunks.
+   * @param chunks - the decoded text
+   */
+  constructor(chunks) {
+    this.buf = "";
+    this.pos = 0;
+    this.linesBefore = 1;
+    this.parts = null;
+    this.captureStart = 0;
+    this.deepest = 0;
+    this.iterator = chunks[Symbol.asyncIterator]();
+  }
+  /**
+   * Read the next chunk once the current one is consumed.
+   * @returns false at the end of the input
+   */
+  async fill() {
+    if (this.parts !== null) {
+      this.parts.push(this.buf.slice(this.captureStart));
+      this.captureStart = 0;
+    }
+    this.linesBefore += countNewlines(this.buf, 0, this.buf.length);
+    const endsWithCr = this.buf.endsWith("\r");
+    for (; ; ) {
+      const next = await this.iterator.next();
+      if (next.done === true) {
+        this.buf = "";
+        this.pos = 0;
+        return false;
+      }
+      if (next.value.length > 0) {
+        if (endsWithCr && next.value.startsWith("\n")) {
+          this.linesBefore--;
+        }
+        this.buf = next.value;
+        this.pos = 0;
+        return true;
+      }
+    }
+  }
+  /**
+   * The 1-based line of the read position.
+   * @returns the line
+   */
+  line() {
+    return this.linesBefore + countNewlines(this.buf, 0, Math.min(this.pos, this.buf.length));
+  }
+  /**
+   * The text from the read position to the end of the current chunk, at most `length` characters.
+   * @param length - the most characters
+   * @returns the text
+   */
+  ahead(length) {
+    return this.buf.slice(this.pos, this.pos + length);
+  }
+  /**
+   * Skip whitespace and return the next character without consuming it.
+   * @returns the character, or "" at the end of the input
+   */
+  async peek() {
+    for (; ; ) {
+      while (this.pos < this.buf.length && isSpace(this.buf.charCodeAt(this.pos))) {
+        this.pos++;
+      }
+      if (this.pos < this.buf.length) {
+        return this.buf[this.pos];
+      }
+      if (!await this.fill()) {
+        return "";
+      }
+    }
+  }
+  /** Start keeping the text from the read position. */
+  beginCapture() {
+    this.parts = [];
+    this.captureStart = this.pos;
+  }
+  /**
+   * Stop keeping text.
+   * @returns the text kept since beginCapture()
+   */
+  endCapture() {
+    const parts = this.parts ?? [];
+    parts.push(this.buf.slice(this.captureStart, this.pos));
+    this.parts = null;
+    return parts.length === 1 ? parts[0] : parts.join("");
+  }
+  /** Drop the capture without building its text. */
+  dropCapture() {
+    this.parts = null;
+  }
+  /**
+   * Advance past one JSON value starting at the read position (which holds its first
+   * character), tracking strings and nesting only; the value is validated when it is parsed.
+   * @param startDepth - the nesting depth already entered (1 when the opening brace was consumed)
+   */
+  async skipValue(startDepth = 0) {
+    let depth = startDepth;
+    this.deepest = depth;
+    if (depth === 0) {
+      const c = this.buf.charCodeAt(this.pos);
+      if (c === 34) {
+        this.pos++;
+        await this.skipString();
+        return;
+      }
+      if (c !== 123 && c !== 91) {
+        await this.skipScalar();
+        return;
+      }
+    }
+    for (; ; ) {
+      if (this.pos >= this.buf.length && !await this.fill()) {
+        throw new JsonScanError("the document ends inside a value", this.line());
+      }
+      const c = this.buf.charCodeAt(this.pos);
+      this.pos++;
+      if (c === 34) {
+        await this.skipString();
+      } else if (c === 123 || c === 91) {
+        depth++;
+        if (depth > this.deepest) {
+          this.deepest = depth;
+        }
+      } else if (c === 125 || c === 93) {
+        depth--;
+        if (depth === 0) {
+          return;
+        }
+      }
+    }
+  }
+  /** Advance past the rest of a string whose opening quote was consumed. */
+  async skipString() {
+    for (; ; ) {
+      QUOTE_OR_BACKSLASH.lastIndex = this.pos;
+      const found = QUOTE_OR_BACKSLASH.exec(this.buf);
+      if (found === null) {
+        this.pos = this.buf.length;
+        if (!await this.fill()) {
+          throw new JsonScanError("the document ends inside a string", this.line());
+        }
+        continue;
+      }
+      this.pos = found.index + 1;
+      if (found[0] === '"') {
+        return;
+      }
+      if (this.pos >= this.buf.length && !await this.fill()) {
+        throw new JsonScanError("the document ends inside a string", this.line());
+      }
+      this.pos++;
+    }
+  }
+  /** Advance past a bare scalar (a number, true, false, null or a stray word). */
+  async skipScalar() {
+    for (; ; ) {
+      while (this.pos < this.buf.length && !endsScalar(this.buf.charCodeAt(this.pos))) {
+        this.pos++;
+      }
+      if (this.pos < this.buf.length || !await this.fill()) {
+        return;
+      }
+    }
+  }
+  /**
+   * Read one JSON string literal at the read position (its opening quote).
+   * @returns the decoded string
+   */
+  async readString() {
+    this.beginCapture();
+    this.pos++;
+    await this.skipString();
+    const literal = this.endCapture();
+    try {
+      return JSON.parse(literal);
+    } catch (err) {
+      throw new JsonScanError(`invalid string: ${messageOf(err)}`, this.line());
+    }
+  }
+}
+function countNewlines(text, from, to) {
+  let count = 0;
+  let i = text.indexOf("\n", from);
+  while (i >= 0 && i < to) {
+    count++;
+    i = text.indexOf("\n", i + 1);
+  }
+  i = text.indexOf("\r", from);
+  while (i >= 0 && i < to) {
+    if (text[i + 1] !== "\n") {
+      count++;
+    }
+    i = text.indexOf("\r", i + 1);
+  }
+  return count;
+}
+function messageOf(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function parseAt(text, line, report) {
+  let parsed;
+  try {
+    parsed = parseExact(text);
+  } catch (err) {
+    const recovered = report === null ? null : parseNonstandard(text);
+    if (recovered === null) {
+      throw new JsonScanError(`invalid JSON: ${messageOf(err)}`, line);
+    }
+    report?.warnOnce(
+      "coercion",
+      JSON_NONSTANDARD_NUMBER_CODE,
+      `the document uses the non-standard token${plural(recovered.tokens.size)} ${[...recovered.tokens].join(", ")}, which strict JSON does not allow; read as numbers`,
+      { line }
+    );
+    parsed = recovered;
+  }
+  if (report !== null) {
+    parsed = { ...parsed, value: checkParsed(text, parsed.value, line, report) };
+  }
+  return parsed;
+}
+function notJsonHint(head) {
+  if (head.startsWith("<")) {
+    return "; the input looks like HTML or XML (an error page saved as the file?), not JSON";
+  }
+  if (head.startsWith("PK")) {
+    return "; the input is a ZIP archive (a Cytoscape session .cys is read by the cys importer), not JSON";
+  }
+  return "";
+}
+async function* scanAspects(chunks, report = null) {
+  const cur = new ChunkCursor(chunks);
+  const first = await cur.peek();
+  if (first === "") {
+    throw new JsonScanError("the input is empty", 1, true);
+  }
+  const hint = notJsonHint(cur.ahead(16));
+  if (hint === "" && cur.ahead(8).includes(String.fromCodePoint(0))) {
+    throw new JsonScanError(
+      'the input holds NUL characters: UTF-16 without a byte order mark (pass the encoding option, such as "utf-16le"), or binary data; not JSON',
+      cur.line()
+    );
+  }
+  if (first === "[") {
+    cur.pos++;
+    yield* members(cur, report);
+    return;
+  }
+  const line = cur.line();
+  if (first === "{") {
+    yield { kind: "root", value: void 0, object: true, line };
+    return;
+  }
+  yield { kind: "root", value: await scalarRoot(cur, line, hint), object: false, line };
+}
+async function scalarRoot(cur, line, hint) {
+  cur.beginCapture();
+  await cur.skipValue();
+  let value;
+  try {
+    ({ value } = parseAt(cur.endCapture(), line, null));
+  } catch (err) {
+    if (err instanceof JsonScanError && hint !== "") {
+      throw new JsonScanError(`${err.message}${hint}`, err.line);
+    }
+    throw err;
+  }
+  if (await cur.peek() !== "") {
+    throw new JsonScanError("unexpected text after the document", cur.line());
+  }
+  return value;
+}
+async function* members(cur, report) {
+  let block = 0;
+  let next = await cur.peek();
+  if (next === "]") {
+    cur.pos++;
+  }
+  while (next !== "]") {
+    yield* member(cur, block, report);
+    block++;
+    next = await cur.peek();
+    if (next !== "," && next !== "]") {
+      throw new JsonScanError(
+        next === "" ? "the document ends before its closing bracket" : `expected "," or "]", found "${next}"`,
+        cur.line()
+      );
+    }
+    cur.pos++;
+  }
+  if (await cur.peek() !== "") {
+    throw new JsonScanError("unexpected text after the closing bracket", cur.line());
+  }
+}
+async function* member(cur, block, report) {
+  const c = await cur.peek();
+  const line = cur.line();
+  if (c === "" || c === "]" || c === ",") {
+    throw new JsonScanError(c === "" ? "the document ends inside its array" : `unexpected "${c}"`, line);
+  }
+  cur.beginCapture();
+  if (c !== "{") {
+    await cur.skipValue();
+    yield wholeMember(cur, block, line, report);
+    return;
+  }
+  cur.pos++;
+  if (await cur.peek() !== '"') {
+    await cur.skipValue(1);
+    yield wholeMember(cur, block, line, report);
+    return;
+  }
+  const outer = cur.endCapture();
+  const firstLine = cur.line();
+  const keys = { others: [], firstBlock: null, deep: 0 };
+  let next = ",";
+  let index = 0;
+  while (next === ",") {
+    const key = await readKey(cur);
+    yield* keyValue(cur, key, index, block, keys, report);
+    index++;
+    next = await cur.peek();
+    if (next !== "," && next !== "}") {
+      throw new JsonScanError(
+        next === "" ? "the document ends inside a member" : `expected "," or "}" after the key "${key.name}"`,
+        cur.line()
+      );
+    }
+    cur.pos++;
+  }
+  yield* memberEnd(keys, block, line, { outer, firstLine }, report);
+}
+function wholeMember(cur, block, line, report) {
+  if (cur.deepest > MAX_ELEMENT_DEPTH) {
+    cur.dropCapture();
+    return { kind: "deep", aspect: null, block, depth: cur.deepest, line };
+  }
+  const text = cur.endCapture();
+  const parsed = parseAt(text, line, report);
+  return { kind: "member", block, value: parsed.value, exact: parsed.exact, text, line };
+}
+async function readKey(cur) {
+  if (await cur.peek() !== '"') {
+    throw new JsonScanError("expected a key", cur.line());
+  }
+  const line = cur.line();
+  const name = await cur.readString();
+  if (await cur.peek() !== ":") {
+    throw new JsonScanError(`expected ":" after the key "${name}"`, cur.line());
+  }
+  cur.pos++;
+  return { name, line };
+}
+async function* keyValue(cur, key, index, block, keys, report) {
+  if (await cur.peek() === "[") {
+    cur.pos++;
+    yield { kind: "block", aspect: key.name, block, shared: index > 0, line: key.line };
+    keys.firstBlock ??= key.name;
+    yield* blockElements(cur, key.name, block, report);
+    return;
+  }
+  cur.beginCapture();
+  await cur.skipValue();
+  if (cur.deepest + 1 > MAX_ELEMENT_DEPTH) {
+    cur.dropCapture();
+    keys.deep = Math.max(keys.deep, cur.deepest + 1);
+    keys.others.push({ key: key.name, text: null, line: key.line });
+  } else {
+    keys.others.push({ key: key.name, text: cur.endCapture(), line: key.line });
+  }
+}
+function* memberEnd(keys, block, line, start, report) {
+  const { others, firstBlock, deep } = keys;
+  if (firstBlock !== null) {
+    for (const other of others) {
+      if (other.text !== null) {
+        parseAt(other.text, other.line, null);
+      }
+    }
+    if (others.length > 0) {
+      yield {
+        kind: "extraKeys",
+        aspect: firstBlock,
+        block,
+        keys: others.map((o) => o.key),
+        line: others[0].line
+      };
+    }
+    return;
+  }
+  if (deep > 0) {
+    yield { kind: "deep", aspect: others[0].key, block, depth: deep, line };
+    return;
+  }
+  const members2 = others.map((o) => [JSON.stringify(o.key), o.text ?? ""].join(":"));
+  const text = `${start.outer}${members2.join(",")}}`;
+  const parsed = parseAt(text, start.firstLine, report);
+  yield { kind: "member", block, value: parsed.value, exact: parsed.exact, text, line };
+}
+async function* blockElements(cur, aspect, block, report) {
+  if (await cur.peek() === "]") {
+    cur.pos++;
+    return;
+  }
+  for (; ; ) {
+    const e = await cur.peek();
+    if (e === "") {
+      throw new JsonScanError(`the document ends inside the "${aspect}" block`, cur.line());
+    }
+    const elementLine = cur.line();
+    cur.beginCapture();
+    await cur.skipValue();
+    if (cur.deepest > MAX_ELEMENT_DEPTH) {
+      cur.dropCapture();
+      yield { kind: "deep", aspect, block, depth: cur.deepest, line: elementLine };
+    } else {
+      const text = cur.endCapture();
+      const parsed = parseAt(text, elementLine, report);
+      yield {
+        kind: "element",
+        aspect,
+        block,
+        value: parsed.value,
+        exact: parsed.exact,
+        text,
+        line: elementLine
+      };
+    }
+    const next = await cur.peek();
+    if (next === ",") {
+      cur.pos++;
+      continue;
+    }
+    if (next === "]") {
+      cur.pos++;
+      return;
+    }
+    throw new JsonScanError(
+      next === "" ? `the document ends inside the "${aspect}" block` : `expected "," or "]" in the "${aspect}" block, found "${next}"`,
+      cur.line()
+    );
+  }
+}
+function reportTooDeep(report, event) {
+  report.error(
+    "parse-error",
+    BAD_ASPECT_BLOCK_CODE,
+    `${event.aspect === null ? "a member of the document" : `an element of "${event.aspect}"`} is nested ${event.depth} levels deep, more than the ${MAX_ELEMENT_DEPTH} a graph keeps; skipped`,
+    { line: event.line, element: event.aspect }
+  );
+}
+function keptPrecision(report, where) {
+  return (digits) => {
+    report.warnOnce(
+      "precision",
+      PRECISION_CODE,
+      `an aspect kept in ${where} holds ${digits}, beyond 2^53; it is kept as the nearest double`,
+      { element: where },
+      `${PRECISION_CODE}:kept`
+    );
+  };
+}
+function reportSharedBlock(report, event) {
+  if (event.shared) {
+    report.warnOnce(
+      "coercion",
+      MULTI_ASPECT_FRAGMENT_CODE,
+      `the "${event.aspect}" aspect shares an array member with another aspect; each is read as its own fragment`,
+      { line: event.line, element: event.aspect }
+    );
+  }
+}
+const DECIMAL_INTEGER_TEXT = /^-?(0|[1-9][0-9]*)$/;
+function cxId(raw, inexactLiteral2 = false) {
+  if (raw instanceof ExactInteger) {
+    return { id: raw.digits, note: "precision" };
+  }
+  if (typeof raw === "number") {
+    if (Number.isSafeInteger(raw)) {
+      return { id: raw === 0 ? 0 : raw, note: inexactLiteral2 ? "text" : null };
+    }
+    throw invalidCxId(raw, Number.isInteger(raw) ? "an integer beyond 2^53 written inexactly" : "not an integer");
+  }
+  if (typeof raw === "string" && raw !== "-0" && DECIMAL_INTEGER_TEXT.test(raw)) {
+    const n = Number(raw);
+    return Number.isSafeInteger(n) ? { id: n, note: "text" } : { id: raw, note: "precision" };
+  }
+  throw invalidCxId(raw, "a CX id is an integer");
+}
+function invalidCxId(raw, reason) {
+  const shown = typeof raw === "string" || typeof raw === "number" ? JSON.stringify(raw) : typeof raw;
+  return new GraphFormatError("E_INVALID_ID", `invalid id ${raw === null ? "null" : shown}: ${reason}`, {
+    reason
+  });
+}
+const NUMBER_LITERAL = /-?\d[\d.eE+-]*/y;
+function inexactLiteral(text, key, keyDepth = 1) {
+  const quoted = JSON.stringify(key);
+  let depth = 0;
+  let i = 0;
+  while (i < text.length) {
+    const c = text[i];
+    if (c === "{" || c === "[") {
+      depth++;
+    } else if (c === "}" || c === "]") {
+      depth--;
+    } else if (c === '"') {
+      const start = i;
+      i = stringEnd(text, i + 1);
+      const colon = skipSpace(text, i + 1);
+      if (depth === keyDepth && text.startsWith(quoted, start) && text[colon] === ":") {
+        return inexactNumberAt(text, skipSpace(text, colon + 1));
+      }
+    }
+    i++;
+  }
+  return false;
+}
+function inexactNumberAt(text, at) {
+  NUMBER_LITERAL.lastIndex = at;
+  const match = NUMBER_LITERAL.exec(text);
+  return match !== null && /[.eE]/.test(match[0]);
+}
+const POSITION_COLUMN = "position";
+const Z_COLUMN = "z";
+function positionDecl(format, sourceDims = 2) {
+  return {
+    name: POSITION_COLUMN,
+    dtype: "f32",
+    components: 3,
+    role: "position",
+    mutable: true,
+    nullable: true,
+    extra: { sourceDims, units: "file" },
+    origin: { format, namespace: "cytoscape" }
+  };
+}
+function zDecl(format) {
+  return {
+    name: Z_COLUMN,
+    dtype: "f64",
+    nullable: true,
+    origin: { format, id: null, namespace: "cytoscape" },
+    extra: { cytoscape: "z" }
+  };
+}
+function fitsF32(value) {
+  return Number.isFinite(Math.fround(value));
+}
+function headText(head) {
+  let encoding = "utf-8";
+  if (head.byteLength >= 2 && head[0] === 255 && head[1] === 254) {
+    encoding = "utf-16le";
+  } else if (head.byteLength >= 2 && head[0] === 254 && head[1] === 255) {
+    encoding = "utf-16be";
+  }
+  return new TextDecoder(encoding).decode(head).replace(/^\uFEFF/, "");
+}
+function flipY(y) {
+  return y === 0 ? 0 : -y;
+}
+const STRUCTURE_ASPECTS = /* @__PURE__ */ new Set(["metaData", "status", "numberVerification"]);
+class CxStructure {
+  /**
+   * Create the checker.
+   * @param report - the report
+   * @param canonical - the name an aspect named in metaData is counted under (default: itself)
+   */
+  constructor(report, canonical = (name) => name) {
+    this.counts = /* @__PURE__ */ new Map();
+    this.blocks = /* @__PURE__ */ new Map();
+    this.declared = /* @__PURE__ */ new Map();
+    this.metaDataBlocks = 0;
+    this.networkBlocks = 0;
+    this.postMetadata = false;
+    this.statusSeen = false;
+    this.status = void 0;
+    this.report = report;
+    this.canonical = canonical;
+  }
+  /**
+   * Whether a status block was read.
+   * @returns true once a status block began
+   */
+  get hasStatus() {
+    return this.statusSeen;
+  }
+  /**
+   * Record the start of a block (or a member holding one aspect).
+   * @param aspect - the aspect name
+   * @param line - its line
+   */
+  block(aspect, line) {
+    this.blocks.set(aspect, (this.blocks.get(aspect) ?? 0) + 1);
+    if (this.statusSeen) {
+      this.report.warnOnce(
+        "validation-error",
+        ASPECT_ORDER_CODE,
+        `the "${aspect}" block comes after the status block, which must be last; it is read`,
+        { line, element: aspect },
+        `${ASPECT_ORDER_CODE}:status`
+      );
+    }
+    if (aspect === "metaData") {
+      this.metaDataBlocks++;
+      if (this.networkBlocks > 0) {
+        this.postMetadata = true;
+      }
+      if (this.metaDataBlocks > 2) {
+        this.report.warnOnce(
+          "validation-error",
+          ASPECT_ORDER_CODE,
+          `${this.metaDataBlocks} metaData blocks; a document has at most two (pre and post)`,
+          { line, element: aspect },
+          `${ASPECT_ORDER_CODE}:metaData`
+        );
+      }
+      return;
+    }
+    if (aspect === "status") {
+      this.statusSeen = true;
+      return;
+    }
+    if (STRUCTURE_ASPECTS.has(aspect)) {
+      return;
+    }
+    this.networkBlocks++;
+    if (this.postMetadata) {
+      this.report.warnOnce(
+        "validation-error",
+        ASPECT_ORDER_CODE,
+        `the "${aspect}" block comes after the post-metadata, where only status is allowed; it is read`,
+        { line, element: aspect },
+        `${ASPECT_ORDER_CODE}:post`
+      );
+    }
+  }
+  /**
+   * Record one element of a block; metaData and status elements are checked here.
+   * @param aspect - the aspect name
+   * @param value - the parsed element
+   * @param line - its line
+   */
+  element(aspect, value, line) {
+    this.counts.set(aspect, (this.counts.get(aspect) ?? 0) + 1);
+    if (aspect === "metaData") {
+      this.readCount(value, line);
+      return;
+    }
+    if (aspect === "status") {
+      this.readStatus(value, line);
+    }
+  }
+  /**
+   * Record the element count a metaData element declares; a count that is not an integer (text,
+   * a fraction) or that names no aspect is W_COUNT_MISMATCH and not checked.
+   * @param value - the metaData element
+   * @param line - its line
+   */
+  readCount(value, line) {
+    if (!isRecord(value) || value.elementCount === void 0 || value.elementCount === null) {
+      return;
+    }
+    const raw = value.elementCount;
+    let count = null;
+    if (raw instanceof ExactInteger) {
+      count = Number(raw.digits);
+    } else if (typeof raw === "number" && Number.isInteger(raw)) {
+      count = raw;
+    }
+    if (typeof value.name !== "string" || count === null) {
+      const shownCount = raw instanceof ExactInteger ? raw.digits : JSON.stringify(raw);
+      this.report.warning(
+        "validation-error",
+        COUNT_MISMATCH_CODE,
+        `a metaData element declares the elementCount ${shownCount} for the name ${JSON.stringify(value.name) ?? "undefined"}; not a count of a named aspect, not checked`,
+        { line, element: "metaData" }
+      );
+      return;
+    }
+    this.declared.set(this.canonical(value.name), count);
+  }
+  /**
+   * Check a status element: success false is fatal, an error text with success true a warning.
+   * @param value - the element
+   * @param line - its line
+   */
+  readStatus(value, line) {
+    if (this.status !== void 0) {
+      this.report.warnOnce(
+        "validation-error",
+        ASPECT_ORDER_CODE,
+        "more than one status element; the last is used",
+        { line, element: "status" },
+        `${ASPECT_ORDER_CODE}:status2`
+      );
+    }
+    this.status = value;
+    if (!isRecord(value)) {
+      return;
+    }
+    const error = typeof value.error === "string" ? value.error : "";
+    if (value.success === false) {
+      const message = `the producer marked the document as failed${error.length > 0 ? `: ${error}` : ""}`;
+      this.report.error("validation-error", STATUS_FAILED_CODE, message, { line, element: "status" });
+      throw this.report.abort(message, { code: STATUS_FAILED_CODE });
+    }
+    if (value.success === true && error.length > 0) {
+      this.report.warning("validation-error", STATUS_WARNING_CODE, `the producer reports a warning: ${error}`, {
+        line,
+        element: "status"
+      });
+    }
+  }
+  /**
+   * Whether the status element is one object with a boolean success.
+   * @returns true for a well-formed status
+   */
+  statusWellFormed() {
+    return isRecord(this.status) && typeof this.status.success === "boolean";
+  }
+  /** Compare the declared element counts with what was read (W_COUNT_MISMATCH per aspect). */
+  checkCounts() {
+    for (const [name, declared] of this.declared) {
+      const read = this.counts.get(name) ?? 0;
+      if (read !== declared) {
+        this.report.warning(
+          "validation-error",
+          COUNT_MISMATCH_CODE,
+          `metaData declares ${declared} "${name}" element${plural(declared)}; ${read} ${agree(read, "was", "were")} read`,
+          { element: name }
+        );
+      }
+    }
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof ExactInteger);
+}
+function declareFresh(sink, domain, decl, report) {
+  const taken = (name) => (domain === "node" ? sink.nodeColumn(name) : sink.edgeColumn(name)) !== INVALID_INDEX;
+  let fresh = decl;
+  if (taken(decl.name)) {
+    fresh = { ...decl, name: uniqueColumnName(decl.name, null, taken) };
+    report.warning(
+      "coercion",
+      COLUMN_RENAMED_CODE,
+      `${domain} column "${decl.name}" renamed to "${fresh.name}": an attribute holds that name`,
+      { element: decl.name }
+    );
+  }
+  return declareResolved(sink, domain, fresh, report).handle;
+}
+export {
+  CxStructure as C,
+  ExactInteger as E,
+  JsonScanError as J,
+  MAYBE_UNSAFE_INTEGER as M,
+  POSITION_COLUMN as P,
+  reportSharedBlock as a,
+  flipY as b,
+  cxId as c,
+  positionDecl as d,
+  declareFresh as e,
+  fitsF32 as f,
+  inexactLiteral as g,
+  headText as h,
+  isRecord as i,
+  setOwn as j,
+  keptPrecision as k,
+  MAYBE_INEXACT_EXPONENT as l,
+  rewriteNumbers as m,
+  findDuplicateKeys as n,
+  plainJson as p,
+  reportTooDeep as r,
+  scanAspects as s,
+  zDecl as z
+};
+//# sourceMappingURL=json-elements-3tnyt5uZ.js.map