@secure-exec/core 0.1.1-rc.2 → 0.1.1-rc.3

package/dist/isolate-runtime/require-setup.js

@@ -96,6 +96,34 @@
     if (lastSlash === 0) return "/";
     return p.slice(0, lastSlash);
   }
+  if (typeof globalThis.TextDecoder === "function") {
+    _OrigTextDecoder = globalThis.TextDecoder;
+    _utf8Aliases = {
+      "utf-8": true,
+      "utf8": true,
+      "unicode-1-1-utf-8": true,
+      "ascii": true,
+      "us-ascii": true,
+      "iso-8859-1": true,
+      "latin1": true,
+      "binary": true,
+      "windows-1252": true,
+      "utf-16le": true,
+      "utf-16": true,
+      "ucs-2": true,
+      "ucs2": true
+    };
+    globalThis.TextDecoder = function TextDecoder(encoding, options) {
+      var label = encoding !== void 0 ? String(encoding).toLowerCase().replace(/\s/g, "") : "utf-8";
+      if (_utf8Aliases[label]) {
+        return new _OrigTextDecoder("utf-8", options);
+      }
+      return new _OrigTextDecoder(encoding, options);
+    };
+    globalThis.TextDecoder.prototype = _OrigTextDecoder.prototype;
+  }
+  var _OrigTextDecoder;
+  var _utf8Aliases;
   function _patchPolyfill(name2, result2) {
     if (typeof result2 !== "object" && typeof result2 !== "function" || result2 === null) {
       return result2;
@@ -129,6 +157,24 @@
         if (typeof BufferCtor.constants !== "object" || BufferCtor.constants === null) {
           BufferCtor.constants = result2.constants;
         }
+        var bProto = BufferCtor.prototype;
+        if (bProto) {
+          var encs = ["utf8", "ascii", "latin1", "binary", "hex", "base64", "ucs2", "utf16le"];
+          for (var ei = 0; ei < encs.length; ei++) {
+            (function(e) {
+              if (typeof bProto[e + "Slice"] !== "function") {
+                bProto[e + "Slice"] = function(start, end) {
+                  return this.toString(e, start, end);
+                };
+              }
+              if (typeof bProto[e + "Write"] !== "function") {
+                bProto[e + "Write"] = function(str, offset, length) {
+                  return this.write(str, offset, length, e);
+                };
+              }
+            })(encs[ei]);
+          }
+        }
       }
       return result2;
     }
@@ -185,6 +231,854 @@
       }
       return result2;
     }
