sandboxedjs 0.1.80 → 0.1.81

package/dist/worker-entry.js

@@ -28502,6 +28502,18 @@ function toBytes(data2) {
   abytes(data2);
   return data2;
 }
+function kdfInputToBytes(data2) {
+  if (typeof data2 === "string")
+    data2 = utf8ToBytes(data2);
+  abytes(data2);
+  return data2;
+}
+function checkOpts(defaults, opts) {
+  if (opts !== void 0 && {}.toString.call(opts) !== "[object Object]")
+    throw new Error("options should be object or undefined");
+  const merged = Object.assign(defaults, opts);
+  return merged;
+}
 var Hash = class {
 };
 function createHasher(hashCons) {
@@ -29304,6 +29316,51 @@ var HMAC = class extends Hash {
 var hmac = (hash, key, message) => new HMAC(hash, key).update(message).digest();
 hmac.create = (hash, key) => new HMAC(hash, key);
 
+// node_modules/@noble/hashes/esm/pbkdf2.js
+function pbkdf2Init(hash, _password, _salt, _opts) {
+  ahash(hash);
+  const opts = checkOpts({ dkLen: 32, asyncTick: 10 }, _opts);
+  const { c, dkLen, asyncTick } = opts;
+  anumber(c);
+  anumber(dkLen);
+  anumber(asyncTick);
+  if (c < 1)
+    throw new Error("iterations (c) should be >= 1");
+  const password = kdfInputToBytes(_password);
+  const salt = kdfInputToBytes(_salt);
+  const DK = new Uint8Array(dkLen);
+  const PRF = hmac.create(hash, password);
+  const PRFSalt = PRF._cloneInto().update(salt);
+  return { c, dkLen, asyncTick, DK, PRF, PRFSalt };
+}
+function pbkdf2Output(PRF, PRFSalt, DK, prfW, u) {
+  PRF.destroy();
+  PRFSalt.destroy();
+  if (prfW)
+    prfW.destroy();
+  clean2(u);
+  return DK;
+}
+function pbkdf2(hash, password, salt, opts) {
+  const { c, dkLen, DK, PRF, PRFSalt } = pbkdf2Init(hash, password, salt, opts);
+  let prfW;
+  const arr = new Uint8Array(4);
+  const view = createView(arr);
+  const u = new Uint8Array(PRF.outputLen);
+  for (let ti = 1, pos = 0; pos < dkLen; ti++, pos += PRF.outputLen) {
+    const Ti = DK.subarray(pos, pos + PRF.outputLen);
+    view.setInt32(0, ti, false);
+    (prfW = PRFSalt._cloneInto(prfW)).update(arr).digestInto(u);
+    Ti.set(u.subarray(0, Ti.length));
+    for (let ui = 1; ui < c; ui++) {
+      PRF._cloneInto(prfW).update(u).digestInto(u);
+      for (let i = 0; i < Ti.length; i++)
+        Ti[i] ^= u[i];
+    }
+  }
+  return pbkdf2Output(PRF, PRFSalt, DK, prfW, u);
+}
+
 // src/node/crypto-module.ts
 var hashes = { md5, sha1, "sha-1": sha1, sha224: sha2242, "sha-224": sha2242, sha256: sha2562, "sha-256": sha2562, sha384: sha3842, "sha-384": sha3842, sha512: sha5122, "sha-512": sha5122 };
 function createCryptoModule() {
@@ -29341,6 +29398,28 @@ function createCryptoModule() {
       };
       return api;
     },
+    pbkdf2Sync(password, salt, iterations, keylen, digest) {
+      return pbkdf2Key(password, salt, iterations, keylen, digest);
+    },
+    /* 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, digest, callback) {
+      if (typeof callback !== "function") {
+        throw Object.assign(new TypeError('The "callback" argument must be of type function'), { code: "ERR_INVALID_ARG_TYPE" });
+      }
+      hashFor(digest);
+      let key;
+      let failure = null;
+      try {
+        key = pbkdf2Key(password, salt, iterations, keylen, digest);
+      } catch (error) {
+        failure = error instanceof Error ? error : new Error(String(error));
+      }
+      setTimeout(() => failure ? callback(failure) : callback(null, key), 0);
+    },
     randomBytes(size, callback) {
       const value = Buffer2.alloc(size);
       cryptoObject.getRandomValues(value);
@@ -29390,6 +29469,15 @@ function createCryptoModule() {
     constants: {}
   };
 }
+function pbkdf2Key(password, salt, iterations, keylen, digest) {
+  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(hashFor(digest), 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" });
@@ -30301,7 +30389,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 import_events4.default(), import_browser.default, {
     argv: options.argv?.slice() ?? ["/usr/bin/node"],
     argv0: "node",
@@ -30344,13 +30432,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
   });
@@ -30362,6 +30451,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;
@@ -30434,8 +30536,10 @@ function createCoreModules(options) {
     }
   };
   let inFlightRequests = 0;
+  let requestsStarted = 0;
   const trackRequest = () => {
     inFlightRequests++;
+    requestsStarted += 1;
     return () => {
       inFlightRequests--;
     };
@@ -30554,6 +30658,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: (data2) => {
       if (options.interactiveStdin) stdin.write(data2);
     },
@@ -31164,8 +31280,28 @@ var ERRNO_CONSTANTS = {
   EWOULDBLOCK: 11,
   EXDEV: 18
 };
+var afterMicrotasks = (() => {
+  const host = globalThis.process;
+  if (typeof host?.nextTick === "function" && host.versions?.node) return (fn) => host.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 {
@@ -31173,11 +31309,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() {
@@ -31282,6 +31421,7 @@ function createTrackedTimers(onError = (error) => {
     },
     pending: () => live.size,
     pendingUnrefed: () => unrefed.size,
+    scheduled: () => scheduled,
     cancelAll
   };
 }
@@ -31767,8 +31907,16 @@ async function run(port, start) {
     aliases: start.aliases
   });
   try {
-    await engine.run(start.script);
+    const main2 = engine.run(start.script);
+    core.runTicks();
+    await main2;
     await settle(router, owner, core, () => finished);
+    while (!finished) {
+      const activity = core.loopActivity();
+      if (!core.emitBeforeExit(core.exitStatus())) break;
+      await settle(router, owner, core, () => finished);
+      if (core.loopActivity() === activity) break;
+    }
     const status = core.exitStatus();
     core.emitExit(status);
     finish(status);