poe-code 14.0.75 → 14.0.77

package/packages/safe-js/dist/interp/interpreter.js

@@ -1,4 +1,5 @@
 import { promiseReplayContext } from "./promise-replay.js";
+import { bigIntOperation } from "./bigint-operators.js";
 import { accessorAdapter, readPropertyDescriptor, writePropertyDescriptor } from "./accessors.js";
 import { deleteHostObjectMember, getHostObjectKeys, getHostObjectMember, hasHostObjectMember, isGuestHostObject, setHostObjectMember } from "./host-capabilities.js";
 import { propertyFunctionName, toPropertyKey } from "./property-key.js";
@@ -51,6 +52,17 @@ const 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,
@@ -1805,8 +1817,11 @@ async function evaluateIdentifierUpdateExpression(node, context) {
             error: createError("UNBOUND_IDENTIFIER", node.argument, `Identifier '${node.argument.name}' is not defined.`)
         };
     }
-    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",
@@ -1823,8 +1838,11 @@ 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 === undefined ? 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 === undefined ? 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 === undefined)
             await setSandboxProperty(member.object, property, next, context.budget, true, createCoercionContext(context));
         else
@@ -1858,7 +1876,7 @@ function getPropertyValue(target, property, context, receiver = target) {
         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 === undefined ? undefined : getPropertyValue(prototype, property, context, receiver);
     }
@@ -2041,6 +2059,8 @@ 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;
     }