+    if (name2 === "zlib") {
+      if (typeof result2.constants !== "object" || result2.constants === null) {
+        var zlibConstants = {};
+        var constKeys = Object.keys(result2);
+        for (var ci = 0; ci < constKeys.length; ci++) {
+          var ck = constKeys[ci];
+          if (ck.indexOf("Z_") === 0 && typeof result2[ck] === "number") {
+            zlibConstants[ck] = result2[ck];
+          }
+        }
+        if (typeof zlibConstants.DEFLATE !== "number") zlibConstants.DEFLATE = 1;
+        if (typeof zlibConstants.INFLATE !== "number") zlibConstants.INFLATE = 2;
+        if (typeof zlibConstants.GZIP !== "number") zlibConstants.GZIP = 3;
+        if (typeof zlibConstants.DEFLATERAW !== "number") zlibConstants.DEFLATERAW = 4;
+        if (typeof zlibConstants.INFLATERAW !== "number") zlibConstants.INFLATERAW = 5;
+        if (typeof zlibConstants.UNZIP !== "number") zlibConstants.UNZIP = 6;
+        if (typeof zlibConstants.GUNZIP !== "number") zlibConstants.GUNZIP = 7;
+        result2.constants = zlibConstants;
+      }
+      return result2;
+    }
+    if (name2 === "crypto") {
+      if (typeof _cryptoHashDigest !== "undefined") {
+        let SandboxHash2 = function(algorithm) {
+          this._algorithm = algorithm;
+          this._chunks = [];
+        };
+        var SandboxHash = SandboxHash2;
+        SandboxHash2.prototype.update = function update(data, inputEncoding) {
+          if (typeof data === "string") {
+            this._chunks.push(Buffer.from(data, inputEncoding || "utf8"));
+          } else {
+            this._chunks.push(Buffer.from(data));
+          }
+          return this;
+        };
+        SandboxHash2.prototype.digest = function digest(encoding) {
+          var combined = Buffer.concat(this._chunks);
+          var resultBase64 = _cryptoHashDigest.applySync(void 0, [
+            this._algorithm,
+            combined.toString("base64")
+          ]);
+          var resultBuffer = Buffer.from(resultBase64, "base64");
+          if (!encoding || encoding === "buffer") return resultBuffer;
+          return resultBuffer.toString(encoding);
+        };
+        SandboxHash2.prototype.copy = function copy() {
+          var c = new SandboxHash2(this._algorithm);
+          c._chunks = this._chunks.slice();
+          return c;
+        };
+        SandboxHash2.prototype.write = function write(data, encoding) {
+          this.update(data, encoding);
+          return true;
+        };
+        SandboxHash2.prototype.end = function end(data, encoding) {
+          if (data) this.update(data, encoding);
+        };
+        result2.createHash = function createHash(algorithm) {
+          return new SandboxHash2(algorithm);
+        };
+        result2.Hash = SandboxHash2;
+      }
+      if (typeof _cryptoHmacDigest !== "undefined") {
+        let SandboxHmac2 = function(algorithm, key) {
+          this._algorithm = algorithm;
+          if (typeof key === "string") {
+            this._key = Buffer.from(key, "utf8");
+          } else if (key && typeof key === "object" && key._pem !== void 0) {
+            this._key = Buffer.from(key._pem, "utf8");
+          } else {
+            this._key = Buffer.from(key);
+          }
+          this._chunks = [];
+        };
+        var SandboxHmac = SandboxHmac2;
+        SandboxHmac2.prototype.update = function update(data, inputEncoding) {
+          if (typeof data === "string") {
+            this._chunks.push(Buffer.from(data, inputEncoding || "utf8"));
+          } else {
+            this._chunks.push(Buffer.from(data));
+          }
+          return this;
+        };
+        SandboxHmac2.prototype.digest = function digest(encoding) {
+          var combined = Buffer.concat(this._chunks);
+          var resultBase64 = _cryptoHmacDigest.applySync(void 0, [
+            this._algorithm,
+            this._key.toString("base64"),
+            combined.toString("base64")
+          ]);
+          var resultBuffer = Buffer.from(resultBase64, "base64");
+          if (!encoding || encoding === "buffer") return resultBuffer;
+          return resultBuffer.toString(encoding);
+        };
+        SandboxHmac2.prototype.copy = function copy() {
+          var c = new SandboxHmac2(this._algorithm, this._key);
+          c._chunks = this._chunks.slice();
+          return c;
+        };
+        SandboxHmac2.prototype.write = function write(data, encoding) {
+          this.update(data, encoding);
+          return true;
+        };
+        SandboxHmac2.prototype.end = function end(data, encoding) {
+          if (data) this.update(data, encoding);
+        };
+        result2.createHmac = function createHmac(algorithm, key) {
+          return new SandboxHmac2(algorithm, key);
+        };
+        result2.Hmac = SandboxHmac2;
+      }
+      if (typeof _cryptoRandomFill !== "undefined") {
+        result2.randomBytes = function randomBytes(size, callback) {
+          if (typeof size !== "number" || size < 0 || size !== (size | 0)) {
+            var err = new TypeError('The "size" argument must be of type number. Received type ' + typeof size);
+            if (typeof callback === "function") {
+              callback(err);
+              return;
+            }
+            throw err;
+          }
+          if (size > 2147483647) {
+            var rangeErr = new RangeError('The value of "size" is out of range. It must be >= 0 && <= 2147483647. Received ' + size);
+            if (typeof callback === "function") {
+              callback(rangeErr);
+              return;
+            }
+            throw rangeErr;
+          }
+          var buf = Buffer.alloc(size);
+          var offset = 0;
+          while (offset < size) {
+            var chunk = Math.min(size - offset, 65536);
+            var base64 = _cryptoRandomFill.applySync(void 0, [chunk]);
+            var hostBytes = Buffer.from(base64, "base64");
+            hostBytes.copy(buf, offset);
+            offset += chunk;
+          }
+          if (typeof callback === "function") {
+            callback(null, buf);
+            return;
+          }
+          return buf;
+        };
+        result2.randomFillSync = function randomFillSync(buffer, offset, size) {
+          if (offset === void 0) offset = 0;
+          var byteLength = buffer.byteLength !== void 0 ? buffer.byteLength : buffer.length;
+          if (size === void 0) size = byteLength - offset;
+          if (offset < 0 || size < 0 || offset + size > byteLength) {
+            throw new RangeError('The value of "offset + size" is out of range.');
+          }
+          var bytes = new Uint8Array(buffer.buffer || buffer, buffer.byteOffset ? buffer.byteOffset + offset : offset, size);
+          var filled = 0;
+          while (filled < size) {
+            var chunk = Math.min(size - filled, 65536);
+            var base64 = _cryptoRandomFill.applySync(void 0, [chunk]);
+            var hostBytes = Buffer.from(base64, "base64");
+            bytes.set(hostBytes, filled);
+            filled += chunk;
+          }
+          return buffer;
+        };
+        result2.randomFill = function randomFill(buffer, offsetOrCb, sizeOrCb, callback) {
+          var offset = 0;
+          var size;
+          var cb;
+          if (typeof offsetOrCb === "function") {
+            cb = offsetOrCb;
+          } else if (typeof sizeOrCb === "function") {
+            offset = offsetOrCb || 0;
+            cb = sizeOrCb;
+          } else {
+            offset = offsetOrCb || 0;
+            size = sizeOrCb;
+            cb = callback;
+          }
+          if (typeof cb !== "function") {
+            throw new TypeError("Callback must be a function");
+          }
+          try {
+            result2.randomFillSync(buffer, offset, size);
+            cb(null, buffer);
+          } catch (e) {
+            cb(e);
+          }
+        };
+        result2.randomInt = function randomInt(minOrMax, maxOrCb, callback) {
+          var min, max, cb;
+          if (typeof maxOrCb === "function" || maxOrCb === void 0) {
+            min = 0;
+            max = minOrMax;
+            cb = maxOrCb;
+          } else {
+            min = minOrMax;
+            max = maxOrCb;
+            cb = callback;
+          }
+          if (!Number.isSafeInteger(min)) {
+            var minErr = new TypeError('The "min" argument must be a safe integer');
+            if (typeof cb === "function") {
+              cb(minErr);
+              return;
+            }
+            throw minErr;
+          }
+          if (!Number.isSafeInteger(max)) {
+            var maxErr = new TypeError('The "max" argument must be a safe integer');
+            if (typeof cb === "function") {
+              cb(maxErr);
+              return;
+            }
+            throw maxErr;
+          }
+          if (max <= min) {
+            var rangeErr2 = new RangeError('The value of "max" is out of range. It must be greater than the value of "min" (' + min + ")");
+            if (typeof cb === "function") {
+              cb(rangeErr2);
+              return;
+            }
+            throw rangeErr2;
+          }
+          var range = max - min;
+          var bytes = 6;
+          var maxValid = Math.pow(2, 48) - Math.pow(2, 48) % range;
+          var val;
+          do {
+            var base64 = _cryptoRandomFill.applySync(void 0, [bytes]);
+            var buf = Buffer.from(base64, "base64");
+            val = buf.readUIntBE(0, bytes);
+          } while (val >= maxValid);
+          var result22 = min + val % range;
+          if (typeof cb === "function") {
+            cb(null, result22);
+            return;
+          }
+          return result22;
+        };
+      }
+      if (typeof _cryptoPbkdf2 !== "undefined") {
+        result2.pbkdf2Sync = function pbkdf2Sync(password, salt, iterations, keylen, digest) {
+          var pwBuf = typeof password === "string" ? Buffer.from(password, "utf8") : Buffer.from(password);
+          var saltBuf = typeof salt === "string" ? Buffer.from(salt, "utf8") : Buffer.from(salt);
+          var resultBase64 = _cryptoPbkdf2.applySync(void 0, [
+            pwBuf.toString("base64"),
+            saltBuf.toString("base64"),
+            iterations,
+            keylen,
+            digest
+          ]);
+          return Buffer.from(resultBase64, "base64");
+        };
+        result2.pbkdf2 = function pbkdf2(password, salt, iterations, keylen, digest, callback) {
+          try {
+            var derived = result2.pbkdf2Sync(password, salt, iterations, keylen, digest);
+            callback(null, derived);
+          } catch (e) {
+            callback(e);
+          }
+        };
+      }
+      if (typeof _cryptoScrypt !== "undefined") {
+        result2.scryptSync = function scryptSync(password, salt, keylen, options) {
+          var pwBuf = typeof password === "string" ? Buffer.from(password, "utf8") : Buffer.from(password);
+          var saltBuf = typeof salt === "string" ? Buffer.from(salt, "utf8") : Buffer.from(salt);
+          var opts = {};
+          if (options) {
+            if (options.N !== void 0) opts.N = options.N;
+            if (options.r !== void 0) opts.r = options.r;
+            if (options.p !== void 0) opts.p = options.p;
+            if (options.maxmem !== void 0) opts.maxmem = options.maxmem;
+            if (options.cost !== void 0) opts.N = options.cost;
+            if (options.blockSize !== void 0) opts.r = options.blockSize;
+            if (options.parallelization !== void 0) opts.p = options.parallelization;
+          }
+          var resultBase64 = _cryptoScrypt.applySync(void 0, [
+            pwBuf.toString("base64"),
+            saltBuf.toString("base64"),
+            keylen,
+            JSON.stringify(opts)
+          ]);
+          return Buffer.from(resultBase64, "base64");
+        };
+        result2.scrypt = function scrypt(password, salt, keylen, optionsOrCb, callback) {
+          var opts = optionsOrCb;
+          var cb = callback;
+          if (typeof optionsOrCb === "function") {
+            opts = void 0;
+            cb = optionsOrCb;
+          }
+          try {
+            var derived = result2.scryptSync(password, salt, keylen, opts);
+            cb(null, derived);
+          } catch (e) {
+            cb(e);
+          }
+        };
+      }
+      var _useStatefulCipher = typeof _cryptoCipherivCreate !== "undefined";
+      if (typeof _cryptoCipheriv !== "undefined" || _useStatefulCipher) {
+        let SandboxCipher2 = function(algorithm, key, iv) {
+          this._algorithm = algorithm;
+          this._key = typeof key === "string" ? Buffer.from(key, "utf8") : Buffer.from(key);
+          this._iv = typeof iv === "string" ? Buffer.from(iv, "utf8") : Buffer.from(iv);
+          this._authTag = null;
+          this._finalized = false;
+          if (_useStatefulCipher) {
+            this._sessionId = _cryptoCipherivCreate.applySync(void 0, [
+              "cipher",
+              algorithm,
+              this._key.toString("base64"),
+              this._iv.toString("base64")
+            ]);
+          } else {
+            this._sessionId = -1;
+            this._chunks = [];
+          }
+        };
+        var SandboxCipher = SandboxCipher2;
+        SandboxCipher2.prototype.update = function update(data, inputEncoding, outputEncoding) {
+          var buf;
+          if (typeof data === "string") {
+            buf = Buffer.from(data, inputEncoding || "utf8");
+          } else {
+            buf = Buffer.from(data);
+          }
+          if (this._sessionId >= 0) {
+            var resultBase64 = _cryptoCipherivUpdate.applySync(void 0, [this._sessionId, buf.toString("base64")]);
+            var resultBuffer = Buffer.from(resultBase64, "base64");
+            if (outputEncoding && outputEncoding !== "buffer") return resultBuffer.toString(outputEncoding);
+            return resultBuffer;
+          }
+          this._chunks.push(buf);
+          if (outputEncoding && outputEncoding !== "buffer") return "";
+          return Buffer.alloc(0);
+        };
+        SandboxCipher2.prototype.final = function final(outputEncoding) {
+          if (this._finalized) throw new Error("Attempting to call final() after already finalized");
+          this._finalized = true;
+          if (this._sessionId >= 0) {
+            var resultJson = _cryptoCipherivFinal.applySync(void 0, [this._sessionId]);
+            var parsed = JSON.parse(resultJson);
+            if (parsed.authTag) this._authTag = Buffer.from(parsed.authTag, "base64");
+            var resultBuffer = Buffer.from(parsed.data, "base64");
+            if (outputEncoding && outputEncoding !== "buffer") return resultBuffer.toString(outputEncoding);
+            return resultBuffer;
+          }
+          var combined = Buffer.concat(this._chunks);
+          var resultJson2 = _cryptoCipheriv.applySync(void 0, [
+            this._algorithm,
+            this._key.toString("base64"),
+            this._iv.toString("base64"),
+            combined.toString("base64")
+          ]);
+          var parsed2 = JSON.parse(resultJson2);
+          if (parsed2.authTag) this._authTag = Buffer.from(parsed2.authTag, "base64");
+          var resultBuffer2 = Buffer.from(parsed2.data, "base64");
+          if (outputEncoding && outputEncoding !== "buffer") return resultBuffer2.toString(outputEncoding);
+          return resultBuffer2;
+        };
+        SandboxCipher2.prototype.getAuthTag = function getAuthTag() {
+          if (!this._finalized) throw new Error("Cannot call getAuthTag before final()");
+          if (!this._authTag) throw new Error("Auth tag is only available for GCM ciphers");
+          return this._authTag;
+        };
+        SandboxCipher2.prototype.setAAD = function setAAD(data) {
+          if (this._sessionId >= 0) {
+            var buf = typeof data === "string" ? Buffer.from(data, "utf8") : Buffer.from(data);
+            _cryptoCipherivUpdate.applySync(void 0, [this._sessionId, "", JSON.stringify({ setAAD: buf.toString("base64") })]);
+          }
+          return this;
+        };
+        SandboxCipher2.prototype.setAutoPadding = function setAutoPadding(autoPadding) {
+          if (this._sessionId >= 0) {
+            _cryptoCipherivUpdate.applySync(void 0, [this._sessionId, "", JSON.stringify({ setAutoPadding: autoPadding !== false })]);
+          }
+          return this;
+        };
+        result2.createCipheriv = function createCipheriv(algorithm, key, iv) {
+          return new SandboxCipher2(algorithm, key, iv);
+        };
+        result2.Cipheriv = SandboxCipher2;
+      }
+      if (typeof _cryptoDecipheriv !== "undefined" || _useStatefulCipher) {
+        let SandboxDecipher2 = function(algorithm, key, iv) {
+          this._algorithm = algorithm;
+          this._key = typeof key === "string" ? Buffer.from(key, "utf8") : Buffer.from(key);
+          this._iv = typeof iv === "string" ? Buffer.from(iv, "utf8") : Buffer.from(iv);
+          this._authTag = null;
+          this._finalized = false;
+          if (_useStatefulCipher) {
+            this._sessionId = _cryptoCipherivCreate.applySync(void 0, [
+              "decipher",
+              algorithm,
+              this._key.toString("base64"),
+              this._iv.toString("base64")
+            ]);
+          } else {
+            this._sessionId = -1;
+            this._chunks = [];
+          }
+        };
+        var SandboxDecipher = SandboxDecipher2;
+        SandboxDecipher2.prototype.update = function update(data, inputEncoding, outputEncoding) {
+          var buf;
+          if (typeof data === "string") {
+            buf = Buffer.from(data, inputEncoding || "utf8");
+          } else {
+            buf = Buffer.from(data);
+          }
+          if (this._sessionId >= 0) {
+            var resultBase64 = _cryptoCipherivUpdate.applySync(void 0, [this._sessionId, buf.toString("base64")]);
+            var resultBuffer = Buffer.from(resultBase64, "base64");
+            if (outputEncoding && outputEncoding !== "buffer") return resultBuffer.toString(outputEncoding);
+            return resultBuffer;
+          }
+          this._chunks.push(buf);
+          if (outputEncoding && outputEncoding !== "buffer") return "";
+          return Buffer.alloc(0);
+        };
+        SandboxDecipher2.prototype.final = function final(outputEncoding) {
+          if (this._finalized) throw new Error("Attempting to call final() after already finalized");
+          this._finalized = true;
+          if (this._sessionId >= 0) {
+            if (this._authTag) {
+              _cryptoCipherivUpdate.applySync(void 0, [this._sessionId, "", JSON.stringify({ setAuthTag: this._authTag.toString("base64") })]);
+            }
+            var resultJson = _cryptoCipherivFinal.applySync(void 0, [this._sessionId]);
+            var parsed = JSON.parse(resultJson);
+            var resultBuffer = Buffer.from(parsed.data, "base64");
+            if (outputEncoding && outputEncoding !== "buffer") return resultBuffer.toString(outputEncoding);
+            return resultBuffer;
+          }
+          var combined = Buffer.concat(this._chunks);
+          var options = {};
+          if (this._authTag) options.authTag = this._authTag.toString("base64");
+          var resultBase64 = _cryptoDecipheriv.applySync(void 0, [
+            this._algorithm,
+            this._key.toString("base64"),
+            this._iv.toString("base64"),
+            combined.toString("base64"),
+            JSON.stringify(options)
+          ]);
+          var resultBuffer2 = Buffer.from(resultBase64, "base64");
+          if (outputEncoding && outputEncoding !== "buffer") return resultBuffer2.toString(outputEncoding);
+          return resultBuffer2;
+        };
+        SandboxDecipher2.prototype.setAuthTag = function setAuthTag(tag) {
+          this._authTag = typeof tag === "string" ? Buffer.from(tag, "base64") : Buffer.from(tag);
+          return this;
+        };
+        SandboxDecipher2.prototype.setAAD = function setAAD(data) {
+          if (this._sessionId >= 0) {
+            var buf = typeof data === "string" ? Buffer.from(data, "utf8") : Buffer.from(data);
+            _cryptoCipherivUpdate.applySync(void 0, [this._sessionId, "", JSON.stringify({ setAAD: buf.toString("base64") })]);
+          }
+          return this;
+        };
+        SandboxDecipher2.prototype.setAutoPadding = function setAutoPadding(autoPadding) {
+          if (this._sessionId >= 0) {
+            _cryptoCipherivUpdate.applySync(void 0, [this._sessionId, "", JSON.stringify({ setAutoPadding: autoPadding !== false })]);
+          }
+          return this;
+        };
+        result2.createDecipheriv = function createDecipheriv(algorithm, key, iv) {
+          return new SandboxDecipher2(algorithm, key, iv);
+        };
+        result2.Decipheriv = SandboxDecipher2;
+      }
+      if (typeof _cryptoSign !== "undefined") {
+        result2.sign = function sign(algorithm, data, key) {
+          var dataBuf = typeof data === "string" ? Buffer.from(data, "utf8") : Buffer.from(data);
+          var keyPem;
+          if (typeof key === "string") {
+            keyPem = key;
+          } else if (key && typeof key === "object" && key._pem) {
+            keyPem = key._pem;
+          } else if (Buffer.isBuffer(key)) {
+            keyPem = key.toString("utf8");
+          } else {
+            keyPem = String(key);
+          }
+          var sigBase64 = _cryptoSign.applySync(void 0, [
+            algorithm,
+            dataBuf.toString("base64"),
+            keyPem
+          ]);
+          return Buffer.from(sigBase64, "base64");
+        };
+      }
+      if (typeof _cryptoVerify !== "undefined") {
+        result2.verify = function verify(algorithm, data, key, signature) {
+          var dataBuf = typeof data === "string" ? Buffer.from(data, "utf8") : Buffer.from(data);
+          var keyPem;
+          if (typeof key === "string") {
+            keyPem = key;
+          } else if (key && typeof key === "object" && key._pem) {
+            keyPem = key._pem;
+          } else if (Buffer.isBuffer(key)) {
+            keyPem = key.toString("utf8");
+          } else {
+            keyPem = String(key);
+          }
+          var sigBuf = typeof signature === "string" ? Buffer.from(signature, "base64") : Buffer.from(signature);
+          return _cryptoVerify.applySync(void 0, [
+            algorithm,
+            dataBuf.toString("base64"),
+            keyPem,
+            sigBuf.toString("base64")
+          ]);
+        };
+      }
+      if (typeof _cryptoGenerateKeyPairSync !== "undefined") {
+        let SandboxKeyObject2 = function(type, pem) {
+          this.type = type;
+          this._pem = pem;
+        };
+        var SandboxKeyObject = SandboxKeyObject2;
+        SandboxKeyObject2.prototype.export = function exportKey(options) {
+          if (!options || options.format === "pem") {
+            return this._pem;
+          }
+          if (options.format === "der") {
+            var lines = this._pem.split("\n").filter(function(l) {
+              return l && l.indexOf("-----") !== 0;
+            });
+            return Buffer.from(lines.join(""), "base64");
+          }
+          return this._pem;
+        };
+        SandboxKeyObject2.prototype.toString = function() {
+          return this._pem;
+        };
+        result2.generateKeyPairSync = function generateKeyPairSync(type, options) {
+          var opts = {};
+          if (options) {
+            if (options.modulusLength !== void 0) opts.modulusLength = options.modulusLength;
+            if (options.publicExponent !== void 0) opts.publicExponent = options.publicExponent;
+            if (options.namedCurve !== void 0) opts.namedCurve = options.namedCurve;
+            if (options.divisorLength !== void 0) opts.divisorLength = options.divisorLength;
+            if (options.primeLength !== void 0) opts.primeLength = options.primeLength;
+          }
+          var resultJson = _cryptoGenerateKeyPairSync.applySync(void 0, [
+            type,
+            JSON.stringify(opts)
+          ]);
+          var parsed = JSON.parse(resultJson);
+          if (options && options.publicKeyEncoding && options.privateKeyEncoding) {
+            return { publicKey: parsed.publicKey, privateKey: parsed.privateKey };
+          }
+          return {
+            publicKey: new SandboxKeyObject2("public", parsed.publicKey),
+            privateKey: new SandboxKeyObject2("private", parsed.privateKey)
+          };
+        };
+        result2.generateKeyPair = function generateKeyPair(type, options, callback) {
+          try {
+            var pair = result2.generateKeyPairSync(type, options);
+            callback(null, pair.publicKey, pair.privateKey);
+          } catch (e) {
+            callback(e);
+          }
+        };
+        result2.createPublicKey = function createPublicKey(key) {
+          if (typeof key === "string") {
+            if (key.indexOf("-----BEGIN") === -1) {
+              throw new TypeError("error:0900006e:PEM routines:OPENSSL_internal:NO_START_LINE");
+            }
+            return new SandboxKeyObject2("public", key);
+          }
+          if (key && typeof key === "object" && key._pem) {
+            return new SandboxKeyObject2("public", key._pem);
+          }
+          if (key && typeof key === "object" && key.type === "private") {
+            return new SandboxKeyObject2("public", key._pem);
+          }
+          if (key && typeof key === "object" && key.key) {
+            var keyData = typeof key.key === "string" ? key.key : key.key.toString("utf8");
+            return new SandboxKeyObject2("public", keyData);
+          }
+          if (Buffer.isBuffer(key)) {
+            var keyStr = key.toString("utf8");
+            if (keyStr.indexOf("-----BEGIN") === -1) {
+              throw new TypeError("error:0900006e:PEM routines:OPENSSL_internal:NO_START_LINE");
+            }
+            return new SandboxKeyObject2("public", keyStr);
+          }
+          return new SandboxKeyObject2("public", String(key));
+        };
+        result2.createPrivateKey = function createPrivateKey(key) {
+          if (typeof key === "string") {
+            if (key.indexOf("-----BEGIN") === -1) {
+              throw new TypeError("error:0900006e:PEM routines:OPENSSL_internal:NO_START_LINE");
+            }
+            return new SandboxKeyObject2("private", key);
+          }
+          if (key && typeof key === "object" && key._pem) {
+            return new SandboxKeyObject2("private", key._pem);
+          }
+          if (key && typeof key === "object" && key.key) {
+            var keyData = typeof key.key === "string" ? key.key : key.key.toString("utf8");
+            return new SandboxKeyObject2("private", keyData);
+          }
+          if (Buffer.isBuffer(key)) {
+            var keyStr = key.toString("utf8");
+            if (keyStr.indexOf("-----BEGIN") === -1) {
+              throw new TypeError("error:0900006e:PEM routines:OPENSSL_internal:NO_START_LINE");
+            }
+            return new SandboxKeyObject2("private", keyStr);
+          }
+          return new SandboxKeyObject2("private", String(key));
+        };
+        result2.createSecretKey = function createSecretKey(key) {
+          if (typeof key === "string") {
+            return new SandboxKeyObject2("secret", key);
+          }
+          if (Buffer.isBuffer(key) || key instanceof Uint8Array) {
+            return new SandboxKeyObject2("secret", Buffer.from(key).toString("utf8"));
+          }
+          return new SandboxKeyObject2("secret", String(key));
+        };
+        result2.KeyObject = SandboxKeyObject2;
+      }
+      if (typeof _cryptoSubtle !== "undefined") {
+        let SandboxCryptoKey2 = function(keyData) {
+          this.type = keyData.type;
+          this.extractable = keyData.extractable;
+          this.algorithm = keyData.algorithm;
+          this.usages = keyData.usages;
+          this._keyData = keyData;
+        }, toBase642 = function(data) {
+          if (typeof data === "string") return Buffer.from(data).toString("base64");
+          if (data instanceof ArrayBuffer) return Buffer.from(new Uint8Array(data)).toString("base64");
+          if (ArrayBuffer.isView(data)) return Buffer.from(new Uint8Array(data.buffer, data.byteOffset, data.byteLength)).toString("base64");
+          return Buffer.from(data).toString("base64");
+        }, subtleCall2 = function(reqObj) {
+          return _cryptoSubtle.applySync(void 0, [JSON.stringify(reqObj)]);
+        }, normalizeAlgo2 = function(algorithm) {
+          if (typeof algorithm === "string") return { name: algorithm };
+          return algorithm;
+        };
+        var SandboxCryptoKey = SandboxCryptoKey2, toBase64 = toBase642, subtleCall = subtleCall2, normalizeAlgo = normalizeAlgo2;
+        var SandboxSubtle = {};
+        SandboxSubtle.digest = function digest(algorithm, data) {
+          return Promise.resolve().then(function() {
+            var algo = normalizeAlgo2(algorithm);
+            var result22 = JSON.parse(subtleCall2({
+              op: "digest",
+              algorithm: algo.name,
+              data: toBase642(data)
+            }));
+            var buf = Buffer.from(result22.data, "base64");
+            return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+          });
+        };
+        SandboxSubtle.generateKey = function generateKey(algorithm, extractable, keyUsages) {
+          return Promise.resolve().then(function() {
+            var algo = normalizeAlgo2(algorithm);
+            var reqAlgo = Object.assign({}, algo);
+            if (reqAlgo.hash) reqAlgo.hash = normalizeAlgo2(reqAlgo.hash);
+            if (reqAlgo.publicExponent) {
+              reqAlgo.publicExponent = Buffer.from(new Uint8Array(reqAlgo.publicExponent.buffer || reqAlgo.publicExponent)).toString("base64");
+            }
+            var result22 = JSON.parse(subtleCall2({
+              op: "generateKey",
+              algorithm: reqAlgo,
+              extractable,
+              usages: Array.from(keyUsages)
+            }));
+            if (result22.publicKey && result22.privateKey) {
+              return {
+                publicKey: new SandboxCryptoKey2(result22.publicKey),
+                privateKey: new SandboxCryptoKey2(result22.privateKey)
+              };
+            }
+            return new SandboxCryptoKey2(result22.key);
+          });
+        };
+        SandboxSubtle.importKey = function importKey(format, keyData, algorithm, extractable, keyUsages) {
+          return Promise.resolve().then(function() {
+            var algo = normalizeAlgo2(algorithm);
+            var reqAlgo = Object.assign({}, algo);
+            if (reqAlgo.hash) reqAlgo.hash = normalizeAlgo2(reqAlgo.hash);
+            var serializedKeyData;
+            if (format === "jwk") {
+              serializedKeyData = keyData;
+            } else if (format === "raw") {
+              serializedKeyData = toBase642(keyData);
+            } else {
+              serializedKeyData = toBase642(keyData);
+            }
+            var result22 = JSON.parse(subtleCall2({
+              op: "importKey",
+              format,
+              keyData: serializedKeyData,
+              algorithm: reqAlgo,
+              extractable,
+              usages: Array.from(keyUsages)
+            }));
+            return new SandboxCryptoKey2(result22.key);
+          });
+        };
+        SandboxSubtle.exportKey = function exportKey(format, key) {
+          return Promise.resolve().then(function() {
+            var result22 = JSON.parse(subtleCall2({
+              op: "exportKey",
+              format,
+              key: key._keyData
+            }));
+            if (format === "jwk") return result22.jwk;
+            var buf = Buffer.from(result22.data, "base64");
+            return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+          });
+        };
+        SandboxSubtle.encrypt = function encrypt(algorithm, key, data) {
+          return Promise.resolve().then(function() {
+            var algo = normalizeAlgo2(algorithm);
+            var reqAlgo = Object.assign({}, algo);
+            if (reqAlgo.iv) reqAlgo.iv = toBase642(reqAlgo.iv);
+            if (reqAlgo.additionalData) reqAlgo.additionalData = toBase642(reqAlgo.additionalData);
+            var result22 = JSON.parse(subtleCall2({
+              op: "encrypt",
+              algorithm: reqAlgo,
+              key: key._keyData,
+              data: toBase642(data)
+            }));
+            var buf = Buffer.from(result22.data, "base64");
+            return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+          });
+        };
+        SandboxSubtle.decrypt = function decrypt(algorithm, key, data) {
+          return Promise.resolve().then(function() {
+            var algo = normalizeAlgo2(algorithm);
+            var reqAlgo = Object.assign({}, algo);
+            if (reqAlgo.iv) reqAlgo.iv = toBase642(reqAlgo.iv);
+            if (reqAlgo.additionalData) reqAlgo.additionalData = toBase642(reqAlgo.additionalData);
+            var result22 = JSON.parse(subtleCall2({
+              op: "decrypt",
+              algorithm: reqAlgo,
+              key: key._keyData,
+              data: toBase642(data)
+            }));
+            var buf = Buffer.from(result22.data, "base64");
+            return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+          });
+        };
+        SandboxSubtle.deriveBits = function deriveBits(algorithm, baseKey, length) {
+          return Promise.resolve().then(function() {
+            var algo = normalizeAlgo2(algorithm);
+            var reqAlgo = Object.assign({}, algo);
+            if (reqAlgo.hash) reqAlgo.hash = normalizeAlgo2(reqAlgo.hash);
+            if (reqAlgo.salt) reqAlgo.salt = toBase642(reqAlgo.salt);
+            var result22 = JSON.parse(subtleCall2({
+              op: "deriveBits",
+              algorithm: reqAlgo,
+              key: baseKey._keyData,
+              length
+            }));
+            var buf = Buffer.from(result22.data, "base64");
+            return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+          });
+        };
+        SandboxSubtle.sign = function sign(algorithm, key, data) {
+          return Promise.resolve().then(function() {
+            var result22 = JSON.parse(subtleCall2({
+              op: "sign",
+              algorithm: normalizeAlgo2(algorithm),
+              key: key._keyData,
+              data: toBase642(data)
+            }));
+            var buf = Buffer.from(result22.data, "base64");
+            return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+          });
+        };
+        SandboxSubtle.verify = function verify(algorithm, key, signature, data) {
+          return Promise.resolve().then(function() {
+            var result22 = JSON.parse(subtleCall2({
+              op: "verify",
+              algorithm: normalizeAlgo2(algorithm),
+              key: key._keyData,
+              signature: toBase642(signature),
+              data: toBase642(data)
+            }));
+            return result22.result;
+          });
+        };
+        result2.subtle = SandboxSubtle;
+        result2.webcrypto = { subtle: SandboxSubtle, getRandomValues: result2.randomFillSync };
+      }
+      if (typeof result2.getCurves !== "function") {
+        result2.getCurves = function getCurves() {
+          return [
+            "prime256v1",
+            "secp256r1",
+            "secp384r1",
+            "secp521r1",
+            "secp256k1",
+            "secp224r1",
+            "secp192k1"
+          ];
+        };
+      }
+      if (typeof result2.getCiphers !== "function") {
+        result2.getCiphers = function getCiphers() {
+          return [
+            "aes-128-cbc",
+            "aes-128-gcm",
+            "aes-192-cbc",
+            "aes-192-gcm",
+            "aes-256-cbc",
+            "aes-256-gcm",
+            "aes-128-ctr",
+            "aes-192-ctr",
+            "aes-256-ctr"
+          ];
+        };
+      }
+      if (typeof result2.getHashes !== "function") {
+        result2.getHashes = function getHashes() {
+          return ["md5", "sha1", "sha256", "sha384", "sha512"];
+        };
+      }
+      if (typeof result2.timingSafeEqual !== "function") {
+        result2.timingSafeEqual = function timingSafeEqual(a, b) {
+          if (a.length !== b.length) {
+            throw new RangeError("Input buffers must have the same byte length");
+          }
+          var out = 0;
+          for (var i = 0; i < a.length; i++) {
+            out |= a[i] ^ b[i];
+          }
+          return out === 0;
+        };
+      }
+      return result2;
+    }
+    if (name2 === "stream") {
+      if (typeof result2 === "function" && result2.prototype && typeof result2.Readable === "function") {
+        var readableProto = result2.Readable.prototype;
+        var streamProto = result2.prototype;
+        if (readableProto && streamProto && !(readableProto instanceof result2)) {
+          var currentParent = Object.getPrototypeOf(readableProto);
+          Object.setPrototypeOf(streamProto, currentParent);
+          Object.setPrototypeOf(readableProto, streamProto);
+        }
+      }
+      return result2;
+    }
     if (name2 === "path") {
       if (result2.win32 === null || result2.win32 === void 0) {
         result2.win32 = result2.posix || result2;
@@ -230,7 +1124,6 @@
     return result2;
   }
   var _deferredCoreModules = /* @__PURE__ */ new Set([
-    "net",
     "tls",
     "readline",
     "perf_hooks",
@@ -275,8 +1168,25 @@
     return _requireFrom(moduleName2, _currentModule.dirname);
   };
   __requireExposeCustomGlobal("require", __require);
+  var _resolveCache = /* @__PURE__ */ Object.create(null);
   function _resolveFrom(moduleName2, fromDir2) {
-    const resolved2 = _resolveModule(moduleName2, fromDir2);
+    const cacheKey2 = fromDir2 + "\0" + moduleName2;
+    if (cacheKey2 in _resolveCache) {
+      const cached = _resolveCache[cacheKey2];
+      if (cached === null) {
+        const err = new Error("Cannot find module '" + moduleName2 + "'");
+        err.code = "MODULE_NOT_FOUND";
+        throw err;
+      }
+      return cached;
+    }
+    let resolved2;
+    if (typeof _resolveModuleSync !== "undefined") {
+      resolved2 = _resolveModuleSync.applySync(void 0, [moduleName2, fromDir2]);
+    } else {
+      resolved2 = _resolveModule.applySyncPromise(void 0, [moduleName2, fromDir2]);
+    }
+    _resolveCache[cacheKey2] = resolved2;
     if (resolved2 === null) {
       const err = new Error("Cannot find module '" + moduleName2 + "'");
       err.code = "MODULE_NOT_FOUND";
@@ -405,6 +1315,18 @@
       _debugRequire("loaded", name, "dns-special");
       return _dnsModule;
     }
+    if (name === "net") {
+      if (__internalModuleCache["net"]) return __internalModuleCache["net"];
+      __internalModuleCache["net"] = _netModule;
+      _debugRequire("loaded", name, "net-special");
+      return _netModule;
+    }
+    if (name === "tls") {
+      if (__internalModuleCache["tls"]) return __internalModuleCache["tls"];
+      __internalModuleCache["tls"] = _tlsModule;
+      _debugRequire("loaded", name, "tls-special");
+      return _tlsModule;
+    }
     if (name === "os") {
       if (__internalModuleCache["os"]) return __internalModuleCache["os"];
       __internalModuleCache["os"] = _osModule;
@@ -522,7 +1444,19 @@
             end: _createChannel2(),
             asyncStart: _createChannel2(),
             asyncEnd: _createChannel2(),
-            error: _createChannel2()
+            error: _createChannel2(),
+            traceSync: function(fn, context, thisArg) {
+              var args = Array.prototype.slice.call(arguments, 3);
+              return fn.apply(thisArg, args);
+            },
+            tracePromise: function(fn, context, thisArg) {
+              var args = Array.prototype.slice.call(arguments, 3);
+              return fn.apply(thisArg, args);
+            },
+            traceCallback: function(fn, context, thisArg) {
+              var args = Array.prototype.slice.call(arguments, 3);
+              return fn.apply(thisArg, args);
+            }
           };
         },
         Channel: function Channel(name2) {
@@ -549,7 +1483,12 @@
     if (_unsupportedCoreModules.has(name)) {
       throw new Error(name + " is not supported in sandbox");
     }
-    const polyfillCode = _loadPolyfill(name);
+    if (__internalModuleCache[name]) {
+      _debugRequire("name-cache-hit", name, name);
+      return __internalModuleCache[name];
+    }
+    const isPath = name[0] === "." || name[0] === "/";
+    const polyfillCode = isPath ? null : _loadPolyfill.applySyncPromise(void 0, [name]);
     if (polyfillCode !== null) {
       if (__internalModuleCache[name]) return __internalModuleCache[name];
       const moduleObj = { exports: {} };
@@ -566,6 +1505,14 @@
       _debugRequire("loaded", name, "polyfill");
       return __internalModuleCache[name];
     }
+    const resolveCacheKey = fromDir + "\0" + name;
+    if (resolveCacheKey in _resolveCache) {
+      const cachedPath = _resolveCache[resolveCacheKey];
+      if (cachedPath !== null && __internalModuleCache[cachedPath]) {
+        _debugRequire("resolve-cache-hit", name, cachedPath);
+        return __internalModuleCache[cachedPath];
+      }
+    }
     resolved = _resolveFrom(name, fromDir);
     cacheKey = resolved;
     if (__internalModuleCache[cacheKey]) {
@@ -576,7 +1523,12 @@
       _debugRequire("pending-hit", name, cacheKey);
       return _pendingModules[cacheKey].exports;
     }
-    const source = _loadFile(resolved);
+    let source;
+    if (typeof _loadFileSync !== "undefined") {
+      source = _loadFileSync.applySync(void 0, [resolved]);
+    } else {
+      source = _loadFile.applySyncPromise(void 0, [resolved]);
+    }
     if (source === null) {
       const err = new Error("Cannot find module '" + resolved + "'");
       err.code = "MODULE_NOT_FOUND";
@@ -642,6 +1594,9 @@
       _currentModule = prevModule;
     }
     __internalModuleCache[cacheKey] = module.exports;
+    if (!isPath && name !== cacheKey) {
+      __internalModuleCache[name] = module.exports;
+    }
     delete _pendingModules[cacheKey];
     _debugRequire("loaded", name, cacheKey);
     return module.exports;