@poe-platform/safe-js 0.1.204 → 0.1.205

package/dist/safe-js/chunks/{chunk-Z2ZXS55C.js → chunk-EOKMWSSM.js}

@@ -27,7 +27,7 @@ import {
   validateMigrationSemantics,
   validateSnapshotData,
   validateSnapshotMigration
-} from "./chunk-EOTY4PCT.js";
+} from "./chunk-YWQDSWZN.js";
 
 // packages/safe-js/src/migrate.ts
 import { createHash } from "node:crypto";
@@ -8249,4 +8249,4 @@ export {
   parseMcpConfig,
   makeMcpModule
 };
-//# sourceMappingURL=chunk-Z2ZXS55C.js.map
+//# sourceMappingURL=chunk-EOKMWSSM.js.map

package/dist/safe-js/chunks/{chunk-EOTY4PCT.js → chunk-YWQDSWZN.js}

@@ -1255,7 +1255,7 @@ var Lexer = class {
         this.advance();
         this.advance();
         this.consumeDigitsForBase(isHexDigit, "hexadecimal");
-        this.rejectBigIntSuffix();
+        if (this.currentChar() === "n") this.advance();
         this.rejectInvalidNumericLiteralContinuation();
         return this.source.slice(start.offset, this.index);
       }
@@ -1263,7 +1263,7 @@ var Lexer = class {
         this.advance();
         this.advance();
         this.consumeDigitsForBase(isBinaryDigit, "binary");
-        this.rejectBigIntSuffix();
+        if (this.currentChar() === "n") this.advance();
         this.rejectInvalidNumericLiteralContinuation();
         return this.source.slice(start.offset, this.index);
       }
@@ -1271,7 +1271,7 @@ var Lexer = class {
         this.advance();
         this.advance();
         this.consumeDigitsForBase(isOctalDigit, "octal");
-        this.rejectBigIntSuffix();
+        if (this.currentChar() === "n") this.advance();
         this.rejectInvalidNumericLiteralContinuation();
         return this.source.slice(start.offset, this.index);
       }
@@ -1285,6 +1285,11 @@ var Lexer = class {
       }
     }
     this.consumeDecimalDigits();
