@poe-platform/safe-js 0.1.244 → 0.1.246

package/dist/safe-js/chunks/{chunk-IBQE6MEC.js → chunk-KQJOGTEH.js}

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

package/dist/safe-js/chunks/{chunk-LQ57UIVW.js → chunk-SIFD2ANX.js}

@@ -8096,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),
@@ -8114,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) => {
@@ -21558,6 +21566,120 @@ function getEnumerableDataValues(value) {
   return getEnumerableDataEntries(value).map(([, entry]) => entry);
 }
 
+// packages/safe-js/src/interp/globals/json-parse.ts
+async function parseJsonWithReviver(text, reviver, budget, context) {
+  budget.visitNode(text.length);
+  JSON.parse(text);
+  const originalValues = [];
+  let position = 0;
+  const root = readValue();
+  const holder = { "": root.value };
+  const release = retainValues(budget, () => [holder, reviver, text, ...originalValues]);
+  try {
+    return await internalize(holder, "", root);
+  } finally {
+    release();
+  }
+  function skipWhitespace2() {
+    while (position < text.length && " 	\r\n".includes(text[position])) position++;
+  }
+  function readToken() {
+    const start = position;
+    if (text[position] === '"') {
+      position++;
+      while (text[position] !== '"') position += text[position] === "\\" ? 2 : 1;
+      position++;
+    } else {
+      while (position < text.length && !",]} 	\r\n".includes(text[position])) position++;
+    }
+    return text.slice(start, position);
+  }
+  function readValue() {
+    budget.visitNode();
+    const leave = budget.enterCall();
+    try {
+      skipWhitespace2();
+      const opening = text[position];
+      if (opening !== "[" && opening !== "{") {
+        const source = readToken();
+        const value2 = JSON.parse(source);
+        if (typeof value2 === "string") budget.allocateString(value2);
+        originalValues.push(value2);
+        return { value: value2, source };
+      }
+      const array2 = opening === "[";
+      const value = array2 ? [] : /* @__PURE__ */ Object.create(null);
+      const children = /* @__PURE__ */ new Map();
+      position++;
+      skipWhitespace2();
+      let index = 0;
+      while (text[position] !== (array2 ? "]" : "}")) {
+        let key;
+        if (array2) {
+          budget.allocateArrayLength(index + 1);
+          key = String(index++);
+        } else {
+          key = JSON.parse(readToken());
+          skipWhitespace2();
+          position++;
+        }
+        const child = readValue();
+        children.set(key, child);
+        Object.defineProperty(value, key, { value: child.value, configurable: true, enumerable: true, writable: true });
+        skipWhitespace2();
+        if (text[position] === ",") {
+          position++;
+          skipWhitespace2();
+        }
+      }
+      position++;
+      originalValues.push(value);
+      return { value, children };
+    } finally {
+      leave();
+    }
+  }
+  async function internalize(holder2, key, record3) {
+    budget.visitNode();
+    const leave = budget.enterCall();
+    let value;
+    const callbackContext = {};
+    const release2 = retainValues(budget, () => [holder2, value, callbackContext]);
+    try {
+      if (context?.getProperty !== void 0) value = await context.getProperty(holder2, key);
+      else {
+        const descriptor = getSandboxPropertyDescriptor(holder2, key, budget);
+        value = descriptor === void 0 ? void 0 : await readPropertyDescriptor(descriptor, holder2, context);
+      }
+      const original = record3 !== void 0 && Object.is(value, record3.value) ? record3 : void 0;
+      if (original?.source !== void 0) callbackContext.source = budget.allocateString(original.source);
+      if (typeof value === "object" && value !== null) {
+        if (Array.isArray(value)) budget.allocateArrayLength(value.length);
+        const keys = Array.isArray(value) ? Array.from({ length: value.length }, (_, index) => String(index)) : ownEnumerableSandboxKeys(value);
+        budget.allocateArrayLength(keys.length);
+        for (const name of keys) {
+          const replacement = await internalize(value, name, original?.children?.get(name));
+          const properties = isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : value;
+          if (replacement === void 0) Reflect.deleteProperty(properties, name);
+          else Reflect.defineProperty(properties, name, {
+            value: replacement,
+            configurable: true,
+            enumerable: true,
+            writable: true
+          });
+          context?.reconcileData?.(value);
+        }
+      }
+      const result = await reviver.call([key, value, callbackContext], { stack: [], thisValue: holder2 });
+      if (isSandboxPromise(result) && result.synchronousPrefix !== void 0) await result.synchronousPrefix;
+      return allocateProducedSandboxValue(result, budget);
+    } finally {
+      release2();
+      leave();
+    }
+  }
+}
+
 // packages/safe-js/src/interp/globals/console-json.ts
 function createConsoleJsonGlobals(options) {
   const sink = options.sink ?? console;
@@ -21565,10 +21687,13 @@ function createConsoleJsonGlobals(options) {
     JSON: {
       parse: createSandboxClosure({
         sandbox: true,
-        call: async ([text], context) => {
+        length: 2,
+        call: async ([text, reviver], context) => {
           const converted = sandboxString(text, options.budget, context);
+          const source = converted instanceof Promise ? await converted : converted;
+          if (isSandboxClosure(reviver)) return parseJsonWithReviver(source, reviver, options.budget, context);
           return copyJsonToSandbox(
-            JSON.parse(converted instanceof Promise ? await converted : converted),
+            JSON.parse(source),
             options.budget
           );
         },
@@ -22401,6 +22526,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) {
@@ -22616,6 +22764,7 @@ function createBuiltinBindings(options) {
     ...createMathGlobals({ random: options.random }),
     ...createObjectArrayGlobals(options),
     ...createMiscGlobals(options),
+    ...createUriGlobals(options.budget),
     ...createPromiseGlobals(options),
     ...createRegexGlobals(options)
   };
@@ -26807,6 +26956,10 @@ var KNOWN_RUNTIME_GLOBALS = [
   "Boolean",
   "BigInt",
   "Date",
+  "decodeURI",
+  "decodeURIComponent",
+  "encodeURI",
+  "encodeURIComponent",
   "Error",
   "EvalError",
   "Infinity",
@@ -39311,4 +39464,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-LQ57UIVW.js.map
+//# sourceMappingURL=chunk-SIFD2ANX.js.map