@poe-platform/safe-js 0.1.365 → 0.1.367

package/dist/safe-js/chunks/{chunk-NLDDBHDH.js → chunk-2UQ2QDUV.js}

@@ -25555,55 +25555,115 @@ function createRegexGlobals(options) {
   return { RegExp: constructor };
 }
 
-// packages/safe-js/src/interp/globals/misc.ts
-function createMiscGlobals(options) {
-  return {
-    structuredClone: createSandboxClosure({
-      sandbox: true,
-      call: ([value], context) => structuredCloneSandboxValue(value, options.budget, context?.compilation),
-      name: "structuredClone"
-    }),
-    ...createNumericParsers(options.budget),
-    isNaN: createSandboxClosure({
-      sandbox: true,
-      call: ([value], context) => {
-        const number = sandboxNumber(value, options.budget, context);
-        return typeof number === "number" ? Number.isNaN(number) : number.then(Number.isNaN);
-      },
-      name: "isNaN"
-    }),
-    isFinite: createSandboxClosure({
-      sandbox: true,
-      call: ([value], context) => {
-        const number = sandboxNumber(value, options.budget, context);
-        return typeof number === "number" ? Number.isFinite(number) : number.then(Number.isFinite);
-      },
-      name: "isFinite"
+// packages/safe-js/src/interp/globals/structured-clone.ts
+var transferBuffer = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "transfer")?.value;
+function createStructuredCloneGlobal(budget) {
+  return createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name: "structuredClone",
+    length: 1,
+    call: (args, context) => {
+      if (args.length === 0) throw new TypeError("structuredClone requires a value argument.");
+      const [value, options] = args;
+      if (options === void 0 || options === null) return cloneStructuredValue(value, [], budget, context);
+      if (typeof options !== "object") throw new TypeError("structuredClone options must be an object.");
+      return cloneWithOptions(value, options, budget, context);
+    }
+  });
+}
+async function cloneWithOptions(value, options, budget, context) {
+  const bridge = {
+    ...context,
+    stack: context?.stack ?? [],
+    thisValue: void 0,
+    getProperty: context?.getProperty ?? ((object, key) => {
+      const descriptor = getSandboxPropertyDescriptor(object, key, budget);
+      return descriptor === void 0 ? void 0 : readPropertyDescriptor(descriptor, object, context);
     })
   };
+  let current;
+  let iterator;
+  const items = [];
+  const release = retainValues(budget, () => [value, options, current, items, iterator?.retainedValue]);
+  try {
+    current = await bridge.getProperty(options, "transfer");
+    if (current !== void 0) {
+      if (current === null || typeof current !== "object") throw new TypeError("Transfer list must be an iterable object.");
+      iterator = await acquireSandboxIterator(current, budget, bridge);
+      if (iterator === void 0) throw new TypeError("Transfer list must be iterable.");
+      for (; ; ) {
+        budget.visitNode();
+        const result = await iterator.next();
+        current = result;
+        if ((await readIteratorResult(iterator, result, "done")).value) break;
+        current = (await readIteratorResult(iterator, result, "value")).value;
+        if (current === null || typeof current !== "object") {
+          throw new TypeError("Transfer list elements must be objects.");
+        }
+        budget.allocateArrayLength(items.length + 1);
+        budget.provisionDataUsage(items.length + 2)();
+        items.push(current);
+      }
+    }
+    const seen = /* @__PURE__ */ new Set();
+    const transfers = [];
+    for (const item of items) {
+      budget.visitNode();
+      if (!isSandboxArrayBuffer(item) || seen.has(item))
+        throw new DOMException("Invalid or duplicate transferable.", "DataCloneError");
+      seen.add(item);
+      transfers.push(item);
+    }
+    return cloneStructuredValue(value, transfers, budget, context);
+  } finally {
+    release();
+  }
 }
-function structuredCloneSandboxValue(value, budget, parent) {
+function cloneStructuredValue(value, transfers, budget, context) {
+  const parent = context?.compilation;
   const operation = budget.acquireCompileOwner(false, parent?.owner);
   const compilation = parent?.owner === operation.owner ? parent : new CompileScope(operation.owner);
+  const buffers = /* @__PURE__ */ new WeakMap();
+  let clone;
+  const release = retainValues(budget, () => [value, clone, transfers]);
   try {
-    const clone = cloneSandboxValue(value, { compilation, resetRegexLastIndex: true, structuredClone: true });
+    let transferSize = 0;
+    for (const buffer of transfers) {
+      const length = arrayBufferLength(buffer);
+      budget.allocateArrayLength(arrayBufferOptions(buffer)?.maxByteLength ?? length);
+      transferSize += length + 1;
+      if (arrayBufferDetached(buffer)) buffers.set(buffer, new ArrayBuffer(0));
+    }
+    budget.provisionDataUsage(transferSize)();
+    clone = cloneSandboxValue(value, { compilation, resetRegexLastIndex: true, structuredClone: true, float32Buffers: buffers });
     assertSandboxGraphDepth(clone);
     assertStructuredCloneable(clone, /* @__PURE__ */ new WeakSet());
     allocateProducedSandboxValue(clone, budget);
     if (compilation !== parent) reconcileCompiledValues(budget, [clone], compilation);
+    if (transfers.length > 0) {
+      createDataCheckpoint(budget, context)(clone, 0, true);
+      budget.visitNode(transferSize + transfers.length);
+      budget.provisionDataUsage(transferBuffer === void 0 ? transferSize : transfers.length)();
+      for (const buffer of transfers) {
+        if (arrayBufferDetached(buffer)) throw new DOMException("Cannot transfer a detached ArrayBuffer.", "DataCloneError");
+        if (transferBuffer !== void 0) Reflect.apply(transferBuffer, buffer, [0]);
+        else structuredClone(buffer, { transfer: [buffer] });
+        if (!arrayBufferDetached(buffer)) throw new DOMException("ArrayBuffer cannot be transferred.", "DataCloneError");
+      }
+    }
     return clone;
   } finally {
+    release();
     if (compilation !== parent) compilation.dispose();
     operation.release();
   }
 }
 function assertStructuredCloneable(value, seen) {
-  if (isSandboxClosure(value) || isSandboxPromise(value) || isSandboxCollectionIterator(value) || isSandboxRegExpIterator(value)) {
-    throw new TypeError("structuredClone() cannot clone closures, promises, or collection iterators.");
-  }
-  if (typeof value !== "object" || value === null || seen.has(value)) {
-    return;
-  }
+  if (typeof value === "symbol") throw new DOMException("Cannot clone a symbol value.", "DataCloneError");
+  if (isSandboxClosure(value) || isSandboxPromise(value) || isSandboxCollectionIterator(value) || isSandboxRegExpIterator(value))
+    throw new DOMException("Cannot clone closures, promises, or collection iterators.", "DataCloneError");
+  if (typeof value !== "object" || value === null || seen.has(value)) return;
   seen.add(value);
   if (isSandboxMap(value)) {
     for (const [key, entry] of value.entries) {
@@ -25613,14 +25673,34 @@ function assertStructuredCloneable(value, seen) {
     return;
   }
   if (isSandboxSet(value)) {
-    for (const entry of value.values) {
-      assertStructuredCloneable(entry, seen);
-    }
+    for (const entry of value.values) assertStructuredCloneable(entry, seen);
     return;
   }
-  for (const entry of Object.values(value)) {
-    assertStructuredCloneable(entry, seen);
-  }
+  for (const entry of Object.values(value)) assertStructuredCloneable(entry, seen);
+}
+
+// packages/safe-js/src/interp/globals/misc.ts
+function createMiscGlobals(options) {
+  return {
+    structuredClone: createStructuredCloneGlobal(options.budget),
+    ...createNumericParsers(options.budget),
+    isNaN: createSandboxClosure({
+      sandbox: true,
+      call: ([value], context) => {
+        const number = sandboxNumber(value, options.budget, context);
+        return typeof number === "number" ? Number.isNaN(number) : number.then(Number.isNaN);
+      },
+      name: "isNaN"
+    }),
+    isFinite: createSandboxClosure({
+      sandbox: true,
+      call: ([value], context) => {
+        const number = sandboxNumber(value, options.budget, context);
+        return typeof number === "number" ? Number.isFinite(number) : number.then(Number.isFinite);
+      },
+      name: "isFinite"
+    })
+  };
 }
 
 // packages/safe-js/src/interp/globals/uri.ts
@@ -25955,7 +26035,7 @@ function createBigIntGlobal(budget) {
 
 // packages/safe-js/src/interp/globals/array-buffer.ts
 var resizeBuffer2 = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "resize")?.value;
-var transferBuffer = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "transfer")?.value;
+var transferBuffer2 = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "transfer")?.value;
 function createArrayBufferGlobal(budget) {
   const prototype = /* @__PURE__ */ Object.create(null);
   const constructor = createSandboxClosure({
@@ -26128,9 +26208,9 @@ function createArrayBufferGlobal(budget) {
           const count = Math.min(length, arrayBufferLength(receiver));
           budget.visitNode(count);
           new Uint8Array(result, 0, count).set(new Uint8Array(receiver, 0, count));
-          if (transferBuffer !== void 0) {
+          if (transferBuffer2 !== void 0) {
             budget.provisionDataUsage(1)();
-            Reflect.apply(transferBuffer, receiver, [0]);
+            Reflect.apply(transferBuffer2, receiver, [0]);
           } else {
             budget.provisionDataUsage(arrayBufferLength(receiver) + 1)();
             budget.visitNode(arrayBufferLength(receiver));
@@ -43423,4 +43503,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-NLDDBHDH.js.map
+//# sourceMappingURL=chunk-2UQ2QDUV.js.map