+    if (this.currentChar() === "n") {
+      this.advance();
+      this.rejectInvalidNumericLiteralContinuation();
+      return this.source.slice(start.offset, this.index);
+    }
     if (this.currentChar() === "." && (this.peekChar(1) !== "." || this.peekChar(2) !== ".")) {
       this.advance();
       this.consumeOptionalDecimalDigits();
@@ -1383,7 +1388,7 @@ var Lexer = class {
   }
   rejectBigIntSuffix() {
     if (this.currentChar() === "n") {
-      this.syntaxError("BigInt not supported", this.position());
+      this.syntaxError("BigInt literals cannot contain a fraction or exponent", this.position());
     }
   }
   rejectInvalidNumericLiteralContinuation() {
@@ -5824,6 +5829,7 @@ function findImportMetaAssignmentInNode(node) {
     case "BooleanLiteral":
     case "NullLiteral":
     case "NumericLiteral":
+    case "BigIntLiteral":
     case "StringLiteral":
     case "ThisExpression":
     case "RegexLiteral":
@@ -5902,6 +5908,12 @@ function isYieldArgumentTerminator(value) {
   return value === ";" || value === "}" || value === ")" || value === "]" || value === ",";
 }
 function createNumericLiteral(token) {
+  if (token.value.endsWith("n")) return {
+    type: "BigIntLiteral",
+    raw: token.value,
+    value: token.value.slice(0, -1).replaceAll("_", ""),
+    span: createTokenSpan(token)
+  };
   return {
     type: "NumericLiteral",
     raw: token.value,
@@ -7102,15 +7114,17 @@ var numberValue = Number.prototype.valueOf;
 var stringValue = String.prototype.valueOf;
 var booleanValue = Boolean.prototype.valueOf;
 var symbolValue = Symbol.prototype.valueOf;
+var bigintValue = BigInt.prototype.valueOf;
 function nativeBoxedValue(value) {
   if (types3.isNumberObject(value)) return Reflect.apply(numberValue, value, []);
   if (types3.isStringObject(value)) return Reflect.apply(stringValue, value, []);
   if (types3.isBooleanObject(value)) return Reflect.apply(booleanValue, value, []);
   if (types3.isSymbolObject(value)) return Reflect.apply(symbolValue, value, []);
+  if (types3.isBigIntObject(value)) return Reflect.apply(bigintValue, value, []);
   return void 0;
 }
 function createSandboxBox(value) {
-  if (typeof value !== "number" && typeof value !== "string" && typeof value !== "boolean" && typeof value !== "symbol")
+  if (typeof value !== "number" && typeof value !== "bigint" && typeof value !== "string" && typeof value !== "boolean" && typeof value !== "symbol")
     throw new TypeError("Invalid boxed primitive payload.");
   const box = Object(value);
   Object.setPrototypeOf(box, null);
@@ -7605,6 +7619,18 @@ async function flushPromiseJobs() {
 // packages/safe-js/src/interp/promise-replay.ts
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
 
+// packages/safe-js/src/snapshot/bigint.ts
+function validateBigIntData(value) {
+  if (typeof value !== "string" || value.length === 0) throw new TypeError("Invalid BigInt snapshot value.");
+  if (value === "0") return;
+  const start = value[0] === "-" ? 1 : 0;
+  if (start === value.length || value[start] === "0") throw new TypeError("Invalid BigInt snapshot value.");
+  for (let index = start; index < value.length; index++) {
+    const code = value.charCodeAt(index);
+    if (code < 48 || code > 57) throw new TypeError("Invalid BigInt snapshot value.");
+  }
+}
+
 // packages/safe-js/src/interp/symbols.ts
 var wellKnownSymbols = Object.freeze({
   iterator: Symbol.iterator,
@@ -8274,6 +8300,7 @@ function createDumpFile(snapshot) {
   return dumped;
 }
 function serializeDumpValue(value, path, state) {
+  if (typeof value === "bigint") return { kind: "bigint", value: String(value) };
   if (typeof value === "symbol") return serializeSymbol(value, state.heapIds, state.heap);
   if (value === null || typeof value === "string" || typeof value === "boolean") {
     return value;
@@ -8705,6 +8732,14 @@ function validateValue(value, path, depth, state) {
 }
 function validateTaggedValue(record2, path, state) {
   switch (record2.kind) {
+    case "bigint":
+      requireString(record2.value, `${path}.value`, state.limits);
+      try {
+        validateBigIntData(record2.value);
+      } catch {
+        fail("invalidValue", `${path}.value`, "invalid BigInt value");
+      }
+      return;
     case "undefined":
       return;
     case "number":
@@ -8871,6 +8906,14 @@ function validateBoxedRecord(record2, path, heap) {
   const value = record2.value;
   if (typeof value === "number" || typeof value === "string" || typeof value === "boolean") return;
   const number = requireRecord(value, `${path}.value`);
+  if (number.kind === "bigint") {
+    try {
+      validateBigIntData(number.value);
+    } catch {
+      fail("invalidValue", `${path}.value`, "invalid boxed BigInt payload");
+    }
+    return;
+  }
   if (number.kind === "ref") {
     const id = requireSafeInteger(number.id, `${path}.value.id`, 1);
     const target = requireRecord(heap[String(id)], `${path}.value`);
@@ -10062,6 +10105,69 @@ function isLineTerminator(character) {
   return character === "\n" || character === "\r" || character === "\u2028" || character === "\u2029";
 }
 
+// packages/safe-js/src/interp/bigint-operators.ts
+function bigIntOperation(operator, left, right, budget) {
+  if (operator === ">>>") throw new TypeError("BigInts have no unsigned right shift.");
+  if ((operator === "/" || operator === "%") && right === 0n) throw new RangeError("Division by zero.");
+  if (operator === "**" && right < 0n) throw new RangeError("BigInt exponent must be nonnegative.");
+  const leftSize = left.toString(16).length;
+  const rightSize = right.toString(16).length;
+  budget.visitNode(leftSize + rightSize);
+  let size = Math.max(leftSize, rightSize) + 1;
+  let work = leftSize + rightSize;
+  if (operator === "*") {
+    size = leftSize + rightSize;
+    work = leftSize * rightSize;
+  } else if (operator === "/" || operator === "%") {
+    size = leftSize;
+    work = leftSize * rightSize;
+  } else if (operator === "**") {
+    if (right === 0n) return 1n;
+    if (left === 0n || left === 1n) return left;
+    if (left === -1n) return right % 2n === 0n ? 1n : -1n;
+    size = leftSize * Number(right);
+    work = size * size;
+  } else if (operator === "<<" || operator === ">>") {
+    if (left === 0n) return 0n;
+    const shift = operator === "<<" ? right : -right;
+    size = shift > 0n ? leftSize + Math.ceil(Number(shift) / 4) : leftSize;
+    work = size + rightSize;
+  }
+  if (!Number.isSafeInteger(size) || !Number.isSafeInteger(work))
+    throw new SandboxError({ budget: "dataSize", current: Infinity, limit: Number.MAX_SAFE_INTEGER });
+  budget.visitNode(work);
+  const allocation = {};
+  budget.setRetainedDataUsage(allocation, size);
+  try {
+    switch (operator) {
+      case "+":
+        return left + right;
+      case "-":
+        return left - right;
+      case "*":
+        return left * right;
+      case "/":
+        return left / right;
+      case "%":
+        return left % right;
+      case "**":
+        return left ** right;
+      case "&":
+        return left & right;
+      case "|":
+        return left | right;
+      case "^":
+        return left ^ right;
+      case "<<":
+        return left << right;
+      case ">>":
+        return left >> right;
+    }
+  } finally {
+    budget.setRetainedDataUsage(allocation, 0);
+  }
+}
+
 // packages/safe-js/src/interp/jobs.ts
 import { AsyncLocalStorage as AsyncLocalStorage4 } from "node:async_hooks";
 var activeJob = new AsyncLocalStorage4();
@@ -10237,7 +10343,7 @@ function callNumberMethod(value, methodName, args, budget, context) {
   if (argument !== null && typeof argument === "object") {
     return formatObjectArgument(value, methodName, argument, budget, context);
   }
-  return formatNumber(value, methodName, argument === void 0 ? void 0 : Number(argument), budget);
+  return formatNumber(value, methodName, argument === void 0 ? void 0 : +argument, budget);
 }
 async function formatObjectArgument(value, methodName, argument, budget, context) {
   const retainedArgument = {};
@@ -11060,10 +11166,10 @@ function splitString(value, separator, limit) {
   return split.call(value, separator, limit);
 }
 function asNumber(value) {
-  return Number(value);
+  return +value;
 }
 function asNumberOrUndefined(value) {
-  return value === void 0 ? void 0 : Number(value);
+  return value === void 0 ? void 0 : +value;
 }
 function asStringOrUndefined(value) {
   return value === void 0 ? void 0 : String(value);
@@ -11413,7 +11519,7 @@ function createObjectArrayGlobals(options) {
     ),
     Number: createPrimitiveConstructor(
       {
-        call: (args, context) => sandboxNumber(args.length === 0 ? 0 : args[0], options.budget, context),
+        call: (args, context) => sandboxNumber(args.length === 0 ? 0 : args[0], options.budget, context, true),
         name: "Number",
         properties: {
           isFinite: createSandboxClosure({
@@ -14097,6 +14203,16 @@ var dispatchTable = {
   ArrowFunctionExpression: evaluateArrowFunction,
   AwaitExpression: evaluateAwait,
   BinaryExpression: evaluateBinaryExpression,
+  BigIntLiteral: async (node, context) => {
+    const allocation = {};
+    context.budget.visitNode(node.value.length);
+    context.budget.setRetainedDataUsage(allocation, node.value.length);
+    try {
+      return { kind: "normal", hasValue: true, value: BigInt(node.value) };
+    } finally {
+      context.budget.setRetainedDataUsage(allocation, 0);
+    }
+  },
   BlockStatement: evaluateBlockStatement,
   BooleanLiteral: evaluatePrimitiveLiteral,
   CallExpression: evaluateCallExpression,
@@ -15871,8 +15987,9 @@ async function evaluateIdentifierUpdateExpression(node, context) {
       )
     };
   }
-  const current = toNumber(await toNumericPrimitive(binding.value, context));
-  const next = node.operator === "++" ? current + 1 : current - 1;
+  const primitive = await toNumericPrimitive(binding.value, context);
+  const current = typeof primitive === "bigint" ? primitive : toNumber(primitive);
+  const next = typeof current === "bigint" ? bigIntOperation(node.operator === "++" ? "+" : "-", current, 1n, context.budget) : node.operator === "++" ? current + 1 : current - 1;
   context.scope.assign(node.argument.name, next);
   return {
     kind: "normal",
@@ -15889,10 +16006,9 @@ async function evaluateMemberUpdateExpression(node, context) {
       throw new TypeError("Cannot update properties of null or undefined.");
     }
     const property = await toPropertyKey(member.property, context.budget, createCoercionContext(context));
-    const current = toNumber(
-      await toNumericPrimitive(await getPropertyValue(member.object, property, context, member.superReceiver === void 0 ? member.object : member.superReceiver.value), context)
-    );
-    const next = node.operator === "++" ? current + 1 : current - 1;
+    const primitive = await toNumericPrimitive(await getPropertyValue(member.object, property, context, member.superReceiver === void 0 ? member.object : member.superReceiver.value), context);
+    const current = typeof primitive === "bigint" ? primitive : toNumber(primitive);
+    const next = typeof current === "bigint" ? bigIntOperation(node.operator === "++" ? "+" : "-", current, 1n, context.budget) : node.operator === "++" ? current + 1 : current - 1;
     if (member.superReceiver === void 0) await setSandboxProperty(member.object, property, next, context.budget, true, createCoercionContext(context));
     else await setSuperProperty(member.object, member.superReceiver.value, property, next, context);
     return {
@@ -15926,7 +16042,7 @@ function getPropertyValue(target, property, context, receiver = target) {
   if (descriptor !== void 0)
     return readPropertyDescriptor(descriptor, receiver, createCoercionContext(context), true);
   if (isSandboxRegExpIterator(target)) return getRegExpIteratorMember(property, context.budget);
-  if (typeof target === "symbol") {
+  if (typeof target === "symbol" || typeof target === "bigint") {
     const prototype = getBoxedPrototype(target, context.budget);
     return prototype === void 0 ? void 0 : getPropertyValue(prototype, property, context, receiver);
   }
@@ -16107,6 +16223,7 @@ async function evaluateObjectPropertyKey(node, context) {
   return evaluateMemberProperty(node.key, context);
 }
 function getStaticPropertyName(node) {
+  if (node.type === "BigIntLiteral") return BigInt(node.value).toString();
   if (node.type === "Identifier") {
     return node.name;
   }
@@ -16140,7 +16257,7 @@ async function evaluateMemberCallExpression(node, context) {
       return evaluateResolvedCallExpression(node, await getPropertyValue(member.object, member.property, context), context, member.object);
     if (Array.isArray(member.object) && hasExplicitSandboxPrototype(member.object))
       return evaluateResolvedCallExpression(node, await getPropertyValue(member.object, member.property, context), context, member.object);
-    if ((typeof member.object === "string" || typeof member.object === "number" || typeof member.object === "boolean" || typeof member.object === "symbol") && getBoxedPrototype(member.object, context.budget) !== void 0) {
+    if ((typeof member.object === "string" || typeof member.object === "number" || typeof member.object === "bigint" || typeof member.object === "boolean" || typeof member.object === "symbol") && getBoxedPrototype(member.object, context.budget) !== void 0) {
       if (isDefaultBoxedMethod(member.object, member.property, context.budget)) {
         if (typeof member.object === "string" && isStringMethodName(member.property))
           return evaluateStringMethodCall(node, member.object, member.property, context);
@@ -16390,10 +16507,14 @@ async function applyUnaryOperator(operator, value, context) {
       return void 0;
     case "+":
       return toNumber(await toNumericPrimitive(value, context));
-    case "-":
-      return -toNumber(await toNumericPrimitive(value, context));
-    case "~":
-      return ~toNumber(await toNumericPrimitive(value, context));
+    case "-": {
+      const primitive = await toNumericPrimitive(value, context);
+      return typeof primitive === "bigint" ? bigIntOperation("-", 0n, primitive, context.budget) : -toNumber(primitive);
+    }
+    case "~": {
+      const primitive = await toNumericPrimitive(value, context);
+      return typeof primitive === "bigint" ? bigIntOperation("^", primitive, -1n, context.budget) : ~toNumber(primitive);
+    }
   }
 }
 function describeTypeofValue(value) {
@@ -16409,6 +16530,10 @@ function isTruthy(value) {
   return Boolean(value);
 }
 function applyBinaryOperator(node, left, right, context) {
+  if ((typeof left === "bigint" || typeof right === "bigint") && ["-", "*", "/", "%", "**", "&", "|", "^", "<<", ">>", ">>>"].includes(node.operator)) {
+    if (typeof left !== "bigint" || typeof right !== "bigint") throw new TypeError("Cannot mix BigInt and other numeric types.");
+    return bigIntOperation(node.operator, left, right, context.budget);
+  }
   switch (node.operator) {
     case "+":
       return applyAdditionOperator(left, right, context);
@@ -16527,6 +16652,10 @@ async function applyCompoundAssignmentOperator(operator, left, right, context) {
     left = await toNumericPrimitive(left, context, operator === "+=" ? "default" : "number");
     if (convertingObject) convertedLeft = left;
     right = await toNumericPrimitive(right, context, operator === "+=" ? "default" : "number");
+    if (operator !== "+=" && (typeof left === "bigint" || typeof right === "bigint")) {
+      if (typeof left !== "bigint" || typeof right !== "bigint") throw new TypeError("Cannot mix BigInt and other numeric types.");
+      return bigIntOperation(operator.slice(0, -1), left, right, context.budget);
+    }
     switch (operator) {
       case "+=":
         return applyAdditionOperator(left, right, context);
@@ -16563,6 +16692,10 @@ function applyAdditionOperator(left, right, context) {
   if (typeof leftPrimitive === "string" || typeof rightPrimitive === "string") {
     return context.budget.allocateString(toString(leftPrimitive) + toString(rightPrimitive));
   }
+  if (typeof leftPrimitive === "bigint" || typeof rightPrimitive === "bigint") {
+    if (typeof leftPrimitive !== "bigint" || typeof rightPrimitive !== "bigint") throw new TypeError("Cannot mix BigInt and other numeric types.");
+    return bigIntOperation("+", leftPrimitive, rightPrimitive, context.budget);
+  }
   return toNumber(leftPrimitive) + toNumber(rightPrimitive);
 }
 function compareRelational(left, right, operator) {
@@ -16580,8 +16713,9 @@ function compareRelational(left, right, operator) {
         return leftPrimitive >= rightPrimitive;
     }
   }
-  const leftNumber = toNumber(leftPrimitive);
-  const rightNumber = toNumber(rightPrimitive);
+  const hasBigInt = typeof leftPrimitive === "bigint" || typeof rightPrimitive === "bigint";
+  const leftNumber = typeof leftPrimitive === "bigint" || hasBigInt && typeof leftPrimitive === "string" ? leftPrimitive : toNumber(leftPrimitive);
+  const rightNumber = typeof rightPrimitive === "bigint" || hasBigInt && typeof rightPrimitive === "string" ? rightPrimitive : toNumber(rightPrimitive);
   switch (operator) {
     case "<":
       return leftNumber < rightNumber;
@@ -16594,6 +16728,7 @@ function compareRelational(left, right, operator) {
   }
 }
 function isLooselyEqual(left, right) {
+  if (typeof left === "bigint" || typeof right === "bigint") return left == right;
   const leftType = getCoercionType(left);
   const rightType = getCoercionType(right);
   if (leftType === rightType) {
@@ -16626,6 +16761,7 @@ function isPrimitiveCoercionType(type) {
   return type !== "object";
 }
 function getCoercionType(value) {
+  if (typeof value === "bigint") return "bigint";
   if (typeof value === "symbol") return "symbol";
   if (value === null) {
     return "null";
@@ -16659,6 +16795,7 @@ async function toNumericPrimitive(value, context, hint = "number") {
   throw new TypeError("Expected a sandbox value.");
 }
 function toNumber(value) {
+  if (typeof value === "bigint") throw new TypeError("Cannot convert a BigInt value to a number");
   if (typeof value === "symbol") throw new TypeError("Cannot convert a Symbol value to a number");
   if (isSandboxDate(value)) return dateTime(value);
   if (typeof value === "number") {
@@ -18256,6 +18393,7 @@ function encodeReplayData(value, options = {}) {
     if (depth > MAX_DATA_DEPTH) throw new TypeError("Replay data exceeds the nesting limit.");
     if (entry === null || typeof entry === "boolean" || typeof entry === "string") return entry;
     if (entry === void 0) return { tag: "undefined" };
+    if (typeof entry === "bigint") return { tag: "bigint", value: String(entry) };
     if (typeof entry === "symbol") {
       let id2 = symbols.get(entry);
       if (id2 === void 0) {
@@ -18458,6 +18596,11 @@ function decodeReplayData(input, options = {}, parent) {
         return capability;
       }
       if (own(atom, "tag") === "undefined") return void 0;
+      if (own(atom, "tag") === "bigint") {
+        const value = own(atom, "value");
+        validateBigIntData(value);
+        return BigInt(value);
+      }
       if (atom.tag === "number") {
         switch (own(atom, "value")) {
           case "NaN":
@@ -18527,7 +18670,7 @@ function decodeReplayData(input, options = {}, parent) {
         const payload = own(node, "value");
         const payloadRecord = payload !== null && typeof payload === "object" ? record(payload) : void 0;
         const symbolReference = payloadRecord !== void 0 && own(payloadRecord, "tag") === "ref" && Number.isSafeInteger(payloadRecord.id) && Number(payloadRecord.id) >= 0 && Number(payloadRecord.id) < nodes.length && own(record(nodes[Number(payloadRecord.id)]), "kind") === "symbol";
-        if (typeof payload !== "number" && typeof payload !== "string" && typeof payload !== "boolean" && !symbolReference && (payload === null || typeof payload !== "object" || own(record(payload), "tag") !== "number"))
+        if (typeof payload !== "number" && typeof payload !== "string" && typeof payload !== "boolean" && !symbolReference && (payload === null || typeof payload !== "object" || !["number", "bigint"].includes(String(own(record(payload), "tag")))))
           throw new TypeError("Invalid boxed primitive payload.");
         const result3 = createSandboxBox(child(payload));
         restored.set(id, result3);
@@ -19278,7 +19421,7 @@ function wrapSandboxClosureForHost(closure, stackFrames, budget, compileOwner, c
   return wrapped;
 }
 function isSandboxLikeValue(value) {
-  if (value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+  if (value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "bigint" || typeof value === "boolean") {
     return true;
   }
   if (isSandboxClosure(value) || isSandboxPromise(value)) {
@@ -19343,7 +19486,7 @@ function copyHostValueToSandbox(value, stackFrames, options, state, path) {
     if (options.realm === void 0 || options.errorData || options.hostCalls !== void 0) throw new TypeError("Live capabilities are not portable replay or error data.");
     return importHostCapability(value, options.realm.owner);
   }
-  if (value === null || value === void 0 || typeof value === "number" || typeof value === "boolean") {
+  if (value === null || value === void 0 || typeof value === "number" || typeof value === "bigint" || typeof value === "boolean") {
     return value;
   }
   if (typeof value === "string") {
@@ -19822,12 +19965,16 @@ function getDatePrototype(value, budget, owner) {
 var defaultStringHook = /* @__PURE__ */ Symbol("defaultStringHook");
 var defaultValueHook = /* @__PURE__ */ Symbol("defaultValueHook");
 var joiningArrays = /* @__PURE__ */ new WeakSet();
-function sandboxNumber(value, budget, context) {
+function sandboxNumber(value, budget, context, allowBigInt = false) {
+  const convert = (primitive) => {
+    if (typeof primitive === "bigint" && !allowBigInt) throw new TypeError("Cannot convert a BigInt value to a number");
+    return Number(primitive);
+  };
   if (value === null || typeof value !== "object") {
     if (typeof value === "function") throw new TypeError("Expected a sandbox value.");
-    return Number(value);
+    return convert(value);
   }
-  return objectToPrimitive(value, budget, context, /* @__PURE__ */ new Set(), "number").then(Number);
+  return objectToPrimitive(value, budget, context, /* @__PURE__ */ new Set(), "number").then(convert);
 }
 function sandboxString(value, budget, context, joining = /* @__PURE__ */ new Set()) {
   if (typeof value === "symbol") throw new TypeError("Cannot convert a Symbol value to a string");
@@ -21831,6 +21978,10 @@ function measureSandboxData(values, options = {}) {
   const seenSymbols = /* @__PURE__ */ new Set();
   let usage = 0;
   const visit = (value, depth = 0) => {
+    if (typeof value === "bigint") {
+      usage += value.toString(16).length;
+      return;
+    }
     if (typeof value === "symbol") {
       if (!seenSymbols.has(value)) {
         seenSymbols.add(value);
@@ -22503,7 +22654,7 @@ function copyFromSandbox(value, state, path = "<root>", options, depth = 0) {
   throw new TypeError(`Unsupported sandbox value at ${path}: ${describeValue2(value)}`);
 }
 function isSandboxPrimitive(value) {
-  return value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "symbol";
+  return value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "bigint" || typeof value === "boolean" || typeof value === "symbol";
 }
 function isHostPromise(value) {
   return value instanceof Promise;
@@ -24227,6 +24378,7 @@ var KNOWN_RUNTIME_GLOBALS = [
   "AggregateError",
   "Array",
   "Boolean",
+  "BigInt",
   "Date",
   "Error",
   "Infinity",
@@ -27498,6 +27650,7 @@ var ASAsyncNotNeededScanner = class {
       case "MetaProperty":
       case "NullLiteral":
       case "NumericLiteral":
+      case "BigIntLiteral":
       case "RegexLiteral":
       case "StringLiteral":
       case "UndefinedLiteral":
@@ -27779,6 +27932,7 @@ function expressionContainsAwait(node) {
     case "MetaProperty":
     case "NullLiteral":
     case "NumericLiteral":
+    case "BigIntLiteral":
     case "RegexLiteral":
     case "StringLiteral":
     case "ThisExpression":
@@ -31192,6 +31346,7 @@ var ASMissingAsyncScanner = class {
       case "MetaProperty":
       case "NullLiteral":
       case "NumericLiteral":
+      case "BigIntLiteral":
       case "RegexLiteral":
       case "StringLiteral":
       case "UndefinedLiteral":
@@ -31462,6 +31617,7 @@ function expressionContainsAwait2(node) {
     case "MetaProperty":
     case "NullLiteral":
     case "NumericLiteral":
+    case "BigIntLiteral":
     case "RegexLiteral":
     case "StringLiteral":
     case "ThisExpression":
@@ -34955,12 +35111,9 @@ function isStringifyObject(value) {
   return isStringifyContainer(value) && !Array.isArray(value);
 }
 function toSandboxValue(value) {
-  if (value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "boolean" || isSandboxClosure(value) || isSandboxPromise(value) || Array.isArray(value) || isStringifyContainer(value)) {
+  if (value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "bigint" || typeof value === "boolean" || isSandboxClosure(value) || isSandboxPromise(value) || Array.isArray(value) || isStringifyContainer(value)) {
     return value;
   }
-  if (typeof value === "bigint") {
-    throw new TypeError("Do not know how to serialize a BigInt.");
-  }
   throw new TypeError(
     `JSON.stringify(value) produced an unsupported value of type ${typeof value}.`
   );
@@ -35522,6 +35675,100 @@ function createSymbolGlobal(budget) {
   return constructor;
 }
 
+// packages/safe-js/src/interp/globals/bigint.ts
+function createBigIntGlobal(budget) {
+  const convert = async (value, context, allowNumber = false) => {
+    const primitive = value !== null && typeof value === "object" ? await objectToPrimitive(value, budget, context, /* @__PURE__ */ new Set(), "number") : value;
+    if (typeof primitive === "bigint") return primitive;
+    if (typeof primitive !== "string" && typeof primitive !== "boolean" && !(allowNumber && typeof primitive === "number"))
+      throw new TypeError("Cannot convert value to BigInt.");
+    const size = typeof primitive === "string" ? primitive.length : 256;
+    budget.visitNode(size);
+    const allocation = {};
+    budget.setRetainedDataUsage(allocation, size);
+    try {
+      return BigInt(primitive);
+    } finally {
+      budget.setRetainedDataUsage(allocation, 0);
+    }
+  };
+  const constructor = createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name: "BigInt",
+    length: 1,
+    call: ([value], context) => convert(value, context, true)
+  });
+  const prototype = /* @__PURE__ */ Object.create(null);
+  Object.defineProperties(prototype, {
+    constructor: { value: constructor, writable: true, configurable: true },
+    valueOf: {
+      value: createSandboxClosure({
+        sandbox: true,
+        name: "valueOf",
+        length: 0,
+        call: (_args, context) => primitiveReceiver(context?.thisValue, "bigint")
+      }),
+      writable: true,
+      configurable: true
+    },
+    toString: {
+      value: createSandboxClosure({
+        sandbox: true,
+        name: "toString",
+        length: 1,
+        call: async ([radix], context) => {
+          const value = primitiveReceiver(context?.thisValue, "bigint");
+          const base = radix === void 0 ? 10 : await sandboxNumber(radix, budget, context);
+          const allocation = {};
+          const size = value.toString(16).length * 4;
+          budget.visitNode(size);
+          budget.setRetainedDataUsage(allocation, size);
+          try {
+            return budget.allocateString(value.toString(base));
+          } finally {
+            budget.setRetainedDataUsage(allocation, 0);
+          }
+        }
+      }),
+      writable: true,
+      configurable: true
+    },
+    [Symbol.toStringTag]: { value: "BigInt", configurable: true }
+  });
+  const properties = materializeFunctionProperties(constructor);
+  Object.defineProperty(properties, "prototype", { value: prototype });
+  for (const name of ["asIntN", "asUintN"]) {
+    Object.defineProperty(properties, name, {
+      writable: true,
+      configurable: true,
+      value: createSandboxClosure({
+        sandbox: true,
+        name,
+        length: 2,
+        call: async ([bits, input], context) => {
+          const number = await sandboxNumber(bits, budget, context);
+          const width = Number.isNaN(number) ? 0 : Math.trunc(number);
+          if (width < 0 || !Number.isSafeInteger(width)) throw new RangeError("Invalid BigInt width.");
+          const value = await convert(input, context);
+          const size = value.toString(16).length;
+          budget.visitNode(size);
+          if (width >= size * 4 + 1 && (name === "asIntN" || value >= 0n)) return value;
+          const allocation = {};
+          budget.setRetainedDataUsage(allocation, Math.ceil(width / 4) + 1);
+          try {
+            return BigInt[name](width, value);
+          } finally {
+            budget.setRetainedDataUsage(allocation, 0);
+          }
+        }
+      })
+    });
+  }
+  installBoxedPrototype(budget, prototype, constructor, "bigint");
+  return constructor;
+}
+
 // packages/safe-js/src/interp/globals.ts
 function createBuiltinBindings(options) {
   return {
@@ -35530,6 +35777,7 @@ function createBuiltinBindings(options) {
     Float32Array: createFloat32ArrayGlobal(options.budget),
     Date: createDateGlobal(options),
     Symbol: createSymbolGlobal(options.budget),
+    BigInt: createBigIntGlobal(options.budget),
     ...createErrorGlobals(options),
     ...createMathGlobals({ random: options.random }),
     ...createObjectArrayGlobals(options),
@@ -37656,4 +37904,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-EOTY4PCT.js.map
+//# sourceMappingURL=chunk-YWQDSWZN.js.map