sandboxedjs 0.1.79 → 0.1.81

package/dist/index.cjs

@@ -21,6 +21,7 @@ var timersModule = require('timers-browserify');
 var legacyUrl = require('url/url.js');
 var legacy$1 = require('@noble/hashes/legacy');
 var hmac = require('@noble/hashes/hmac');
+var pbkdf2 = require('@noble/hashes/pbkdf2');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -20237,7 +20238,7 @@ var wheels_default = {
 
 // package.json
 var package_default = {
-  version: "0.1.79"};
+  version: "0.1.81"};
 
 // src/python/config.ts
 function runtimeModuleUrl() {
@@ -28255,6 +28256,28 @@ function createCryptoModule() {
       };
       return api;
     },
+    pbkdf2Sync(password, salt, iterations, keylen, digest2) {
+      return pbkdf2Key(password, salt, iterations, keylen, digest2);
+    },
+    /* Node derives the key on the libuv thread pool and calls back from the poll
+     * phase. Here it is derived on the calling thread — the ordering a program
+     * observes is the same (the call returns first, the callback comes on a later
+     * turn), but the main thread is busy while it computes. Invalid arguments throw
+     * synchronously, as in Node. */
+    pbkdf2(password, salt, iterations, keylen, digest2, callback) {
+      if (typeof callback !== "function") {
+        throw Object.assign(new TypeError('The "callback" argument must be of type function'), { code: "ERR_INVALID_ARG_TYPE" });
+      }
+      hashFor(digest2);
+      let key;
+      let failure2 = null;
+      try {
+        key = pbkdf2Key(password, salt, iterations, keylen, digest2);
+      } catch (error) {
+        failure2 = error instanceof Error ? error : new Error(String(error));
+      }
+      setTimeout(() => failure2 ? callback(failure2) : callback(null, key), 0);
+    },
     randomBytes(size, callback) {
       const value = Buffer2.alloc(size);
       cryptoObject.getRandomValues(value);
@@ -28304,6 +28327,15 @@ function createCryptoModule() {
     constants: {}
   };
 }
+function pbkdf2Key(password, salt, iterations, keylen, digest2) {
+  if (!Number.isInteger(iterations) || iterations < 1) {
+    throw Object.assign(new RangeError(`The value of "iterations" is out of range. It must be >= 1. Received ${iterations}`), { code: "ERR_OUT_OF_RANGE" });
+  }
+  if (!Number.isInteger(keylen) || keylen < 0) {
+    throw Object.assign(new RangeError(`The value of "keylen" is out of range. It must be >= 0. Received ${keylen}`), { code: "ERR_OUT_OF_RANGE" });
+  }
+  return Buffer2.from(pbkdf2.pbkdf2(hashFor(digest2), toBytes2(password), toBytes2(salt), { c: iterations, dkLen: keylen }));
+}
 function hashFor(algorithm) {
   const hash = hashes[algorithm.toLowerCase()];
   if (!hash) throw Object.assign(new Error(`Digest method not supported: ${algorithm}`), { code: "ERR_OSSL_EVP_UNSUPPORTED" });
@@ -29175,7 +29207,7 @@ function createCoreModules(options) {
   });
   const stderrWrite = options.stderr ?? (() => {
   });
-  const timers = createTrackedTimers((error) => reportUncaught(error));
+  const timers = createTrackedTimers((error) => reportUncaught(error), () => runTicks());
   const processObject = Object.assign(new EventEmitter4__default.default(), processShim__default.default, {
     argv: options.argv?.slice() ?? ["/usr/bin/node"],
     argv0: "node",
@@ -29218,13 +29250,14 @@ function createCoreModules(options) {
       options.onExit?.(status);
     },
     nextTick: (fn, ...args) => {
-      queueMicrotask(() => {
-        try {
-          fn(...args);
-        } catch (error) {
-          reportUncaught(error);
-        }
-      });
+      if (typeof fn !== "function") {
+        throw Object.assign(new TypeError('The "callback" argument must be of type function'), { code: "ERR_INVALID_ARG_TYPE" });
+      }
+      tickQueue.push([fn, args]);
+      if (!tickDrainScheduled) {
+        tickDrainScheduled = true;
+        afterMicrotasks(runTicks);
+      }
     },
     kill: () => true
   });
