@carbonenginejs/runtime 0.1.0-alpha.2 → 0.1.0-alpha.4

package/dist/resource/formats/pickle/core/CjsPickleProtocol0Reader.js

@@ -1,54 +1,49 @@
-const MARK = Symbol("pickle-mark");
-const PICKLE_PROTOCOL_0_LIMITS = {
-  maxContainerItems: 1000000,
-  maxInputBytes: 32 * 1024 * 1024,
-  maxMemoEntries: 500000,
-  maxMemoID: 1000000,
-  maxOperations: 2000000,
-  maxStackDepth: 100000,
-  maxStringBytes: 4 * 1024 * 1024
-};
-const LIMIT_NAMES = Object.keys(PICKLE_PROTOCOL_0_LIMITS);
+import { normalizeBytes, normalizeLimits, pickleError, assertJSONCompatible, chargeOperation, stateError, displayOpcode, reduce, push, setItem, putMemo, readSequence, getMemo, readDictionary, append, stop, createState, createGlobalMarker, MARK } from './pickleCommon.js';
 
-/**
- * Construction-bound decoder for the inert data subset of Python pickle
- * protocol 0.
- *
- * The reader never imports modules, resolves globals, invokes reducers, or
- * constructs Python objects. Unsupported opcodes fail closed at their byte
- * offset.
+const PROTOCOL = 0;
+
+/**
+ * Construction-bound decoder for the inert data subset of Python pickle
+ * protocol 0.
+ *
+ * The reader never imports modules, resolves globals, invokes reducers, or
+ * constructs Python objects. Unsupported opcodes fail closed at their byte
+ * offset. Everything about what a decoded value may be - limits, memo,
+ * containers, the closed set of rebuildable globals - lives in `pickleCommon`
+ * and is shared with the binary-protocol reader; this file owns only how
+ * protocol 0 spells its opcodes, which is as printable ASCII lines.
  */
 class CjsPickleProtocol0Reader {
   #bytes;
   #limits;
 
-  /**
-   * Bind one byte source and its resource limits.
-   *
-   * @param {ArrayBuffer|ArrayBufferView} input Pickle protocol-0 bytes.
-   * @param {object} [options] Reader options containing optional limits.
+  /**
+   * Bind one byte source and its resource limits.
+   *
+   * @param {ArrayBuffer|ArrayBufferView} input Pickle protocol-0 bytes.
+   * @param {object} [options] Reader options containing optional limits.
    */
   constructor(input, options = {}) {
     this.#bytes = normalizeBytes(input);
     this.#limits = normalizeLimits(options.limits ?? options);
     if (this.#bytes.byteLength > this.#limits.maxInputBytes) {
-      throw pickleError("CJS_PICKLE_FORMAT_LIMIT_EXCEEDED", `Pickle input exceeds maxInputBytes (${this.#limits.maxInputBytes}).`, 0);
+      throw pickleError("CJS_PICKLE_FORMAT_LIMIT_EXCEEDED", `Pickle input exceeds maxInputBytes (${this.#limits.maxInputBytes}).`, 0, PROTOCOL);
     }
   }
 
-  /**
-   * Decode an inert JavaScript value while preserving pickle memo identity.
-   *
-   * @returns {*} Decoded scalar, array, or plain object graph.
+  /**
+   * Decode an inert JavaScript value while preserving pickle memo identity.
+   *
+   * @returns {*} Decoded scalar, array, or plain object graph.
    */
   Read() {
     return decode(this.#bytes, this.#limits);
   }
 
-  /**
-   * Decode a value and reject cycles or values JSON cannot represent.
-   *
-   * @returns {*} JSON-compatible decoded graph.
+  /**
+   * Decode a value and reject cycles or values JSON cannot represent.
+   *
+   * @returns {*} JSON-compatible decoded graph.
    */
   ReadJSON() {
     const value = this.Read();
@@ -56,11 +51,11 @@ class CjsPickleProtocol0Reader {
     return value;
   }
 
-  /**
-   * Verify that a decoded value can cross the JSON boundary unchanged.
-   *
-   * @param {*} value Candidate decoded graph.
-   * @returns {*} The supplied value.
+  /**
+   * Verify that a decoded value can cross the JSON boundary unchanged.
+   *
+   * @param {*} value Candidate decoded graph.
+   * @returns {*} The supplied value.
    */
   static ToJSON(value) {
     assertJSONCompatible(value);
@@ -68,32 +63,11 @@ class CjsPickleProtocol0Reader {
   }
 }
 function decode(bytes, limits) {
-  const state = {
-    bytes,
-    containers: new WeakMap(),
-    dictionaryKeys: new WeakMap(),
-    limits,
-    lists: new WeakSet(),
-    marks: [],
-    memo: new Map(),
-    offset: 0,
-    operations: 0,
-    // Every global marker created, and separately those no REDUCE has consumed.
-    // A marker is a decoding artifact, never data: it may sit on the stack and
-    // in the memo on its way to a REDUCE, and it may reach nothing else.
-    globalMarkers: new WeakSet(),
-    pendingGlobals: new Set(),
-    // Properties built by REDUCE across the WHOLE decode, not per container.
-    rebuiltItems: 0,
-    stack: []
-  };
+  const state = createState(bytes, limits, PROTOCOL);
   while (state.offset < bytes.byteLength) {
     const opcodeOffset = state.offset;
     const opcode = bytes[state.offset++];
-    state.operations += 1;
-    if (state.operations > limits.maxOperations) {
-      throw pickleError("CJS_PICKLE_FORMAT_LIMIT_EXCEEDED", `Pickle operation count exceeds maxOperations (${limits.maxOperations}).`, opcodeOffset);
-    }
+    chargeOperation(state, opcodeOffset);
     switch (opcode) {
       case 0x28:
         // MARK
@@ -137,7 +111,7 @@ function decode(bytes, limits) {
         break;
       case 0x67:
         // GET
-        getMemo(state, opcodeOffset);
+        getMemo(state, readMemoID(state, opcodeOffset), opcodeOffset);
         break;
       case 0x6c:
         // LIST
@@ -149,7 +123,7 @@ function decode(bytes, limits) {
         break;
       case 0x70:
         // PUT
-        putMemo(state, opcodeOffset);
+        putMemo(state, readMemoID(state, opcodeOffset), opcodeOffset);
         break;
       case 0x73:
         // SETITEM
@@ -164,34 +138,19 @@ function decode(bytes, limits) {
         reduce(state, opcodeOffset);
         break;
       default:
-        throw pickleError("CJS_PICKLE_FORMAT_OPCODE_UNSUPPORTED", `Data-only pickle protocol 0 rejects opcode ${displayOpcode(opcode)}.`, opcodeOffset);
+        throw stateError(state, "CJS_PICKLE_FORMAT_OPCODE_UNSUPPORTED", `Data-only pickle protocol 0 rejects opcode ${displayOpcode(opcode)}.`, opcodeOffset);
     }
   }
-  throw pickleError("CJS_PICKLE_FORMAT_STOP_MISSING", "Pickle input ended without a STOP opcode.", state.offset);
-}
-function stop(state, offset) {
-  // A GLOBAL that no REDUCE consumed would otherwise reach the caller as an
-  // empty object, indistinguishable from an empty dictionary.
-  if (state.pendingGlobals.size) {
-    throw pickleError("CJS_PICKLE_FORMAT_GLOBAL_UNSUPPORTED", "Pickle names a global that no REDUCE consumes.", offset);
-  }
-  rejectGlobalMarker(state, state.stack[0], offset);
-  if (state.marks.length || state.stack.length !== 1 || state.stack[0] === MARK) {
-    throw pickleError("CJS_PICKLE_FORMAT_STACK_INVALID", "Pickle STOP requires one completed value and no open marks.", offset);
-  }
-  if (state.offset !== state.bytes.byteLength) {
-    throw pickleError("CJS_PICKLE_FORMAT_TRAILING_DATA", "Pickle input contains bytes after STOP.", state.offset);
-  }
-  return state.stack[0];
+  throw stateError(state, "CJS_PICKLE_FORMAT_STOP_MISSING", "Pickle input ended without a STOP opcode.", state.offset);
 }
 function readFloat(state, offset) {
   const value = readAsciiLine(state, state.limits.maxStringBytes, offset);
   if (!/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/u.test(value)) {
-    throw pickleError("CJS_PICKLE_FORMAT_NUMBER_INVALID", `Pickle FLOAT value is invalid: ${JSON.stringify(value)}.`, offset);
+    throw stateError(state, "CJS_PICKLE_FORMAT_NUMBER_INVALID", `Pickle FLOAT value is invalid: ${JSON.stringify(value)}.`, offset);
   }
   const result = Number(value);
   if (!Number.isFinite(result)) {
-    throw pickleError("CJS_PICKLE_FORMAT_NUMBER_INVALID", "Pickle FLOAT must be finite for JSON-compatible output.", offset);
+    throw stateError(state, "CJS_PICKLE_FORMAT_NUMBER_INVALID", "Pickle FLOAT must be finite for JSON-compatible output.", offset);
   }
   return result;
 }
@@ -201,7 +160,7 @@ function readInteger(state, offset, isLong) {
   if (!isLong && value === "01") return true;
   if (isLong && value.endsWith("L")) value = value.slice(0, -1);
   if (!/^[+-]?\d+$/u.test(value)) {
-    throw pickleError("CJS_PICKLE_FORMAT_NUMBER_INVALID", `Pickle integer value is invalid: ${JSON.stringify(value)}.`, offset);
+    throw stateError(state, "CJS_PICKLE_FORMAT_NUMBER_INVALID", `Pickle integer value is invalid: ${JSON.stringify(value)}.`, offset);
   }
   const result = BigInt(value);
   if (result >= BigInt(Number.MIN_SAFE_INTEGER) && result <= BigInt(Number.MAX_SAFE_INTEGER)) {
@@ -212,11 +171,11 @@ function readInteger(state, offset, isLong) {
 function readString(state, offset) {
   const bytes = readLine(state, state.limits.maxStringBytes, offset);
   if (bytes.byteLength < 2) {
-    throw pickleError("CJS_PICKLE_FORMAT_STRING_INVALID", "Pickle STRING must be a quoted Python string literal.", offset);
+    throw stateError(state, "CJS_PICKLE_FORMAT_STRING_INVALID", "Pickle STRING must be a quoted Python string literal.", offset);
   }
   const quote = bytes[0];
   if (quote !== 0x27 && quote !== 0x22 || bytes[bytes.byteLength - 1] !== quote) {
-    throw pickleError("CJS_PICKLE_FORMAT_STRING_INVALID", "Pickle STRING must use matching single or double quotes.", offset);
+    throw stateError(state, "CJS_PICKLE_FORMAT_STRING_INVALID", "Pickle STRING must use matching single or double quotes.", offset);
   }
   const result = [];
   for (let index = 1; index < bytes.byteLength - 1; index += 1) {
@@ -227,14 +186,14 @@ function readString(state, offset) {
     }
     index += 1;
     if (index >= bytes.byteLength - 1) {
-      throw pickleError("CJS_PICKLE_FORMAT_STRING_INVALID", "Pickle STRING ends with an incomplete escape.", offset);
+      throw stateError(state, "CJS_PICKLE_FORMAT_STRING_INVALID", "Pickle STRING ends with an incomplete escape.", offset);
     }
     const escaped = bytes[index];
     const simple = decodeSimpleEscape(escaped);
     if (simple !== null) {
       result.push(String.fromCharCode(simple));
     } else if (escaped === 0x78) {
-      result.push(String.fromCharCode(readHex(bytes, index + 1, 2, offset)));
+      result.push(String.fromCharCode(readHex(state, bytes, index + 1, 2, offset)));
       index += 2;
     } else if (escaped >= 0x30 && escaped <= 0x37) {
       let digits = String.fromCharCode(escaped);
@@ -244,7 +203,7 @@ function readString(state, offset) {
       }
       result.push(String.fromCharCode(Number.parseInt(digits, 8)));
     } else {
-      throw pickleError("CJS_PICKLE_FORMAT_STRING_INVALID", `Pickle STRING contains unsupported escape \\${String.fromCharCode(escaped)}.`, offset);
+      throw stateError(state, "CJS_PICKLE_FORMAT_STRING_INVALID", `Pickle STRING contains unsupported escape \\${String.fromCharCode(escaped)}.`, offset);
     }
   }
   return result.join("");
@@ -260,12 +219,12 @@ function readUnicode(state, offset) {
     }
     const escaped = bytes[index + 1];
     if (escaped === 0x75) {
-      result.push(String.fromCharCode(readHex(bytes, index + 2, 4, offset)));
+      result.push(String.fromCharCode(readHex(state, bytes, index + 2, 4, offset)));
       index += 5;
     } else if (escaped === 0x55) {
-      const codePoint = readHex(bytes, index + 2, 8, offset);
+      const codePoint = readHex(state, bytes, index + 2, 8, offset);
       if (codePoint > 0x10ffff) {
-        throw pickleError("CJS_PICKLE_FORMAT_STRING_INVALID", `Pickle UNICODE code point is out of range: ${codePoint}.`, offset);
+        throw stateError(state, "CJS_PICKLE_FORMAT_STRING_INVALID", `Pickle UNICODE code point is out of range: ${codePoint}.`, offset);
       }
       result.push(String.fromCodePoint(codePoint));
       index += 9;
@@ -275,227 +234,19 @@ function readUnicode(state, offset) {
   }
   return result.join("");
 }
-function readSequence(state, offset, isList) {
-  const values = popMarkedValues(state, offset);
-  requireContainerLimit(state, values.length, offset);
-  state.containers.set(values, values.length);
-  if (isList) state.lists.add(values);
-  return values;
-}
-function readDictionary(state, offset) {
-  const values = popMarkedValues(state, offset);
-  if (values.length % 2 !== 0) {
-    throw pickleError("CJS_PICKLE_FORMAT_CONTAINER_INVALID", "Pickle DICT requires key/value pairs.", offset);
-  }
-  requireContainerLimit(state, values.length / 2, offset);
-  const result = {};
-  let count = 0;
-  state.dictionaryKeys.set(result, new Map());
-  for (let index = 0; index < values.length; index += 2) {
-    count = defineDictionaryValue(state, result, values[index], values[index + 1], count, offset);
-  }
-  state.containers.set(result, count);
-  return result;
-}
-function append(state, offset) {
-  requireStack(state, 2, offset);
-  const value = rejectGlobalMarker(state, state.stack.pop(), offset);
-  const target = state.stack[state.stack.length - 1];
-  if (!Array.isArray(target) || !state.lists.has(target)) {
-    throw pickleError("CJS_PICKLE_FORMAT_CONTAINER_INVALID", "Pickle APPEND target must be a list.", offset);
-  }
-  requireContainerLimit(state, target.length + 1, offset);
-  target.push(value);
-  state.containers.set(target, target.length);
-}
-function setItem(state, offset) {
-  requireStack(state, 3, offset);
-  const value = rejectGlobalMarker(state, state.stack.pop(), offset);
-  const key = state.stack.pop();
-  const target = state.stack[state.stack.length - 1];
-  if (!isDictionary(target)) {
-    throw pickleError("CJS_PICKLE_FORMAT_CONTAINER_INVALID", "Pickle SETITEM target must be a dictionary.", offset);
-  }
-  const count = defineDictionaryValue(state, target, key, value, state.containers.get(target) ?? Object.keys(target).length, offset);
-  requireContainerLimit(state, count, offset);
-  state.containers.set(target, count);
-}
-function defineDictionaryValue(state, target, key, value, count, offset) {
-  const normalized = normalizeDictionaryKey(key, offset);
-  const keyTypes = state.dictionaryKeys.get(target) ?? new Map();
-  const previousType = keyTypes.get(normalized.value);
-  if (previousType && previousType !== normalized.type) {
-    throw pickleError("CJS_PICKLE_FORMAT_CONTAINER_INVALID", `Pickle dictionary keys collide after JSON normalization: ${JSON.stringify(normalized.value)}.`, offset);
-  }
-  const exists = Object.hasOwn(target, normalized.value);
-  Object.defineProperty(target, normalized.value, {
-    configurable: true,
-    enumerable: true,
-    value,
-    writable: true
-  });
-  keyTypes.set(normalized.value, normalized.type);
-  state.dictionaryKeys.set(target, keyTypes);
-  return exists ? count : count + 1;
-}
-function normalizeDictionaryKey(key, offset) {
-  if (typeof key === "string") return {
-    type: "string",
-    value: key
-  };
-  if (typeof key === "number" && Number.isSafeInteger(key)) {
-    return {
-      type: "integer",
-      value: String(key)
-    };
-  }
-  throw pickleError("CJS_PICKLE_FORMAT_CONTAINER_INVALID", "Data-only pickle dictionaries require string or safe-integer keys.", offset);
-}
-function putMemo(state, offset) {
-  requireStack(state, 1, offset);
-  if (state.stack[state.stack.length - 1] === MARK) {
-    throw pickleError("CJS_PICKLE_FORMAT_MARK_INVALID", "Pickle MARK cannot be stored in the memo.", offset);
-  }
-  const id = readMemoID(state, offset);
-  if (!state.memo.has(id) && state.memo.size >= state.limits.maxMemoEntries) {
-    throw pickleError("CJS_PICKLE_FORMAT_LIMIT_EXCEEDED", `Pickle memo exceeds maxMemoEntries (${state.limits.maxMemoEntries}).`, offset);
-  }
-  state.memo.set(id, state.stack[state.stack.length - 1]);
-}
-function getMemo(state, offset) {
-  const id = readMemoID(state, offset);
-  if (!state.memo.has(id)) {
-    throw pickleError("CJS_PICKLE_FORMAT_MEMO_INVALID", `Pickle memo entry ${id} does not exist.`, offset);
-  }
-  push(state, state.memo.get(id), offset);
-}
 function readMemoID(state, offset) {
   const value = readAsciiLine(state, 64, offset);
   if (!/^\d+$/u.test(value)) {
-    throw pickleError("CJS_PICKLE_FORMAT_MEMO_INVALID", `Pickle memo ID is invalid: ${JSON.stringify(value)}.`, offset);
+    throw stateError(state, "CJS_PICKLE_FORMAT_MEMO_INVALID", `Pickle memo ID is invalid: ${JSON.stringify(value)}.`, offset);
   }
-  const result = Number(value);
-  if (!Number.isSafeInteger(result) || result > state.limits.maxMemoID) {
-    throw pickleError("CJS_PICKLE_FORMAT_LIMIT_EXCEEDED", `Pickle memo ID exceeds maxMemoID (${state.limits.maxMemoID}).`, offset);
-  }
-  return result;
+  return Number(value);
 }
 
-/**
- * The one closed set of globals this reader will name, and how each rebuilds.
- *
- * `GLOBAL` is the opcode that makes a pickle dangerous: it names a module and an
- * attribute for the unpickler to import, and `REDUCE` then calls it. The general
- * form stays refused, and nothing here imports, resolves or invokes anything.
- * What this table does instead is recognize a fixed name and build the plain
- * data it stands for.
- *
- * `collections.OrderedDict` earns its place because it is not a behaviour, it is
- * a dictionary that remembers insertion order — and a JavaScript object already
- * does. It is also, measured across every self-describing container CCP ships,
- * **the only global any of them uses**: 25 files, one name, once each. They use
- * it because a schema's attribute order is its field order, which is exactly the
- * property an ordinary dict would lose.
- *
- * **Adding to this table is not a small change.** A name belongs here only if
- * reconstructing it is pure data with no behaviour of its own, and the entry has
- * to build that data directly rather than defer to anything callable.
- */
-const REBUILDABLE_GLOBALS = new Map([["collections.OrderedDict", RebuildOrderedDict]]);
-const GLOBAL_NAME = Symbol("pickle-global");
-
-/** Reads a GLOBAL, and refuses every name outside the closed set above. */
+/** Reads a GLOBAL, and refuses every name outside the closed set. */
 function readGlobal(state, offset) {
   const module = decodeAscii(readLine(state, state.limits.maxStringBytes, offset));
   const attribute = decodeAscii(readLine(state, state.limits.maxStringBytes, offset));
-  const name = `${module}.${attribute}`;
-  if (!REBUILDABLE_GLOBALS.has(name)) {
-    throw pickleError("CJS_PICKLE_FORMAT_GLOBAL_UNSUPPORTED", `Data-only pickle protocol 0 rejects the global ${JSON.stringify(name)}. ` + "Only a closed set of pure-data containers can be rebuilt, and this is not one.", offset);
-  }
-  const marker = {
-    [GLOBAL_NAME]: name
-  };
-  state.globalMarkers.add(marker);
-  state.pendingGlobals.add(marker);
-  return marker;
-}
-
-/** Rebuilds one allowed global from its arguments. Calls nothing. */
-function reduce(state, offset) {
-  const args = state.stack.pop();
-  const callable = state.stack.pop();
-  const name = callable && typeof callable === "object" ? callable[GLOBAL_NAME] : undefined;
-  if (!name || !REBUILDABLE_GLOBALS.has(name)) {
-    throw pickleError("CJS_PICKLE_FORMAT_REDUCE_INVALID", "Pickle REDUCE applies only to a global this reader can rebuild.", offset);
-  }
-  if (!Array.isArray(args)) {
-    throw pickleError("CJS_PICKLE_FORMAT_REDUCE_INVALID", "Pickle REDUCE requires an argument tuple.", offset);
-  }
-  state.pendingGlobals.delete(callable);
-  push(state, REBUILDABLE_GLOBALS.get(name)(args, state, offset), offset);
-}
-
-/**
- * Rebuilds `OrderedDict(pairs)` as a plain object.
- *
- * JavaScript preserves the insertion order of string keys, but NOT of keys that
- * look like array indices — those sort ahead of everything else, in ascending
- * numeric order. Refusing every numeric key was too blunt: real containers use
- * them, and where they already ascend the object's order is the source's order
- * and nothing is lost.
- *
- * So the order is checked rather than the keys. The result is compared against
- * the order it was built in, and only a dictionary JavaScript would actually
- * reorder is refused.
- */
-function RebuildOrderedDict(args, state, offset) {
-  const pairs = args.length ? args[0] : [];
-  if (!Array.isArray(pairs)) {
-    throw pickleError("CJS_PICKLE_FORMAT_REDUCE_INVALID", "An ordered dictionary is rebuilt from a list of key/value pairs.", offset);
-  }
-  requireContainerLimit(state, pairs.length, offset);
-  const order = [];
-
-  // A per-container check is not enough here. REDUCE is the only path that
-  // builds N properties for a constant number of opcodes, so a memoized pair
-  // list rebuilt in a loop multiplies `maxOperations` by `maxContainerItems`
-  // instead of being bounded by either. A decode-wide budget is what bounds it.
-  state.rebuiltItems += pairs.length;
-  if (state.rebuiltItems > state.limits.maxContainerItems) {
-    throw pickleError("CJS_PICKLE_FORMAT_LIMIT_EXCEEDED", `Rebuilt items exceed maxContainerItems (${state.limits.maxContainerItems}) across the decode.`, offset);
-  }
-  const result = {};
-  for (const pair of pairs) {
-    if (!Array.isArray(pair) || pair.length !== 2) {
-      throw pickleError("CJS_PICKLE_FORMAT_REDUCE_INVALID", "An ordered dictionary entry must be a key/value pair.", offset);
-    }
-    const key = pair[0];
-    if (typeof key !== "string") {
-      throw pickleError("CJS_PICKLE_FORMAT_REDUCE_INVALID", "An ordered dictionary key must be a string.", offset);
-    }
-    order.push(key);
-
-    // Defined rather than assigned, as the dictionary path already does. A
-    // plain assignment to `__proto__` sets the object's prototype instead of
-    // storing a property: the field silently disappears from the decoded record
-    // and, if its value is an object, becomes a phantom the JSON never shows.
-    Object.defineProperty(result, key, {
-      configurable: true,
-      enumerable: true,
-      value: pair[1],
-      writable: true
-    });
-  }
-
-  // Order is the one thing this type exists to carry, so it is checked rather
-  // than assumed. A repeated key keeps its first position, which is what both
-  // Python and JavaScript do.
-  const expected = [...new Set(order)];
-  const kept = Object.keys(result);
-  if (kept.length !== expected.length || kept.some((key, index) => key !== expected[index])) {
-    throw pickleError("CJS_PICKLE_FORMAT_REDUCE_INVALID", "An ordered dictionary's key order would not survive as a JavaScript object.", offset);
-  }
-  return result;
+  return createGlobalMarker(state, `${module}.${attribute}`, offset);
 }
 
 /** Decodes a GLOBAL's module or attribute line, which is always ASCII. */
@@ -504,56 +255,12 @@ function decodeAscii(bytes) {
   for (const byte of bytes) result += String.fromCharCode(byte);
   return result.trim();
 }
-
-/**
- * Refuses a global marker anywhere a decoded value is stored or returned.
- *
- * Consuming a marker with REDUCE is the only thing it is for. Appended to a
- * list, set as a dictionary value or left as the result, it would reach the
- * caller as `{}` - indistinguishable from an empty dictionary, and buryable
- * anywhere in the graph through the memo.
- */
-function rejectGlobalMarker(state, value, offset) {
-  if (value && typeof value === "object" && state.globalMarkers.has(value)) {
-    throw pickleError("CJS_PICKLE_FORMAT_GLOBAL_UNSUPPORTED", "A pickle global is only usable as the target of a REDUCE.", offset);
-  }
-  return value;
-}
-function popMarkedValues(state, offset) {
-  if (!state.marks.length) {
-    throw pickleError("CJS_PICKLE_FORMAT_MARK_INVALID", "Pickle container has no matching MARK.", offset);
-  }
-  const mark = state.marks.pop();
-  if (state.stack[mark] !== MARK) {
-    throw pickleError("CJS_PICKLE_FORMAT_MARK_INVALID", "Pickle MARK stack is inconsistent.", offset);
-  }
-  const values = state.stack.slice(mark + 1);
-  state.stack.length = mark;
-  for (const value of values) rejectGlobalMarker(state, value, offset);
-  return values;
-}
-function push(state, value, offset) {
-  if (state.stack.length >= state.limits.maxStackDepth) {
-    throw pickleError("CJS_PICKLE_FORMAT_LIMIT_EXCEEDED", `Pickle stack exceeds maxStackDepth (${state.limits.maxStackDepth}).`, offset);
-  }
-  state.stack.push(value);
-}
-function requireStack(state, count, offset) {
-  if (state.stack.length < count) {
-    throw pickleError("CJS_PICKLE_FORMAT_STACK_INVALID", `Pickle opcode requires ${count} stack values.`, offset);
-  }
-}
-function requireContainerLimit(state, count, offset) {
-  if (count > state.limits.maxContainerItems) {
-    throw pickleError("CJS_PICKLE_FORMAT_LIMIT_EXCEEDED", `Pickle container exceeds maxContainerItems (${state.limits.maxContainerItems}).`, offset);
-  }
-}
 function readAsciiLine(state, limit, offset) {
   const bytes = readLine(state, limit, offset);
   let result = "";
   for (const byte of bytes) {
     if (byte > 0x7f) {
-      throw pickleError("CJS_PICKLE_FORMAT_STRING_INVALID", "Pickle control line must contain ASCII bytes.", offset);
+      throw stateError(state, "CJS_PICKLE_FORMAT_STRING_INVALID", "Pickle control line must contain ASCII bytes.", offset);
     }
     result += String.fromCharCode(byte);
   }
@@ -564,25 +271,25 @@ function readLine(state, limit, offset) {
   while (state.offset < state.bytes.byteLength && state.bytes[state.offset] !== 0x0a) {
     state.offset += 1;
     if (state.offset - start > limit) {
-      throw pickleError("CJS_PICKLE_FORMAT_LIMIT_EXCEEDED", `Pickle line exceeds its ${limit}-byte limit.`, offset);
+      throw stateError(state, "CJS_PICKLE_FORMAT_LIMIT_EXCEEDED", `Pickle line exceeds its ${limit}-byte limit.`, offset);
     }
   }
   if (state.offset >= state.bytes.byteLength) {
-    throw pickleError("CJS_PICKLE_FORMAT_EOF", "Pickle line is missing its newline terminator.", offset);
+    throw stateError(state, "CJS_PICKLE_FORMAT_EOF", "Pickle line is missing its newline terminator.", offset);
   }
   const result = state.bytes.subarray(start, state.offset);
   state.offset += 1;
   return result;
 }
-function readHex(bytes, start, length, offset) {
+function readHex(state, bytes, start, length, offset) {
   if (start + length > bytes.byteLength) {
-    throw pickleError("CJS_PICKLE_FORMAT_STRING_INVALID", "Pickle escape sequence is truncated.", offset);
+    throw stateError(state, "CJS_PICKLE_FORMAT_STRING_INVALID", "Pickle escape sequence is truncated.", offset);
   }
   let result = 0;
   for (let index = 0; index < length; index += 1) {
     const value = hexValue(bytes[start + index]);
     if (value === -1) {
-      throw pickleError("CJS_PICKLE_FORMAT_STRING_INVALID", "Pickle escape sequence contains a non-hexadecimal digit.", offset);
+      throw stateError(state, "CJS_PICKLE_FORMAT_STRING_INVALID", "Pickle escape sequence contains a non-hexadecimal digit.", offset);
     }
     result = result * 16 + value;
   }
@@ -609,104 +316,6 @@ function decodeSimpleEscape(byte) {
   };
   return Object.hasOwn(values, byte) ? values[byte] : null;
 }
-function assertJSONCompatible(value) {
-  const active = new WeakSet();
-  const verified = new WeakSet();
-  const pending = [{
-    exit: false,
-    value
-  }];
-  while (pending.length) {
-    const item = pending.pop();
-    const current = item.value;
-    if (current === null || typeof current === "string" || typeof current === "boolean") {
-      continue;
-    }
-    if (typeof current === "number") {
-      if (!Number.isFinite(current)) {
-        throw pickleError("CJS_PICKLE_FORMAT_JSON_INVALID", "Pickle output contains a non-finite number.", null);
-      }
-      continue;
-    }
-    if (!current || typeof current !== "object") {
-      throw pickleError("CJS_PICKLE_FORMAT_JSON_INVALID", `Pickle output contains unsupported ${typeof current} data.`, null);
-    }
-    if (item.exit) {
-      active.delete(current);
-      verified.add(current);
-      continue;
-    }
-    if (verified.has(current)) continue;
-    if (active.has(current)) {
-      throw pickleError("CJS_PICKLE_FORMAT_JSON_INVALID", "Pickle output contains a cyclic reference.", null);
-    }
-    active.add(current);
-    pending.push({
-      exit: true,
-      value: current
-    });
-    if (Array.isArray(current)) {
-      for (let index = current.length - 1; index >= 0; index -= 1) {
-        pending.push({
-          exit: false,
-          value: current[index]
-        });
-      }
-    } else if (Object.getPrototypeOf(current) === Object.prototype) {
-      const keys = Object.keys(current);
-      for (let index = keys.length - 1; index >= 0; index -= 1) {
-        pending.push({
-          exit: false,
-          value: current[keys[index]]
-        });
-      }
-    } else {
-      throw pickleError("CJS_PICKLE_FORMAT_JSON_INVALID", "Pickle output contains a non-plain object.", null);
-    }
-  }
-}
-function normalizeBytes(input) {
-  if (input instanceof ArrayBuffer) return new Uint8Array(input);
-  if (ArrayBuffer.isView(input)) {
-    return new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
-  }
-  throw pickleError("CJS_PICKLE_FORMAT_INPUT_INVALID", "Pickle input must be an ArrayBuffer or an ArrayBuffer view.", 0);
-}
-function normalizeLimits(options) {
-  if (!options || typeof options !== "object" || Array.isArray(options)) {
-    throw pickleError("CJS_PICKLE_FORMAT_LIMIT_INVALID", "Pickle limits must be an object.", 0);
-  }
-  for (const name of Object.keys(options)) {
-    if (!LIMIT_NAMES.includes(name)) {
-      throw pickleError("CJS_PICKLE_FORMAT_LIMIT_INVALID", `Pickle limits contain unknown value ${JSON.stringify(name)}.`, 0);
-    }
-  }
-  const result = {};
-  for (const name of LIMIT_NAMES) {
-    const value = options[name] ?? PICKLE_PROTOCOL_0_LIMITS[name];
-    if (!Number.isSafeInteger(value) || value <= 0) {
-      throw pickleError("CJS_PICKLE_FORMAT_LIMIT_INVALID", `Pickle ${name} must be a positive safe integer.`, 0);
-    }
-    result[name] = value;
-  }
-  return result;
-}
-function isDictionary(value) {
-  return Boolean(value && typeof value === "object" && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype);
-}
-function displayOpcode(value) {
-  if (value >= 0x20 && value <= 0x7e) {
-    return JSON.stringify(String.fromCharCode(value));
-  }
-  return `0x${value.toString(16).padStart(2, "0")}`;
-}
-function pickleError(code, message, offset) {
-  const error = new Error(message);
-  error.code = code;
-  error.protocol = 0;
-  if (offset !== null) error.offset = offset;
-  return error;
-}
 
-export { CjsPickleProtocol0Reader, PICKLE_PROTOCOL_0_LIMITS };
+export { CjsPickleProtocol0Reader };
 //# sourceMappingURL=CjsPickleProtocol0Reader.js.map