@graphty/graph-io 0.3.18 → 0.3.19

package/dist/chunks/json-elements-CZY1wiZh.js

@@ -0,0 +1,779 @@
+import { GraphFormatError, INVALID_INDEX } from "@graphty/graph-format";
+import { B as BAD_ASPECT_BLOCK_CODE, a as ASPECT_ORDER_CODE, a3 as STATUS_FAILED_CODE, a4 as STATUS_WARNING_CODE, g as COUNT_MISMATCH_CODE, aE as uniqueColumnName, C as COLUMN_RENAMED_CODE, ar as declareResolved } from "./report-BcWboivV.js";
+const MAYBE_UNSAFE_INTEGER = new RegExp("(?<![0-9.])[0-9]{16}");
+const SENTINEL = `${String.fromCharCode(0)}graph-io:`;
+const EXACT_SENTINEL = `${SENTINEL}exact:`;
+const NONSTANDARD_TOKENS = [
+  ["-Infinity", -Infinity],
+  ["Infinity", Infinity],
+  ["NaN", NaN]
+];
+const INTEGER_LITERAL = /^-?(0|[1-9][0-9]*)$/;
+function rewriteNumbers(text, options = {}) {
+  const nonstandard = options.nonstandard ?? true;
+  const exactSentinel = options.exactSentinel ?? false;
+  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 ? 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) && !Number.isSafeInteger(Number(literal))) {
+          bigIntegers.push(literal);
+          replacement = exactSentinel ? JSON.stringify(`${EXACT_SENTINEL}${literal}`) : `"${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(SENTINEL)) {
+    const found = NONSTANDARD_TOKENS.find(([word]) => word === value.slice(SENTINEL.length));
+    return found === void 0 ? value : found[1];
+  }
+  return value;
+}
+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 reviveExact(_key, value) {
+  if (typeof value === "string" && value.startsWith(EXACT_SENTINEL)) {
+    return new ExactInteger(value.slice(EXACT_SENTINEL.length));
+  }
+  return value;
+}
+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, 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)) {
+      out[key] = plainJson(item, onPrecision);
+    }
+    return out;
+  }
+  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);
+    for (; ; ) {
+      const next = await this.iterator.next();
+      if (next.done === true) {
+        this.buf = "";
+        this.pos = 0;
+        return false;
+      }
+      if (next.value.length > 0) {
+        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));
+  }
+  /**
+   * 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);
+  }
+  return count;
+}
+function messageOf(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function parseAt(text, line) {
+  try {
+    return parseExact(text);
+  } catch (err) {
+    throw new JsonScanError(`invalid JSON: ${messageOf(err)}`, line);
+  }
+}
+async function* scanAspects(chunks) {
+  const cur = new ChunkCursor(chunks);
+  const first = await cur.peek();
+  if (first === "") {
+    throw new JsonScanError("the input is empty", 1, true);
+  }
+  if (first !== "[") {
+    const line = cur.line();
+    cur.beginCapture();
+    await cur.skipValue();
+    const { value } = parseAt(cur.endCapture(), line);
+    if (await cur.peek() !== "") {
+      throw new JsonScanError("unexpected text after the document", cur.line());
+    }
+    yield { kind: "root", value, line };
+    return;
+  }
+  cur.pos++;
+  let block = 0;
+  if (await cur.peek() === "]") {
+    cur.pos++;
+  } else {
+    for (; ; ) {
+      yield* member(cur, block);
+      block++;
+      const next = await cur.peek();
+      if (next === ",") {
+        cur.pos++;
+        continue;
+      }
+      if (next === "]") {
+        cur.pos++;
+        break;
+      }
+      throw new JsonScanError(
+        next === "" ? "the document ends before its closing bracket" : `expected "," or "]", found "${next}"`,
+        cur.line()
+      );
+    }
+  }
+  if (await cur.peek() !== "") {
+    throw new JsonScanError("unexpected text after the closing bracket", cur.line());
+  }
+}
+async function* member(cur, block) {
+  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);
+  }
+  if (c !== "{") {
+    cur.beginCapture();
+    await cur.skipValue();
+    if (cur.deepest > MAX_ELEMENT_DEPTH) {
+      cur.dropCapture();
+      yield { kind: "deep", aspect: null, block, depth: cur.deepest, line };
+      return;
+    }
+    const parsed = parseAt(cur.endCapture(), line);
+    yield { kind: "member", block, value: parsed.value, exact: parsed.exact, line };
+    return;
+  }
+  cur.beginCapture();
+  cur.pos++;
+  const k = await cur.peek();
+  if (k !== '"') {
+    await cur.skipValue(1);
+    if (cur.deepest > MAX_ELEMENT_DEPTH) {
+      cur.dropCapture();
+      yield { kind: "deep", aspect: null, block, depth: cur.deepest, line };
+      return;
+    }
+    const parsed = parseAt(cur.endCapture(), line);
+    yield { kind: "member", block, value: parsed.value, exact: parsed.exact, line };
+    return;
+  }
+  const outer = cur.endCapture();
+  const keyLine = cur.line();
+  const aspect = await cur.readString();
+  if (await cur.peek() !== ":") {
+    throw new JsonScanError(`expected ":" after the key "${aspect}"`, cur.line());
+  }
+  cur.pos++;
+  const v = await cur.peek();
+  if (v !== "[") {
+    cur.beginCapture();
+    await cur.skipValue(1);
+    if (cur.deepest > MAX_ELEMENT_DEPTH) {
+      cur.dropCapture();
+      yield { kind: "deep", aspect, block, depth: cur.deepest, line };
+      return;
+    }
+    const rest = cur.endCapture();
+    const text = `${outer}${JSON.stringify(aspect)}:${rest}`;
+    const parsed = parseAt(text, keyLine);
+    yield { kind: "member", block, value: parsed.value, exact: parsed.exact, line };
+    return;
+  }
+  cur.pos++;
+  yield { kind: "block", aspect, block, line };
+  if (await cur.peek() === "]") {
+    cur.pos++;
+  } else {
+    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);
+        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++;
+        break;
+      }
+      throw new JsonScanError(
+        next === "" ? `the document ends inside the "${aspect}" block` : `expected "," or "]" in the "${aspect}" block, found "${next}"`,
+        cur.line()
+      );
+    }
+  }
+  const end = await cur.peek();
+  if (end === "}") {
+    cur.pos++;
+    return;
+  }
+  if (end !== ",") {
+    throw new JsonScanError(
+      end === "" ? "the document ends inside a member" : `expected "}" after the "${aspect}" block`,
+      cur.line()
+    );
+  }
+  const keys = [];
+  const extraLine = cur.line();
+  while (await cur.peek() === ",") {
+    cur.pos++;
+    if (await cur.peek() !== '"') {
+      throw new JsonScanError("expected a key", cur.line());
+    }
+    keys.push(await cur.readString());
+    if (await cur.peek() !== ":") {
+      throw new JsonScanError('expected ":"', cur.line());
+    }
+    cur.pos++;
+    await cur.peek();
+    cur.beginCapture();
+    await cur.skipValue();
+    parseAt(cur.endCapture(), cur.line());
+  }
+  if (await cur.peek() !== "}") {
+    throw new JsonScanError('expected "}"', cur.line());
+  }
+  cur.pos++;
+  yield { kind: "extraKeys", aspect, block, keys, line: extraLine };
+}
+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 }
+  );
+}
+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
+  });
+}
+function inexactLiteral(text, key) {
+  const quoted = JSON.stringify(key);
+  let depth = 0;
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i];
+    if (c === "{" || c === "[") {
+      depth++;
+    } else if (c === "}" || c === "]") {
+      depth--;
+    } else if (c === '"') {
+      const start = i;
+      for (i++; i < text.length && text[i] !== '"'; i++) {
+        if (text[i] === "\\") {
+          i++;
+        }
+      }
+      if (depth === 1 && text.startsWith(quoted, start) && /^\s*:/.test(text.slice(i + 1, i + 16))) {
+        const match = /^\s*:\s*(-?[0-9][0-9.eE+-]*)/.exec(text.slice(i + 1, i + 64));
+        return match !== null && /[.eE]/.test(match[1]);
+      }
+    }
+  }
+  return false;
+}
+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 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
+   */
+  constructor(report) {
+    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;
+  }
+  /**
+   * 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") {
+      if (isRecord(value) && typeof value.name === "string" && typeof value.elementCount === "number") {
+        this.declared.set(value.name, value.elementCount);
+      }
+      return;
+    }
+    if (aspect === "status") {
+      this.readStatus(value, line);
+    }
+  }
+  /**
+   * 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(s); ${read} 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,
+  positionDecl as a,
+  inexactLiteral as b,
+  cxId as c,
+  declareFresh as d,
+  rewriteNumbers as e,
+  flipY as f,
+  reviveNonstandard as g,
+  isRecord as i,
+  plainJson as p,
+  reportTooDeep as r,
+  scanAspects as s,
+  zDecl as z
+};
+//# sourceMappingURL=json-elements-CZY1wiZh.js.map