@poe-platform/safe-js 0.1.243 → 0.1.245

package/dist/safe-js/chunks/{chunk-AVVWPQWG.js → chunk-ITCCCKXY.js}

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

package/dist/safe-js/chunks/{chunk-NM7QH5TW.js → chunk-NOQSV7MP.js}

@@ -6,6 +6,8 @@ var sandboxErrorNames = [
   "RangeError",
   "ReferenceError",
   "SyntaxError",
+  "URIError",
+  "EvalError",
   "AbortError",
   "AggregateError",
   "HarnessFailure"
@@ -8094,11 +8096,19 @@ function isIntrinsicFunction(value) {
 function registerIntrinsicPrototype(budget, prototype, constructor) {
   if (constructor.name === void 0) throw new TypeError("Intrinsic constructors require an installation name.");
   registerBuiltinIdentities(budget, { [constructor.name]: constructor });
+  const methods = [prototype, materializeFunctionProperties(constructor)].flatMap((owner) => Reflect.ownKeys(owner).map((key) => Object.getOwnPropertyDescriptor(owner, key)?.value)).filter(isGuestClosure);
+  trackIntrinsicState(budget, prototype, constructor, [prototype, constructor, ...methods]);
+}
+function registerIntrinsicFunction(budget, closure) {
+  if (closure.name === void 0) throw new TypeError("Intrinsic functions require an installation name.");
+  registerBuiltinIdentities(budget, { [closure.name]: closure });
+  trackIntrinsicState(budget, closure, closure, [closure]);
+}
+function trackIntrinsicState(budget, root, owner, targets) {
   let roots = intrinsicPrototypeRoots.get(budget);
   if (roots === void 0) intrinsicPrototypeRoots.set(budget, roots = /* @__PURE__ */ new Set());
-  roots.add(prototype);
-  const methods = [prototype, materializeFunctionProperties(constructor)].flatMap((owner) => Reflect.ownKeys(owner).map((key) => Object.getOwnPropertyDescriptor(owner, key)?.value)).filter(isGuestClosure);
-  const records = [.../* @__PURE__ */ new Set([prototype, constructor, ...methods])].map((target) => ({
+  roots.add(root);
+  const records = [...new Set(targets)].map((target) => ({
     target,
     value: isGuestClosure(target) ? materializeFunctionProperties(target) : target,
     prototype: getSandboxPrototype(target),
@@ -8112,14 +8122,14 @@ function registerIntrinsicPrototype(budget, prototype, constructor) {
     if (isGuestClosure(target)) intrinsicFunctions.add(target);
   const unchanged = (before, after) => before !== void 0 && after !== void 0 && Object.is(before.value, after.value) && before.get === after.get && before.set === after.set && before.writable === after.writable && before.configurable === after.configurable && before.enumerable === after.enumerable;
   intrinsicConstructors.set(
-    constructor,
+    owner,
     () => records.every(({ target, value, descriptors: descriptors2, prototype: parent, explicit, extensible }) => {
       const current = Object.getOwnPropertyDescriptors(value);
       return getSandboxPrototype(target) === parent && Object.isExtensible(value) === extensible && hasExplicitSandboxPrototype(target) === explicit && Reflect.ownKeys(current).length === descriptors2.size && Reflect.ownKeys(value).every((key) => unchanged(descriptors2.get(key), Object.getOwnPropertyDescriptor(value, key)));
     })
   );
   budget.setRetainedValues(
-    prototype,
+    root,
     () => records.flatMap(({ target, value, descriptors: descriptors2, prototype: parent }) => [
       ...getSandboxPrototype(target) === parent ? [] : [getSandboxPrototype(target)],
       ...Reflect.ownKeys(value).flatMap((key) => {
@@ -14633,6 +14643,8 @@ var errorNames = [
   "RangeError",
   "ReferenceError",
   "SyntaxError",
+  "URIError",
+  "EvalError",
   "AggregateError"
 ];
 function createErrorGlobals(options) {
@@ -22397,6 +22409,29 @@ function assertStructuredCloneable(value, seen) {
   }
 }
 
+// packages/safe-js/src/interp/globals/uri.ts
+var conversions = { encodeURI, encodeURIComponent, decodeURI, decodeURIComponent };
+function createUriGlobals(budget) {
+  return Object.fromEntries(Object.entries(conversions).map(([name, conversion]) => {
+    const closure = createSandboxClosure({
+      sandbox: true,
+      guest: true,
+      name,
+      length: 1,
+      call: ([value], context) => {
+        const convert = (text2) => {
+          budget.visitNode(text2.length);
+          return budget.allocateString(conversion(text2));
+        };
+        const text = sandboxString(value, budget, context);
+        return typeof text === "string" ? convert(text) : text.then(convert);
+      }
+    });
+    registerIntrinsicFunction(budget, closure);
+    return [name, closure];
+  }));
+}
+
 // packages/safe-js/src/interp/globals/symbol.ts
 var registries = /* @__PURE__ */ new WeakMap();
 function createSymbolGlobal(budget) {
@@ -22612,6 +22647,7 @@ function createBuiltinBindings(options) {
     ...createMathGlobals({ random: options.random }),
     ...createObjectArrayGlobals(options),
     ...createMiscGlobals(options),
+    ...createUriGlobals(options.budget),
     ...createPromiseGlobals(options),
     ...createRegexGlobals(options)
   };
@@ -26803,7 +26839,12 @@ var KNOWN_RUNTIME_GLOBALS = [
   "Boolean",
   "BigInt",
   "Date",
+  "decodeURI",
+  "decodeURIComponent",
+  "encodeURI",
+  "encodeURIComponent",
   "Error",
+  "EvalError",
   "Infinity",
   "isFinite",
   "isNaN",
@@ -26826,6 +26867,7 @@ var KNOWN_RUNTIME_GLOBALS = [
   "structuredClone",
   "SyntaxError",
   "TypeError",
+  "URIError",
   "console"
 ];
 
@@ -39305,4 +39347,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-NM7QH5TW.js.map
+//# sourceMappingURL=chunk-NOQSV7MP.js.map