wreq-js 1.6.1 → 2.0.0

package/dist/wreq-js.js

@@ -5,7 +5,7 @@ import { createRequire } from "module";
 import { ReadableStream } from "stream/web";
 
 // src/types.ts
-var RequestError = class extends Error {
+var RequestError = class extends TypeError {
   constructor(message) {
     super(message);
     this.name = "RequestError";
@@ -15,7 +15,9 @@ var RequestError = class extends Error {
 // src/wreq-js.ts
 var nativeBinding;
 var cachedProfiles;
+var cachedProfileSet;
 var cachedOperatingSystems;
+var cachedOperatingSystemSet;
 function detectLibc() {
   if (process.platform !== "linux") {
     return void 0;
@@ -84,8 +86,13 @@ var bodyHandleFinalizer = typeof FinalizationRegistry === "function" ? new Final
 }) : void 0;
 var DEFAULT_BROWSER = "chrome_142";
 var DEFAULT_OS = "macos";
+var DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
 var SUPPORTED_OSES = ["windows", "macos", "linux", "android", "ios"];
 var UTF8_DECODER = new TextDecoder("utf-8");
+var ephemeralIdCounter = 0;
+function generateEphemeralSessionId() {
+  return `_e${++ephemeralIdCounter}`;
+}
 function generateSessionId() {
   return randomUUID();
 }
@@ -248,37 +255,37 @@ var Headers = class _Headers {
   }
 };
 function headersToTuples(init) {
-  if (Array.isArray(init)) {
-    return init;
-  }
-  if (init instanceof Headers) {
-    return init.toTuples();
+  return new Headers(init).toTuples();
+}
+function hasHeaderName(tuples, name) {
+  if (!tuples) {
+    return false;
   }
-  const out = [];
-  if (isPlainObject(init)) {
-    for (const name in init) {
-      if (!Object.hasOwn(init, name)) {
-        continue;
-      }
-      const value = init[name];
-      if (value === void 0 || value === null) {
-        continue;
-      }
-      out.push([name, String(value)]);
+  const target = name.toLowerCase();
+  for (const [headerName] of tuples) {
+    if (headerName.toLowerCase() === target) {
+      return true;
     }
-    return out;
   }
-  if (isIterable(init)) {
-    for (const tuple of init) {
-      if (!tuple) {
-        continue;
-      }
-      const [name, value] = tuple;
-      out.push([name, value]);
-    }
-    return out;
+  return false;
+}
+function hasWebSocketProtocolHeader(headers) {
+  const protocolHeaderName = "Sec-WebSocket-Protocol";
+  if (!headers) {
+    return false;
+  }
+  return hasHeaderName(headersToTuples(headers), protocolHeaderName);
+}
+function assertNoManualWebSocketProtocolHeader(headers) {
+  if (hasWebSocketProtocolHeader(headers)) {
+    throw new RequestError("Do not set `Sec-WebSocket-Protocol` header manually; use the `protocols` option instead.");
+  }
+}
+function normalizeWebSocketProtocolList(protocols) {
+  if (protocols === void 0) {
+    return void 0;
   }
-  return out;
+  return typeof protocols === "string" ? [protocols] : [...protocols];
 }
 function mergeHeaderTuples(defaults, overrides) {
   if (!defaults) {
@@ -291,9 +298,19 @@ function mergeHeaderTuples(defaults, overrides) {
   if (overrideTuples.length === 0) {
     return defaults;
   }
-  const overrideKeys = new Set(overrideTuples.map(([name]) => name.toLowerCase()));
-  const merged = defaults.filter(([name]) => !overrideKeys.has(name.toLowerCase()));
-  merged.push(...overrideTuples);
+  const overrideKeys = /* @__PURE__ */ new Set();
+  for (const tuple of overrideTuples) {
+    overrideKeys.add(tuple[0].toLowerCase());
+  }
+  const merged = [];
+  for (const tuple of defaults) {
+    if (!overrideKeys.has(tuple[0].toLowerCase())) {
+      merged.push(tuple);
+    }
+  }
+  for (const tuple of overrideTuples) {
+    merged.push(tuple);
+  }
   return merged;
 }
 function cloneNativeResponse(payload) {
@@ -350,13 +367,16 @@ function createNativeBodyStream(handle) {
 }
 function wrapBodyStream(source, onFirstUse) {
   let started = false;
-  const reader = source.getReader();
+  let reader = null;
   return new ReadableStream({
     async pull(controller) {
       if (!started) {
         started = true;
         onFirstUse();
       }
+      if (!reader) {
+        reader = source.getReader();
+      }
       try {
         const { done, value } = await reader.read();
         if (done) {
@@ -369,6 +389,9 @@ function wrapBodyStream(source, onFirstUse) {
       }
     },
     cancel(reason) {
+      if (!reader) {
+        return source.cancel(reason);
+      }
       return reader.cancel(reason);
     }
   });
@@ -502,6 +525,9 @@ var Response = class _Response {
     const bytes = await this.consumeBody();
     const { buffer, byteOffset, byteLength } = bytes;
     if (buffer instanceof ArrayBuffer) {
+      if (byteOffset === 0 && byteLength === buffer.byteLength) {
+        return buffer;
+      }
       return buffer.slice(byteOffset, byteOffset + byteLength);
     }
     const view = new Uint8Array(byteLength);
@@ -512,8 +538,22 @@ var Response = class _Response {
     const bytes = await this.consumeBody();
     return UTF8_DECODER.decode(bytes);
   }
+  async blob() {
+    const bytes = await this.consumeBody();
+    const contentType = this.headers.get("content-type") ?? "";
+    return new Blob([bytes], contentType ? { type: contentType } : void 0);
+  }
+  async formData() {
+    const bytes = await this.consumeBody();
+    const contentType = this.headers.get("content-type");
+    const response = new globalThis.Response(
+      bytes,
+      contentType ? { headers: { "content-type": contentType } } : void 0
+    );
+    return response.formData();
+  }
   clone() {
-    if (this.bodyUsed || this.bodyStream) {
+    if (this.bodyUsed) {
       throw new TypeError("Cannot clone a Response whose body is already used");
     }
     if (this.nativeHandleAvailable && this.payload.bodyHandle !== null) {
@@ -551,7 +591,7 @@ var Response = class _Response {
       try {
         return await nativeBinding.readBodyAll(this.payload.bodyHandle);
       } catch (error) {
-        if (String(error).includes("not found")) {
+        if (String(error).includes("Body handle") && String(error).includes("not found")) {
           return Buffer.alloc(0);
         }
         throw error;
@@ -648,6 +688,36 @@ var Session = class {
       throw new RequestError(String(error));
     }
   }
+  async websocket(urlOrOptions, options) {
+    this.ensureActive();
+    const normalized = normalizeSessionWebSocketArgs(urlOrOptions, options);
+    validateWebSocketProtocols(normalized.options.protocols);
+    assertNoManualWebSocketProtocolHeader(normalized.options.headers);
+    const protocols = normalizeWebSocketProtocolList(normalized.options.protocols);
+    const transportId = this.defaults.transportId;
+    if (!transportId) {
+      throw new RequestError(
+        "Session has no transport. Create the session with browser/os options or pass a transport to use session.websocket()."
+      );
+    }
+    return WebSocket._connectWithInit({
+      _internal: true,
+      url: normalized.url,
+      options: normalized.options,
+      openDispatchMode: "deferred",
+      connect: (callbacks) => nativeBinding.websocketConnectSession({
+        url: normalized.url,
+        sessionId: this.id,
+        transportId,
+        headers: headersToTuples(normalized.options.headers ?? {}),
+        ...protocols && protocols.length > 0 && { protocols },
+        onMessage: callbacks.onMessage,
+        onClose: callbacks.onClose,
+        onError: callbacks.onError
+      }),
+      legacyCallbacks: normalized.legacyCallbacks
+    });
+  }
   async close() {
     if (this.disposed) {
       return;
@@ -715,7 +785,7 @@ function resolveSessionContext(config) {
     throw new RequestError("cookieMode 'session' requires a session or sessionId");
   }
   return {
-    sessionId: generateSessionId(),
+    sessionId: generateEphemeralSessionId(),
     cookieMode: "ephemeral",
     dropAfterRequest: true
   };
@@ -728,7 +798,7 @@ function resolveTransportContext(config, sessionDefaults) {
     if (config.transport.closed) {
       throw new RequestError("Transport has been closed");
     }
-    const hasProxy = Object.hasOwn(config, "proxy");
+    const hasProxy = config.proxy !== void 0;
     if (config.browser !== void 0 || config.os !== void 0 || hasProxy || config.insecure !== void 0) {
       throw new RequestError("`transport` cannot be combined with browser/os/proxy/insecure options");
     }
@@ -779,8 +849,10 @@ function createAbortError(reason) {
     return reason.name === "AbortError" ? reason : new DOMException(reason.message || fallbackMessage, "AbortError");
   }
   if (reason instanceof Error) {
-    reason.name = "AbortError";
-    return reason;
+    const error2 = new Error(reason.message);
+    error2.name = "AbortError";
+    error2.cause = reason;
+    return error2;
   }
   if (typeof DOMException !== "undefined") {
     return new DOMException(fallbackMessage, "AbortError");
@@ -826,11 +898,55 @@ function setupAbort(signal, cancelNative) {
   return { promise, cleanup };
 }
 function coerceUrlInput(input) {
-  const value = typeof input === "string" ? input.trim() : input.href;
-  if (!value) {
+  if (input instanceof URL) {
+    return input.href;
+  }
+  if (input.length === 0) {
     throw new RequestError("URL is required");
   }
-  return value;
+  if (input.charCodeAt(0) > 32 && input.charCodeAt(input.length - 1) > 32) {
+    return input;
+  }
+  const trimmed = input.trim();
+  if (trimmed.length === 0) {
+    throw new RequestError("URL is required");
+  }
+  return trimmed;
+}
+function isRequestLike(input) {
+  if (!input || typeof input !== "object") {
+    return false;
+  }
+  if (typeof Request !== "undefined" && input instanceof Request) {
+    return true;
+  }
+  const candidate = input;
+  return typeof candidate.url === "string" && typeof candidate.method === "string" && typeof candidate.arrayBuffer === "function" && typeof candidate.redirect === "string";
+}
+async function resolveFetchArgs(input, init) {
+  if (!isRequestLike(input)) {
+    return { url: coerceUrlInput(input), init: init ?? {} };
+  }
+  const mergedInit = init ? { ...init } : {};
+  if (mergedInit.method === void 0) {
+    mergedInit.method = input.method;
+  }
+  if (mergedInit.headers === void 0) {
+    mergedInit.headers = input.headers;
+  }
+  if (mergedInit.redirect === void 0 && (input.redirect === "follow" || input.redirect === "manual" || input.redirect === "error")) {
+    mergedInit.redirect = input.redirect;
+  }
+  if (mergedInit.signal === void 0) {
+    mergedInit.signal = input.signal;
+  }
+  if (mergedInit.body === void 0 && input.body !== null) {
+    if (input.bodyUsed) {
+      throw new TypeError("Request body is already used");
+    }
+    mergedInit.body = Buffer.from(await input.arrayBuffer());
+  }
+  return { url: coerceUrlInput(input.url), init: mergedInit };
 }
 function normalizeUrlForComparison(value) {
   try {
@@ -845,30 +961,58 @@ function validateRedirectMode(mode) {
   }
   throw new RequestError(`Redirect mode '${mode}' is not supported`);
 }
-function serializeBody(body) {
+async function serializeBody(body) {
   if (body === null || body === void 0) {
-    return void 0;
+    return {};
   }
   if (typeof body === "string") {
-    return Buffer.from(body, "utf8");
+    return { body: Buffer.from(body, "utf8") };
   }
   if (Buffer.isBuffer(body)) {
-    return body;
+    return { body };
   }
   if (body instanceof URLSearchParams) {
-    return Buffer.from(body.toString(), "utf8");
+    return {
+      body: Buffer.from(body.toString(), "utf8"),
+      contentType: "application/x-www-form-urlencoded;charset=UTF-8"
+    };
   }
   if (body instanceof ArrayBuffer) {
-    return Buffer.from(body);
+    return { body: Buffer.from(body) };
   }
   if (ArrayBuffer.isView(body)) {
-    return Buffer.from(body.buffer, body.byteOffset, body.byteLength);
+    return { body: Buffer.from(body.buffer, body.byteOffset, body.byteLength) };
+  }
+  if (typeof Blob !== "undefined" && body instanceof Blob) {
+    const buffer = Buffer.from(await body.arrayBuffer());
+    return { body: buffer, ...body.type ? { contentType: body.type } : {} };
+  }
+  if (typeof FormData !== "undefined" && body instanceof FormData) {
+    const encoded = new globalThis.Response(body);
+    const contentType = encoded.headers.get("content-type") ?? void 0;
+    const buffer = Buffer.from(await encoded.arrayBuffer());
+    return { body: buffer, ...contentType ? { contentType } : {} };
   }
-  throw new TypeError("Unsupported body type; expected string, Buffer, ArrayBuffer, or URLSearchParams");
+  throw new TypeError(
+    "Unsupported body type; expected string, Buffer, ArrayBuffer, ArrayBufferView, URLSearchParams, Blob, or FormData"
+  );
 }
 function ensureMethod(method) {
-  const normalized = method?.trim().toUpperCase();
-  return normalized && normalized.length > 0 ? normalized : "GET";
+  if (method === void 0 || method.length === 0) {
+    return "GET";
+  }
+  switch (method) {
+    case "GET":
+    case "POST":
+    case "PUT":
+    case "DELETE":
+    case "PATCH":
+    case "HEAD":
+    case "OPTIONS":
+      return method;
+  }
+  const normalized = method.trim().toUpperCase();
+  return normalized.length > 0 ? normalized : "GET";
 }
 function ensureBodyAllowed(method, body) {
   if (body === void 0) {
@@ -879,21 +1023,25 @@ function ensureBodyAllowed(method, body) {
   }
 }
 function validateBrowserProfile(browser) {
-  if (!browser) {
+  if (browser === void 0) {
     return;
   }
-  const profiles = getProfiles();
-  if (!profiles.includes(browser)) {
-    throw new RequestError(`Invalid browser profile: ${browser}. Available profiles: ${profiles.join(", ")}`);
+  if (typeof browser !== "string" || browser.trim().length === 0) {
+    throw new RequestError("Browser profile must not be empty");
+  }
+  if (!getProfileSet().has(browser)) {
+    throw new RequestError(`Invalid browser profile: ${browser}. Available profiles: ${getProfiles().join(", ")}`);
   }
 }
 function validateOperatingSystem(os) {
-  if (!os) {
+  if (os === void 0) {
     return;
   }
-  const operatingSystems = getOperatingSystems();
-  if (!operatingSystems.includes(os)) {
-    throw new RequestError(`Invalid operating system: ${os}. Available options: ${operatingSystems.join(", ")}`);
+  if (typeof os !== "string" || os.trim().length === 0) {
+    throw new RequestError("Operating system must not be empty");
+  }
+  if (!getOperatingSystemSet().has(os)) {
+    throw new RequestError(`Invalid operating system: ${os}. Available options: ${getOperatingSystems().join(", ")}`);
   }
 }
 function validateTimeout(timeout) {
@@ -903,8 +1051,8 @@ function validateTimeout(timeout) {
   if (typeof timeout !== "number" || !Number.isFinite(timeout)) {
     throw new RequestError("Timeout must be a finite number");
   }
-  if (timeout <= 0) {
-    throw new RequestError("Timeout must be greater than 0");
+  if (timeout < 0) {
+    throw new RequestError("Timeout must be 0 (no timeout) or a positive number");
   }
 }
 function validatePositiveNumber(value, label) {
@@ -953,10 +1101,6 @@ async function dispatchRequest(options, requestUrl, signal) {
     }
   };
   const abortHandler = setupAbort(signal, cancelNative);
-  if (!abortHandler) {
-    cancelNative();
-    throw createAbortError(signal.reason);
-  }
   const pending = Promise.race([nativeBinding.request(options, requestId, true), abortHandler.promise]);
   let payload;
   try {
@@ -975,8 +1119,9 @@ async function dispatchRequest(options, requestUrl, signal) {
   return new Response(payload, requestUrl);
 }
 async function fetch(input, init) {
-  const url = coerceUrlInput(input);
-  const config = init ?? {};
+  const resolved = await resolveFetchArgs(input, init);
+  const url = resolved.url;
+  const config = resolved.init;
   const sessionContext = resolveSessionContext(config);
   const sessionDefaults = sessionContext.defaults;
   validateRedirectMode(config.redirect);
@@ -984,11 +1129,18 @@ async function fetch(input, init) {
     validateTimeout(config.timeout);
   }
   const method = ensureMethod(config.method);
-  const body = serializeBody(config.body ?? null);
+  const serializedBody = await serializeBody(config.body ?? null);
+  const body = serializedBody.body;
   ensureBodyAllowed(method, body);
-  const headerTuples = mergeHeaderTuples(sessionDefaults?.defaultHeaders, config.headers);
+  let headerTuples = mergeHeaderTuples(sessionDefaults?.defaultHeaders, config.headers);
+  if (serializedBody.contentType && !hasHeaderName(headerTuples, "content-type")) {
+    if (!headerTuples) {
+      headerTuples = [];
+    }
+    headerTuples.push(["Content-Type", serializedBody.contentType]);
+  }
   const transport = resolveTransportContext(config, sessionDefaults);
-  const timeout = config.timeout ?? sessionDefaults?.timeout;
+  const timeout = config.timeout ?? sessionDefaults?.timeout ?? DEFAULT_REQUEST_TIMEOUT_MS;
   const requestOptions = {
     url,
     method,
@@ -1010,9 +1162,7 @@ async function fetch(input, init) {
       requestOptions.insecure = transport.insecure;
     }
   }
-  if (timeout !== void 0) {
-    requestOptions.timeout = timeout;
-  }
+  requestOptions.timeout = timeout;
   if (config.redirect !== void 0) {
     requestOptions.redirect = config.redirect;
   }
@@ -1106,6 +1256,7 @@ async function request(options) {
   }
   const { url, ...rest } = options;
   const init = {};
+  const legacy = rest;
   if (rest.method !== void 0) {
     init.method = rest.method;
   }
@@ -1133,12 +1284,26 @@ async function request(options) {
   if (rest.transport !== void 0) {
     init.transport = rest.transport;
   }
+  if (rest.insecure !== void 0) {
+    init.insecure = rest.insecure;
+  }
   if (rest.disableDefaultHeaders !== void 0) {
     init.disableDefaultHeaders = rest.disableDefaultHeaders;
   }
   if (rest.redirect !== void 0) {
     init.redirect = rest.redirect;
   }
+  if (legacy.signal !== void 0) {
+    init.signal = legacy.signal;
+  }
+  if (legacy.session !== void 0) {
+    init.session = legacy.session;
+  }
+  if (legacy.cookieMode !== void 0) {
+    init.cookieMode = legacy.cookieMode;
+  } else if (legacy.ephemeral === true) {
+    init.cookieMode = "ephemeral";
+  }
   return fetch(url, init);
 }
 function getProfiles() {
@@ -1147,6 +1312,12 @@ function getProfiles() {
   }
   return cachedProfiles;
 }
+function getProfileSet() {
+  if (!cachedProfileSet) {
+    cachedProfileSet = new Set(getProfiles());
+  }
+  return cachedProfileSet;
+}
 function getOperatingSystems() {
   if (!cachedOperatingSystems) {
     const fromNative = nativeBinding.getOperatingSystems?.();
@@ -1154,6 +1325,12 @@ function getOperatingSystems() {
   }
   return cachedOperatingSystems;
 }
+function getOperatingSystemSet() {
+  if (!cachedOperatingSystemSet) {
+    cachedOperatingSystemSet = new Set(getOperatingSystems());
+  }
+  return cachedOperatingSystemSet;
+}
 async function get(url, init) {
   const config = {};
   if (init) {
@@ -1173,72 +1350,696 @@ async function post(url, body, init) {
   }
   return fetch(url, config);
 }
-var WebSocket = class {
+function normalizeWebSocketUrl(url) {
+  const normalized = String(url).trim();
+  if (!normalized) {
+    throw new RequestError("URL is required");
+  }
+  let parsed;
+  try {
+    parsed = new URL(normalized);
+  } catch (error) {
+    throw new RequestError(String(error));
+  }
+  if (parsed.hash) {
+    throw new RequestError("WebSocket URL must not include a hash fragment");
+  }
+  if (parsed.protocol === "http:") {
+    parsed.protocol = "ws:";
+  } else if (parsed.protocol === "https:") {
+    parsed.protocol = "wss:";
+  }
+  if (parsed.protocol !== "ws:" && parsed.protocol !== "wss:") {
+    throw new RequestError("expected a ws: or wss: url");
+  }
+  return parsed.toString();
+}
+function validateWebSocketProtocols(protocols) {
+  if (protocols === void 0) {
+    return;
+  }
+  const protocolList = typeof protocols === "string" ? [protocols] : protocols;
+  const seen = /* @__PURE__ */ new Set();
+  const validToken = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+  for (const protocol of protocolList) {
+    if (typeof protocol !== "string" || protocol.length === 0) {
+      throw new RequestError("WebSocket protocol values must be non-empty strings");
+    }
+    if (!validToken.test(protocol)) {
+      throw new RequestError(`Invalid WebSocket protocol value: ${protocol}`);
+    }
+    if (seen.has(protocol)) {
+      throw new RequestError(`Duplicate WebSocket protocol: ${protocol}`);
+    }
+    seen.add(protocol);
+  }
+}
+function normalizeStandaloneWebSocketOptions(options) {
+  const normalized = {};
+  if (!options) {
+    return normalized;
+  }
+  if (options.browser !== void 0) {
+    normalized.browser = options.browser;
+  }
+  if (options.os !== void 0) {
+    normalized.os = options.os;
+  }
+  if (options.headers !== void 0) {
+    normalized.headers = options.headers;
+  }
+  if (options.proxy !== void 0) {
+    normalized.proxy = options.proxy;
+  }
+  if (options.protocols !== void 0) {
+    normalized.protocols = options.protocols;
+  }
+  if (options.binaryType !== void 0) {
+    if (options.binaryType !== "nodebuffer" && options.binaryType !== "arraybuffer" && options.binaryType !== "blob") {
+      throw new RequestError("binaryType must be one of: 'nodebuffer', 'arraybuffer', 'blob'");
+    }
+    normalized.binaryType = options.binaryType;
+  }
+  return normalized;
+}
+function normalizeSessionWebSocketOptions(options) {
+  const normalized = {};
+  if (!options) {
+    return normalized;
+  }
+  const optionsWithOverrides = options;
+  if (optionsWithOverrides.browser !== void 0) {
+    throw new RequestError(
+      "`browser` is not supported in session.websocket(); the session controls browser emulation."
+    );
+  }
+  if (optionsWithOverrides.os !== void 0) {
+    throw new RequestError("`os` is not supported in session.websocket(); the session controls OS emulation.");
+  }
+  if (optionsWithOverrides.proxy !== void 0) {
+    throw new RequestError("`proxy` is not supported in session.websocket(); the session transport controls proxying.");
+  }
+  if (options.headers !== void 0) {
+    normalized.headers = options.headers;
+  }
+  if (options.protocols !== void 0) {
+    normalized.protocols = options.protocols;
+  }
+  if (options.binaryType !== void 0) {
+    if (options.binaryType !== "nodebuffer" && options.binaryType !== "arraybuffer" && options.binaryType !== "blob") {
+      throw new RequestError("binaryType must be one of: 'nodebuffer', 'arraybuffer', 'blob'");
+    }
+    normalized.binaryType = options.binaryType;
+  }
+  return normalized;
+}
+function extractLegacyWebSocketCallbacks(options) {
+  if (!isPlainObject(options)) {
+    return void 0;
+  }
+  const maybeCallbacks = options;
+  const callbacks = {};
+  if (typeof maybeCallbacks.onMessage === "function") {
+    callbacks.onMessage = maybeCallbacks.onMessage;
+  }
+  if (typeof maybeCallbacks.onClose === "function") {
+    callbacks.onClose = maybeCallbacks.onClose;
+  }
+  if (typeof maybeCallbacks.onError === "function") {
+    callbacks.onError = maybeCallbacks.onError;
+  }
+  return Object.keys(callbacks).length > 0 ? callbacks : void 0;
+}
+function normalizeWebSocketCloseOptions(code, reason) {
+  if (code === void 0 && reason === void 0) {
+    return void 0;
+  }
+  if (code === void 0) {
+    throw new RequestError("A close code is required when providing a close reason");
+  }
+  if (!Number.isInteger(code)) {
+    throw new RequestError("Close code must be an integer");
+  }
+  if (code !== 1e3 && (code < 3e3 || code > 4999)) {
+    throw new RequestError("Close code must be 1000 or in range 3000-4999");
+  }
+  const normalizedReason = reason ?? "";
+  if (Buffer.byteLength(normalizedReason, "utf8") > 123) {
+    throw new RequestError("Close reason must be 123 bytes or fewer");
+  }
+  return {
+    code,
+    reason: normalizedReason
+  };
+}
+function isWebSocketListenerType(type) {
+  return type === "open" || type === "message" || type === "close" || type === "error";
+}
+var WebSocket = class _WebSocket {
+  static CONNECTING = 0;
+  static OPEN = 1;
+  static CLOSING = 2;
+  static CLOSED = 3;
+  url;
+  protocol = "";
+  extensions = "";
+  readyState = _WebSocket.CONNECTING;
+  _binaryType = "nodebuffer";
+  _bufferedAmount = 0;
+  _onopen = null;
+  _onmessage = null;
+  _onclose = null;
+  _onerror = null;
+  _onHandlerOrder = {
+    open: -1,
+    message: -1,
+    close: -1,
+    error: -1
+  };
+  _listenerOrderCounter = 0;
+  _listeners = {
+    open: /* @__PURE__ */ new Map(),
+    message: /* @__PURE__ */ new Map(),
+    close: /* @__PURE__ */ new Map(),
+    error: /* @__PURE__ */ new Map()
+  };
+  _legacyCallbacks;
+  _openDispatchMode;
   _connection;
+  _connectPromise;
+  _closeOptions;
   _finalizerToken;
-  _closed = false;
-  constructor(connection) {
-    this._connection = connection;
-    if (websocketFinalizer) {
-      this._finalizerToken = connection;
-      websocketFinalizer.register(this, connection, connection);
-    }
-  }
-  /**
-   * Send a message (text or binary)
-   */
-  async send(data) {
+  _openEventDispatched = false;
+  _openEventQueued = false;
+  _closeEventDispatched = false;
+  _nativeCloseStarted = false;
+  _pendingMessages = [];
+  _sendChain = Promise.resolve();
+  constructor(urlOrInit, protocolsOrOptions, maybeOptions) {
+    let init;
+    if (isInternalWebSocketInit(urlOrInit)) {
+      init = urlOrInit;
+    } else {
+      init = _WebSocket.buildStandaloneInit(urlOrInit, protocolsOrOptions, maybeOptions);
+    }
+    this.url = init.url;
+    this.binaryType = init.options.binaryType ?? "nodebuffer";
+    this._legacyCallbacks = init.legacyCallbacks;
+    this._openDispatchMode = init.openDispatchMode;
+    this._connectPromise = this.connect(init.connect);
+    void this._connectPromise.catch(() => void 0);
+  }
+  get binaryType() {
+    return this._binaryType;
+  }
+  set binaryType(value) {
+    if (value === "arraybuffer" || value === "blob" || value === "nodebuffer") {
+      this._binaryType = value;
+    }
+  }
+  get bufferedAmount() {
+    return this._bufferedAmount;
+  }
+  get onopen() {
+    return this._onopen;
+  }
+  set onopen(listener) {
+    this._onopen = listener;
+    this._onHandlerOrder.open = listener ? ++this._listenerOrderCounter : -1;
+  }
+  get onmessage() {
+    return this._onmessage;
+  }
+  set onmessage(listener) {
+    this._onmessage = listener;
+    this._onHandlerOrder.message = listener ? ++this._listenerOrderCounter : -1;
+  }
+  get onclose() {
+    return this._onclose;
+  }
+  set onclose(listener) {
+    this._onclose = listener;
+    this._onHandlerOrder.close = listener ? ++this._listenerOrderCounter : -1;
+  }
+  get onerror() {
+    return this._onerror;
+  }
+  set onerror(listener) {
+    this._onerror = listener;
+    this._onHandlerOrder.error = listener ? ++this._listenerOrderCounter : -1;
+  }
+  static async _connectWithInit(init) {
+    const ws = new _WebSocket(init);
+    await ws._waitUntilConnected();
+    ws.scheduleOpenEventAfterAwait();
+    return ws;
+  }
+  static buildStandaloneInit(url, protocolsOrOptions, maybeOptions) {
+    const optionsCandidate = typeof protocolsOrOptions === "string" || Array.isArray(protocolsOrOptions) ? maybeOptions : protocolsOrOptions ?? maybeOptions;
+    const normalizedOptions = normalizeStandaloneWebSocketOptions(optionsCandidate);
+    validateWebSocketProtocols(
+      typeof protocolsOrOptions === "string" || Array.isArray(protocolsOrOptions) ? protocolsOrOptions : normalizedOptions.protocols
+    );
+    assertNoManualWebSocketProtocolHeader(normalizedOptions.headers);
+    validateBrowserProfile(normalizedOptions.browser);
+    const os = normalizedOptions.os ?? DEFAULT_OS;
+    validateOperatingSystem(os);
+    const browser = normalizedOptions.browser ?? DEFAULT_BROWSER;
+    const protocols = normalizeWebSocketProtocolList(
+      typeof protocolsOrOptions === "string" || Array.isArray(protocolsOrOptions) ? protocolsOrOptions : normalizedOptions.protocols
+    );
+    return {
+      _internal: true,
+      url: normalizeWebSocketUrl(url),
+      options: normalizedOptions,
+      openDispatchMode: "automatic",
+      connect: (callbacks) => nativeBinding.websocketConnect({
+        url: normalizeWebSocketUrl(url),
+        browser,
+        os,
+        headers: headersToTuples(normalizedOptions.headers ?? {}),
+        ...protocols && protocols.length > 0 && { protocols },
+        ...normalizedOptions.proxy !== void 0 && { proxy: normalizedOptions.proxy },
+        onMessage: callbacks.onMessage,
+        onClose: callbacks.onClose,
+        onError: callbacks.onError
+      }),
+      legacyCallbacks: extractLegacyWebSocketCallbacks(optionsCandidate)
+    };
+  }
+  async connect(connectFn) {
     try {
-      await nativeBinding.websocketSend(this._connection, data);
+      const connection = await connectFn({
+        onMessage: (data) => {
+          this.handleNativeMessage(data);
+        },
+        onClose: (event) => {
+          this.handleNativeClose(event);
+        },
+        onError: (message) => {
+          this.handleNativeError(message);
+        }
+      });
+      this._connection = connection;
+      this.protocol = connection.protocol ?? "";
+      this.extensions = connection.extensions ?? "";
+      if (websocketFinalizer) {
+        this._finalizerToken = connection;
+        websocketFinalizer.register(this, connection, connection);
+      }
+      if (this.readyState === _WebSocket.CLOSING) {
+        this.startNativeClose();
+        return;
+      }
+      this.readyState = _WebSocket.OPEN;
+      if (this._openDispatchMode === "automatic") {
+        this.scheduleOpenEventAfterConnect();
+      }
     } catch (error) {
+      this.handleNativeError(String(error));
+      this.finalizeClosed({ code: 1006, reason: "" }, false);
       throw new RequestError(String(error));
     }
   }
-  /**
-   * Close the WebSocket connection
-   */
-  async close() {
-    if (this._closed) {
+  _waitUntilConnected() {
+    return this._connectPromise;
+  }
+  scheduleOpenEventAfterConnect() {
+    this.scheduleOpenEventWithDepth(2);
+  }
+  scheduleOpenEventAfterAwait() {
+    this.scheduleOpenEventWithDepth(3);
+  }
+  scheduleOpenEventWithDepth(depth) {
+    if (this._openEventDispatched || this._openEventQueued || this.readyState !== _WebSocket.OPEN) {
       return;
     }
-    this._closed = true;
-    if (this._finalizerToken && websocketFinalizer) {
-      websocketFinalizer.unregister(this._finalizerToken);
-      this._finalizerToken = void 0;
+    this._openEventQueued = true;
+    const queue = (remaining) => {
+      if (remaining === 0) {
+        this._openEventQueued = false;
+        if (this._openEventDispatched || this.readyState !== _WebSocket.OPEN) {
+          return;
+        }
+        this._openEventDispatched = true;
+        this.dispatchOpenEvent();
+        return;
+      }
+      queueMicrotask(() => {
+        queue(remaining - 1);
+      });
+    };
+    queue(depth);
+  }
+  releaseConnectionTracking() {
+    if (!this._finalizerToken || !websocketFinalizer) {
+      return;
+    }
+    websocketFinalizer.unregister(this._finalizerToken);
+    this._finalizerToken = void 0;
+  }
+  toMessageEventData(data) {
+    if (typeof data === "string") {
+      return data;
     }
+    if (this._binaryType === "arraybuffer") {
+      const arrayBuffer = new ArrayBuffer(data.byteLength);
+      new Uint8Array(arrayBuffer).set(data);
+      return arrayBuffer;
+    }
+    if (this._binaryType === "blob") {
+      return new Blob([data]);
+    }
+    return data;
+  }
+  invokeListener(listener, event) {
     try {
-      await nativeBinding.websocketClose(this._connection);
-    } catch (error) {
-      throw new RequestError(String(error));
+      if (typeof listener === "function") {
+        listener.call(this, event);
+      } else {
+        listener.handleEvent(event);
+      }
+    } catch {
     }
   }
+  createBaseEvent(type) {
+    return {
+      type,
+      isTrusted: false,
+      timeStamp: Date.now(),
+      target: this,
+      currentTarget: this
+    };
+  }
+  getOnHandler(type) {
+    switch (type) {
+      case "open":
+        return this._onopen;
+      case "message":
+        return this._onmessage;
+      case "close":
+        return this._onclose;
+      case "error":
+        return this._onerror;
+      default:
+        return null;
+    }
+  }
+  getOnHandlerOrder(type) {
+    return this._onHandlerOrder[type];
+  }
+  getListenerMap(type) {
+    return this._listeners[type];
+  }
+  dispatchEvent(type, event) {
+    const listenerMap = this.getListenerMap(type);
+    const onHandler = this.getOnHandler(type);
+    if (listenerMap.size === 0 && !onHandler) {
+      return;
+    }
+    const ordered = [];
+    for (const descriptor of listenerMap.values()) {
+      ordered.push({
+        order: descriptor.order,
+        listener: descriptor.listener,
+        once: descriptor.once
+      });
+    }
+    if (onHandler) {
+      ordered.push({
+        order: this.getOnHandlerOrder(type),
+        listener: onHandler,
+        once: false
+      });
+    }
+    ordered.sort((a, b) => a.order - b.order);
+    for (const entry of ordered) {
+      if (entry.once) {
+        this.removeEventListener(type, entry.listener);
+      }
+      this.invokeListener(entry.listener, event);
+    }
+  }
+  dispatchOpenEvent() {
+    const event = this.createBaseEvent("open");
+    this.dispatchEvent("open", event);
+    if (!this._closeEventDispatched && this._pendingMessages.length > 0) {
+      const pending = this._pendingMessages;
+      this._pendingMessages = [];
+      for (const data of pending) {
+        this.dispatchMessageEvent(this.toMessageEventData(data));
+      }
+    }
+  }
+  dispatchMessageEvent(data) {
+    const event = {
+      ...this.createBaseEvent("message"),
+      data
+    };
+    this.dispatchEvent("message", event);
+  }
+  dispatchCloseEvent(event) {
+    this.dispatchEvent("close", event);
+  }
+  dispatchErrorEvent(message) {
+    const event = {
+      ...this.createBaseEvent("error"),
+      ...message !== void 0 && { message }
+    };
+    this.dispatchEvent("error", event);
+  }
+  handleNativeMessage(data) {
+    if (this._closeEventDispatched) {
+      return;
+    }
+    this._legacyCallbacks?.onMessage?.(data);
+    if (!this._openEventDispatched && this.readyState === _WebSocket.OPEN) {
+      this._pendingMessages.push(data);
+      return;
+    }
+    this.dispatchMessageEvent(this.toMessageEventData(data));
+  }
+  handleNativeError(message) {
+    this._legacyCallbacks?.onError?.(message);
+    this.dispatchErrorEvent(message);
+  }
+  handleNativeClose(event) {
+    const wasClean = this.readyState === _WebSocket.CLOSING || event.code === 1e3;
+    this.finalizeClosed(event, wasClean);
+  }
+  finalizeClosed(event, wasClean) {
+    if (this._closeEventDispatched) {
+      return;
+    }
+    this.readyState = _WebSocket.CLOSED;
+    this._closeEventDispatched = true;
+    this._pendingMessages = [];
+    this.releaseConnectionTracking();
+    const closeEvent = {
+      ...this.createBaseEvent("close"),
+      code: event.code,
+      reason: event.reason,
+      wasClean
+    };
+    this._legacyCallbacks?.onClose?.(closeEvent);
+    this.dispatchCloseEvent(closeEvent);
+  }
+  startNativeClose() {
+    if (this._nativeCloseStarted || !this._connection) {
+      return;
+    }
+    this._nativeCloseStarted = true;
+    const connection = this._connection;
+    const closeOptions = this._closeOptions;
+    void nativeBinding.websocketClose(connection, closeOptions).catch((error) => {
+      this.handleNativeError(String(error));
+      this.finalizeClosed({ code: 1006, reason: "" }, false);
+    });
+  }
+  addEventListener(type, listener, options) {
+    if (!listener || !isWebSocketListenerType(type)) {
+      return;
+    }
+    const normalizedListener = listener;
+    if (typeof normalizedListener !== "function" && (typeof normalizedListener !== "object" || normalizedListener === null || typeof normalizedListener.handleEvent !== "function")) {
+      return;
+    }
+    const listenerMap = this.getListenerMap(type);
+    if (listenerMap.has(normalizedListener)) {
+      return;
+    }
+    const parsedOptions = typeof options === "boolean" ? {} : options ?? {};
+    const once = parsedOptions.once === true;
+    const signal = parsedOptions.signal;
+    if (signal?.aborted) {
+      return;
+    }
+    const descriptor = {
+      listener: normalizedListener,
+      order: ++this._listenerOrderCounter,
+      once
+    };
+    if (signal) {
+      const onAbort = () => {
+        this.removeEventListener(type, normalizedListener);
+      };
+      descriptor.abortSignal = signal;
+      descriptor.abortHandler = onAbort;
+      signal.addEventListener("abort", onAbort, { once: true });
+    }
+    listenerMap.set(normalizedListener, descriptor);
+  }
+  removeEventListener(type, listener) {
+    if (!listener || !isWebSocketListenerType(type)) {
+      return;
+    }
+    const normalizedListener = listener;
+    if (typeof normalizedListener !== "function" && typeof normalizedListener !== "object") {
+      return;
+    }
+    const listenerMap = this.getListenerMap(type);
+    const descriptor = listenerMap.get(normalizedListener);
+    if (!descriptor) {
+      return;
+    }
+    if (descriptor.abortSignal && descriptor.abortHandler) {
+      descriptor.abortSignal.removeEventListener("abort", descriptor.abortHandler);
+    }
+    listenerMap.delete(normalizedListener);
+  }
+  getSendByteLength(data) {
+    if (typeof data === "string") {
+      return Buffer.byteLength(data);
+    }
+    if (Buffer.isBuffer(data)) {
+      return data.byteLength;
+    }
+    if (data instanceof ArrayBuffer) {
+      return data.byteLength;
+    }
+    if (ArrayBuffer.isView(data)) {
+      return data.byteLength;
+    }
+    if (typeof Blob !== "undefined" && data instanceof Blob) {
+      return data.size;
+    }
+    throw new TypeError("WebSocket data must be a string, Buffer, ArrayBuffer, ArrayBufferView, or Blob");
+  }
+  async normalizeSendPayload(data) {
+    if (typeof data === "string") {
+      return data;
+    }
+    if (Buffer.isBuffer(data)) {
+      return data;
+    }
+    if (data instanceof ArrayBuffer) {
+      return Buffer.from(data);
+    }
+    if (ArrayBuffer.isView(data)) {
+      return Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+    }
+    if (typeof Blob !== "undefined" && data instanceof Blob) {
+      return Buffer.from(await data.arrayBuffer());
+    }
+    throw new TypeError("WebSocket data must be a string, Buffer, ArrayBuffer, ArrayBufferView, or Blob");
+  }
+  send(data) {
+    if (this.readyState !== _WebSocket.OPEN || !this._connection) {
+      throw new RequestError("WebSocket is not open");
+    }
+    const queuedBytes = this.getSendByteLength(data);
+    const connection = this._connection;
+    this._bufferedAmount += queuedBytes;
+    const sendTask = async () => {
+      try {
+        const payload = await this.normalizeSendPayload(data);
+        await nativeBinding.websocketSend(connection, payload);
+      } catch (error) {
+        this.handleNativeError(String(error));
+        this.finalizeClosed({ code: 1006, reason: "" }, false);
+      } finally {
+        this._bufferedAmount = Math.max(0, this._bufferedAmount - queuedBytes);
+      }
+    };
+    this._sendChain = this._sendChain.then(sendTask, sendTask);
+  }
+  close(code, reason) {
+    if (this.readyState === _WebSocket.CLOSING || this.readyState === _WebSocket.CLOSED) {
+      return;
+    }
+    this._closeOptions = normalizeWebSocketCloseOptions(code, reason);
+    this.readyState = _WebSocket.CLOSING;
+    this.startNativeClose();
+  }
 };
-async function websocket(options) {
-  if (!options.url) {
-    throw new RequestError("URL is required");
+function isInternalWebSocketInit(value) {
+  if (!isPlainObject(value)) {
+    return false;
   }
-  if (!options.onMessage) {
-    throw new RequestError("onMessage callback is required");
+  const candidate = value;
+  return candidate._internal === true && typeof candidate.url === "string" && typeof candidate.connect === "function";
+}
+function normalizeStandaloneWebSocketArgs(urlOrOptions, options) {
+  if (typeof urlOrOptions === "string" || urlOrOptions instanceof URL) {
+    const normalizedOptions2 = normalizeStandaloneWebSocketOptions(options);
+    return {
+      url: normalizeWebSocketUrl(urlOrOptions),
+      options: normalizedOptions2,
+      legacyCallbacks: extractLegacyWebSocketCallbacks(options)
+    };
   }
-  validateBrowserProfile(options.browser);
-  const os = options.os ?? DEFAULT_OS;
+  const legacy = urlOrOptions;
+  const normalizedOptions = normalizeStandaloneWebSocketOptions(legacy);
+  return {
+    url: normalizeWebSocketUrl(legacy.url),
+    options: normalizedOptions,
+    legacyCallbacks: extractLegacyWebSocketCallbacks(legacy)
+  };
+}
+function normalizeSessionWebSocketArgs(urlOrOptions, options) {
+  if (typeof urlOrOptions === "string" || urlOrOptions instanceof URL) {
+    const normalizedOptions2 = normalizeSessionWebSocketOptions(options);
+    return {
+      url: normalizeWebSocketUrl(urlOrOptions),
+      options: normalizedOptions2,
+      legacyCallbacks: extractLegacyWebSocketCallbacks(options)
+    };
+  }
+  const legacy = urlOrOptions;
+  const normalizedOptions = normalizeSessionWebSocketOptions(legacy);
+  return {
+    url: normalizeWebSocketUrl(legacy.url),
+    options: normalizedOptions,
+    legacyCallbacks: extractLegacyWebSocketCallbacks(legacy)
+  };
+}
+async function websocket(urlOrOptions, options) {
+  const normalized = normalizeStandaloneWebSocketArgs(urlOrOptions, options);
+  validateWebSocketProtocols(normalized.options.protocols);
+  assertNoManualWebSocketProtocolHeader(normalized.options.headers);
+  validateBrowserProfile(normalized.options.browser);
+  const os = normalized.options.os ?? DEFAULT_OS;
   validateOperatingSystem(os);
-  const browser = options.browser ?? DEFAULT_BROWSER;
-  try {
-    const connection = await nativeBinding.websocketConnect({
-      url: options.url,
+  const browser = normalized.options.browser ?? DEFAULT_BROWSER;
+  const protocols = normalizeWebSocketProtocolList(normalized.options.protocols);
+  return WebSocket._connectWithInit({
+    _internal: true,
+    url: normalized.url,
+    options: normalized.options,
+    openDispatchMode: "deferred",
+    connect: (callbacks) => nativeBinding.websocketConnect({
+      url: normalized.url,
       browser,
       os,
-      headers: options.headers ?? {},
-      ...options.proxy !== void 0 && { proxy: options.proxy },
-      onMessage: options.onMessage,
-      ...options.onClose !== void 0 && { onClose: options.onClose },
-      ...options.onError !== void 0 && { onError: options.onError }
-    });
-    return new WebSocket(connection);
-  } catch (error) {
-    throw new RequestError(String(error));
-  }
+      headers: headersToTuples(normalized.options.headers ?? {}),
+      ...protocols && protocols.length > 0 && { protocols },
+      ...normalized.options.proxy !== void 0 && { proxy: normalized.options.proxy },
+      onMessage: callbacks.onMessage,
+      onClose: callbacks.onClose,
+      onError: callbacks.onError
+    }),
+    legacyCallbacks: normalized.legacyCallbacks
+  });
 }
 var wreq_js_default = {
   fetch,
@@ -1255,7 +2056,8 @@ var wreq_js_default = {
   Headers,
   Response,
   Transport,
-  Session
+  Session,
+  RequestError
 };
 export {
   Headers,