@@ -2074,7 +2094,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") &&
+        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) !== undefined) {
             if (isDefaultBoxedMethod(member.object, member.property, context.budget)) {
                 if (typeof member.object === "string" && isStringMethodName(member.property))
@@ -2259,10 +2279,14 @@ async function applyUnaryOperator(operator, value, context) {
             return undefined;
         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) {
@@ -2278,6 +2302,12 @@ 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);
@@ -2410,6 +2440,11 @@ async function applyCompoundAssignmentOperator(operator, left, right, context) {
         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);
@@ -2447,6 +2482,11 @@ 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) {
@@ -2464,8 +2504,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;
@@ -2478,6 +2519,8 @@ 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) {
@@ -2510,6 +2553,8 @@ function isPrimitiveCoercionType(type) {
     return type !== "object";
 }
 function getCoercionType(value) {
+    if (typeof value === "bigint")
+        return "bigint";
     if (typeof value === "symbol")
         return "symbol";
     if (value === null) {
@@ -2544,6 +2589,8 @@ 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))

package/packages/safe-js/dist/interp/methods/number.js

@@ -30,7 +30,7 @@ export 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 === undefined ? undefined : Number(argument), budget);
+    return formatNumber(value, methodName, argument === undefined ? undefined : +argument, budget);
 }
 async function formatObjectArgument(value, methodName, argument, budget, context) {
     const retainedArgument = {};

package/packages/safe-js/dist/interp/methods/string.js

@@ -852,10 +852,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 === undefined ? undefined : Number(value);
+    return value === undefined ? undefined : +value;
 }
 function asStringOrUndefined(value) {
     return value === undefined ? undefined : String(value);

package/packages/safe-js/dist/interp/string-coercion.d.ts

@@ -1,6 +1,6 @@
 import type { Budget } from "./budget.js";
 import { type SandboxCallContext, type SandboxPrimitive, type SandboxValue } from "./values.js";
-export declare function sandboxNumber(value: SandboxValue, budget: Budget, context?: SandboxCallContext): number | Promise<number>;
+export declare function sandboxNumber(value: SandboxValue, budget: Budget, context?: SandboxCallContext, allowBigInt?: boolean): number | Promise<number>;
 export declare function sandboxString(value: SandboxValue, budget: Budget, context?: SandboxCallContext, joining?: Set<object>): string | Promise<string>;
 export declare function joinSandboxArray(value: SandboxValue & object, length: number, separator: string, budget: Budget, context?: SandboxCallContext, joining?: Set<object>): Promise<string>;
 export declare function objectToPrimitive(value: SandboxValue & object, budget: Budget, context: SandboxCallContext | undefined, joining: Set<object>, hint: "string" | "number" | "default", ordinary?: boolean): Promise<SandboxPrimitive>;

package/packages/safe-js/dist/interp/string-coercion.js

@@ -17,13 +17,18 @@ import { isSandboxClosure, isSandboxPromise, isSandboxMap, isSandboxSet, isSandb
 const defaultStringHook = Symbol("defaultStringHook");
 const defaultValueHook = Symbol("defaultValueHook");
 const joiningArrays = new WeakSet();
-export function sandboxNumber(value, budget, context) {
+export 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, new Set(), "number").then(Number);
+    return objectToPrimitive(value, budget, context, new Set(), "number").then(convert);
 }
 export function sandboxString(value, budget, context, joining = new Set()) {
     if (typeof value === "symbol")

package/packages/safe-js/dist/interp/values.d.ts

@@ -15,7 +15,7 @@ declare const sandboxPromiseBrand: unique symbol;
 declare const sandboxRegexBrand: unique symbol;
 declare const sandboxRegexPattern: unique symbol;
 declare const sandboxRetainedValues: unique symbol;
-export type SandboxPrimitive = string | number | boolean | symbol | null | undefined;
+export type SandboxPrimitive = string | number | bigint | boolean | symbol | null | undefined;
 export type SandboxValue = SandboxPrimitive | Date | Float32Array | SandboxObject | SandboxArray | SandboxClosure | SandboxGenerator | SandboxCollectionIterator | SandboxRegExpIterator | SandboxMap | SandboxSet | SandboxPromise | SandboxRegex;
 export type SandboxObject = {
     [key: string]: SandboxValue;

package/packages/safe-js/dist/interp/values.js

@@ -299,6 +299,10 @@ export function measureSandboxData(values, options = {}) {
     const seenSymbols = 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);
@@ -994,6 +998,7 @@ function isSandboxPrimitive(value) {
         value === undefined ||
         typeof value === "string" ||
         typeof value === "number" ||
+        typeof value === "bigint" ||
         typeof value === "boolean" ||
         typeof value === "symbol");
 }

package/packages/safe-js/dist/lint/rules/AS-async-not-needed.js

@@ -229,6 +229,7 @@ class ASAsyncNotNeededScanner {
             case "MetaProperty":
             case "NullLiteral":
             case "NumericLiteral":
+            case "BigIntLiteral":
             case "RegexLiteral":
             case "StringLiteral":
             case "UndefinedLiteral":
@@ -539,6 +540,7 @@ function expressionContainsAwait(node) {
         case "MetaProperty":
         case "NullLiteral":
         case "NumericLiteral":
+        case "BigIntLiteral":
         case "RegexLiteral":
         case "StringLiteral":
         case "ThisExpression":

package/packages/safe-js/dist/lint/rules/AS-missing-async.js

@@ -213,6 +213,7 @@ class ASMissingAsyncScanner {
             case "MetaProperty":
             case "NullLiteral":
             case "NumericLiteral":
+            case "BigIntLiteral":
             case "RegexLiteral":
             case "StringLiteral":
             case "UndefinedLiteral":
@@ -509,6 +510,7 @@ function expressionContainsAwait(node) {
         case "MetaProperty":
         case "NullLiteral":
         case "NumericLiteral":
+        case "BigIntLiteral":
         case "RegexLiteral":
         case "StringLiteral":
         case "ThisExpression":

package/packages/safe-js/dist/lint/rules/known-globals.d.ts

@@ -1 +1 @@
-export declare const KNOWN_RUNTIME_GLOBALS: readonly ["AggregateError", "Array", "Boolean", "Date", "Error", "Infinity", "isFinite", "isNaN", "JSON", "Map", "Float32Array", "Math", "NaN", "Number", "Object", "parseFloat", "parseInt", "Promise", "RangeError", "ReferenceError", "RegExp", "Set", "String", "Symbol", "structuredClone", "SyntaxError", "TypeError", "console"];
+export declare const KNOWN_RUNTIME_GLOBALS: readonly ["AggregateError", "Array", "Boolean", "BigInt", "Date", "Error", "Infinity", "isFinite", "isNaN", "JSON", "Map", "Float32Array", "Math", "NaN", "Number", "Object", "parseFloat", "parseInt", "Promise", "RangeError", "ReferenceError", "RegExp", "Set", "String", "Symbol", "structuredClone", "SyntaxError", "TypeError", "console"];

package/packages/safe-js/dist/lint/rules/known-globals.js

@@ -2,6 +2,7 @@ export const KNOWN_RUNTIME_GLOBALS = [
     "AggregateError",
     "Array",
     "Boolean",
+    "BigInt",
     "Date",
     "Error",
     "Infinity",

package/packages/safe-js/dist/parse/parser.d.ts

@@ -26,6 +26,11 @@ export type NumericLiteral = BaseNode & {
     raw: string;
     value: number;
 };
+export type BigIntLiteral = BaseNode & {
+    type: "BigIntLiteral";
+    raw: string;
+    value: string;
+};
 export type StringLiteral = BaseNode & {
     type: "StringLiteral";
     raw: string;
@@ -390,7 +395,7 @@ export type ArrowFunctionExpression = BaseNode & {
     params: Array<AssignmentPattern | ArrayPattern | Identifier | ObjectPattern | RestElement>;
 };
 export type FunctionNode = ArrowFunctionExpression | FunctionDeclaration | FunctionExpression;
-export type Expression = ArrowFunctionExpression | AssignmentExpression | ArrayExpression | AwaitExpression | BinaryExpression | BooleanLiteral | CallExpression | ConditionalExpression | ClassExpression | FunctionExpression | Identifier | LogicalExpression | MemberExpression | MetaProperty | NewExpression | NewTargetExpression | NullLiteral | NumericLiteral | ObjectExpression | RegexLiteral | SequenceExpression | StringLiteral | SuperExpression | TaggedTemplateExpression | TemplateLiteral | ThisExpression | UnaryExpression | UpdateExpression | UndefinedLiteral | YieldExpression;
+export type Expression = ArrowFunctionExpression | AssignmentExpression | ArrayExpression | AwaitExpression | BinaryExpression | BooleanLiteral | CallExpression | ConditionalExpression | ClassExpression | FunctionExpression | Identifier | LogicalExpression | MemberExpression | MetaProperty | NewExpression | NewTargetExpression | NullLiteral | NumericLiteral | BigIntLiteral | ObjectExpression | RegexLiteral | SequenceExpression | StringLiteral | SuperExpression | TaggedTemplateExpression | TemplateLiteral | ThisExpression | UnaryExpression | UpdateExpression | UndefinedLiteral | YieldExpression;
 export type ParseResult = Expression | Statement;
 export declare function parse(source: string, filename?: string, owner?: CompileOwner): ParseResult;
 export declare function parseModule(source: string, filename?: string, owner?: CompileOwner): Module;

package/packages/safe-js/dist/parse/parser.js

@@ -3082,6 +3082,7 @@ function findImportMetaAssignmentInNode(node) {
         case "BooleanLiteral":
         case "NullLiteral":
         case "NumericLiteral":
+        case "BigIntLiteral":
         case "StringLiteral":
         case "ThisExpression":
         case "RegexLiteral":
@@ -3159,6 +3160,13 @@ 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,

package/packages/safe-js/dist/parse/tokenizer.js

@@ -480,7 +480,8 @@ class Lexer {
                 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);
             }
@@ -488,7 +489,8 @@ class Lexer {
                 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);
             }
@@ -496,7 +498,8 @@ class Lexer {
                 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);
             }
@@ -512,6 +515,11 @@ class Lexer {
             }
         }
         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();
@@ -610,7 +618,7 @@ class Lexer {
     }
     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() {

package/packages/safe-js/dist/parse.d.ts

@@ -1,4 +1,4 @@
 import { type ParseResult as ParsedNode } from "./parse/parser.js";
 export { DisallowedSyntaxError } from "./parse/parser.js";
 export declare const parse: (source: string, filename?: string) => ParsedNode;
-export type { ArrayPattern, ArrayExpression, ArrowFunctionExpression, AssignmentExpression, AssignmentPattern, AssignmentProperty, AwaitExpression, BinaryExpression, BlockStatement, BooleanLiteral, BreakStatement, CallExpression, CatchClause, ClassBody, ClassDeclaration, ClassElement, ClassExpression, ClassNode, ConditionalExpression, ContinueStatement, DoWhileStatement, EmptyStatement, Expression, ExpressionStatement, ExportDefaultDeclaration, ExportNamedDeclaration, ImportDeclaration, ImportDefaultSpecifier, ImportNamespaceSpecifier, ImportSpecifier, ForInStatement, ForOfStatement, ForStatement, FunctionDeclaration, FunctionExpression, Identifier, IfStatement, LogicalExpression, MemberExpression, MetaProperty, NewExpression, NewTargetExpression, NullLiteral, NumericLiteral, ObjectExpression, ObjectPattern, ParseResult, PatternTarget, Property, RegexLiteral, RestElement, ReturnStatement, SequenceExpression, SourceSpan, SpreadElement, Statement, StringLiteral, SuperExpression, SwitchCase, SwitchStatement, TaggedTemplateExpression, TemplateElement, TemplateLiteral, ThisExpression, ThrowStatement, TryStatement, UnaryExpression, UndefinedLiteral, UpdateExpression, UpdateTarget, VariableDeclaration, VariableDeclarationKind, VariableDeclarator, WhileStatement } from "./parse/parser.js";
+export type { ArrayPattern, ArrayExpression, ArrowFunctionExpression, AssignmentExpression, AssignmentPattern, AssignmentProperty, AwaitExpression, BinaryExpression, BigIntLiteral, BlockStatement, BooleanLiteral, BreakStatement, CallExpression, CatchClause, ClassBody, ClassDeclaration, ClassElement, ClassExpression, ClassNode, ConditionalExpression, ContinueStatement, DoWhileStatement, EmptyStatement, Expression, ExpressionStatement, ExportDefaultDeclaration, ExportNamedDeclaration, ImportDeclaration, ImportDefaultSpecifier, ImportNamespaceSpecifier, ImportSpecifier, ForInStatement, ForOfStatement, ForStatement, FunctionDeclaration, FunctionExpression, Identifier, IfStatement, LogicalExpression, MemberExpression, MetaProperty, NewExpression, NewTargetExpression, NullLiteral, NumericLiteral, ObjectExpression, ObjectPattern, ParseResult, PatternTarget, Property, RegexLiteral, RestElement, ReturnStatement, SequenceExpression, SourceSpan, SpreadElement, Statement, StringLiteral, SuperExpression, SwitchCase, SwitchStatement, TaggedTemplateExpression, TemplateElement, TemplateLiteral, ThisExpression, ThrowStatement, TryStatement, UnaryExpression, UndefinedLiteral, UpdateExpression, UpdateTarget, VariableDeclaration, VariableDeclarationKind, VariableDeclarator, WhileStatement } from "./parse/parser.js";

package/packages/safe-js/dist/snapshot/bigint.d.ts

@@ -0,0 +1 @@
+export declare function validateBigIntData(value: unknown): asserts value is string;

package/packages/safe-js/dist/snapshot/bigint.js

@@ -0,0 +1,14 @@
+export 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.");
+    }
+}

package/packages/safe-js/dist/snapshot/dump-format.js

@@ -58,6 +58,8 @@ 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") {

package/packages/safe-js/dist/snapshot/replay-data.d.ts

@@ -8,6 +8,9 @@ import { type SandboxClosure, type SandboxPromise, type SandboxValue } from "../
 import { type SerializedArguments } from "./arguments.js";
 type Atom = boolean | null | number | string | {
     tag: "undefined";
+} | {
+    tag: "bigint";
+    value: string;
 } | {
     tag: "number";
     value: "NaN" | "Infinity" | "-Infinity" | "-0";

package/packages/safe-js/dist/snapshot/replay-data.js

@@ -1,4 +1,5 @@
 import { MAX_DATA_DEPTH } from "../graph-depth.js";
+import { validateBigIntData } from "./bigint.js";
 import { serializeRegexProperties, restoreRegexProperties } from "./regexp-properties.js";
 import { wellKnownSymbols } from "../interp/symbols.js";
 import { symbolData, serializeSymbolProperties } from "./symbols.js";
@@ -29,6 +30,8 @@ export function encodeReplayData(value, options = {}) {
             return entry;
         if (entry === undefined)
             return { tag: "undefined" };
+        if (typeof entry === "bigint")
+            return { tag: "bigint", value: String(entry) };
         if (typeof entry === "symbol") {
             let id = symbols.get(entry);
             if (id === undefined) {
@@ -243,6 +246,11 @@ export function decodeReplayData(input, options = {}, parent) {
             }
             if (own(atom, "tag") === "undefined")
                 return undefined;
+            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":
@@ -328,7 +336,7 @@ export function decodeReplayData(input, options = {}, parent) {
                     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"))
+                    (payload === null || typeof payload !== "object" || !["number", "bigint"].includes(String(own(record(payload), "tag")))))
                     throw new TypeError("Invalid boxed primitive payload.");
                 const result = createSandboxBox(child(payload));
                 restored.set(id, result);

package/packages/safe-js/dist/snapshot/restore.js

@@ -234,6 +234,8 @@ function deserializeValue(value, state) {
     if (Array.isArray(value)) {
         return value.map((entry) => deserializeValue(entry, state));
     }
+    if (value.kind === "bigint" && typeof value.value === "string")
+        return BigInt(value.value);
     if (isSerializedUndefinedValue(value)) {
         return undefined;
     }

package/packages/safe-js/dist/snapshot/serialize.d.ts

@@ -105,7 +105,7 @@ export type RuntimePromiseValue = {
     id: SnapshotId;
     promise?: Promise<unknown>;
 };
-export type RuntimeSnapshotValue = symbol | SandboxBox | Date | Float32Array | boolean | null | number | string | undefined | RuntimeClosureValue | SandboxGenerator | SandboxCollectionIterator | SandboxRegExpIterator | RuntimePromiseValue | SandboxMap | SandboxRegex | SandboxSet | RuntimeSnapshotValue[] | {
+export type RuntimeSnapshotValue = bigint | symbol | SandboxBox | Date | Float32Array | boolean | null | number | string | undefined | RuntimeClosureValue | SandboxGenerator | SandboxCollectionIterator | SandboxRegExpIterator | RuntimePromiseValue | SandboxMap | SandboxRegex | SandboxSet | RuntimeSnapshotValue[] | {
     [key: string]: RuntimeSnapshotValue;
 };
 export type RuntimeScopeFrame = {

package/packages/safe-js/dist/snapshot/serialize.js

@@ -116,6 +116,8 @@ function serializeValue(value, path, state) {
                     : "-Infinity"
         };
     }
+    if (typeof value === "bigint")
+        return { kind: "bigint", value: String(value) };
     if (Array.isArray(value)) {
         const reference = serializeHeapReference(value, path, state);
         if (reference !== undefined) {

package/packages/safe-js/dist/snapshot/validation.js

@@ -1,4 +1,5 @@
 import { replaceErrorStack, sandboxErrorNames } from "../error/shape.js";
+import { validateBigIntData } from "./bigint.js";
 import { validateRegexProperties } from "./regexp-properties.js";
 import { wellKnownSymbols } from "../interp/symbols.js";
 import { types } from "node:util";
@@ -357,6 +358,15 @@ function validateValue(value, path, depth, state) {
 }
 function validateTaggedValue(record, path, state) {
     switch (record.kind) {
+        case "bigint":
+            requireString(record.value, `${path}.value`, state.limits);
+            try {
+                validateBigIntData(record.value);
+            }
+            catch {
+                fail("invalidValue", `${path}.value`, "invalid BigInt value");
+            }
+            return;
         case "undefined":
             return;
         case "number":
@@ -547,6 +557,15 @@ function validateBoxedRecord(record, path, heap) {
     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`);