@poe-platform/safe-js 0.1.130 → 0.1.132

package/dist/safe-js/chunks/{chunk-ZTGKRKQH.js → chunk-7IGOMKO4.js}

@@ -1811,6 +1811,9 @@ function isAstNode(value) {
   return typeof value === "object" && value !== null && "type" in value && typeof value.type === "string" && "span" in value && typeof value.span?.start.offset === "number" && typeof value.span?.end.offset === "number";
 }
 
+// packages/safe-js/src/parse/function-source.ts
+var functionSources = /* @__PURE__ */ new WeakMap();
+
 // packages/safe-js/src/parse/format-error.ts
 var ParseError = class extends Error {
   constructor(filename, message, line, column, excerpt, caret, span) {
@@ -2459,7 +2462,11 @@ function parse(source, filename = "<input>", owner) {
   const compilation = new CompileScope(owner);
   try {
     const result = assignIds(
-      parseTokens(tokenize(source, { allowRegexLiterals: true, compilation }), compilation)
+      new Parser(
+        tokenize(source, { allowRegexLiterals: true, compilation }),
+        source,
+        compilation
+      ).parseTopLevel()
     );
     const regexLiteral = findRegexLiteral(result);
     if (regexLiteral !== void 0) {
@@ -2485,7 +2492,11 @@ function parseModule(source, filename = "<input>", owner) {
   const compilation = new CompileScope(owner);
   try {
     return assignIds(
-      parseModuleTokens(tokenize(source, { allowRegexLiterals: true, compilation }), compilation)
+      new Parser(
+        tokenize(source, { allowRegexLiterals: true, compilation }),
+        source,
+        compilation
+      ).parseModule()
     );
   } catch (error) {
     if (error instanceof DisallowedSyntaxError || error instanceof SandboxError) {
@@ -2503,7 +2514,11 @@ function parseExecutableModule(source, filename = "<input>", owner) {
   const compilation = new CompileScope(owner);
   try {
     const result = assignIds(
-      parseModuleTokens(tokenize(source, { allowRegexLiterals: true, compilation }), compilation)
+      new Parser(
+        tokenize(source, { allowRegexLiterals: true, compilation }),
+        source,
+        compilation
+      ).parseModule()
     );
     throwIfImportMetaAssignment(result);
     return result;
@@ -2519,20 +2534,16 @@ function parseExecutableModule(source, filename = "<input>", owner) {
     compilation.dispose();
   }
 }
-function parseTokens(tokens, compilation) {
-  return new Parser(tokens, compilation).parseTopLevel();
-}
-function parseModuleTokens(tokens, compilation) {
-  return new Parser(tokens, compilation).parseModule();
-}
 var Parser = class {
-  constructor(tokens, compilation, functionContext = "normal") {
+  constructor(tokens, source, compilation, functionContext = "normal") {
     this.tokens = tokens;
+    this.source = source;
     this.compilation = compilation;
     this.functionContext = functionContext;
     this.functionScopes.add(this.scopes[0]);
   }
   tokens;
+  source;
   compilation;
   functionContext;
   index = 0;
@@ -2543,6 +2554,14 @@ var Parser = class {
   scopes = [/* @__PURE__ */ new Map()];
   functionScopes = /* @__PURE__ */ new WeakSet();
   varNames = /* @__PURE__ */ new WeakMap();
+  withFunctionSource(node) {
+    functionSources.set(node, {
+      text: this.source,
+      start: node.span.start.offset,
+      end: node.span.end.offset
+    });
+    return node;
+  }
   parseTopLevel() {
     if (this.isExportToken(this.currentToken())) {
       throw new DisallowedSyntaxError("export", this.currentToken().start);
@@ -2684,14 +2703,14 @@ var Parser = class {
     });
     this.expectPunctuator("=>");
     const body = this.parseArrowFunctionBody(params);
-    return {
+    return this.withFunctionSource({
       type: "ArrowFunctionExpression",
       async: isAsync,
       body,
       expression: body.type !== "BlockStatement",
       params,
       span: createSpan2(start, body.span.end)
-    };
+    });
   }
   parseConditionalExpression() {
     if (this.conditionalExpressionDepth >= MAX_CONDITIONAL_EXPRESSION_DEPTH) {
@@ -3331,8 +3350,11 @@ var Parser = class {
       return parsedParams;
     });
     const generator = generatorToken !== void 0;
-    const body = this.withFunctionContext(generator ? "generator" : "normal", () => this.parseBlockStatement(params));
-    return {
+    const body = this.withFunctionContext(
+      generator ? "generator" : "normal",
+      () => this.parseBlockStatement(params)
+    );
+    return this.withFunctionSource({
       type: "FunctionDeclaration",
       async: asyncToken !== void 0,
       body,
@@ -3340,7 +3362,7 @@ var Parser = class {
       id,
       params,
       span: createSpan2(asyncToken?.start ?? functionToken.start, body.span.end)
-    };
+    });
   }
   parseVariableDeclarator(kind) {
     const id = this.parseBindingTarget();
@@ -4108,7 +4130,11 @@ var Parser = class {
       if (this.currentToken().type === "template") {
         const quasi = createTemplateLiteral(
           this.currentToken(),
-          { allowMalformedEscapes: true, functionContext: this.functionContext },
+          {
+            allowMalformedEscapes: true,
+            functionContext: this.functionContext,
+            source: this.source
+          },
           this.compilation
         );
         this.index += 1;
@@ -4197,7 +4223,11 @@ var Parser = class {
       return {
         node: createTemplateLiteral(
           token,
-          { allowMalformedEscapes: false, functionContext: this.functionContext },
+          {
+            allowMalformedEscapes: false,
+            functionContext: this.functionContext,
+            source: this.source
+          },
           this.compilation
         ),
         parenthesized: false
@@ -4282,7 +4312,8 @@ var Parser = class {
       break;
     }
     const optional = this.consumePunctuator("?.");
-    if (optional !== void 0) throw new DisallowedSyntaxError("new optional chain", optional.start);
+    if (optional !== void 0)
+      throw new DisallowedSyntaxError("new optional chain", optional.start);
     const args = this.consumePunctuator("(") === void 0 ? [] : this.parseArguments();
     const end = this.previousToken();
     return {
@@ -4315,8 +4346,11 @@ var Parser = class {
       return parsedParams;
     });
     const generator = generatorToken !== void 0;
-    const body = this.withFunctionContext(generator ? "generator" : "normal", () => this.parseBlockStatement(params));
-    return {
+    const body = this.withFunctionContext(
+      generator ? "generator" : "normal",
+      () => this.parseBlockStatement(params)
+    );
+    return this.withFunctionSource({
       type: "FunctionExpression",
       async: asyncToken !== void 0,
       body,
@@ -4324,7 +4358,7 @@ var Parser = class {
       id,
       params,
       span: createSpan2(asyncToken?.start ?? functionToken.start, body.span.end)
-    };
+    });
   }
   parseArrayExpression() {
     const start = this.expectPunctuator("[");
@@ -4560,7 +4594,7 @@ var Parser = class {
       return parsedParams;
     });
     const body = this.withFunctionContext("normal", () => this.parseBlockStatement(params));
-    return {
+    return this.withFunctionSource({
       type: "FunctionExpression",
       async: asyncToken !== void 0,
       body,
@@ -4569,7 +4603,7 @@ var Parser = class {
       method: true,
       params,
       span: createSpan2(asyncToken?.start ?? methodStart, body.span.end)
-    };
+    });
   }
   parseIdentifierName() {
     const token = this.currentToken();
@@ -5432,6 +5466,7 @@ function createTemplateLiteral(token, options, compilation) {
           raw.slice(expressionStart, expressionEnd),
           positionWithinRaw(token.start, raw, expressionStart),
           options.functionContext,
+          options.source,
           compilation
         )
       );
@@ -5794,13 +5829,13 @@ function decodeHexEscape(value, start) {
     end: index + 2
   };
 }
-function parseEmbeddedExpression(source, base, functionContext, compilation) {
+function parseEmbeddedExpression(source, base, functionContext, fullSource, compilation) {
   const tokens = tokenize(source, { allowRegexLiterals: true, compilation }).map((token) => ({
     ...token,
     start: rebasePosition(token.start, base),
     end: rebasePosition(token.end, base)
   }));
-  return new Parser(tokens, compilation, functionContext).parseExpressionOnly();
+  return new Parser(tokens, fullSource, compilation, functionContext).parseExpressionOnly();
 }
 function findRegexLiteral(node) {
   if (node === null || node === void 0) {
@@ -7247,7 +7282,7 @@ function decodeFloat32Storage(value, resolve) {
 
 // packages/safe-js/src/snapshot/dump-format.ts
 var DUMP_FORMAT_VERSION = 1;
-var EXECUTION_SEMANTICS = "jobs-v7";
+var EXECUTION_SEMANTICS = "jobs-v8";
 var SKIP_VALUE = /* @__PURE__ */ Symbol("SafeJS.skip-dump-value");
 function serializeSafeJSSnapshot(snapshot) {
   const replayError = Object.getOwnPropertyDescriptor(snapshot, "replayError");
@@ -8676,6 +8711,22 @@ async function withRunResources(signal, execute) {
   return result;
 }
 
+// packages/safe-js/src/interp/function-string.ts
+function functionString(value) {
+  if (runResources.getStore()?.functionSourceText === false) return "[object Object]";
+  const source = value.sourceRange;
+  if (source !== void 0) return source.text.slice(source.start, source.end);
+  let name = value.boundTarget === void 0 ? value.name?.split("#").at(-1) ?? "" : "";
+  for (let index = 0; index < name.length; index++) {
+    const code = name.charCodeAt(index);
+    if (!(code >= 65 && code <= 90 || code >= 97 && code <= 122 || code === 36 || code === 95 || index > 0 && code >= 48 && code <= 57)) {
+      name = "";
+      break;
+    }
+  }
+  return `function ${name}() { [native code] }`;
+}
+
 // packages/safe-js/src/interp/string-coercion.ts
 var defaultStringHook = /* @__PURE__ */ Symbol("defaultStringHook");
 var defaultValueHook = /* @__PURE__ */ Symbol("defaultValueHook");
@@ -8743,6 +8794,7 @@ function conversionHook(value, name, budget) {
   return void 0;
 }
 async function defaultToString(value, budget, context, joining) {
+  if (isSandboxClosure(value)) return budget.allocateString(functionString(value));
   if (isSandboxMap(value)) return "[object Map]";
   if (isSandboxSet(value)) return "[object Set]";
   if (isSandboxCollectionIterator(value)) return collectionIteratorState(value).collectionKind === "map" ? "[object Map Iterator]" : "[object Set Iterator]";
@@ -10427,6 +10479,9 @@ function createSandboxClosure(input) {
     enumerable: false,
     value: true
   });
+  if (input.sourceRange !== void 0) {
+    Object.defineProperty(closure, "sourceRange", { value: input.sourceRange });
+  }
   if (input.sandbox === true) {
     Object.defineProperty(closure, "sandbox", { value: true });
   }
@@ -12274,19 +12329,19 @@ function normalize(value, seen) {
 var FNV_OFFSET_BASIS = 2166136261;
 var FNV_PRIME = 16777619;
 var IGNORED_KEYS = /* @__PURE__ */ new Set(["nodeId", "raw", "span"]);
-function hashSource(source, owner) {
+function hashSource(source, owner, includeFunctionSource = true) {
   try {
-    return hashParsedAst(parse(source, "<input>", owner));
+    return hashParsedAst(parse(source, "<input>", owner), includeFunctionSource);
   } catch (error) {
     if (error instanceof SandboxError) throw error;
-    return hashParsedAst(parseModule(source, "<input>", owner));
+    return hashParsedAst(parseModule(source, "<input>", owner), includeFunctionSource);
   }
 }
-function hashParsedAst(ast) {
+function hashParsedAst(ast, includeFunctionSource = true) {
   let hash = FNV_OFFSET_BASIS;
   visit(ast);
   return hash.toString(16).padStart(8, "0");
-  function visit(value, includeTemplateRaw = false) {
+  function visit(value, includeTemplateRaw = false, enclosingSource) {
     if (value === null) {
       write("null");
       return;
@@ -12298,7 +12353,7 @@ function hashParsedAst(ast) {
     if (Array.isArray(value)) {
       write("[");
       for (const entry of value) {
-        visit(entry, includeTemplateRaw);
+        visit(entry, includeTemplateRaw, enclosingSource);
         write(",");
       }
       write("]");
@@ -12316,12 +12371,23 @@ function hashParsedAst(ast) {
         return;
       case "object": {
         const record2 = value;
+        const source = includeFunctionSource ? functionSources.get(value) : void 0;
+        if (source !== void 0 && !(enclosingSource !== void 0 && source.text === enclosingSource.text && source.start >= enclosingSource.start && source.end <= enclosingSource.end)) {
+          write("function-source:");
+          write(String(source.end - source.start));
+          write(":");
+          write(source.text, source.start, source.end);
+        }
         const keys = Object.keys(value).filter((key) => shouldHashKey(record2, key, includeTemplateRaw)).sort();
         write("{");
         for (const key of keys) {
           write(JSON.stringify(key));
           write(":");
-          visit(record2[key], shouldIncludeTemplateRaw(record2, key, includeTemplateRaw));
+          visit(
+            record2[key],
+            shouldIncludeTemplateRaw(record2, key, includeTemplateRaw),
+            source ?? enclosingSource
+          );
           write(",");
         }
         write("}");
@@ -12331,8 +12397,8 @@ function hashParsedAst(ast) {
         throw new TypeError(`Unsupported AST value type: ${typeof value}`);
     }
   }
-  function write(chunk) {
-    for (let index = 0; index < chunk.length; index += 1) {
+  function write(chunk, start = 0, end = chunk.length) {
+    for (let index = start; index < end; index += 1) {
       hash ^= chunk.charCodeAt(index);
       hash = Math.imul(hash, FNV_PRIME) >>> 0;
     }
@@ -12359,11 +12425,11 @@ function shouldIncludeTemplateRaw(record2, key, includeTemplateRaw) {
 
 // packages/safe-js/src/snapshot/migration.ts
 function validateMigrationSemantics(value) {
-  if (!["jobs-v1", "jobs-v2", "jobs-v3", "jobs-v4", "jobs-v5", "jobs-v6", "jobs-v7"].includes(
+  if (!["jobs-v1", "jobs-v2", "jobs-v3", "jobs-v4", "jobs-v5", "jobs-v6", "jobs-v7", "jobs-v8"].includes(
     value
   ))
     throw new TypeError(
-      "Migration requires a supported execution-semantics marker (jobs-v1 through jobs-v7)."
+      "Migration requires a supported execution-semantics marker (jobs-v1 through jobs-v8)."
     );
 }
 function validateMigrationJournal(sourceHash, replay, hostCalls = [], owner) {
@@ -12472,14 +12538,18 @@ function restore(snapshot, options, owner) {
   assertSnapshotInactive(snapshot);
   validateDumpEnvelope(snapshot);
   validateSnapshotMigration(snapshot.migration, snapshot.sourceHash, owner);
-  if (snapshot.executionSemantics !== EXECUTION_SEMANTICS && snapshot.executionSemantics !== "jobs-v6" && (snapshot.executionSemantics !== void 0 || snapshot.promiseReplay !== void 0 || snapshot.replay !== void 0 || snapshot.initialInputs !== void 0)) {
+  if (snapshot.executionSemantics !== EXECUTION_SEMANTICS && snapshot.executionSemantics !== "jobs-v6" && snapshot.executionSemantics !== "jobs-v7" && (snapshot.executionSemantics !== void 0 || snapshot.promiseReplay !== void 0 || snapshot.replay !== void 0 || snapshot.initialInputs !== void 0)) {
     throw new SnapshotValidationError(
       "unsupportedVersion",
       "$.executionSemantics",
       "incompatible execution semantics; resume with the SafeJS version that created this snapshot. Migration requires explicit reconciliation, not changing its version marker."
     );
   }
-  const currentSourceHash = hashSource(options.source, owner);
+  const currentSourceHash = hashSource(
+    options.source,
+    owner,
+    snapshot.executionSemantics !== "jobs-v6" && snapshot.executionSemantics !== "jobs-v7"
+  );
   if (snapshot.sourceHash !== currentSourceHash) {
     throw new SnapshotMismatchError(snapshot.sourceHash, currentSourceHash);
   }
@@ -24724,7 +24794,7 @@ function toIntegerOrInfinity(value) {
 }
 
 // packages/safe-js/src/interp/methods/function.ts
-var functionMethodNames = /* @__PURE__ */ new Set(["apply", "bind", "call"]);
+var functionMethodNames = /* @__PURE__ */ new Set(["apply", "bind", "call", "toString"]);
 function getFunctionMember(target, property, options) {
   if (isGuestClosure(target)) {
     const value = getGuestFunctionProperty(target, String(property));
@@ -24738,12 +24808,14 @@ function getFunctionMember(target, property, options) {
   if (property === "length") {
     return target.length;
   }
+  if (property === "toString" && runResources.getStore()?.functionSourceText === false) return void 0;
   if (!isFunctionMethodName(property)) {
     return void 0;
   }
   return createSandboxClosure({
     sandbox: true,
     name: `Function#${property}`,
+    ...property === "toString" ? { length: 0 } : {},
     call: (args, context) => callFunctionMethod(context?.thisValue, property, args, options, context?.stack ?? [])
   });
 }
@@ -24754,6 +24826,10 @@ function callFunctionMethod(target, methodName, args, options, stack) {
   if (!isSandboxClosure(target)) {
     throw new TypeError(`Function#${methodName} requires a callable receiver.`);
   }
+  if (methodName === "toString") {
+    const text = functionString(target);
+    return options.budget?.allocateString(text) ?? text;
+  }
   const thisValue = args[0];
   if (methodName === "bind") {
     const boundArgs = args.slice(1);
@@ -28938,6 +29014,7 @@ function createSetMethodOptions(context) {
 }
 function createFunctionMethodOptions(context) {
   return {
+    budget: context.budget,
     callClosure: (closure, args, stack, thisValue, construct) => invokeSandboxClosure(closure, args, context, stack, void 0, thisValue, construct)
   };
 }
@@ -29175,6 +29252,7 @@ function createInterpretedClosure(node, context, evaluateNode2) {
     return isConstructResult(result) ? result : thisValue;
   } : void 0;
   const closure = createSandboxClosure({
+    sourceRange: functionSources.get(node),
     guest: true,
     sandbox: true,
     length: getFunctionLength(node.params),
@@ -29237,6 +29315,7 @@ function executeAsyncFunction(execute, budget, signal) {
 }
 function createGeneratorClosure(node, context, evaluateNode2) {
   return createSandboxClosure({
+    sourceRange: functionSources.get(node),
     guest: true,
     generator: true,
     sandbox: true,
@@ -30847,6 +30926,46 @@ function createRegexGlobals(options) {
   };
 }
 
+// packages/safe-js/src/interp/globals/numeric-parsers.ts
+function createNumericParsers(budget) {
+  return {
+    parseInt: createSandboxClosure({
+      sandbox: true,
+      name: "parseInt",
+      call: ([value, radix], context) => {
+        const parse2 = (text2) => {
+          const release = retainValues(budget, () => [text2]);
+          let convertedRadix;
+          try {
+            convertedRadix = sandboxNumber(radix, budget, context);
+          } catch (error) {
+            release();
+            throw error;
+          }
+          if (typeof convertedRadix === "number") {
+            try {
+              return globalThis.parseInt(text2, convertedRadix);
+            } finally {
+              release();
+            }
+          }
+          return convertedRadix.then((number) => globalThis.parseInt(text2, number)).finally(release);
+        };
+        const text = sandboxString(value, budget, context);
+        return typeof text === "string" ? parse2(text) : text.then(parse2);
+      }
+    }),
+    parseFloat: createSandboxClosure({
+      sandbox: true,
+      name: "parseFloat",
+      call: ([value], context) => {
+        const text = sandboxString(value, budget, context);
+        return typeof text === "string" ? globalThis.parseFloat(text) : text.then(globalThis.parseFloat);
+      }
+    })
+  };
+}
+
 // packages/safe-js/src/interp/globals/misc.ts
 function createMiscGlobals(options) {
   return {
@@ -30855,16 +30974,7 @@ function createMiscGlobals(options) {
       call: ([value], context) => structuredCloneSandboxValue(value, options.budget, context?.compilation),
       name: "structuredClone"
     }),
-    parseInt: createSandboxClosure({
-      sandbox: true,
-      call: (args) => Reflect.apply(globalThis.parseInt, globalThis, [...args]),
-      name: "parseInt"
-    }),
-    parseFloat: createSandboxClosure({
-      sandbox: true,
-      call: (args) => Reflect.apply(globalThis.parseFloat, globalThis, [...args]),
-      name: "parseFloat"
-    }),
+    ...createNumericParsers(options.budget),
     isNaN: createSandboxClosure({
       sandbox: true,
       call: ([value]) => globalThis.isNaN(value),
@@ -31126,16 +31236,7 @@ function createObjectArrayGlobals(options) {
           call: ([value]) => typeof value === "number" && Number.isInteger(value),
           name: "isInteger"
         }),
-        parseInt: createSandboxClosure({
-          sandbox: true,
-          call: (args) => Reflect.apply(Number.parseInt, Number, [...args]),
-          name: "parseInt"
-        }),
-        parseFloat: createSandboxClosure({
-          sandbox: true,
-          call: (args) => Reflect.apply(Number.parseFloat, Number, [...args]),
-          name: "parseFloat"
-        }),
+        ...createNumericParsers(options.budget),
         isSafeInteger: createSandboxClosure({
           sandbox: true,
           call: ([value]) => typeof value === "number" && Number.isSafeInteger(value),
@@ -32961,7 +33062,8 @@ function run(source, options = {}) {
         options.signal?.addEventListener("abort", captureCancellationSnapshot, { once: true });
         try {
           const restoredSnapshot = options.snapshot === void 0 ? void 0 : restore(options.snapshot, { source }, operation.owner);
-          const executionSemantics = restoredSnapshot?.executionSemantics === "jobs-v6" ? "jobs-v6" : EXECUTION_SEMANTICS;
+          const executionSemantics = restoredSnapshot?.executionSemantics === "jobs-v6" || restoredSnapshot?.executionSemantics === "jobs-v7" ? restoredSnapshot.executionSemantics : EXECUTION_SEMANTICS;
+          runResources.getStore().functionSourceText = executionSemantics === EXECUTION_SEMANTICS;
           const convertInitialInput = (convert) => executionSemantics === "jobs-v6" ? convert() : promiseReplayContext.exit(convert);
           if (restoredSnapshot !== void 0) {
             leaveSnapshotRun = enterSnapshotRun(restoredSnapshot);
@@ -32970,7 +33072,7 @@ function run(source, options = {}) {
           const filename = options.filename ?? "<input>";
           const module = parseExecutableModule(source, filename, operation.owner);
           promiseReplay.validateNodes(module);
-          const sourceHash = findRegexLiteral(module) === void 0 ? hashSource(source, operation.owner) : hashParsedAst(module);
+          const sourceHash = findRegexLiteral(module) === void 0 ? hashSource(source, operation.owner, executionSemantics === EXECUTION_SEMANTICS) : hashParsedAst(module, executionSemantics === EXECUTION_SEMANTICS);
           const hostCalls = new HostCallJournal(
             sourceHash,
             readHostCallSnapshot(restoredSnapshot),
@@ -32997,7 +33099,14 @@ function run(source, options = {}) {
               lifecycle
             })
           );
-          const builtinBindings = createBuiltinBindings({ compileOwner: operation.owner, budget, hostCalls, sink: options.sink, random: random?.generator.next, clock: options.clock });
+          const builtinBindings = createBuiltinBindings({
+            compileOwner: operation.owner,
+            budget,
+            hostCalls,
+            sink: options.sink,
+            random: random?.generator.next,
+            clock: options.clock
+          });
           const importMeta = convertInitialInput(
             () => deepCopyToSandbox(options.importMeta ?? {})
           );
@@ -33500,4 +33609,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-ZTGKRKQH.js.map
+//# sourceMappingURL=chunk-7IGOMKO4.js.map