@secure-exec/core 0.2.0-rc.1 → 0.2.0-rc.2

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

@@ -1,14 +1,54 @@
 "use strict";
 (() => {
   // ../core/isolate-runtime/src/inject/require-setup.ts
-  var __requireExposeCustomGlobal = typeof globalThis.__runtimeExposeCustomGlobal === "function" ? globalThis.__runtimeExposeCustomGlobal : function exposeCustomGlobal(name2, value) {
-    Object.defineProperty(globalThis, name2, {
+  var REQUIRE_TRANSFORM_MARKER = "/*__secure_exec_require_esm__*/";
+  var __requireExposeCustomGlobal = typeof globalThis.__runtimeExposeCustomGlobal === "function" ? globalThis.__runtimeExposeCustomGlobal : function exposeCustomGlobal(name, value) {
+    Object.defineProperty(globalThis, name, {
       value,
       writable: false,
       configurable: false,
       enumerable: true
     });
   };
+  if (typeof globalThis.global === "undefined") {
+    globalThis.global = globalThis;
+  }
+  if (typeof globalThis.RegExp === "function" && !globalThis.RegExp.__secureExecRgiEmojiCompat) {
+    const NativeRegExp = globalThis.RegExp;
+    const RGI_EMOJI_PATTERN = "^\\p{RGI_Emoji}$";
+    const RGI_EMOJI_BASE_CLASS = "[\\u{00A9}\\u{00AE}\\u{203C}\\u{2049}\\u{2122}\\u{2139}\\u{2194}-\\u{21AA}\\u{231A}-\\u{23FF}\\u{24C2}\\u{25AA}-\\u{27BF}\\u{2934}-\\u{2935}\\u{2B05}-\\u{2B55}\\u{3030}\\u{303D}\\u{3297}\\u{3299}\\u{1F000}-\\u{1FAFF}]";
+    const RGI_EMOJI_KEYCAP = "[#*0-9]\\uFE0F?\\u20E3";
+    const RGI_EMOJI_FALLBACK_SOURCE = "^(?:" + RGI_EMOJI_KEYCAP + "|\\p{Regional_Indicator}{2}|" + RGI_EMOJI_BASE_CLASS + "(?:\\uFE0F|\\u200D(?:" + RGI_EMOJI_KEYCAP + "|" + RGI_EMOJI_BASE_CLASS + ")|[\\u{1F3FB}-\\u{1F3FF}])*)$";
+    try {
+      new NativeRegExp(RGI_EMOJI_PATTERN, "v");
+    } catch (error) {
+      if (String(error && error.message || error).includes("RGI_Emoji")) {
+        let CompatRegExp = function(pattern, flags) {
+          const normalizedPattern = pattern instanceof NativeRegExp && flags === void 0 ? pattern.source : String(pattern);
+          const normalizedFlags = flags === void 0 ? pattern instanceof NativeRegExp ? pattern.flags : "" : String(flags);
+          try {
+            return new NativeRegExp(pattern, flags);
+          } catch (innerError) {
+            if (normalizedPattern === RGI_EMOJI_PATTERN && normalizedFlags === "v") {
+              return new NativeRegExp(RGI_EMOJI_FALLBACK_SOURCE, "u");
+            }
+            throw innerError;
+          }
+        };
+        CompatRegExp2 = CompatRegExp;
+        Object.setPrototypeOf(CompatRegExp, NativeRegExp);
+        CompatRegExp.prototype = NativeRegExp.prototype;
+        Object.defineProperty(CompatRegExp.prototype, "constructor", {
+          value: CompatRegExp,
+          writable: true,
+          configurable: true
+        });
+        CompatRegExp.__secureExecRgiEmojiCompat = true;
+        globalThis.RegExp = CompatRegExp;
+      }
+    }
+  }
+  var CompatRegExp2;
   if (typeof globalThis.AbortController === "undefined" || typeof globalThis.AbortSignal === "undefined" || typeof globalThis.AbortSignal?.prototype?.addEventListener !== "function" || typeof globalThis.AbortSignal?.prototype?.removeEventListener !== "function") {
     let getAbortSignalState = function(signal) {
       const state = abortSignalState.get(signal);
@@ -94,6 +134,60 @@
       return controller.signal;
     };
   }
+  if (typeof globalThis.AbortSignal === "function" && typeof globalThis.AbortController === "function" && typeof globalThis.AbortSignal.timeout !== "function") {
+    globalThis.AbortSignal.timeout = function timeout(milliseconds) {
+      var delay = Number(milliseconds);
+      if (!Number.isFinite(delay) || delay < 0) {
+        throw new RangeError('The value of "milliseconds" is out of range. It must be a finite, non-negative number.');
+      }
+      var controller = new globalThis.AbortController();
+      var timer = setTimeout(function() {
+        controller.abort(
+          new globalThis.DOMException(
+            "The operation was aborted due to timeout",
+            "TimeoutError"
+          )
+        );
+      }, delay);
+      if (timer && typeof timer.unref === "function") {
+        timer.unref();
+      }
+      return controller.signal;
+    };
+  }
+  if (typeof globalThis.AbortSignal === "function" && typeof globalThis.AbortController === "function" && typeof globalThis.AbortSignal.any !== "function") {
+    globalThis.AbortSignal.any = function any(signals) {
+      if (signals === null || signals === void 0 || typeof signals[Symbol.iterator] !== "function") {
+        throw new TypeError('The "signals" argument must be an iterable.');
+      }
+      var controller = new globalThis.AbortController();
+      var cleanup = [];
+      var abortFromSignal = function abortFromSignal2(signal) {
+        for (var index = 0; index < cleanup.length; index += 1) {
+          cleanup[index]();
+        }
+        cleanup.length = 0;
+        controller.abort(signal.reason);
+      };
+      for (const signal of signals) {
+        if (!signal || typeof signal.aborted !== "boolean" || typeof signal.addEventListener !== "function" || typeof signal.removeEventListener !== "function") {
+          throw new TypeError('The "signals" argument must contain only AbortSignal instances.');
+        }
+        if (signal.aborted) {
+          abortFromSignal(signal);
+          break;
+        }
+        var listener = function() {
+          abortFromSignal(signal);
+        };
+        signal.addEventListener("abort", listener, { once: true });
+        cleanup.push(function() {
+          signal.removeEventListener("abort", listener);
+        });
+      }
+      return controller.signal;
+    };
+  }
   if (typeof globalThis.structuredClone !== "function") {
     let structuredClonePolyfill = function(value) {
       if (value === null || typeof value !== "object") {
@@ -134,58 +228,851 @@
     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
+  (function installWhatwgEncodingAndEvents() {
+    function _withCode(error, code) {
+      error.code = code;
+      return error;
+    }
+    function _trimAsciiWhitespace(value) {
+      return value.replace(/^[\t\n\f\r ]+|[\t\n\f\r ]+$/g, "");
+    }
+    function _normalizeEncodingLabel(label) {
+      var normalized = _trimAsciiWhitespace(
+        label === void 0 ? "utf-8" : String(label)
+      ).toLowerCase();
+      switch (normalized) {
+        case "utf-8":
+        case "utf8":
+        case "unicode-1-1-utf-8":
+        case "unicode11utf8":
+        case "unicode20utf8":
+        case "x-unicode20utf8":
+          return "utf-8";
+        case "utf-16":
+        case "utf-16le":
+        case "ucs-2":
+        case "ucs2":
+        case "csunicode":
+        case "iso-10646-ucs-2":
+        case "unicode":
+        case "unicodefeff":
+          return "utf-16le";
+        case "utf-16be":
+        case "unicodefffe":
+          return "utf-16be";
+        default:
+          throw _withCode(
+            new RangeError('The "' + normalized + '" encoding is not supported'),
+            "ERR_ENCODING_NOT_SUPPORTED"
+          );
+      }
+    }
+    function _toUint8Array(input) {
+      if (input === void 0) {
+        return new Uint8Array(0);
+      }
+      if (ArrayBuffer.isView(input)) {
+        return new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+      }
+      if (input instanceof ArrayBuffer) {
+        return new Uint8Array(input);
+      }
+      if (typeof SharedArrayBuffer !== "undefined" && input instanceof SharedArrayBuffer) {
+        return new Uint8Array(input);
+      }
+      throw _withCode(
+        new TypeError(
+          'The "input" argument must be an instance of ArrayBuffer, SharedArrayBuffer, or ArrayBufferView.'
+        ),
+        "ERR_INVALID_ARG_TYPE"
+      );
+    }
+    function _encodeUtf8ScalarValue(codePoint, bytes) {
+      if (codePoint <= 127) {
+        bytes.push(codePoint);
+        return;
+      }
+      if (codePoint <= 2047) {
+        bytes.push(192 | codePoint >> 6, 128 | codePoint & 63);
+        return;
+      }
+      if (codePoint <= 65535) {
+        bytes.push(
+          224 | codePoint >> 12,
+          128 | codePoint >> 6 & 63,
+          128 | codePoint & 63
+        );
+        return;
+      }
+      bytes.push(
+        240 | codePoint >> 18,
+        128 | codePoint >> 12 & 63,
+        128 | codePoint >> 6 & 63,
+        128 | codePoint & 63
+      );
+    }
+    function _encodeUtf8(input) {
+      var value = String(input === void 0 ? "" : input);
+      var bytes = [];
+      for (var index = 0; index < value.length; index += 1) {
+        var codeUnit = value.charCodeAt(index);
+        if (codeUnit >= 55296 && codeUnit <= 56319) {
+          var nextIndex = index + 1;
+          if (nextIndex < value.length) {
+            var nextCodeUnit = value.charCodeAt(nextIndex);
+            if (nextCodeUnit >= 56320 && nextCodeUnit <= 57343) {
+              _encodeUtf8ScalarValue(
+                65536 + (codeUnit - 55296 << 10) + (nextCodeUnit - 56320),
+                bytes
+              );
+              index = nextIndex;
+              continue;
+            }
+          }
+          _encodeUtf8ScalarValue(65533, bytes);
+          continue;
+        }
+        if (codeUnit >= 56320 && codeUnit <= 57343) {
+          _encodeUtf8ScalarValue(65533, bytes);
+          continue;
+        }
+        _encodeUtf8ScalarValue(codeUnit, bytes);
+      }
+      return new Uint8Array(bytes);
+    }
+    function _appendCodePoint(output, codePoint) {
+      if (codePoint <= 65535) {
+        output.push(String.fromCharCode(codePoint));
+        return;
+      }
+      var adjusted = codePoint - 65536;
+      output.push(
+        String.fromCharCode(55296 + (adjusted >> 10)),
+        String.fromCharCode(56320 + (adjusted & 1023))
+      );
+    }
+    function _isContinuationByte(value) {
+      return value >= 128 && value <= 191;
+    }
+    function _createInvalidDataError(encoding) {
+      return _withCode(
+        new TypeError("The encoded data was not valid for encoding " + encoding),
+        "ERR_ENCODING_INVALID_ENCODED_DATA"
+      );
+    }
+    function _decodeUtf8(bytes, fatal, stream, encoding) {
+      var output = [];
+      for (var index = 0; index < bytes.length; ) {
+        var first = bytes[index];
+        if (first <= 127) {
+          output.push(String.fromCharCode(first));
+          index += 1;
+          continue;
+        }
+        var needed = 0;
+        var codePoint = 0;
+        if (first >= 194 && first <= 223) {
+          needed = 1;
+          codePoint = first & 31;
+        } else if (first >= 224 && first <= 239) {
+          needed = 2;
+          codePoint = first & 15;
+        } else if (first >= 240 && first <= 244) {
+          needed = 3;
+          codePoint = first & 7;
+        } else {
+          if (fatal) throw _createInvalidDataError(encoding);
+          output.push("\uFFFD");
+          index += 1;
+          continue;
+        }
+        if (index + needed >= bytes.length) {
+          if (stream) {
+            return { text: output.join(""), pending: Array.from(bytes.slice(index)) };
+          }
+          if (fatal) throw _createInvalidDataError(encoding);
+          output.push("\uFFFD");
+          break;
+        }
+        var second = bytes[index + 1];
+        if (!_isContinuationByte(second)) {
+          if (fatal) throw _createInvalidDataError(encoding);
+          output.push("\uFFFD");
+          index += 1;
+          continue;
+        }
+        if (first === 224 && second < 160 || first === 237 && second > 159 || first === 240 && second < 144 || first === 244 && second > 143) {
+          if (fatal) throw _createInvalidDataError(encoding);
+          output.push("\uFFFD");
+          index += 1;
+          continue;
+        }
+        codePoint = codePoint << 6 | second & 63;
+        if (needed >= 2) {
+          var third = bytes[index + 2];
+          if (!_isContinuationByte(third)) {
+            if (fatal) throw _createInvalidDataError(encoding);
+            output.push("\uFFFD");
+            index += 1;
+            continue;
+          }
+          codePoint = codePoint << 6 | third & 63;
+        }
+        if (needed === 3) {
+          var fourth = bytes[index + 3];
+          if (!_isContinuationByte(fourth)) {
+            if (fatal) throw _createInvalidDataError(encoding);
+            output.push("\uFFFD");
+            index += 1;
+            continue;
+          }
+          codePoint = codePoint << 6 | fourth & 63;
+        }
+        if (codePoint >= 55296 && codePoint <= 57343) {
+          if (fatal) throw _createInvalidDataError(encoding);
+          output.push("\uFFFD");
+          index += needed + 1;
+          continue;
+        }
+        _appendCodePoint(output, codePoint);
+        index += needed + 1;
+      }
+      return { text: output.join(""), pending: [] };
+    }
+    function _decodeUtf16(bytes, encoding, fatal, stream, bomSeen) {
+      var output = [];
+      var endian = encoding === "utf-16be" ? "be" : "le";
+      if (!bomSeen && encoding === "utf-16le" && bytes.length >= 2) {
+        if (bytes[0] === 254 && bytes[1] === 255) {
+          endian = "be";
+        }
+      }
+      for (var index = 0; index < bytes.length; ) {
+        if (index + 1 >= bytes.length) {
+          if (stream) {
+            return { text: output.join(""), pending: Array.from(bytes.slice(index)) };
+          }
+          if (fatal) throw _createInvalidDataError(encoding);
+          output.push("\uFFFD");
+          break;
+        }
+        var first = bytes[index];
+        var second = bytes[index + 1];
+        var codeUnit = endian === "le" ? first | second << 8 : first << 8 | second;
+        index += 2;
+        if (codeUnit >= 55296 && codeUnit <= 56319) {
+          if (index + 1 >= bytes.length) {
+            if (stream) {
+              return { text: output.join(""), pending: Array.from(bytes.slice(index - 2)) };
+            }
+            if (fatal) throw _createInvalidDataError(encoding);
+            output.push("\uFFFD");
+            continue;
+          }
+          var nextFirst = bytes[index];
+          var nextSecond = bytes[index + 1];
+          var nextCodeUnit = endian === "le" ? nextFirst | nextSecond << 8 : nextFirst << 8 | nextSecond;
+          if (nextCodeUnit >= 56320 && nextCodeUnit <= 57343) {
+            _appendCodePoint(
+              output,
+              65536 + (codeUnit - 55296 << 10) + (nextCodeUnit - 56320)
+            );
+            index += 2;
+            continue;
+          }
+          if (fatal) throw _createInvalidDataError(encoding);
+          output.push("\uFFFD");
+          continue;
+        }
+        if (codeUnit >= 56320 && codeUnit <= 57343) {
+          if (fatal) throw _createInvalidDataError(encoding);
+          output.push("\uFFFD");
+          continue;
+        }
+        output.push(String.fromCharCode(codeUnit));
+      }
+      return { text: output.join(""), pending: [] };
+    }
+    function TextEncoder() {
+    }
+    TextEncoder.prototype.encode = function encode(input) {
+      return _encodeUtf8(input === void 0 ? "" : input);
     };
-    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);
+    TextEncoder.prototype.encodeInto = function encodeInto(input, destination) {
+      var value = String(input);
+      var read = 0;
+      var written = 0;
+      for (var index = 0; index < value.length; index += 1) {
+        var codeUnit = value.charCodeAt(index);
+        var chunk = value[index] || "";
+        if (codeUnit >= 55296 && codeUnit <= 56319 && index + 1 < value.length) {
+          var nextCodeUnit = value.charCodeAt(index + 1);
+          if (nextCodeUnit >= 56320 && nextCodeUnit <= 57343) {
+            chunk = value.slice(index, index + 2);
+          }
+        }
+        var encoded = _encodeUtf8(chunk);
+        if (written + encoded.length > destination.length) break;
+        destination.set(encoded, written);
+        written += encoded.length;
+        read += chunk.length;
+        if (chunk.length === 2) index += 1;
       }
-      return new _OrigTextDecoder(encoding, options);
+      return { read, written };
     };
-    globalThis.TextDecoder.prototype = _OrigTextDecoder.prototype;
-  }
-  var _OrigTextDecoder;
-  var _utf8Aliases;
-  function _patchPolyfill(name2, result2) {
-    if (typeof result2 !== "object" && typeof result2 !== "function" || result2 === null) {
-      return result2;
+    Object.defineProperty(TextEncoder.prototype, "encoding", {
+      get: function() {
+        return "utf-8";
+      }
+    });
+    function TextDecoder(label, options) {
+      var normalizedOptions = options == null ? {} : Object(options);
+      this._encoding = _normalizeEncodingLabel(label);
+      this._fatal = Boolean(normalizedOptions.fatal);
+      this._ignoreBOM = Boolean(normalizedOptions.ignoreBOM);
+      this._pendingBytes = [];
+      this._bomSeen = false;
     }
-    if (name2 === "buffer") {
-      const maxLength = typeof result2.kMaxLength === "number" ? result2.kMaxLength : 2147483647;
-      const maxStringLength = typeof result2.kStringMaxLength === "number" ? result2.kStringMaxLength : 536870888;
-      if (typeof result2.constants !== "object" || result2.constants === null) {
-        result2.constants = {};
+    Object.defineProperty(TextDecoder.prototype, "encoding", {
+      get: function() {
+        return this._encoding;
+      }
+    });
+    Object.defineProperty(TextDecoder.prototype, "fatal", {
+      get: function() {
+        return this._fatal;
+      }
+    });
+    Object.defineProperty(TextDecoder.prototype, "ignoreBOM", {
+      get: function() {
+        return this._ignoreBOM;
       }
-      if (typeof result2.constants.MAX_LENGTH !== "number") {
-        result2.constants.MAX_LENGTH = maxLength;
+    });
+    TextDecoder.prototype.decode = function decode(input, options) {
+      var normalizedOptions = options == null ? {} : Object(options);
+      var stream = Boolean(normalizedOptions.stream);
+      var incoming = _toUint8Array(input);
+      var merged = new Uint8Array(this._pendingBytes.length + incoming.length);
+      merged.set(this._pendingBytes, 0);
+      merged.set(incoming, this._pendingBytes.length);
+      var decoded = this._encoding === "utf-8" ? _decodeUtf8(merged, this._fatal, stream, this._encoding) : _decodeUtf16(merged, this._encoding, this._fatal, stream, this._bomSeen);
+      this._pendingBytes = decoded.pending;
+      var text = decoded.text;
+      if (!this._bomSeen && text.length > 0) {
+        if (!this._ignoreBOM && text.charCodeAt(0) === 65279) {
+          text = text.slice(1);
+        }
+        this._bomSeen = true;
+      }
+      if (!stream && this._pendingBytes.length > 0) {
+        var pendingLength = this._pendingBytes.length;
+        this._pendingBytes = [];
+        if (this._fatal) throw _createInvalidDataError(this._encoding);
+        return text + "\uFFFD".repeat(Math.ceil(pendingLength / 2));
+      }
+      return text;
+    };
+    function _normalizeAddEventListenerOptions(options) {
+      if (typeof options === "boolean") {
+        return { capture: options, once: false, passive: false };
+      }
+      if (options == null) {
+        return { capture: false, once: false, passive: false };
+      }
+      var normalized = Object(options);
+      return {
+        capture: Boolean(normalized.capture),
+        once: Boolean(normalized.once),
+        passive: Boolean(normalized.passive),
+        signal: normalized.signal
+      };
+    }
+    function _normalizeRemoveEventListenerOptions(options) {
+      if (typeof options === "boolean") return options;
+      if (options == null) return false;
+      return Boolean(Object(options).capture);
+    }
+    function _isAbortSignalLike(value) {
+      return typeof value === "object" && value !== null && "aborted" in value && typeof value.addEventListener === "function" && typeof value.removeEventListener === "function";
+    }
+    function Event(type, init) {
+      if (arguments.length === 0) {
+        throw new TypeError("The event type must be provided");
       }
-      if (typeof result2.constants.MAX_STRING_LENGTH !== "number") {
-        result2.constants.MAX_STRING_LENGTH = maxStringLength;
+      var normalizedInit = init == null ? {} : Object(init);
+      this.type = String(type);
+      this.bubbles = Boolean(normalizedInit.bubbles);
+      this.cancelable = Boolean(normalizedInit.cancelable);
+      this.composed = Boolean(normalizedInit.composed);
+      this.detail = null;
+      this.defaultPrevented = false;
+      this.target = null;
+      this.currentTarget = null;
+      this.eventPhase = 0;
+      this.returnValue = true;
+      this.cancelBubble = false;
+      this.timeStamp = Date.now();
+      this.isTrusted = false;
+      this.srcElement = null;
+      this._inPassiveListener = false;
+      this._propagationStopped = false;
+      this._immediatePropagationStopped = false;
+    }
+    Event.NONE = 0;
+    Event.CAPTURING_PHASE = 1;
+    Event.AT_TARGET = 2;
+    Event.BUBBLING_PHASE = 3;
+    Event.prototype.preventDefault = function preventDefault() {
+      if (this.cancelable && !this._inPassiveListener) {
+        this.defaultPrevented = true;
+        this.returnValue = false;
       }
-      if (typeof result2.kMaxLength !== "number") {
-        result2.kMaxLength = maxLength;
+    };
+    Event.prototype.stopPropagation = function stopPropagation() {
+      this._propagationStopped = true;
+      this.cancelBubble = true;
+    };
+    Event.prototype.stopImmediatePropagation = function stopImmediatePropagation() {
+      this._propagationStopped = true;
+      this._immediatePropagationStopped = true;
+      this.cancelBubble = true;
+    };
+    Event.prototype.composedPath = function composedPath() {
+      return this.target ? [this.target] : [];
+    };
+    function CustomEvent(type, init) {
+      Event.call(this, type, init);
+      var normalizedInit = init == null ? null : Object(init);
+      this.detail = normalizedInit && "detail" in normalizedInit ? normalizedInit.detail : null;
+    }
+    CustomEvent.prototype = Object.create(Event.prototype);
+    CustomEvent.prototype.constructor = CustomEvent;
+    function EventTarget() {
+      this._listeners = /* @__PURE__ */ new Map();
+    }
+    EventTarget.prototype.addEventListener = function addEventListener(type, listener, options) {
+      var normalized = _normalizeAddEventListenerOptions(options);
+      if (normalized.signal !== void 0 && !_isAbortSignalLike(normalized.signal)) {
+        throw new TypeError('The "signal" option must be an instance of AbortSignal.');
       }
-      if (typeof result2.kStringMaxLength !== "number") {
-        result2.kStringMaxLength = maxStringLength;
+      if (listener == null) return void 0;
+      if (typeof listener !== "function" && (typeof listener !== "object" || listener === null)) {
+        return void 0;
+      }
+      if (normalized.signal && normalized.signal.aborted) return void 0;
+      var records = this._listeners.get(type) || [];
+      for (var i = 0; i < records.length; i += 1) {
+        if (records[i].listener === listener && records[i].capture === normalized.capture) {
+          return void 0;
+        }
+      }
+      var record = {
+        listener,
+        capture: normalized.capture,
+        once: normalized.once,
+        passive: normalized.passive,
+        kind: typeof listener === "function" ? "function" : "object",
+        signal: normalized.signal,
+        abortListener: void 0
+      };
+      if (normalized.signal) {
+        var self = this;
+        record.abortListener = function() {
+          self.removeEventListener(type, listener, normalized.capture);
+        };
+        normalized.signal.addEventListener("abort", record.abortListener, { once: true });
+      }
+      records.push(record);
+      this._listeners.set(type, records);
+      return void 0;
+    };
+    EventTarget.prototype.removeEventListener = function removeEventListener(type, listener, options) {
+      if (listener == null) return;
+      var capture = _normalizeRemoveEventListenerOptions(options);
+      var records = this._listeners.get(type);
+      if (!records) return;
+      var nextRecords = [];
+      for (var i = 0; i < records.length; i += 1) {
+        var record = records[i];
+        var match = record.listener === listener && record.capture === capture;
+        if (match) {
+          if (record.signal && record.abortListener) {
+            record.signal.removeEventListener("abort", record.abortListener);
+          }
+        } else {
+          nextRecords.push(record);
+        }
+      }
+      if (nextRecords.length === 0) {
+        this._listeners.delete(type);
+      } else {
+        this._listeners.set(type, nextRecords);
+      }
+    };
+    EventTarget.prototype.dispatchEvent = function dispatchEvent(event) {
+      if (!event || typeof event !== "object" || typeof event.type !== "string") {
+        throw new TypeError("Argument 1 must be an Event");
+      }
+      var records = (this._listeners.get(event.type) || []).slice();
+      event.target = this;
+      event.currentTarget = this;
+      event.eventPhase = 2;
+      for (var i = 0; i < records.length; i += 1) {
+        var record = records[i];
+        var active = this._listeners.get(event.type);
+        if (!active || active.indexOf(record) === -1) continue;
+        if (record.once) {
+          this.removeEventListener(event.type, record.listener, record.capture);
+        }
+        event._inPassiveListener = record.passive;
+        if (record.kind === "function") {
+          record.listener.call(this, event);
+        } else {
+          var handleEvent = record.listener.handleEvent;
+          if (typeof handleEvent === "function") {
+            handleEvent.call(record.listener, event);
+          }
+        }
+        event._inPassiveListener = false;
+        if (event._immediatePropagationStopped || event._propagationStopped) {
+          break;
+        }
+      }
+      event.currentTarget = null;
+      event.eventPhase = 0;
+      return !event.defaultPrevented;
+    };
+    globalThis.TextEncoder = TextEncoder;
+    globalThis.TextDecoder = TextDecoder;
+    globalThis.Event = Event;
+    globalThis.CustomEvent = CustomEvent;
+    globalThis.EventTarget = EventTarget;
+    if (typeof globalThis.DOMException === "undefined") {
+      let DOMException3 = function(message, name) {
+        if (!(this instanceof DOMException3)) {
+          throw new TypeError("Class constructor DOMException cannot be invoked without 'new'");
+        }
+        Error.call(this, message);
+        this.message = message === void 0 ? "" : String(message);
+        this.name = name === void 0 ? "Error" : String(name);
+        this.code = DOM_EXCEPTION_LEGACY_CODES[this.name] || 0;
+        if (typeof Error.captureStackTrace === "function") {
+          Error.captureStackTrace(this, DOMException3);
+        }
+      };
+      var DOMException2 = DOMException3;
+      var DOM_EXCEPTION_LEGACY_CODES = {
+        IndexSizeError: 1,
+        DOMStringSizeError: 2,
+        HierarchyRequestError: 3,
+        WrongDocumentError: 4,
+        InvalidCharacterError: 5,
+        NoDataAllowedError: 6,
+        NoModificationAllowedError: 7,
+        NotFoundError: 8,
+        NotSupportedError: 9,
+        InUseAttributeError: 10,
+        InvalidStateError: 11,
+        SyntaxError: 12,
+        InvalidModificationError: 13,
+        NamespaceError: 14,
+        InvalidAccessError: 15,
+        ValidationError: 16,
+        TypeMismatchError: 17,
+        SecurityError: 18,
+        NetworkError: 19,
+        AbortError: 20,
+        URLMismatchError: 21,
+        QuotaExceededError: 22,
+        TimeoutError: 23,
+        InvalidNodeTypeError: 24,
+        DataCloneError: 25
+      };
+      DOMException3.prototype = Object.create(Error.prototype);
+      Object.defineProperty(DOMException3.prototype, "constructor", {
+        value: DOMException3,
+        writable: true,
+        configurable: true
+      });
+      Object.defineProperty(DOMException3.prototype, Symbol.toStringTag, {
+        value: "DOMException",
+        writable: false,
+        enumerable: false,
+        configurable: true
+      });
+      for (var codeName in DOM_EXCEPTION_LEGACY_CODES) {
+        if (!Object.prototype.hasOwnProperty.call(DOM_EXCEPTION_LEGACY_CODES, codeName)) {
+          continue;
+        }
+        var codeValue = DOM_EXCEPTION_LEGACY_CODES[codeName];
+        var constantName = codeName.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toUpperCase();
+        Object.defineProperty(DOMException3, constantName, {
+          value: codeValue,
+          writable: false,
+          enumerable: true,
+          configurable: false
+        });
+        Object.defineProperty(DOMException3.prototype, constantName, {
+          value: codeValue,
+          writable: false,
+          enumerable: true,
+          configurable: false
+        });
+      }
+      __requireExposeCustomGlobal("DOMException", DOMException3);
+    }
+    if (typeof globalThis.Blob === "undefined") {
+      let Blob2 = function(parts, options) {
+        if (!(this instanceof Blob2)) {
+          throw new TypeError("Class constructor Blob cannot be invoked without 'new'");
+        }
+        this._parts = Array.isArray(parts) ? parts.slice() : [];
+        this.type = options && options.type ? String(options.type).toLowerCase() : "";
+        var size = 0;
+        for (var index = 0; index < this._parts.length; index += 1) {
+          var part = this._parts[index];
+          if (typeof part === "string") {
+            size += part.length;
+          } else if (part && typeof part.byteLength === "number") {
+            size += part.byteLength;
+          }
+        }
+        this.size = size;
+      };
+      var Blob = Blob2;
+      Blob2.prototype.arrayBuffer = function arrayBuffer() {
+        return Promise.resolve(new ArrayBuffer(0));
+      };
+      Blob2.prototype.text = function text() {
+        return Promise.resolve("");
+      };
+      Blob2.prototype.slice = function slice() {
+        return new Blob2();
+      };
+      Blob2.prototype.stream = function stream() {
+        throw new Error("Blob.stream is not supported in sandbox");
+      };
+      Object.defineProperty(Blob2.prototype, Symbol.toStringTag, {
+        value: "Blob",
+        writable: false,
+        enumerable: false,
+        configurable: true
+      });
+      __requireExposeCustomGlobal("Blob", Blob2);
+    }
+    if (typeof globalThis.File === "undefined") {
+      let File2 = function(parts, name, options) {
+        if (!(this instanceof File2)) {
+          throw new TypeError("Class constructor File cannot be invoked without 'new'");
+        }
+        globalThis.Blob.call(this, parts, options);
+        this.name = String(name);
+        this.lastModified = options && typeof options.lastModified === "number" ? options.lastModified : Date.now();
+        this.webkitRelativePath = "";
+      };
+      var File = File2;
+      File2.prototype = Object.create(globalThis.Blob.prototype);
+      Object.defineProperty(File2.prototype, "constructor", {
+        value: File2,
+        writable: true,
+        configurable: true
+      });
+      Object.defineProperty(File2.prototype, Symbol.toStringTag, {
+        value: "File",
+        writable: false,
+        enumerable: false,
+        configurable: true
+      });
+      __requireExposeCustomGlobal("File", File2);
+    }
+    if (typeof globalThis.FormData === "undefined") {
+      let FormData2 = function() {
+        if (!(this instanceof FormData2)) {
+          throw new TypeError("Class constructor FormData cannot be invoked without 'new'");
+        }
+        this._entries = [];
+      };
+      var FormData = FormData2;
+      FormData2.prototype.append = function append(name, value) {
+        this._entries.push([String(name), value]);
+      };
+      FormData2.prototype.get = function get(name) {
+        var key = String(name);
+        for (var index = 0; index < this._entries.length; index += 1) {
+          if (this._entries[index][0] === key) {
+            return this._entries[index][1];
+          }
+        }
+        return null;
+      };
+      FormData2.prototype.getAll = function getAll(name) {
+        var key = String(name);
+        var values = [];
+        for (var index = 0; index < this._entries.length; index += 1) {
+          if (this._entries[index][0] === key) {
+            values.push(this._entries[index][1]);
+          }
+        }
+        return values;
+      };
+      FormData2.prototype.has = function has(name) {
+        return this.get(name) !== null;
+      };
+      FormData2.prototype.delete = function del(name) {
+        var key = String(name);
+        this._entries = this._entries.filter(function(entry) {
+          return entry[0] !== key;
+        });
+      };
+      FormData2.prototype.entries = function entries() {
+        return this._entries[Symbol.iterator]();
+      };
+      FormData2.prototype[Symbol.iterator] = function iterator() {
+        return this.entries();
+      };
+      Object.defineProperty(FormData2.prototype, Symbol.toStringTag, {
+        value: "FormData",
+        writable: false,
+        enumerable: false,
+        configurable: true
+      });
+      __requireExposeCustomGlobal("FormData", FormData2);
+    }
+    if (typeof globalThis.MessageEvent === "undefined") {
+      let MessageEvent2 = function(type, options) {
+        if (!(this instanceof MessageEvent2)) {
+          throw new TypeError("Class constructor MessageEvent cannot be invoked without 'new'");
+        }
+        globalThis.Event.call(this, type, options);
+        this.data = options && "data" in options ? options.data : void 0;
+      };
+      var MessageEvent = MessageEvent2;
+      MessageEvent2.prototype = Object.create(globalThis.Event.prototype);
+      Object.defineProperty(MessageEvent2.prototype, "constructor", {
+        value: MessageEvent2,
+        writable: true,
+        configurable: true
+      });
+      globalThis.MessageEvent = MessageEvent2;
+    }
+    if (typeof globalThis.MessagePort === "undefined") {
+      let MessagePort2 = function() {
+        if (!(this instanceof MessagePort2)) {
+          throw new TypeError("Class constructor MessagePort cannot be invoked without 'new'");
+        }
+        globalThis.EventTarget.call(this);
+        this.onmessage = null;
+        this._pairedPort = null;
+      };
+      var MessagePort = MessagePort2;
+      MessagePort2.prototype = Object.create(globalThis.EventTarget.prototype);
+      Object.defineProperty(MessagePort2.prototype, "constructor", {
+        value: MessagePort2,
+        writable: true,
+        configurable: true
+      });
+      MessagePort2.prototype.postMessage = function postMessage(data) {
+        var target = this._pairedPort;
+        if (!target) {
+          return;
+        }
+        var event = new globalThis.MessageEvent("message", { data });
+        target.dispatchEvent(event);
+        if (typeof target.onmessage === "function") {
+          target.onmessage.call(target, event);
+        }
+      };
+      MessagePort2.prototype.start = function start() {
+      };
+      MessagePort2.prototype.close = function close() {
+        this._pairedPort = null;
+      };
+      globalThis.MessagePort = MessagePort2;
+    }
+    if (typeof globalThis.MessageChannel === "undefined") {
+      let MessageChannel2 = function() {
+        if (!(this instanceof MessageChannel2)) {
+          throw new TypeError("Class constructor MessageChannel cannot be invoked without 'new'");
+        }
+        this.port1 = new globalThis.MessagePort();
+        this.port2 = new globalThis.MessagePort();
+        this.port1._pairedPort = this.port2;
+        this.port2._pairedPort = this.port1;
+      };
+      var MessageChannel = MessageChannel2;
+      globalThis.MessageChannel = MessageChannel2;
+    }
+  })();
+  (function installWebStreamsGlobals() {
+    if (typeof globalThis.ReadableStream !== "undefined") {
+      return;
+    }
+    if (typeof _loadPolyfill === "undefined") {
+      return;
+    }
+    const polyfillCode = _loadPolyfill.applySyncPromise(void 0, ["stream/web"]);
+    if (polyfillCode === null) {
+      return;
+    }
+    const webStreams = Function('"use strict"; return (' + polyfillCode + ");")();
+    const names = [
+      "ReadableStream",
+      "ReadableStreamDefaultReader",
+      "ReadableStreamBYOBReader",
+      "ReadableStreamBYOBRequest",
+      "ReadableByteStreamController",
+      "ReadableStreamDefaultController",
+      "TransformStream",
+      "TransformStreamDefaultController",
+      "WritableStream",
+      "WritableStreamDefaultWriter",
+      "WritableStreamDefaultController",
+      "ByteLengthQueuingStrategy",
+      "CountQueuingStrategy",
+      "TextEncoderStream",
+      "TextDecoderStream",
+      "CompressionStream",
+      "DecompressionStream"
+    ];
+    for (const name of names) {
+      if (typeof webStreams?.[name] !== "undefined") {
+        globalThis[name] = webStreams[name];
+      }
+    }
+  })();
+  function _patchPolyfill(name, result) {
+    if (typeof result !== "object" && typeof result !== "function" || result === null) {
+      return result;
+    }
+    if (name === "buffer") {
+      const maxLength = typeof result.kMaxLength === "number" ? result.kMaxLength : 2147483647;
+      const maxStringLength = typeof result.kStringMaxLength === "number" ? result.kStringMaxLength : 536870888;
+      if (typeof result.constants !== "object" || result.constants === null) {
+        result.constants = {};
+      }
+      if (typeof result.constants.MAX_LENGTH !== "number") {
+        result.constants.MAX_LENGTH = maxLength;
+      }
+      if (typeof result.constants.MAX_STRING_LENGTH !== "number") {
+        result.constants.MAX_STRING_LENGTH = maxStringLength;
+      }
+      if (typeof result.kMaxLength !== "number") {
+        result.kMaxLength = maxLength;
+      }
+      if (typeof result.kStringMaxLength !== "number") {
+        result.kStringMaxLength = maxStringLength;
+      }
+      var BufferCtor = result.Buffer;
+      if (typeof globalThis.Buffer === "function" && globalThis.Buffer !== BufferCtor) {
+        BufferCtor = globalThis.Buffer;
+        result.Buffer = BufferCtor;
+      } else if (typeof globalThis.Buffer !== "function" && typeof BufferCtor === "function") {
+        globalThis.Buffer = BufferCtor;
       }
-      const BufferCtor = result2.Buffer;
       if ((typeof BufferCtor === "function" || typeof BufferCtor === "object") && BufferCtor !== null) {
+        if (typeof result.SlowBuffer !== "function") {
+          result.SlowBuffer = BufferCtor;
+        }
         if (typeof BufferCtor.kMaxLength !== "number") {
           BufferCtor.kMaxLength = maxLength;
         }
@@ -193,7 +1080,7 @@
           BufferCtor.kStringMaxLength = maxStringLength;
         }
         if (typeof BufferCtor.constants !== "object" || BufferCtor.constants === null) {
-          BufferCtor.constants = result2.constants;
+          BufferCtor.constants = result.constants;
         }
         var proto = BufferCtor.prototype;
         if (proto && typeof proto.utf8Slice !== "function") {
@@ -229,20 +1116,38 @@
           BufferCtor.allocUnsafe._secureExecPatched = true;
         }
       }
-      return result2;
+      return result;
     }
-    if (name2 === "util" && typeof result2.formatWithOptions === "undefined" && typeof result2.format === "function") {
-      result2.formatWithOptions = function formatWithOptions(inspectOptions, ...args) {
-        return result2.format.apply(null, args);
+    if (name === "util" && typeof result.formatWithOptions === "undefined" && typeof result.format === "function") {
+      result.formatWithOptions = function formatWithOptions(inspectOptions, ...args) {
+        return result.format.apply(null, args);
       };
     }
-    if (name2 === "util") {
-      if (typeof result2.inspect === "function" && typeof result2.inspect.custom === "undefined") {
-        result2.inspect.custom = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
+    if (name === "util") {
+      if (typeof result.types === "undefined" && typeof _requireFrom === "function") {
+        try {
+          result.types = _requireFrom("util/types", "/");
+        } catch {
+        }
       }
-      if (typeof result2.inspect === "function" && !result2.inspect._secureExecPatchedCustomInspect) {
-        const customInspectSymbol = result2.inspect.custom || /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
-        const originalInspect = result2.inspect;
+      if ((typeof result.MIMEType === "undefined" || typeof result.MIMEParams === "undefined") && typeof _requireFrom === "function") {
+        try {
+          const mimeModule = _requireFrom("internal/mime", "/");
+          if (typeof result.MIMEType === "undefined") {
+            result.MIMEType = mimeModule.MIMEType;
+          }
+          if (typeof result.MIMEParams === "undefined") {
+            result.MIMEParams = mimeModule.MIMEParams;
+          }
+        } catch {
+        }
+      }
+      if (typeof result.inspect === "function" && typeof result.inspect.custom === "undefined") {
+        result.inspect.custom = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
+      }
+      if (typeof result.inspect === "function" && !result.inspect._secureExecPatchedCustomInspect) {
+        const customInspectSymbol = result.inspect.custom || /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
+        const originalInspect = result.inspect;
         const formatObjectKey = function(key) {
           return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : originalInspect(key);
         };
@@ -287,7 +1192,7 @@
             return "[Circular]";
           }
           if (typeof value[customInspectSymbol] === "function") {
-            return value[customInspectSymbol](depth, options, result2.inspect);
+            return value[customInspectSymbol](depth, options, result.inspect);
           }
           if (depth < 0) {
             return originalInspect(value, options);
@@ -309,22 +1214,25 @@
           seen.delete(value);
           return originalInspect(value, options);
         };
-        result2.inspect = function inspect(value, options) {
+        result.inspect = function inspect(value, options) {
           const inspectOptions = typeof options === "object" && options !== null ? options : {};
           const depth = typeof inspectOptions.depth === "number" ? inspectOptions.depth : 2;
+          if (typeof value === "symbol") {
+            return value.toString();
+          }
           if (!containsCustomInspectable(value, depth, /* @__PURE__ */ new Set())) {
             return originalInspect.call(this, value, options);
           }
           return inspectWithCustom(value, depth, inspectOptions, /* @__PURE__ */ new Set());
         };
-        result2.inspect.custom = customInspectSymbol;
-        result2.inspect._secureExecPatchedCustomInspect = true;
+        result.inspect.custom = customInspectSymbol;
+        result.inspect._secureExecPatchedCustomInspect = true;
       }
-      return result2;
+      return result;
     }
-    if (name2 === "events") {
-      if (typeof result2.getEventListeners !== "function") {
-        result2.getEventListeners = function getEventListeners(target, eventName) {
+    if (name === "events") {
+      if (typeof result.getEventListeners !== "function") {
+        result.getEventListeners = function getEventListeners(target, eventName) {
           if (target && typeof target.listeners === "function") {
             return target.listeners(eventName);
           }
@@ -337,10 +1245,33 @@
           return [];
         };
       }
-      return result2;
+      return result;
     }
-    if (name2 === "stream") {
-      const ReadableCtor = result2.Readable;
+    if (name === "stream" || name === "node:stream") {
+      const getWebStreamsState2 = function() {
+        return globalThis.__secureExecWebStreams || null;
+      };
+      const webStreamsState2 = getWebStreamsState2();
+      if (typeof result.isReadable !== "function") {
+        result.isReadable = function(stream) {
+          const stateKey = getWebStreamsState2() && getWebStreamsState2().kState;
+          return Boolean(stateKey && stream && stream[stateKey] && stream[stateKey].state === "readable");
+        };
+      }
+      if (typeof result.isErrored !== "function") {
+        result.isErrored = function(stream) {
+          const stateKey = getWebStreamsState2() && getWebStreamsState2().kState;
+          return Boolean(stateKey && stream && stream[stateKey] && stream[stateKey].state === "errored");
+        };
+      }
+      if (typeof result.isDisturbed !== "function") {
+        result.isDisturbed = function(stream) {
+          const stateKey = getWebStreamsState2() && getWebStreamsState2().kState;
+          return Boolean(stateKey && stream && stream[stateKey] && stream[stateKey].disturbed === true);
+        };
+      }
+      const ReadableCtor = result.Readable;
+      const WritableCtor = result.Writable;
       const readableFrom = typeof ReadableCtor === "function" ? ReadableCtor.from : void 0;
       const readableFromSource = typeof readableFrom === "function" ? Function.prototype.toString.call(readableFrom) : "";
       const hasBrowserReadableFromStub = readableFromSource.indexOf(
@@ -375,12 +1306,66 @@
           return readable;
         };
       }
-      return result2;
+      if (webStreamsState2 && typeof ReadableCtor === "function") {
+        if (typeof ReadableCtor.fromWeb !== "function" && typeof webStreamsState2.newStreamReadableFromReadableStream === "function") {
+          ReadableCtor.fromWeb = function fromWeb(readableStream, options) {
+            return webStreamsState2.newStreamReadableFromReadableStream(readableStream, options);
+          };
+        }
+        if (typeof ReadableCtor.toWeb !== "function" && typeof webStreamsState2.newReadableStreamFromStreamReadable === "function") {
+          ReadableCtor.toWeb = function toWeb(readable) {
+            return webStreamsState2.newReadableStreamFromStreamReadable(readable);
+          };
+        }
+      }
+      if (webStreamsState2 && typeof WritableCtor === "function") {
+        if (typeof WritableCtor.fromWeb !== "function" && typeof webStreamsState2.newStreamWritableFromWritableStream === "function") {
+          WritableCtor.fromWeb = function fromWeb(writableStream, options) {
+            return webStreamsState2.newStreamWritableFromWritableStream(writableStream, options);
+          };
+        }
+        if (typeof WritableCtor.toWeb !== "function" && typeof webStreamsState2.newWritableStreamFromStreamWritable === "function") {
+          WritableCtor.toWeb = function toWeb(writable) {
+            return webStreamsState2.newWritableStreamFromStreamWritable(writable);
+          };
+        }
+      }
+      if (webStreamsState2 && typeof result.Duplex === "function") {
+        if (typeof result.Duplex.fromWeb !== "function" && typeof webStreamsState2.newStreamDuplexFromReadableWritablePair === "function") {
+          result.Duplex.fromWeb = function fromWeb(pair, options) {
+            return webStreamsState2.newStreamDuplexFromReadableWritablePair(pair, options);
+          };
+        }
+        if (typeof result.Duplex.toWeb !== "function" && typeof webStreamsState2.newReadableWritablePairFromDuplex === "function") {
+          result.Duplex.toWeb = function toWeb(duplex) {
+            return webStreamsState2.newReadableWritablePairFromDuplex(duplex);
+          };
+        }
+      }
+      if (typeof ReadableCtor === "function" && !Object.getOwnPropertyDescriptor(ReadableCtor.prototype, "readableObjectMode")) {
+        Object.defineProperty(ReadableCtor.prototype, "readableObjectMode", {
+          configurable: true,
+          enumerable: false,
+          get() {
+            return Boolean(this?._readableState?.objectMode);
+          }
+        });
+      }
+      if (typeof WritableCtor === "function" && !Object.getOwnPropertyDescriptor(WritableCtor.prototype, "writableObjectMode")) {
+        Object.defineProperty(WritableCtor.prototype, "writableObjectMode", {
+          configurable: true,
+          enumerable: false,
+          get() {
+            return Boolean(this?._writableState?.objectMode);
+          }
+        });
+      }
+      return result;
     }
-    if (name2 === "url") {
-      const OriginalURL = result2.URL;
+    if (name === "url") {
+      const OriginalURL = result.URL;
       if (typeof OriginalURL !== "function" || OriginalURL._patched) {
-        return result2;
+        return result;
       }
       const PatchedURL = function PatchedURL2(url, base) {
         if (typeof url === "string" && url.startsWith("file:") && !url.startsWith("file://") && base === void 0) {
@@ -405,15 +1390,15 @@
       Object.setPrototypeOf(PatchedURL, OriginalURL);
       PatchedURL.prototype = OriginalURL.prototype;
       PatchedURL._patched = true;
-      const descriptor = Object.getOwnPropertyDescriptor(result2, "URL");
+      const descriptor = Object.getOwnPropertyDescriptor(result, "URL");
       if (descriptor && descriptor.configurable !== true && descriptor.writable !== true && typeof descriptor.set !== "function") {
-        return result2;
+        return result;
       }
       try {
-        result2.URL = PatchedURL;
+        result.URL = PatchedURL;
       } catch {
         try {
-          Object.defineProperty(result2, "URL", {
+          Object.defineProperty(result, "URL", {
             value: PatchedURL,
             writable: true,
             configurable: true,
@@ -422,16 +1407,16 @@
         } catch {
         }
       }
-      return result2;
+      return result;
     }
-    if (name2 === "zlib") {
-      if (typeof result2.constants !== "object" || result2.constants === null) {
+    if (name === "zlib") {
+      if (typeof result.constants !== "object" || result.constants === null) {
         var zlibConstants = {};
-        var constKeys = Object.keys(result2);
+        var constKeys = Object.keys(result);
         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 (ck.indexOf("Z_") === 0 && typeof result[ck] === "number") {
+            zlibConstants[ck] = result[ck];
           }
         }
         if (typeof zlibConstants.DEFLATE !== "number") zlibConstants.DEFLATE = 1;
@@ -441,12 +1426,12 @@
         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;
+        result.constants = zlibConstants;
       }
-      return result2;
+      return result;
     }
-    if (name2 === "crypto") {
-      let createCryptoRangeError2 = function(name3, message) {
+    if (name === "crypto") {
+      let createCryptoRangeError2 = function(name2, message) {
         var error = new RangeError(message);
         error.code = "ERR_OUT_OF_RANGE";
         error.name = "RangeError";
@@ -462,7 +1447,7 @@
         return typeof SharedArrayBuffer !== "undefined" && value instanceof SharedArrayBuffer;
       }, isBinaryLike2 = function(value) {
         return Buffer.isBuffer(value) || ArrayBuffer.isView(value) || value instanceof ArrayBuffer || isSharedArrayBufferInstance2(value);
-      }, normalizeByteSource2 = function(value, name3, options) {
+      }, normalizeByteSource2 = function(value, name2, options) {
         var allowNull = options && options.allowNull;
         if (allowNull && value === null) {
           return null;
@@ -480,7 +1465,7 @@
           return Buffer.from(value);
         }
         throw createInvalidArgTypeError(
-          name3,
+          name2,
           "of type string or an instance of ArrayBuffer, Buffer, TypedArray, or DataView",
           value
         );
@@ -599,10 +1584,10 @@
             callback(normalizeCryptoBridgeError(error));
           }
         };
-        result2.createHash = function createHash(algorithm, options) {
+        result.createHash = function createHash(algorithm, options) {
           return new SandboxHash2(algorithm, options);
         };
-        result2.Hash = SandboxHash2;
+        result.Hash = SandboxHash2;
       }
       if (typeof _cryptoHmacDigest !== "undefined") {
         let SandboxHmac2 = function(algorithm, key) {
@@ -648,13 +1633,13 @@
         SandboxHmac2.prototype.end = function end(data, encoding) {
           if (data) this.update(data, encoding);
         };
-        result2.createHmac = function createHmac(algorithm, key) {
+        result.createHmac = function createHmac(algorithm, key) {
           return new SandboxHmac2(algorithm, key);
         };
-        result2.Hmac = SandboxHmac2;
+        result.Hmac = SandboxHmac2;
       }
       if (typeof _cryptoRandomFill !== "undefined") {
-        result2.randomBytes = function randomBytes(size, callback) {
+        result.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") {
@@ -686,7 +1671,7 @@
           }
           return buf;
         };
-        result2.randomFillSync = function randomFillSync(buffer, offset, size) {
+        result.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;
@@ -704,7 +1689,7 @@
           }
           return buffer;
         };
-        result2.randomFill = function randomFill(buffer, offsetOrCb, sizeOrCb, callback) {
+        result.randomFill = function randomFill(buffer, offsetOrCb, sizeOrCb, callback) {
           var offset = 0;
           var size;
           var cb;
@@ -722,13 +1707,13 @@
             throw new TypeError("Callback must be a function");
           }
           try {
-            result2.randomFillSync(buffer, offset, size);
+            result.randomFillSync(buffer, offset, size);
             cb(null, buffer);
           } catch (e) {
             cb(e);
           }
         };
-        result2.randomInt = function randomInt(minOrMax, maxOrCb, callback) {
+        result.randomInt = function randomInt(minOrMax, maxOrCb, callback) {
           var min, max, cb;
           if (typeof maxOrCb === "function" || maxOrCb === void 0) {
             min = 0;
@@ -772,16 +1757,37 @@
             var buf = Buffer.from(base64, "base64");
             val = buf.readUIntBE(0, bytes);
           } while (val >= maxValid);
-          var result22 = min + val % range;
+          var result2 = min + val % range;
           if (typeof cb === "function") {
-            cb(null, result22);
+            cb(null, result2);
             return;
           }
-          return result22;
+          return result2;
+        };
+      }
+      if (typeof _cryptoRandomUUID !== "undefined" && typeof result.randomUUID !== "function") {
+        result.randomUUID = function randomUUID(options) {
+          if (options !== void 0) {
+            if (options === null || typeof options !== "object") {
+              throw createInvalidArgTypeError("options", "of type object", options);
+            }
+            if (Object.prototype.hasOwnProperty.call(options, "disableEntropyCache") && typeof options.disableEntropyCache !== "boolean") {
+              throw createInvalidArgTypeError(
+                "options.disableEntropyCache",
+                "of type boolean",
+                options.disableEntropyCache
+              );
+            }
+          }
+          var uuid = _cryptoRandomUUID.applySync(void 0, []);
+          if (typeof uuid !== "string") {
+            throw new Error("invalid host uuid");
+          }
+          return uuid;
         };
       }
       if (typeof _cryptoPbkdf2 !== "undefined") {
-        let createPbkdf2ArgTypeError2 = function(name3, value) {
+        let createPbkdf2ArgTypeError2 = function(name2, value) {
           var received;
           if (value == null) {
             received = " Received " + value;
@@ -791,7 +1797,7 @@
             var inspected = typeof value === "string" ? "'" + value + "'" : String(value);
             received = " Received type " + typeof value + " (" + inspected + ")";
           }
-          var error = new TypeError('The "' + name3 + '" argument must be of type number.' + received);
+          var error = new TypeError('The "' + name2 + '" argument must be of type number.' + received);
           error.code = "ERR_INVALID_ARG_TYPE";
           return error;
         }, validatePbkdf2Args2 = function(password, salt, iterations, keylen, digest) {
@@ -836,7 +1842,7 @@
           };
         };
         var createPbkdf2ArgTypeError = createPbkdf2ArgTypeError2, validatePbkdf2Args = validatePbkdf2Args2;
-        result2.pbkdf2Sync = function pbkdf2Sync(password, salt, iterations, keylen, digest) {
+        result.pbkdf2Sync = function pbkdf2Sync(password, salt, iterations, keylen, digest) {
           var normalized = validatePbkdf2Args2(password, salt, iterations, keylen, digest);
           try {
             var resultBase64 = _cryptoPbkdf2.applySync(void 0, [
@@ -851,7 +1857,7 @@
             throw normalizeCryptoBridgeError(error);
           }
         };
-        result2.pbkdf2 = function pbkdf2(password, salt, iterations, keylen, digest, callback) {
+        result.pbkdf2 = function pbkdf2(password, salt, iterations, keylen, digest, callback) {
           if (typeof digest === "function" && callback === void 0) {
             callback = digest;
             digest = void 0;
@@ -860,7 +1866,7 @@
             throw createInvalidArgTypeError("callback", "of type function", callback);
           }
           try {
-            var derived = result2.pbkdf2Sync(password, salt, iterations, keylen, digest);
+            var derived = result.pbkdf2Sync(password, salt, iterations, keylen, digest);
             scheduleCryptoCallback(callback, [null, derived]);
           } catch (e) {
             throw normalizeCryptoBridgeError(e);
@@ -868,7 +1874,7 @@
         };
       }
       if (typeof _cryptoScrypt !== "undefined") {
-        result2.scryptSync = function scryptSync(password, salt, keylen, options) {
+        result.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 = {};
@@ -889,7 +1895,7 @@
           ]);
           return Buffer.from(resultBase64, "base64");
         };
-        result2.scrypt = function scrypt(password, salt, keylen, optionsOrCb, callback) {
+        result.scrypt = function scrypt(password, salt, keylen, optionsOrCb, callback) {
           var opts = optionsOrCb;
           var cb = callback;
           if (typeof optionsOrCb === "function") {
@@ -897,7 +1903,7 @@
             cb = optionsOrCb;
           }
           try {
-            var derived = result2.scryptSync(password, salt, keylen, opts);
+            var derived = result.scryptSync(password, salt, keylen, opts);
             cb(null, derived);
           } catch (e) {
             cb(e);
@@ -1052,10 +2058,10 @@
             callback(normalizeCryptoBridgeError(error));
           }
         };
-        result2.createCipheriv = function createCipheriv(algorithm, key, iv, options) {
+        result.createCipheriv = function createCipheriv(algorithm, key, iv, options) {
           return new SandboxCipher2(algorithm, key, iv, options);
         };
-        result2.Cipheriv = SandboxCipher2;
+        result.Cipheriv = SandboxCipher2;
       }
       if (typeof _cryptoDecipheriv !== "undefined") {
         let SandboxDecipher2 = function(algorithm, key, iv, options) {
@@ -1203,13 +2209,13 @@
             callback(normalizeCryptoBridgeError(error));
           }
         };
-        result2.createDecipheriv = function createDecipheriv(algorithm, key, iv, options) {
+        result.createDecipheriv = function createDecipheriv(algorithm, key, iv, options) {
           return new SandboxDecipher2(algorithm, key, iv, options);
         };
-        result2.Decipheriv = SandboxDecipher2;
+        result.Decipheriv = SandboxDecipher2;
       }
       if (typeof _cryptoSign !== "undefined") {
-        result2.sign = function sign(algorithm, data, key) {
+        result.sign = function sign(algorithm, data, key) {
           var dataBuf = typeof data === "string" ? Buffer.from(data, "utf8") : Buffer.from(data);
           var sigBase64;
           try {
@@ -1225,7 +2231,7 @@
         };
       }
       if (typeof _cryptoVerify !== "undefined") {
-        result2.verify = function verify(algorithm, data, key, signature) {
+        result.verify = function verify(algorithm, data, key, signature) {
           var dataBuf = typeof data === "string" ? Buffer.from(data, "utf8") : Buffer.from(data);
           var sigBuf = typeof signature === "string" ? Buffer.from(signature, "base64") : Buffer.from(signature);
           try {
@@ -1256,16 +2262,16 @@
           return Buffer.from(resultBase64, "base64");
         };
         var asymmetricBridgeCall = asymmetricBridgeCall2;
-        result2.publicEncrypt = function publicEncrypt(key, data) {
+        result.publicEncrypt = function publicEncrypt(key, data) {
           return asymmetricBridgeCall2("publicEncrypt", key, data);
         };
-        result2.privateDecrypt = function privateDecrypt(key, data) {
+        result.privateDecrypt = function privateDecrypt(key, data) {
           return asymmetricBridgeCall2("privateDecrypt", key, data);
         };
-        result2.privateEncrypt = function privateEncrypt(key, data) {
+        result.privateEncrypt = function privateEncrypt(key, data) {
           return asymmetricBridgeCall2("privateEncrypt", key, data);
         };
-        result2.publicDecrypt = function publicDecrypt(key, data) {
+        result.publicDecrypt = function publicDecrypt(key, data) {
           return asymmetricBridgeCall2("publicDecrypt", key, data);
         };
       }
@@ -1351,7 +2357,7 @@
             output[keys[i]] = restoreDhValue2(value[keys[i]]);
           }
           return output;
-        }, createDhSession2 = function(type, name3, argsLike) {
+        }, createDhSession2 = function(type, name2, argsLike) {
           var args = [];
           for (var i = 0; i < argsLike.length; i++) {
             args.push(serializeDhValue2(argsLike[i]));
@@ -1359,7 +2365,7 @@
           return _cryptoDiffieHellmanSessionCreate.applySync(void 0, [
             JSON.stringify({
               type,
-              name: name3,
+              name: name2,
               args
             })
           ]);
@@ -1424,27 +2430,27 @@
         SandboxECDH2.prototype.getPublicKey = function getPublicKey(encoding, format) {
           return callDhSession2(this._sessionId, "getPublicKey", Array.prototype.slice.call(arguments));
         };
-        result2.createDiffieHellman = function createDiffieHellman() {
+        result.createDiffieHellman = function createDiffieHellman() {
           return new SandboxDiffieHellman2(createDhSession2("dh", void 0, arguments));
         };
-        result2.getDiffieHellman = function getDiffieHellman(name3) {
-          return new SandboxDiffieHellman2(createDhSession2("group", name3, []));
+        result.getDiffieHellman = function getDiffieHellman(name2) {
+          return new SandboxDiffieHellman2(createDhSession2("group", name2, []));
         };
-        result2.createDiffieHellmanGroup = result2.getDiffieHellman;
-        result2.createECDH = function createECDH(curve) {
+        result.createDiffieHellmanGroup = result.getDiffieHellman;
+        result.createECDH = function createECDH(curve) {
           return new SandboxECDH2(createDhSession2("ecdh", curve, []));
         };
         if (typeof _cryptoDiffieHellman !== "undefined") {
-          result2.diffieHellman = function diffieHellman(options) {
+          result.diffieHellman = function diffieHellman(options) {
             var resultJson = _cryptoDiffieHellman.applySync(void 0, [
               JSON.stringify(serializeDhValue2(options))
             ]);
             return restoreDhValue2(JSON.parse(resultJson));
           };
         }
-        result2.DiffieHellman = SandboxDiffieHellman2;
-        result2.DiffieHellmanGroup = SandboxDiffieHellman2;
-        result2.ECDH = SandboxECDH2;
+        result.DiffieHellman = SandboxDiffieHellman2;
+        result.DiffieHellmanGroup = SandboxDiffieHellman2;
+        result.ECDH = SandboxECDH2;
       }
       if (typeof _cryptoGenerateKeyPairSync !== "undefined") {
         let restoreBridgeValue2 = function(value) {
@@ -1479,12 +2485,12 @@
             output[keys[i]] = cloneObject2(value[keys[i]]);
           }
           return output;
-        }, createDomException2 = function(message, name3) {
+        }, createDomException2 = function(message, name2) {
           if (typeof DOMException === "function") {
-            return new DOMException(message, name3);
+            return new DOMException(message, name2);
           }
           var error = new Error(message);
-          error.name = name3;
+          error.name = name2;
           return error;
         }, toRawBuffer2 = function(data, encoding) {
           if (Buffer.isBuffer(data)) {
@@ -1594,7 +2600,7 @@
             hasOptions: options !== void 0,
             options: options === void 0 ? null : serializeBridgeValue2(options)
           });
-        }, createInvalidArgTypeError2 = function(name3, expected, value) {
+        }, createInvalidArgTypeError2 = function(name2, expected, value) {
           var received;
           if (value == null) {
             received = " Received " + value;
@@ -1613,7 +2619,7 @@
             }
             received = " Received type " + typeof value + " (" + inspected + ")";
           }
-          var error = new TypeError('The "' + name3 + '" argument must be ' + expected + "." + received);
+          var error = new TypeError('The "' + name2 + '" argument must be ' + expected + "." + received);
           error.code = "ERR_INVALID_ARG_TYPE";
           return error;
         }, scheduleCryptoCallback2 = function(callback, args) {
@@ -1677,10 +2683,10 @@
           return new SandboxCryptoKey(keyData);
         }, buildCryptoKeyFromKeyObject2 = function(keyObject, algorithm, extractable, usages) {
           var algo = normalizeAlgorithmInput2(algorithm);
-          var name3 = algo.name;
+          var name2 = algo.name;
           if (keyObject.type === "secret") {
             var secretBytes = Buffer.from(keyObject._raw || "", "base64");
-            if (name3 === "PBKDF2") {
+            if (name2 === "PBKDF2") {
               if (extractable) {
                 throw new SyntaxError("PBKDF2 keys are not extractable");
               }
@@ -1692,7 +2698,7 @@
               return createCompatibleCryptoKey2({
                 type: "secret",
                 extractable,
-                algorithm: { name: name3 },
+                algorithm: { name: name2 },
                 usages: Array.from(usages),
                 _raw: keyObject._raw,
                 _sourceKeyObjectData: {
@@ -1701,7 +2707,7 @@
                 }
               });
             }
-            if (name3 === "HMAC") {
+            if (name2 === "HMAC") {
               if (!secretBytes.byteLength || algo.length === 0) {
                 throw createDomException2("Zero-length key is not supported", "DataError");
               }
@@ -1712,7 +2718,7 @@
                 type: "secret",
                 extractable,
                 algorithm: {
-                  name: name3,
+                  name: name2,
                   hash: typeof algo.hash === "string" ? { name: algo.hash } : cloneObject2(algo.hash),
                   length: secretBytes.byteLength * 8
                 },
@@ -1728,7 +2734,7 @@
               type: "secret",
               extractable,
               algorithm: {
-                name: name3,
+                name: name2,
                 length: secretBytes.byteLength * 8
               },
               usages: Array.from(usages),
@@ -1740,7 +2746,7 @@
             });
           }
           var keyType = String(keyObject.asymmetricKeyType || "").toLowerCase();
-          var algorithmName = String(name3 || "");
+          var algorithmName = String(name2 || "");
           if ((keyType === "ed25519" || keyType === "ed448" || keyType === "x25519" || keyType === "x448") && keyType !== algorithmName.toLowerCase()) {
             throw createDomException2("Invalid key type", "DataError");
           }
@@ -1851,7 +2857,7 @@
         SandboxKeyObject2.prototype.toCryptoKey = function toCryptoKey(algorithm, extractable, usages) {
           return buildCryptoKeyFromKeyObject2(this, algorithm, extractable, Array.from(usages || []));
         };
-        result2.generateKeyPairSync = function generateKeyPairSync(type, options) {
+        result.generateKeyPairSync = function generateKeyPairSync(type, options) {
           var resultJson = _cryptoGenerateKeyPairSync.applySync(void 0, [
             type,
             serializeBridgeOptions2(options)
@@ -1868,16 +2874,16 @@
             privateKey: createGeneratedKeyObject2(parsed.privateKey)
           };
         };
-        result2.generateKeyPair = function generateKeyPair(type, options, callback) {
+        result.generateKeyPair = function generateKeyPair(type, options, callback) {
           if (typeof options === "function") {
             callback = options;
             options = void 0;
           }
           callback = ensureCryptoCallback2(callback, function() {
-            result2.generateKeyPairSync(type, options);
+            result.generateKeyPairSync(type, options);
           });
           try {
-            var pair = result2.generateKeyPairSync(type, options);
+            var pair = result.generateKeyPairSync(type, options);
             scheduleCryptoCallback2(callback, [null, pair.publicKey, pair.privateKey]);
           } catch (e) {
             if (shouldThrowCryptoValidationError2(e)) {
@@ -1887,7 +2893,7 @@
           }
         };
         if (typeof _cryptoGenerateKeySync !== "undefined") {
-          result2.generateKeySync = function generateKeySync(type, options) {
+          result.generateKeySync = function generateKeySync(type, options) {
             var resultJson;
             try {
               resultJson = _cryptoGenerateKeySync.applySync(void 0, [
@@ -1899,12 +2905,12 @@
             }
             return createGeneratedKeyObject2(JSON.parse(resultJson));
           };
-          result2.generateKey = function generateKey(type, options, callback) {
+          result.generateKey = function generateKey(type, options, callback) {
             callback = ensureCryptoCallback2(callback, function() {
-              result2.generateKeySync(type, options);
+              result.generateKeySync(type, options);
             });
             try {
-              var key = result2.generateKeySync(type, options);
+              var key = result.generateKeySync(type, options);
               scheduleCryptoCallback2(callback, [null, key]);
             } catch (e) {
               if (shouldThrowCryptoValidationError2(e)) {
@@ -1915,7 +2921,7 @@
           };
         }
         if (typeof _cryptoGeneratePrimeSync !== "undefined") {
-          result2.generatePrimeSync = function generatePrimeSync(size, options) {
+          result.generatePrimeSync = function generatePrimeSync(size, options) {
             var resultJson;
             try {
               resultJson = _cryptoGeneratePrimeSync.applySync(void 0, [
@@ -1927,16 +2933,16 @@
             }
             return restoreBridgeValue2(JSON.parse(resultJson));
           };
-          result2.generatePrime = function generatePrime(size, options, callback) {
+          result.generatePrime = function generatePrime(size, options, callback) {
             if (typeof options === "function") {
               callback = options;
               options = void 0;
             }
             callback = ensureCryptoCallback2(callback, function() {
-              result2.generatePrimeSync(size, options);
+              result.generatePrimeSync(size, options);
             });
             try {
-              var prime = result2.generatePrimeSync(size, options);
+              var prime = result.generatePrimeSync(size, options);
               scheduleCryptoCallback2(callback, [null, prime]);
             } catch (e) {
               if (shouldThrowCryptoValidationError2(e)) {
@@ -1946,7 +2952,7 @@
             }
           };
         }
-        result2.createPublicKey = function createPublicKey(key) {
+        result.createPublicKey = function createPublicKey(key) {
           if (typeof _cryptoCreateKeyObject !== "undefined") {
             var resultJson;
             try {
@@ -1961,7 +2967,7 @@
           }
           return createAsymmetricKeyObject2("public", key);
         };
-        result2.createPrivateKey = function createPrivateKey(key) {
+        result.createPrivateKey = function createPrivateKey(key) {
           if (typeof _cryptoCreateKeyObject !== "undefined") {
             var resultJson;
             try {
@@ -1976,7 +2982,7 @@
           }
           return createAsymmetricKeyObject2("private", key);
         };
-        result2.createSecretKey = function createSecretKey(key, encoding) {
+        result.createSecretKey = function createSecretKey(key, encoding) {
           return new SandboxKeyObject2("secret", {
             raw: toRawBuffer2(key, encoding).toString("base64")
           });
@@ -1997,7 +3003,7 @@
             asymmetricKeyDetails: key._sourceKeyObjectData && key._sourceKeyObjectData.asymmetricKeyDetails
           });
         };
-        result2.KeyObject = SandboxKeyObject2;
+        result.KeyObject = SandboxKeyObject2;
       }
       if (typeof _cryptoSubtle !== "undefined") {
         let SandboxCryptoKey2 = function(keyData) {
@@ -2044,12 +3050,12 @@
         SandboxSubtle.digest = function digest(algorithm, data) {
           return Promise.resolve().then(function() {
             var algo = normalizeAlgo2(algorithm);
-            var result22 = JSON.parse(subtleCall2({
+            var result2 = JSON.parse(subtleCall2({
               op: "digest",
               algorithm: algo.name,
               data: toBase642(data)
             }));
-            var buf = Buffer.from(result22.data, "base64");
+            var buf = Buffer.from(result2.data, "base64");
             return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
           });
         };
@@ -2061,19 +3067,19 @@
             if (reqAlgo.publicExponent) {
               reqAlgo.publicExponent = Buffer.from(new Uint8Array(reqAlgo.publicExponent.buffer || reqAlgo.publicExponent)).toString("base64");
             }
-            var result22 = JSON.parse(subtleCall2({
+            var result2 = JSON.parse(subtleCall2({
               op: "generateKey",
               algorithm: reqAlgo,
               extractable,
               usages: Array.from(keyUsages)
             }));
-            if (result22.publicKey && result22.privateKey) {
+            if (result2.publicKey && result2.privateKey) {
               return {
-                publicKey: new SandboxCryptoKey2(result22.publicKey),
-                privateKey: new SandboxCryptoKey2(result22.privateKey)
+                publicKey: new SandboxCryptoKey2(result2.publicKey),
+                privateKey: new SandboxCryptoKey2(result2.privateKey)
               };
             }
-            return new SandboxCryptoKey2(result22.key);
+            return new SandboxCryptoKey2(result2.key);
           });
         };
         SandboxSubtle.importKey = function importKey(format, keyData, algorithm, extractable, keyUsages) {
@@ -2089,7 +3095,7 @@
             } else {
               serializedKeyData = toBase642(keyData);
             }
-            var result22 = JSON.parse(subtleCall2({
+            var result2 = JSON.parse(subtleCall2({
               op: "importKey",
               format,
               keyData: serializedKeyData,
@@ -2097,18 +3103,18 @@
               extractable,
               usages: Array.from(keyUsages)
             }));
-            return new SandboxCryptoKey2(result22.key);
+            return new SandboxCryptoKey2(result2.key);
           });
         };
         SandboxSubtle.exportKey = function exportKey(format, key) {
           return Promise.resolve().then(function() {
-            var result22 = JSON.parse(subtleCall2({
+            var result2 = JSON.parse(subtleCall2({
               op: "exportKey",
               format,
               key: key._keyData
             }));
-            if (format === "jwk") return result22.jwk;
-            var buf = Buffer.from(result22.data, "base64");
+            if (format === "jwk") return result2.jwk;
+            var buf = Buffer.from(result2.data, "base64");
             return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
           });
         };
@@ -2118,13 +3124,13 @@
             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({
+            var result2 = JSON.parse(subtleCall2({
               op: "encrypt",
               algorithm: reqAlgo,
               key: key._keyData,
               data: toBase642(data)
             }));
-            var buf = Buffer.from(result22.data, "base64");
+            var buf = Buffer.from(result2.data, "base64");
             return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
           });
         };
@@ -2134,38 +3140,38 @@
             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({
+            var result2 = JSON.parse(subtleCall2({
               op: "decrypt",
               algorithm: reqAlgo,
               key: key._keyData,
               data: toBase642(data)
             }));
-            var buf = Buffer.from(result22.data, "base64");
+            var buf = Buffer.from(result2.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({
+            var result2 = JSON.parse(subtleCall2({
               op: "sign",
               algorithm: normalizeAlgo2(algorithm),
               key: key._keyData,
               data: toBase642(data)
             }));
-            var buf = Buffer.from(result22.data, "base64");
+            var buf = Buffer.from(result2.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({
+            var result2 = JSON.parse(subtleCall2({
               op: "verify",
               algorithm: normalizeAlgo2(algorithm),
               key: key._keyData,
               signature: toBase642(signature),
               data: toBase642(data)
             }));
-            return result22.result;
+            return result2.result;
           });
         };
         SandboxSubtle.deriveBits = function deriveBits(algorithm, baseKey, length) {
@@ -2174,13 +3180,13 @@
             var reqAlgo = Object.assign({}, algo);
             if (reqAlgo.salt) reqAlgo.salt = toBase642(reqAlgo.salt);
             if (reqAlgo.info) reqAlgo.info = toBase642(reqAlgo.info);
-            var result22 = JSON.parse(subtleCall2({
+            var result2 = JSON.parse(subtleCall2({
               op: "deriveBits",
               algorithm: reqAlgo,
               baseKey: baseKey._keyData,
               length
             }));
-            return Buffer.from(result22.data, "base64").buffer;
+            return Buffer.from(result2.data, "base64").buffer;
           });
         };
         SandboxSubtle.deriveKey = function deriveKey(algorithm, baseKey, derivedKeyAlgorithm, extractable, keyUsages) {
@@ -2189,7 +3195,7 @@
             var reqAlgo = Object.assign({}, algo);
             if (reqAlgo.salt) reqAlgo.salt = toBase642(reqAlgo.salt);
             if (reqAlgo.info) reqAlgo.info = toBase642(reqAlgo.info);
-            var result22 = JSON.parse(subtleCall2({
+            var result2 = JSON.parse(subtleCall2({
               op: "deriveKey",
               algorithm: reqAlgo,
               baseKey: baseKey._keyData,
@@ -2197,19 +3203,19 @@
               extractable,
               usages: keyUsages
             }));
-            return new SandboxCryptoKey2(result22.key);
+            return new SandboxCryptoKey2(result2.key);
           });
         };
         if (globalThis.crypto && globalThis.crypto.subtle && typeof globalThis.crypto.subtle.importKey === "function") {
-          result2.subtle = globalThis.crypto.subtle;
-          result2.webcrypto = globalThis.crypto;
+          result.subtle = globalThis.crypto.subtle;
+          result.webcrypto = globalThis.crypto;
         } else {
-          result2.subtle = SandboxSubtle;
-          result2.webcrypto = { subtle: SandboxSubtle, getRandomValues: result2.randomFillSync };
+          result.subtle = SandboxSubtle;
+          result.webcrypto = { subtle: SandboxSubtle, getRandomValues: result.randomFillSync };
         }
       }
-      if (typeof result2.getCurves !== "function") {
-        result2.getCurves = function getCurves() {
+      if (typeof result.getCurves !== "function") {
+        result.getCurves = function getCurves() {
           return [
             "prime256v1",
             "secp256r1",
@@ -2221,8 +3227,8 @@
           ];
         };
       }
-      if (typeof result2.getCiphers !== "function") {
-        result2.getCiphers = function getCiphers() {
+      if (typeof result.getCiphers !== "function") {
+        result.getCiphers = function getCiphers() {
           return [
             "aes-128-cbc",
             "aes-128-gcm",
@@ -2236,13 +3242,13 @@
           ];
         };
       }
-      if (typeof result2.getHashes !== "function") {
-        result2.getHashes = function getHashes() {
+      if (typeof result.getHashes !== "function") {
+        result.getHashes = function getHashes() {
           return ["md5", "sha1", "sha256", "sha384", "sha512"];
         };
       }
-      if (typeof result2.timingSafeEqual !== "function") {
-        result2.timingSafeEqual = function timingSafeEqual(a, b) {
+      if (typeof result.timingSafeEqual !== "function") {
+        result.timingSafeEqual = function timingSafeEqual(a, b) {
           if (a.length !== b.length) {
             throw new RangeError("Input buffers must have the same byte length");
           }
@@ -2253,36 +3259,112 @@
           return out === 0;
         };
       }
-      if (typeof result2.getFips !== "function") {
-        result2.getFips = function getFips() {
+      if (typeof result.getFips !== "function") {
+        result.getFips = function getFips() {
           return 0;
         };
       }
-      if (typeof result2.setFips !== "function") {
-        result2.setFips = function setFips() {
+      if (typeof result.setFips !== "function") {
+        result.setFips = function setFips() {
           throw new Error("FIPS mode is not supported in sandbox");
         };
       }
-      return result2;
+      return result;
     }
-    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)) {
+    if (name === "stream") {
+      var getWebStreamsState = function() {
+        return globalThis.__secureExecWebStreams || null;
+      };
+      var webStreamsState = getWebStreamsState();
+      if (typeof result.isReadable !== "function") {
+        result.isReadable = function(stream) {
+          var stateKey = getWebStreamsState() && getWebStreamsState().kState;
+          return Boolean(stateKey && stream && stream[stateKey] && stream[stateKey].state === "readable");
+        };
+      }
+      if (typeof result.isErrored !== "function") {
+        result.isErrored = function(stream) {
+          var stateKey = getWebStreamsState() && getWebStreamsState().kState;
+          return Boolean(stateKey && stream && stream[stateKey] && stream[stateKey].state === "errored");
+        };
+      }
+      if (typeof result.isDisturbed !== "function") {
+        result.isDisturbed = function(stream) {
+          var stateKey = getWebStreamsState() && getWebStreamsState().kState;
+          return Boolean(stateKey && stream && stream[stateKey] && stream[stateKey].disturbed === true);
+        };
+      }
+      if (typeof result === "function" && result.prototype && typeof result.Readable === "function") {
+        var readableProto = result.Readable.prototype;
+        var streamProto = result.prototype;
+        if (readableProto && streamProto && !(readableProto instanceof result)) {
           var currentParent = Object.getPrototypeOf(readableProto);
           Object.setPrototypeOf(streamProto, currentParent);
           Object.setPrototypeOf(readableProto, streamProto);
         }
       }
-      return result2;
+      if (typeof result.Readable === "function" && !Object.getOwnPropertyDescriptor(result.Readable.prototype, "readableObjectMode")) {
+        Object.defineProperty(result.Readable.prototype, "readableObjectMode", {
+          configurable: true,
+          enumerable: false,
+          get: function() {
+            return Boolean(this && this._readableState && this._readableState.objectMode);
+          }
+        });
+      }
+      if (typeof result.Writable === "function" && !Object.getOwnPropertyDescriptor(result.Writable.prototype, "writableObjectMode")) {
+        Object.defineProperty(result.Writable.prototype, "writableObjectMode", {
+          configurable: true,
+          enumerable: false,
+          get: function() {
+            return Boolean(this && this._writableState && this._writableState.objectMode);
+          }
+        });
+      }
+      if (webStreamsState && typeof result.Readable === "function") {
+        if (typeof result.Readable.fromWeb !== "function" && typeof webStreamsState.newStreamReadableFromReadableStream === "function") {
+          result.Readable.fromWeb = function fromWeb(readableStream, options) {
+            return webStreamsState.newStreamReadableFromReadableStream(readableStream, options);
+          };
+        }
+        if (typeof result.Readable.toWeb !== "function" && typeof webStreamsState.newReadableStreamFromStreamReadable === "function") {
+          result.Readable.toWeb = function toWeb(readable) {
+            return webStreamsState.newReadableStreamFromStreamReadable(readable);
+          };
+        }
+      }
+      if (webStreamsState && typeof result.Writable === "function") {
+        if (typeof result.Writable.fromWeb !== "function" && typeof webStreamsState.newStreamWritableFromWritableStream === "function") {
+          result.Writable.fromWeb = function fromWeb(writableStream, options) {
+            return webStreamsState.newStreamWritableFromWritableStream(writableStream, options);
+          };
+        }
+        if (typeof result.Writable.toWeb !== "function" && typeof webStreamsState.newWritableStreamFromStreamWritable === "function") {
+          result.Writable.toWeb = function toWeb(writable) {
+            return webStreamsState.newWritableStreamFromStreamWritable(writable);
+          };
+        }
+      }
+      if (webStreamsState && typeof result.Duplex === "function") {
+        if (typeof result.Duplex.fromWeb !== "function" && typeof webStreamsState.newStreamDuplexFromReadableWritablePair === "function") {
+          result.Duplex.fromWeb = function fromWeb(pair, options) {
+            return webStreamsState.newStreamDuplexFromReadableWritablePair(pair, options);
+          };
+        }
+        if (typeof result.Duplex.toWeb !== "function" && typeof webStreamsState.newReadableWritablePairFromDuplex === "function") {
+          result.Duplex.toWeb = function toWeb(duplex) {
+            return webStreamsState.newReadableWritablePairFromDuplex(duplex);
+          };
+        }
+      }
+      return result;
     }
-    if (name2 === "path") {
-      if (result2.win32 === null || result2.win32 === void 0) {
-        result2.win32 = result2.posix || result2;
+    if (name === "path") {
+      if (result.win32 === null || result.win32 === void 0) {
+        result.win32 = result.posix || result;
       }
-      if (result2.posix === null || result2.posix === void 0) {
-        result2.posix = result2;
+      if (result.posix === null || result.posix === void 0) {
+        result.posix = result;
       }
       const hasAbsoluteSegment = function(args) {
         return args.some(function(arg) {
@@ -2298,7 +3380,7 @@
           }
         }
       };
-      const originalResolve = result2.resolve;
+      const originalResolve = result.resolve;
       if (typeof originalResolve === "function" && !originalResolve._patchedForCwd) {
         const patchedResolve = function resolve2() {
           const args = Array.from(arguments);
@@ -2306,20 +3388,20 @@
           return originalResolve.apply(this, args);
         };
         patchedResolve._patchedForCwd = true;
-        result2.resolve = patchedResolve;
+        result.resolve = patchedResolve;
       }
-      if (result2.posix && typeof result2.posix.resolve === "function" && !result2.posix.resolve._patchedForCwd) {
-        const originalPosixResolve = result2.posix.resolve;
+      if (result.posix && typeof result.posix.resolve === "function" && !result.posix.resolve._patchedForCwd) {
+        const originalPosixResolve = result.posix.resolve;
         const patchedPosixResolve = function resolve2() {
           const args = Array.from(arguments);
           prependCwd(args);
           return originalPosixResolve.apply(this, args);
         };
         patchedPosixResolve._patchedForCwd = true;
-        result2.posix.resolve = patchedPosixResolve;
+        result.posix.resolve = patchedPosixResolve;
       }
     }
-    return result2;
+    return result;
   }
   var _deferredCoreModules = /* @__PURE__ */ new Set([
     "readline",
@@ -2336,11 +3418,29 @@
     "trace_events",
     "domain"
   ]);
-  function _unsupportedApiError(moduleName2, apiName) {
-    return new Error(moduleName2 + "." + apiName + " is not supported in sandbox");
+  function _unsupportedApiError(moduleName, apiName) {
+    return new Error(moduleName + "." + apiName + " is not supported in sandbox");
   }
-  function _createDeferredModuleStub(moduleName2) {
+  function _createDeferredModuleStub(moduleName) {
     const methodCache = {};
+    const workerThreadsCompat = {
+      markAsUncloneable: function markAsUncloneable(value) {
+        return value;
+      },
+      markAsUntransferable: function markAsUntransferable(value) {
+        return value;
+      },
+      isMarkedAsUntransferable: function isMarkedAsUntransferable() {
+        return false;
+      },
+      MessagePort: globalThis.MessagePort,
+      MessageChannel: globalThis.MessageChannel,
+      MessageEvent: globalThis.MessageEvent
+    };
+    const moduleCompat = {
+      worker_threads: workerThreadsCompat,
+      "node:worker_threads": workerThreadsCompat
+    };
     let stub = null;
     stub = new Proxy({}, {
       get(_target, prop) {
@@ -2349,9 +3449,12 @@
         if (prop === Symbol.toStringTag) return "Module";
         if (prop === "then") return void 0;
         if (typeof prop !== "string") return void 0;
+        if (moduleCompat[moduleName] && Object.prototype.hasOwnProperty.call(moduleCompat[moduleName], prop)) {
+          return moduleCompat[moduleName][prop];
+        }
         if (!methodCache[prop]) {
           methodCache[prop] = function deferredApiStub() {
-            throw _unsupportedApiError(moduleName2, prop);
+            throw _unsupportedApiError(moduleName, prop);
           };
         }
         return methodCache[prop];
@@ -2360,38 +3463,38 @@
     return stub;
   }
   var __internalModuleCache = _moduleCache;
-  var __require = function require2(moduleName2) {
-    return _requireFrom(moduleName2, _currentModule.dirname);
+  var __require = function require2(moduleName) {
+    return _requireFrom(moduleName, _currentModule.dirname);
   };
   __requireExposeCustomGlobal("require", __require);
-  function _resolveFrom(moduleName2, fromDir2) {
-    var resolved2;
+  function _resolveFrom(moduleName, fromDir) {
+    var resolved;
     if (typeof _resolveModuleSync !== "undefined") {
-      resolved2 = _resolveModuleSync.applySync(void 0, [moduleName2, fromDir2]);
+      resolved = _resolveModuleSync.applySync(void 0, [moduleName, fromDir]);
     }
-    if (resolved2 === null || resolved2 === void 0) {
-      resolved2 = _resolveModule.applySyncPromise(void 0, [moduleName2, fromDir2, "require"]);
+    if (resolved === null || resolved === void 0) {
+      resolved = _resolveModule.applySyncPromise(void 0, [moduleName, fromDir, "require"]);
     }
-    if (resolved2 === null) {
-      const err = new Error("Cannot find module '" + moduleName2 + "'");
+    if (resolved === null) {
+      const err = new Error("Cannot find module '" + moduleName + "'");
       err.code = "MODULE_NOT_FOUND";
       throw err;
     }
-    return resolved2;
+    return resolved;
   }
-  globalThis.require.resolve = function resolve(moduleName2) {
-    return _resolveFrom(moduleName2, _currentModule.dirname);
+  globalThis.require.resolve = function resolve(moduleName) {
+    return _resolveFrom(moduleName, _currentModule.dirname);
   };
-  function _debugRequire(phase, moduleName2, extra) {
+  function _debugRequire(phase, moduleName, extra) {
     if (globalThis.__sandboxRequireDebug !== true) {
       return;
     }
-    if (moduleName2 !== "rivetkit" && moduleName2 !== "@rivetkit/traces" && moduleName2 !== "@rivetkit/on-change" && moduleName2 !== "async_hooks" && !moduleName2.startsWith("rivetkit/") && !moduleName2.startsWith("@rivetkit/")) {
+    if (moduleName !== "rivetkit" && moduleName !== "@rivetkit/traces" && moduleName !== "@rivetkit/on-change" && moduleName !== "async_hooks" && !moduleName.startsWith("rivetkit/") && !moduleName.startsWith("@rivetkit/")) {
       return;
     }
     if (typeof console !== "undefined" && typeof console.log === "function") {
       console.log(
-        "[sandbox.require] " + phase + " " + moduleName2 + (extra ? " " + extra : "")
+        "[sandbox.require] " + phase + " " + moduleName + (extra ? " " + extra : "")
       );
     }
   }
@@ -2577,13 +3680,14 @@
     }
     if (name === "internal/http2/util") {
       if (__internalModuleCache[name]) return __internalModuleCache[name];
-      class NghttpError extends Error {
+      const sharedNghttpError = _http2Module?.NghttpError;
+      const NghttpError = typeof sharedNghttpError === "function" ? sharedNghttpError : class NghttpError extends Error {
         constructor(message) {
           super(message);
           this.name = "Error";
           this.code = "ERR_HTTP2_ERROR";
         }
-      }
+      };
       const utilModule = {
         kSocket: /* @__PURE__ */ Symbol.for("secure-exec.http2.kSocket"),
         NghttpError
@@ -2620,6 +3724,13 @@
       _debugRequire("loaded", name, "process-special");
       return globalThis.process;
     }
+    if (name === "v8") {
+      if (__internalModuleCache["v8"]) return __internalModuleCache["v8"];
+      const v8Module = globalThis._moduleCache?.v8 || {};
+      __internalModuleCache["v8"] = v8Module;
+      _debugRequire("loaded", name, "v8-special");
+      return v8Module;
+    }
     if (name === "async_hooks") {
       if (__internalModuleCache["async_hooks"]) return __internalModuleCache["async_hooks"];
       class AsyncLocalStorage {
@@ -2765,7 +3876,7 @@
       if (__internalModuleCache[name]) return __internalModuleCache[name];
       const moduleObj = { exports: {} };
       _pendingModules[name] = moduleObj;
-      let result = eval(polyfillCode);
+      let result = Function('"use strict"; return (' + polyfillCode + ");")();
       result = _patchPolyfill(name, result);
       if (typeof result === "object" && result !== null) {
         Object.assign(moduleObj.exports, result);
@@ -2804,7 +3915,6 @@
       __internalModuleCache[cacheKey] = parsed;
       return parsed;
     }
-    const normalizedSource = typeof source === "string" ? source.replace(/import\.meta\.url/g, "__filename").replace(/fileURLToPath\(__filename\)/g, "__filename").replace(/url\.fileURLToPath\(__filename\)/g, "__filename").replace(/fileURLToPath\.call\(void 0, __filename\)/g, "__filename") : source;
     const module = {
       exports: {},
       filename: resolved,
@@ -2817,15 +3927,17 @@
     _currentModule = module;
     try {
       let wrapper;
+      const isRequireTransformedEsm = typeof source === "string" && source.startsWith(REQUIRE_TRANSFORM_MARKER);
+      const wrapperPrologue = isRequireTransformedEsm ? "" : "var __filename = __secureExecFilename;\nvar __dirname = __secureExecDirname;\n";
       try {
         wrapper = new Function(
           "exports",
           "require",
           "module",
-          "__filename",
-          "__dirname",
+          "__secureExecFilename",
+          "__secureExecDirname",
           "__dynamicImport",
-          normalizedSource + "\n//# sourceURL=" + resolved
+          wrapperPrologue + source + "\n//# sourceURL=" + resolved
         );
       } catch (error) {
         const details = error && error.stack ? error.stack : String(error);