@poe-platform/safe-bash 0.1.756 → 0.1.758

package/dist/safe-bash/chunks/chunk-4QTSSQKP.js

@@ -1,898 +0,0 @@
-import {
-  Decimal,
-  numberText,
-  object,
-  objectKeyIterator,
-  objectKeys,
-  objectSize,
-  put,
-  utf8ByteLength
-} from "./chunk-44WUNUPV.js";
-import {
-  init_platform
-} from "./chunk-ZG7GWQ5P.js";
-
-// packages/safe-bash-command-yq/src/accounting.ts
-init_platform();
-
-// packages/safe-bash-command-yq/src/errors.ts
-init_platform();
-var YqError = class extends Error {
-  constructor(category, code, status, source, line, column) {
-    super(`${category}: ${code}`);
-    this.category = category;
-    this.code = code;
-    this.status = status;
-    this.source = source;
-    this.line = line;
-    this.column = column;
-  }
-  category;
-  code;
-  status;
-  source;
-  line;
-  column;
-};
-var budgetLimits = Object.freeze({
-  maxInputBytes: "LIMIT_MAX_INPUT_BYTES",
-  maxValueBytes: "LIMIT_MAX_VALUE_BYTES",
-  maxOutputBytes: "LIMIT_MAX_OUTPUT_BYTES",
-  maxSourceBytes: "LIMIT_MAX_QUERY_SOURCE_BYTES",
-  maxDepth: "LIMIT_MAX_DEPTH",
-  maxAstDepth: "LIMIT_MAX_AST_DEPTH",
-  maxSteps: "LIMIT_MAX_STEPS",
-  maxResults: "LIMIT_MAX_RESULTS",
-  maxCollectionSize: "LIMIT_MAX_COLLECTION_SIZE"
-});
-function fromJqLimit(error) {
-  const prefix = error.message.slice(0, error.message.indexOf(" "));
-  return new YqError("limit", budgetLimits[prefix] ?? "LIMIT_MAX_STEPS", 5);
-}
-function limit(code, source, line, column) {
-  return new YqError("limit", code, 5, source, line, column);
-}
-
-// packages/safe-bash-command-yq/src/accounting.ts
-var yqCaps = Object.freeze({
-  maxArgvEntries: Infinity,
-  maxArgvUtf8Bytes: Infinity,
-  maxVfsOperandPathBytes: Infinity,
-  maxInputBytes: Infinity,
-  maxDocumentBytes: Infinity,
-  maxValueBytes: Infinity,
-  maxScalarBytes: Infinity,
-  maxQuerySourceBytes: Infinity,
-  maxDepth: Infinity,
-  maxAstDepth: Infinity,
-  maxSteps: Infinity,
-  maxResults: Infinity,
-  maxCollectionSize: Infinity,
-  maxDocuments: Infinity,
-  maxAnchorsPerDocument: Infinity,
-  maxAliasReferences: Infinity,
-  maxSourceLines: Infinity,
-  maxDocumentNodes: Infinity,
-  maxOutputBytes: Infinity,
-  diagnosticReserveBytes: Infinity,
-  stdoutCapBytes: Infinity,
-  maxDisplayedFilenameBytes: Infinity
-});
-function resolveYqLimits(overrides = {}) {
-  if (typeof overrides !== "object" || overrides === null) throw new TypeError("limits must be an object");
-  const limits = {
-    maxAliasReferences: yqCaps.maxAliasReferences,
-    maxSourceLines: yqCaps.maxSourceLines,
-    maxDocumentNodes: yqCaps.maxDocumentNodes,
-    maxValueBytes: yqCaps.maxValueBytes,
-    maxSteps: yqCaps.maxSteps
-  };
-  for (const [key, value] of Object.entries(overrides)) {
-    if (!Object.hasOwn(limits, key) || value !== Infinity && (!Number.isSafeInteger(value) || value < 0)) {
-      throw new TypeError("yq limits must be nonnegative safe integers or Infinity with supported names");
-    }
-    Object.assign(limits, { [key]: value });
-  }
-  return Object.freeze(limits);
-}
-function checked(current, incoming, limitValue, code) {
-  if (!Number.isSafeInteger(incoming) || incoming < 0) throw new RangeError("invalid yq accounting projection");
-  if (incoming > limitValue - current) throw limit(code);
-  return current + incoming;
-}
-var YqLedger = class {
-  constructor(limits = resolveYqLimits()) {
-    this.limits = limits;
-  }
-  limits;
-  documents = 0;
-  aliases = 0;
-  documentNodes = 0;
-  documentValueBytes = 0;
-  anchors = 0;
-  stdoutBytes = 0;
-  combinedOutputBytes = 0;
-  admitDocumentBytes(rawBytes) {
-    if (!Number.isSafeInteger(rawBytes) || rawBytes < 0) throw new RangeError("invalid raw document byte count");
-    if (rawBytes > yqCaps.maxDocumentBytes) throw limit("LIMIT_MAX_DOCUMENT_BYTES");
-  }
-  beginDocument(rawBytes) {
-    this.admitDocumentBytes(rawBytes);
-    this.documents = checked(this.documents, 1, yqCaps.maxDocuments, "LIMIT_MAX_DOCUMENTS");
-    this.documentNodes = 0;
-    this.documentValueBytes = 0;
-    this.anchors = 0;
-  }
-  admitNode() {
-    this.documentNodes = checked(this.documentNodes, 1, this.limits.maxDocumentNodes, "LIMIT_MAX_DOCUMENT_NODES");
-  }
-  admitAnchor() {
-    this.anchors = checked(this.anchors, 1, yqCaps.maxAnchorsPerDocument, "LIMIT_MAX_ANCHORS_PER_DOCUMENT");
-  }
-  admitScalar(bytes) {
-    if (bytes > yqCaps.maxScalarBytes) throw limit("LIMIT_MAX_SCALAR_BYTES");
-  }
-  admitValueBytes(bytes) {
-    this.documentValueBytes = checked(this.documentValueBytes, bytes, this.limits.maxValueBytes, "LIMIT_MAX_VALUE_BYTES");
-  }
-  preflightAlias(descriptor) {
-    const aliases = checked(this.aliases, 1, this.limits.maxAliasReferences, "LIMIT_MAX_ALIAS_REFERENCES");
-    const nodes = checked(this.documentNodes, descriptor.nodes, this.limits.maxDocumentNodes, "LIMIT_MAX_DOCUMENT_NODES");
-    const valueBytes = checked(this.documentValueBytes, descriptor.compactBytes, this.limits.maxValueBytes, "LIMIT_MAX_VALUE_BYTES");
-    if (descriptor.maxDepth > yqCaps.maxDepth) throw limit("LIMIT_MAX_DEPTH");
-    return { aliases, nodes, valueBytes };
-  }
-  commitAlias(projection) {
-    this.aliases = projection.aliases;
-    this.documentNodes = projection.nodes;
-    this.documentValueBytes = projection.valueBytes;
-  }
-  admitStdout(bytes) {
-    this.stdoutBytes = checked(this.stdoutBytes, bytes, yqCaps.stdoutCapBytes, "LIMIT_MAX_OUTPUT_BYTES");
-    this.combinedOutputBytes = checked(this.combinedOutputBytes, bytes, yqCaps.maxOutputBytes, "LIMIT_MAX_OUTPUT_BYTES");
-  }
-  canAdmitDiagnostic(bytes) {
-    return Number.isSafeInteger(bytes) && bytes >= 0 && bytes <= yqCaps.diagnosticReserveBytes && bytes <= yqCaps.maxOutputBytes - this.combinedOutputBytes;
-  }
-  admitDiagnostic(bytes) {
-    if (!this.canAdmitDiagnostic(bytes)) throw limit("LIMIT_MAX_OUTPUT_BYTES");
-    this.combinedOutputBytes += bytes;
-  }
-};
-function addProjection(current, incoming) {
-  if (!Number.isSafeInteger(incoming) || incoming < 0 || incoming > Number.MAX_SAFE_INTEGER - current) {
-    throw new RangeError("alias projection overflow");
-  }
-  return current + incoming;
-}
-async function payload(work, text) {
-  let codePoints = 0;
-  let bytes = 0;
-  for (const character of text) {
-    codePoints++;
-    bytes += utf8ByteLength(character);
-    if (codePoints === 256) {
-      await work.charge(codePoints);
-      work.assertOpen();
-      codePoints = 0;
-    }
-  }
-  if (codePoints > 0) {
-    await work.charge(codePoints);
-    work.assertOpen();
-  }
-  const units = bytes === 0 ? 0 : Math.ceil(bytes / 1024);
-  if (units > 0) {
-    await work.charge(units);
-    work.assertOpen();
-  }
-  return units;
-}
-function jsonStringBytes(text) {
-  let bytes = 2;
-  for (const character of text) {
-    const point = character.codePointAt(0);
-    if (point === 34 || point === 92 || point === 8 || point === 12 || point === 10 || point === 13 || point === 9) bytes += 2;
-    else if (point < 32) bytes += 6;
-    else bytes += utf8ByteLength(character);
-  }
-  return bytes;
-}
-async function estimateAlias(value, work, limits = resolveYqLimits()) {
-  let nodes = 0;
-  let compactBytes = 0;
-  let maxDepth = 0;
-  let ordinaryUnits = 0;
-  const stack = [{ value, depth: 0 }];
-  while (stack.length > 0) {
-    const item = stack.pop();
-    await work.charge(1);
-    work.assertOpen();
-    nodes = checked(nodes, 1, limits.maxDocumentNodes, "LIMIT_MAX_DOCUMENT_NODES");
-    ordinaryUnits = addProjection(ordinaryUnits, 1);
-    maxDepth = Math.max(maxDepth, item.depth);
-    if (maxDepth > yqCaps.maxDepth) throw limit("LIMIT_MAX_DEPTH");
-    const current = item.value;
-    if (current === null || typeof current === "boolean") {
-      compactBytes = addProjection(compactBytes, utf8ByteLength(JSON.stringify(current)));
-    } else if (typeof current === "number" || current instanceof Decimal) {
-      const text = numberText(current);
-      const units = await payload(work, text);
-      work.assertOpen();
-      ordinaryUnits = addProjection(ordinaryUnits, units);
-      compactBytes = addProjection(compactBytes, utf8ByteLength(text));
-    } else if (typeof current === "string") {
-      const units = await payload(work, current);
-      work.assertOpen();
-      ordinaryUnits = addProjection(ordinaryUnits, units);
-      compactBytes = addProjection(compactBytes, jsonStringBytes(current));
-    } else {
-      const keys = Array.isArray(current) ? Object.keys(current) : objectKeys(current);
-      if (keys.length > yqCaps.maxCollectionSize) throw limit("LIMIT_MAX_COLLECTION_SIZE");
-      compactBytes = addProjection(compactBytes, 2 + Math.max(0, keys.length - 1));
-      for (let index = keys.length - 1; index >= 0; index--) {
-        const key = keys[index];
-        if (!Array.isArray(current)) {
-          const units = await payload(work, key);
-          work.assertOpen();
-          ordinaryUnits = addProjection(ordinaryUnits, units);
-          compactBytes = addProjection(compactBytes, jsonStringBytes(key) + 1);
-        }
-        stack.push({ value: current[key], depth: item.depth + 1 });
-      }
-    }
-    if (compactBytes > limits.maxValueBytes) throw limit("LIMIT_MAX_VALUE_BYTES");
-  }
-  return Object.freeze({ nodes, compactBytes, maxDepth, ordinaryUnits });
-}
-async function consumePayload(work, reservation, text) {
-  const bytes = utf8ByteLength(text);
-  const units = bytes === 0 ? 0 : Math.ceil(bytes / 1024);
-  for (let unit = 0; unit < units; unit++) {
-    await reservation.beforeUnit();
-    work.assertOpen();
-  }
-}
-async function copyAlias(value, ledger, work) {
-  const descriptor = await estimateAlias(value, work, ledger.limits);
-  work.assertOpen();
-  const projection = ledger.preflightAlias(descriptor);
-  const reservation = work.reserve(descriptor.ordinaryUnits);
-  ledger.commitAlias(projection);
-  let completed = false;
-  const copy = async (current) => {
-    await reservation.beforeUnit();
-    work.assertOpen();
-    if (current === null || typeof current === "boolean") return current;
-    if (typeof current === "number" || current instanceof Decimal) {
-      await consumePayload(work, reservation, numberText(current));
-      work.assertOpen();
-      return current;
-    }
-    if (typeof current === "string") {
-      await consumePayload(work, reservation, current);
-      work.assertOpen();
-      return current;
-    }
-    if (Array.isArray(current)) {
-      const result2 = [];
-      for (const child of current) {
-        const copied = await copy(child);
-        work.assertOpen();
-        result2.push(copied);
-      }
-      return result2;
-    }
-    const result = object();
-    for (const key of objectKeys(current)) {
-      await consumePayload(work, reservation, key);
-      work.assertOpen();
-      const copied = await copy(current[key]);
-      work.assertOpen();
-      put(result, key, copied);
-    }
-    return result;
-  };
-  try {
-    const result = await copy(value);
-    work.assertOpen();
-    reservation.finish();
-    work.assertOpen();
-    completed = true;
-    return result;
-  } finally {
-    if (!completed) reservation.abandon();
-  }
-}
-function aliasFailure(code) {
-  return new YqError("alias", code, 5);
-}
-
-// packages/safe-bash-command-yq/src/toml.ts
-init_platform();
-var TomlParser = class {
-  constructor(source, work, ledger) {
-    this.source = source;
-    this.work = work;
-    this.ledger = ledger;
-  }
-  source;
-  work;
-  ledger;
-  #offset = 0;
-  #line = 1;
-  #column = 1;
-  #pending = 0;
-  #tables = /* @__PURE__ */ new WeakMap();
-  #arraysOfTables = /* @__PURE__ */ new WeakSet();
-  #syntax() {
-    throw new YqError("input", "INPUT_TOML_SYNTAX", 5, void 0, this.#line, this.#column);
-  }
-  #conflict() {
-    throw new YqError("schema", "SCHEMA_DUPLICATE_KEY", 5, void 0, this.#line, this.#column);
-  }
-  #schema(code) {
-    throw new YqError("schema", code, 5, void 0, this.#line, this.#column);
-  }
-  #peek(distance = 0) {
-    return this.source[this.#offset + distance] ?? "";
-  }
-  #take() {
-    if (this.#offset >= this.source.length) this.#syntax();
-    const point = this.source.codePointAt(this.#offset);
-    if (point >= 55296 && point <= 57343 || point < 32 && point !== 9 && point !== 10 && point !== 13 || point === 127) this.#syntax();
-    let value = String.fromCodePoint(point);
-    this.#offset += value.length;
-    this.#pending++;
-    if (point === 13) {
-      if (this.#peek() !== "\n") this.#syntax();
-      this.#offset++;
-      value = "\n";
-    }
-    if (value === "\n") {
-      this.#line++;
-      this.#column = 1;
-    } else this.#column++;
-    return value;
-  }
-  async #flush() {
-    if (this.#pending) {
-      const units = this.#pending;
-      this.#pending = 0;
-      await this.work.charge(units);
-    }
-    this.work.assertOpen();
-  }
-  async #space(newlines) {
-    while (true) {
-      const character = this.#peek();
-      if (character === " " || character === "	" || newlines && (character === "\n" || character === "\r")) this.#take();
-      else if (newlines && character === "#") {
-        while (this.#peek() && this.#peek() !== "\n" && this.#peek() !== "\r") {
-          this.#take();
-          if (this.#pending >= 256) await this.#flush();
-        }
-      } else break;
-      if (this.#pending >= 256) await this.#flush();
-    }
-  }
-  async #lineEnd() {
-    await this.#space(false);
-    if (this.#peek() === "#") {
-      while (this.#peek() && this.#peek() !== "\n" && this.#peek() !== "\r") {
-        this.#take();
-        if (this.#pending >= 256) await this.#flush();
-      }
-    }
-    if (this.#peek() === "\n" || this.#peek() === "\r") this.#take();
-    else if (this.#peek()) this.#syntax();
-  }
-  #depth(depth) {
-    if (depth > yqCaps.maxDepth) throw limit("LIMIT_MAX_DEPTH");
-  }
-  async #node() {
-    await this.#flush();
-    await this.work.charge(1);
-    this.work.assertOpen();
-    this.ledger.admitNode();
-  }
-  async #table(kind, depth) {
-    this.#depth(depth);
-    await this.#node();
-    this.ledger.admitValueBytes(2);
-    const value = object();
-    this.#tables.set(value, { kind, depth, sealed: false });
-    return value;
-  }
-  async #array(depth) {
-    this.#depth(depth);
-    await this.#node();
-    this.ledger.admitValueBytes(2);
-    return [];
-  }
-  async #scalar(value) {
-    await this.#node();
-    if (typeof value !== "string") {
-      const text = typeof value === "boolean" ? String(value) : numberText(value);
-      this.ledger.admitScalar(text.length);
-      this.ledger.admitValueBytes(text.length);
-      return;
-    }
-    let rawBytes = 0;
-    let compactBytes = 2;
-    let work = 0;
-    for (const character of value) {
-      const point = character.codePointAt(0);
-      const bytes = point <= 127 ? 1 : point <= 2047 ? 2 : point <= 65535 ? 3 : 4;
-      rawBytes += bytes;
-      compactBytes += point === 34 || point === 92 || [8, 9, 10, 12, 13].includes(point) ? 2 : point < 32 ? 6 : bytes;
-      this.ledger.admitScalar(rawBytes);
-      if (++work === 256) {
-        await this.work.charge(work);
-        this.work.assertOpen();
-        work = 0;
-      }
-    }
-    if (work) await this.work.charge(work);
-    this.work.assertOpen();
-    this.ledger.admitValueBytes(compactBytes);
-  }
-  async #member(table, key, value) {
-    if (Object.hasOwn(table, key)) this.#conflict();
-    const size = objectSize(table);
-    if (size >= yqCaps.maxCollectionSize) throw limit("LIMIT_MAX_COLLECTION_SIZE");
-    await this.#scalar(key);
-    this.ledger.admitValueBytes(size ? 2 : 1);
-    this.work.assertOpen();
-    put(table, key, value);
-  }
-  #append(array, value) {
-    if (array.length >= yqCaps.maxCollectionSize) throw limit("LIMIT_MAX_COLLECTION_SIZE");
-    if (array.length) this.ledger.admitValueBytes(1);
-    this.work.assertOpen();
-    array.push(value);
-  }
-  async #string(key = false) {
-    const quote = this.#take();
-    let multiline = false;
-    if (!key && this.#peek() === quote && this.#peek(1) === quote) {
-      this.#take();
-      this.#take();
-      multiline = true;
-      if (this.#peek() === "\n" || this.#peek() === "\r") this.#take();
-    }
-    const parts = [];
-    let part = "";
-    let bytes = 0;
-    const append = (value) => {
-      bytes += utf8ByteLength(value);
-      this.ledger.admitScalar(bytes);
-      part += value;
-      if (part.length >= 256) {
-        parts.push(part);
-        part = "";
-      }
-    };
-    while (this.#peek()) {
-      const character = this.#take();
-      if (character === quote) {
-        if (!multiline) {
-          parts.push(part);
-          return parts.join("");
-        }
-        let count = 1;
-        while (count < 5 && this.#peek() === quote) {
-          this.#take();
-          count++;
-        }
-        if (count >= 3) {
-          append(quote.repeat(count - 3));
-          parts.push(part);
-          return parts.join("");
-        }
-        append(quote.repeat(count));
-      } else if (character === "\n") {
-        if (!multiline) this.#syntax();
-        append(character);
-      } else if (quote === '"' && character === "\\") {
-        if (multiline && [" ", "	", "\n", "\r"].includes(this.#peek())) {
-          await this.#space(false);
-          if (this.#peek() !== "\n" && this.#peek() !== "\r") this.#syntax();
-          this.#take();
-          while ([" ", "	", "\n", "\r"].includes(this.#peek())) {
-            this.#take();
-            if (this.#pending >= 256) await this.#flush();
-          }
-        } else {
-          const escape = this.#take();
-          const simple = { b: "\b", t: "	", n: "\n", f: "\f", r: "\r", '"': '"', "\\": "\\" };
-          if (Object.hasOwn(simple, escape)) append(simple[escape]);
-          else if (escape === "u" || escape === "U") {
-            let point = 0;
-            for (let index = 0; index < (escape === "u" ? 4 : 8); index++) {
-              const digit = this.#digit(this.#take(), 16);
-              if (digit < 0) this.#syntax();
-              point = point * 16 + digit;
-            }
-            if (point > 1114111 || point >= 55296 && point <= 57343) this.#syntax();
-            append(String.fromCodePoint(point));
-          } else this.#syntax();
-        }
-      } else append(character);
-      if (this.#pending >= 256) await this.#flush();
-    }
-    return this.#syntax();
-  }
-  #digit(character, base) {
-    const code = character.charCodeAt(0);
-    const digit = code >= 48 && code <= 57 ? code - 48 : code >= 65 && code <= 70 ? code - 55 : code >= 97 && code <= 102 ? code - 87 : -1;
-    return digit >= 0 && digit < base ? digit : -1;
-  }
-  async #keyPath() {
-    const path = [];
-    while (true) {
-      await this.#space(false);
-      let key;
-      if (this.#peek() === '"' || this.#peek() === "'") key = await this.#string(true);
-      else {
-        const start = this.#offset;
-        while (this.#peek()) {
-          const code = this.#peek().charCodeAt(0);
-          if (!(code >= 65 && code <= 90 || code >= 97 && code <= 122 || code >= 48 && code <= 57 || code === 95 || code === 45)) break;
-          this.#take();
-          if (this.#offset - start > yqCaps.maxScalarBytes) throw limit("LIMIT_MAX_SCALAR_BYTES");
-          if (this.#pending >= 256) await this.#flush();
-        }
-        if (this.#offset === start) this.#syntax();
-        key = this.source.slice(start, this.#offset);
-      }
-      if (path.length >= yqCaps.maxDepth) throw limit("LIMIT_MAX_DEPTH");
-      path.push(key);
-      await this.#space(false);
-      if (this.#peek() !== ".") return path;
-      this.#take();
-    }
-  }
-  #state(table) {
-    const state = this.#tables.get(table);
-    if (!state) this.#conflict();
-    return state;
-  }
-  async #parents(start, path, kind, allowAoT) {
-    let current = start;
-    for (const key of path) {
-      await this.work.charge(1);
-      this.work.assertOpen();
-      const parent = this.#state(current);
-      if (parent.sealed) this.#conflict();
-      let value = current[key];
-      if (!Object.hasOwn(current, key)) {
-        value = await this.#table(kind, parent.depth + 1);
-        await this.#member(current, key, value);
-      } else if (Array.isArray(value) && allowAoT && this.#arraysOfTables.has(value)) value = value.at(-1);
-      if (typeof value !== "object" || value === null || Array.isArray(value) || value instanceof Decimal) this.#conflict();
-      const state = this.#state(value);
-      if (state.sealed) this.#conflict();
-      if (kind === "dotted" && state.kind === "header") this.#conflict();
-      if (kind === "dotted" && state.kind === "implicit") state.kind = "dotted";
-      current = value;
-    }
-    return current;
-  }
-  async #assignment(current) {
-    const path = await this.#keyPath();
-    if (this.#take() !== "=") this.#syntax();
-    await this.#space(false);
-    const parent = await this.#parents(current, path.slice(0, -1), "dotted", false);
-    if (this.#state(parent).sealed || Object.hasOwn(parent, path.at(-1))) this.#conflict();
-    if (objectSize(parent) >= yqCaps.maxCollectionSize) throw limit("LIMIT_MAX_COLLECTION_SIZE");
-    const value = await this.#value(this.#state(parent).depth + 1);
-    await this.#member(parent, path.at(-1), value);
-  }
-  async #header(root) {
-    this.#take();
-    const array = this.#peek() === "[";
-    if (array) this.#take();
-    const path = await this.#keyPath();
-    if (this.#take() !== "]" || array && this.#take() !== "]") this.#syntax();
-    await this.#lineEnd();
-    const parent = await this.#parents(root, path.slice(0, -1), "implicit", true);
-    const key = path.at(-1);
-    const parentState = this.#state(parent);
-    if (parentState.sealed) this.#conflict();
-    const exists = Object.hasOwn(parent, key);
-    const existing = parent[key];
-    if (array) {
-      let values;
-      if (exists) {
-        if (!Array.isArray(existing) || !this.#arraysOfTables.has(existing)) this.#conflict();
-        values = existing;
-      } else {
-        values = await this.#array(parentState.depth + 1);
-        this.#arraysOfTables.add(values);
-        await this.#member(parent, key, values);
-      }
-      if (values.length >= yqCaps.maxCollectionSize) throw limit("LIMIT_MAX_COLLECTION_SIZE");
-      const table2 = await this.#table("header", parentState.depth + 2);
-      this.#append(values, table2);
-      return table2;
-    }
-    if (exists) {
-      if (typeof existing !== "object" || existing === null || Array.isArray(existing) || existing instanceof Decimal) this.#conflict();
-      const state = this.#state(existing);
-      if (state.kind !== "implicit" || state.sealed) this.#conflict();
-      state.kind = "header";
-      return existing;
-    }
-    const table = await this.#table("header", parentState.depth + 1);
-    await this.#member(parent, key, table);
-    return table;
-  }
-  async #seal(table) {
-    const pending = [table];
-    while (pending.length) {
-      const current = pending.pop();
-      await this.work.charge(1);
-      this.work.assertOpen();
-      this.#state(current).sealed = true;
-      for (const key of objectKeyIterator(current)) {
-        await this.work.charge(1);
-        this.work.assertOpen();
-        const value = current[key];
-        if (typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Decimal)) pending.push(value);
-      }
-    }
-  }
-  async #value(depth) {
-    this.#depth(depth);
-    const character = this.#peek();
-    if (character === '"' || character === "'") {
-      const value2 = await this.#string();
-      await this.#scalar(value2);
-      return value2;
-    }
-    if (character === "[") {
-      this.#take();
-      const result = await this.#array(depth);
-      await this.#space(true);
-      while (this.#peek() !== "]") {
-        if (!this.#peek()) this.#syntax();
-        if (result.length >= yqCaps.maxCollectionSize) throw limit("LIMIT_MAX_COLLECTION_SIZE");
-        const value2 = await this.#value(depth + 1);
-        this.#append(result, value2);
-        await this.#space(true);
-        if (this.#peek() !== ",") break;
-        this.#take();
-        await this.#space(true);
-      }
-      if (this.#take() !== "]") this.#syntax();
-      return result;
-    }
-    if (character === "{") {
-      this.#take();
-      const result = await this.#table("inline", depth);
-      await this.#space(false);
-      if (this.#peek() !== "}") {
-        while (true) {
-          await this.#assignment(result);
-          await this.#space(false);
-          if (this.#peek() !== ",") break;
-          this.#take();
-          await this.#space(false);
-          if (this.#peek() === "}") this.#syntax();
-        }
-      }
-      if (this.#take() !== "}") this.#syntax();
-      await this.#seal(result);
-      return result;
-    }
-    const start = this.#offset;
-    while (this.#peek()) {
-      const next = this.#peek();
-      if (" 	\r\n#,]}".includes(next)) {
-        if (next === " " && this.#offset - start === 10 && this.source[start + 4] === "-" && this.source[start + 7] === "-" && this.#digit(this.#peek(1), 10) >= 0) this.#take();
-        else break;
-      } else this.#take();
-      if (this.#offset - start > yqCaps.maxScalarBytes) throw limit("LIMIT_MAX_SCALAR_BYTES");
-      if (this.#pending >= 256) await this.#flush();
-    }
-    if (this.#offset === start) this.#syntax();
-    const raw = this.source.slice(start, this.#offset);
-    await this.#flush();
-    let value;
-    if (raw === "true" || raw === "false") value = raw === "true";
-    else if (raw.length >= 8 && (raw[2] === ":" || raw[4] === "-" && raw[7] === "-")) {
-      await this.#date(raw);
-      value = raw;
-    } else value = await this.#number(raw);
-    await this.#scalar(value);
-    return value;
-  }
-  async #number(raw) {
-    let start = 0;
-    const negative = raw[0] === "-";
-    if (negative || raw[0] === "+") start++;
-    const unsigned = raw.slice(start);
-    if (unsigned === "inf" || unsigned === "nan") this.#schema("SCHEMA_NONFINITE_NUMBER");
-    let base = 10;
-    if (unsigned.startsWith("0x")) base = 16;
-    else if (unsigned.startsWith("0o")) base = 8;
-    else if (unsigned.startsWith("0b")) base = 2;
-    if (base !== 10) {
-      if (start) this.#syntax();
-      let value2 = 0;
-      let previousDigit2 = false;
-      if (raw.length <= 2) this.#syntax();
-      for (let index = 2; index < raw.length; index++) {
-        const character = raw[index];
-        if (character === "_") {
-          if (!previousDigit2 || this.#digit(raw[index + 1] ?? "", base) < 0) this.#syntax();
-          previousDigit2 = false;
-        } else {
-          const digit = this.#digit(character, base);
-          if (digit < 0) this.#syntax();
-          if (value2 > Math.floor((Number.MAX_SAFE_INTEGER - digit) / base)) this.#schema("SCHEMA_UNSAFE_INTEGER");
-          value2 = value2 * base + digit;
-          previousDigit2 = true;
-        }
-        if (index % 256 === 0) {
-          await this.work.charge(256);
-          this.work.assertOpen();
-        }
-      }
-      return value2;
-    }
-    let clean = "";
-    let integerDigits = 0;
-    let fractionDigits = 0;
-    let exponentDigits = 0;
-    let exponentValue = 0;
-    let exponentNegative = false;
-    let state = "integer";
-    let previousDigit = false;
-    let coefficient = "";
-    for (let index = start; index < raw.length; index++) {
-      const character = raw[index];
-      const digit = this.#digit(character, 10);
-      if (digit >= 0) {
-        clean += character;
-        previousDigit = true;
-        if (state === "integer") {
-          integerDigits++;
-          coefficient += character;
-        } else if (state === "fraction") {
-          fractionDigits++;
-          coefficient += character;
-        } else {
-          exponentDigits++;
-          if (exponentValue > 1147483646) this.#schema("SCHEMA_DECIMAL_RANGE");
-          exponentValue = exponentValue * 10 + digit;
-        }
-      } else if (character === "_") {
-        if (!previousDigit || this.#digit(raw[index + 1] ?? "", 10) < 0) this.#syntax();
-        previousDigit = false;
-      } else if (character === "." && state === "integer" && previousDigit) {
-        state = "fraction";
-        previousDigit = false;
-        clean += character;
-      } else if ((character === "e" || character === "E") && state !== "exponent" && previousDigit) {
-        state = "exponent";
-        previousDigit = false;
-        clean += "e";
-        if (raw[index + 1] === "+" || raw[index + 1] === "-") {
-          exponentNegative = raw[index + 1] === "-";
-          clean += raw[++index];
-        }
-      } else this.#syntax();
-      if ((index - start + 1) % 256 === 0) {
-        await this.work.charge(256);
-        this.work.assertOpen();
-      }
-    }
-    if (!previousDigit || !integerDigits || integerDigits > 1 && unsigned[0] === "0" || state === "fraction" && !fractionDigits || state === "exponent" && !exponentDigits) this.#syntax();
-    const signed = (negative ? "-" : "") + clean;
-    const value = Number(signed);
-    if (!Number.isFinite(value)) this.#schema("SCHEMA_NONFINITE_NUMBER");
-    if (Number.isInteger(value) && !Number.isSafeInteger(value)) this.#schema("SCHEMA_UNSAFE_INTEGER");
-    if (state === "integer") return value;
-    let exponent = (exponentNegative ? -exponentValue : exponentValue) - fractionDigits;
-    if (exponent < -1147483646 || exponent > 999999999) this.#schema("SCHEMA_DECIMAL_RANGE");
-    let first = 0;
-    while (first < coefficient.length - 1 && coefficient[first] === "0") {
-      first++;
-      if (first % 256 === 0) {
-        await this.work.charge(256);
-        this.work.assertOpen();
-      }
-    }
-    let last = coefficient.length;
-    while (last > first + 1 && coefficient[last - 1] === "0") {
-      last--;
-      exponent++;
-      if ((coefficient.length - last) % 256 === 0) {
-        await this.work.charge(256);
-        this.work.assertOpen();
-      }
-    }
-    const digits = coefficient.slice(first, last);
-    if (digits !== "0" && exponent >= 0 && (digits.length + exponent > 16 || !Number.isSafeInteger(Number(`${digits}e${exponent}`)))) this.#schema("SCHEMA_UNSAFE_INTEGER");
-    return new Decimal(digits, exponent, negative, signed, value);
-  }
-  async #date(raw) {
-    const digits = (offset2, length) => {
-      let value = 0;
-      for (let index = offset2; index < offset2 + length; index++) {
-        const digit = this.#digit(raw[index] ?? "", 10);
-        if (digit < 0) this.#syntax();
-        value = value * 10 + digit;
-      }
-      return value;
-    };
-    let offset = 0;
-    const date = raw[4] === "-" && raw[7] === "-";
-    if (date) {
-      const year = digits(0, 4), month = digits(5, 2), day = digits(8, 2);
-      const leap = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
-      const days = [31, leap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
-      if (year < 1 || month < 1 || month > 12 || day < 1 || day > days[month - 1]) this.#syntax();
-      if (raw.length === 10) return;
-      if (!["T", "t", " "].includes(raw[10])) this.#syntax();
-      offset = 11;
-    }
-    if (raw[offset + 2] !== ":" || raw[offset + 5] !== ":" || digits(offset, 2) > 23 || digits(offset + 3, 2) > 59 || digits(offset + 6, 2) > 59) this.#syntax();
-    offset += 8;
-    if (raw[offset] === ".") {
-      const start = ++offset;
-      while (this.#digit(raw[offset] ?? "", 10) >= 0) {
-        offset++;
-        if ((offset - start) % 256 === 0) {
-          await this.work.charge(256);
-          this.work.assertOpen();
-        }
-      }
-      if (offset === start) this.#syntax();
-    }
-    if (offset === raw.length) return;
-    if (!date) this.#syntax();
-    if (raw[offset] === "Z" || raw[offset] === "z") offset++;
-    else if (raw[offset] === "+" || raw[offset] === "-") {
-      if (raw[offset + 3] !== ":" || digits(offset + 1, 2) > 23 || digits(offset + 4, 2) > 59) this.#syntax();
-      offset += 6;
-    } else this.#syntax();
-    if (offset !== raw.length) this.#syntax();
-  }
-  async parse() {
-    if (this.source.charCodeAt(0) === 65279) this.#syntax();
-    const root = await this.#table("root", 1);
-    let current = root;
-    while (true) {
-      await this.#space(true);
-      if (!this.#peek()) break;
-      if (this.#peek() === "[") current = await this.#header(root);
-      else {
-        await this.#assignment(current);
-        await this.#lineEnd();
-      }
-    }
-    await this.#flush();
-    return root;
-  }
-};
-async function parseTomlDocument(text, work, ledger, rawBytes) {
-  work.assertOpen();
-  ledger.beginDocument(rawBytes);
-  return new TomlParser(text, work, ledger).parse();
-}
-
-export {
-  YqError,
-  fromJqLimit,
-  limit,
-  yqCaps,
-  resolveYqLimits,
-  YqLedger,
-  copyAlias,
-  aliasFailure,
-  parseTomlDocument
-};
-//# sourceMappingURL=chunk-4QTSSQKP.js.map