@@ -29236,6 +29269,19 @@ function createCoreModules(options) {
   processObject.stdout = makeOutputStream(stdoutWrite, 1, tty);
   processObject.stderr = makeOutputStream(stderrWrite, 2, tty);
   let exiting = false;
+  const tickQueue = [];
+  let tickDrainScheduled = false;
+  const runTicks = () => {
+    tickDrainScheduled = false;
+    while (tickQueue.length && !exiting) {
+      const [fn, args] = tickQueue.shift();
+      try {
+        fn(...args);
+      } catch (error) {
+        reportUncaught(error);
+      }
+    }
+  };
   const emitExit = (status) => {
     if (exiting) return;
     exiting = true;
@@ -29308,8 +29354,10 @@ function createCoreModules(options) {
     }
   };
   let inFlightRequests = 0;
+  let requestsStarted = 0;
   const trackRequest = () => {
     inFlightRequests++;
+    requestsStarted += 1;
     return () => {
       inFlightRequests--;
     };
@@ -29428,6 +29476,18 @@ function createCoreModules(options) {
     reportUnhandledRejection: (reason) => reportUncaught(reason, "unhandledRejection"),
     exitStatus: () => normalizeExitCode(processObject.exitCode),
     emitExit,
+    runTicks,
+    emitBeforeExit: (status) => {
+      if (exiting || processObject.listenerCount("beforeExit") === 0) return false;
+      try {
+        processObject.emit("beforeExit", status);
+      } catch (error) {
+        reportUncaught(error);
+      }
+      runTicks();
+      return true;
+    },
+    loopActivity: () => timers.scheduled() + requestsStarted,
     writeStdin: (data) => {
       if (options.interactiveStdin) stdin.write(data);
     },
@@ -30038,8 +30098,28 @@ var ERRNO_CONSTANTS = {
   EWOULDBLOCK: 11,
   EXDEV: 18
 };
+var afterMicrotasks = (() => {
+  const host2 = globalThis.process;
+  if (typeof host2?.nextTick === "function" && host2.versions?.node) return (fn) => host2.nextTick(fn);
+  if (typeof MessageChannel === "function") {
+    const queue = [];
+    let channel = null;
+    return (fn) => {
+      if (!channel) {
+        channel = new MessageChannel();
+        channel.port1.onmessage = () => queue.shift()?.();
+      }
+      queue.push(fn);
+      channel.port2.postMessage(null);
+    };
+  }
+  return (fn) => {
+    setTimeout(fn, 0);
+  };
+})();
 function createTrackedTimers(onError = (error) => {
   throw error;
+}, afterCallback = () => {
 }) {
   const run2 = (fn, args) => {
     try {
@@ -30047,11 +30127,14 @@ function createTrackedTimers(onError = (error) => {
     } catch (error) {
       onError(error);
     }
+    afterCallback();
   };
+  let scheduled = 0;
   const live = /* @__PURE__ */ new Set();
   const unrefed = /* @__PURE__ */ new Set();
   const states = /* @__PURE__ */ new WeakMap();
   const track = (native) => {
+    scheduled += 1;
     const state = { native, active: true, referenced: true };
     const handle = {
       ref() {
@@ -30156,6 +30239,7 @@ function createTrackedTimers(onError = (error) => {
     },
     pending: () => live.size,
     pendingUnrefed: () => unrefed.size,
+    scheduled: () => scheduled,
     cancelAll
   };
 }
@@ -31761,8 +31845,17 @@ var LocalRuntimePod = class _LocalRuntimePod {
         overrides: Object.fromEntries(Object.entries(this.modules).map(([key, value]) => [key, hostWork.wrap(value)]))
       });
       try {
-        await Promise.race([engine.run(script), proc.waitForKill()]);
-        await this.settle(owner, core.pendingHandles, core.readingStdin, () => core.pendingRequests() + hostWork.pending(), () => proc.isKilled());
+        const main = engine.run(script);
+        core.runTicks();
+        await Promise.race([main, proc.waitForKill()]);
+        const settle = () => this.settle(owner, core.pendingHandles, core.readingStdin, () => core.pendingRequests() + hostWork.pending(), () => proc.isKilled());
+        await settle();
+        while (!proc.isKilled()) {
+          const activity = core.loopActivity();
+          if (!core.emitBeforeExit(core.exitStatus())) break;
+          await settle();
+          if (core.loopActivity() === activity) break;
+        }
         const status = core.exitStatus();
         core.emitExit(status);
         return status;