wreq-js 1.4.0 → 1.5.2

package/dist/wreq-js.cjs

@@ -0,0 +1,1174 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/wreq-js.ts
+var wreq_js_exports = {};
+__export(wreq_js_exports, {
+  Headers: () => Headers,
+  RequestError: () => RequestError,
+  Response: () => Response,
+  Session: () => Session,
+  WebSocket: () => WebSocket,
+  createSession: () => createSession,
+  default: () => wreq_js_default,
+  fetch: () => fetch,
+  get: () => get,
+  getOperatingSystems: () => getOperatingSystems,
+  getProfiles: () => getProfiles,
+  post: () => post,
+  request: () => request,
+  websocket: () => websocket,
+  withSession: () => withSession
+});
+module.exports = __toCommonJS(wreq_js_exports);
+var import_node_crypto = require("crypto");
+var import_node_http = require("http");
+var import_node_module = require("module");
+var import_web = require("stream/web");
+
+// src/types.ts
+var RequestError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RequestError";
+  }
+};
+
+// src/wreq-js.ts
+var import_meta = {};
+var nativeBinding;
+var cachedProfiles;
+var cachedOperatingSystems;
+function detectLibc() {
+  if (process.platform !== "linux") {
+    return void 0;
+  }
+  const envLibc = process.env.LIBC ?? process.env.npm_config_libc;
+  if (envLibc) {
+    return envLibc.toLowerCase().includes("musl") ? "musl" : "gnu";
+  }
+  try {
+    const report = process.report?.getReport?.();
+    const glibcVersion = report?.header?.glibcVersionRuntime;
+    if (glibcVersion) {
+      return "gnu";
+    }
+    return "musl";
+  } catch {
+    return "gnu";
+  }
+}
+var require2 = typeof import_meta !== "undefined" && import_meta.url ? (0, import_node_module.createRequire)(import_meta.url) : (0, import_node_module.createRequire)(__filename);
+function loadNativeBinding() {
+  const platform = process.platform;
+  const arch = process.arch;
+  const libc = detectLibc();
+  const platformArchMap = {
+    darwin: { x64: "darwin-x64", arm64: "darwin-arm64" },
+    linux: {
+      x64: { gnu: "linux-x64-gnu", musl: "linux-x64-musl" },
+      arm64: "linux-arm64-gnu"
+    },
+    win32: { x64: "win32-x64-msvc" }
+  };
+  const platformArchMapEntry = platformArchMap[platform]?.[arch];
+  const platformArch = typeof platformArchMapEntry === "string" ? platformArchMapEntry : platformArchMapEntry?.[libc ?? "gnu"];
+  if (!platformArch) {
+    throw new Error(
+      `Unsupported platform: ${platform}-${arch}${libc ? `-${libc}` : ""}. Supported platforms: darwin-x64, darwin-arm64, linux-x64-gnu, linux-x64-musl, linux-arm64-gnu, win32-x64-msvc`
+    );
+  }
+  const binaryName = `wreq-js.${platformArch}.node`;
+  try {
+    return require2(`../rust/${binaryName}`);
+  } catch {
+    try {
+      return require2("../rust/wreq-js.node");
+    } catch {
+      throw new Error(
+        `Failed to load native module for ${platform}-${arch}. Tried: ../rust/${binaryName} and ../rust/wreq-js.node. Make sure the package is installed correctly and the native module is built for your platform.`
+      );
+    }
+  }
+}
+nativeBinding = loadNativeBinding();
+var websocketFinalizer = typeof FinalizationRegistry === "function" ? new FinalizationRegistry((connection) => {
+  void nativeBinding.websocketClose(connection).catch(() => void 0);
+}) : void 0;
+var bodyHandleFinalizer = typeof FinalizationRegistry === "function" ? new FinalizationRegistry((handle) => {
+  if (handle.released) {
+    return;
+  }
+  handle.released = true;
+  try {
+    nativeBinding.cancelBody(handle.id);
+  } catch {
+  }
+}) : void 0;
+var DEFAULT_BROWSER = "chrome_142";
+var DEFAULT_OS = "macos";
+var SUPPORTED_OSES = ["windows", "macos", "linux", "android", "ios"];
+var UTF8_DECODER = new TextDecoder("utf-8");
+function generateSessionId() {
+  return (0, import_node_crypto.randomUUID)();
+}
+function normalizeSessionOptions(options) {
+  const sessionId = options?.sessionId ?? generateSessionId();
+  const defaults = {
+    browser: options?.browser ?? DEFAULT_BROWSER,
+    os: options?.os ?? DEFAULT_OS
+  };
+  if (options?.proxy !== void 0) {
+    defaults.proxy = options.proxy;
+  }
+  if (options?.timeout !== void 0) {
+    validateTimeout(options.timeout);
+    defaults.timeout = options.timeout;
+  }
+  if (options?.insecure !== void 0) {
+    defaults.insecure = options.insecure;
+  }
+  return { sessionId, defaults };
+}
+function isIterable(value) {
+  return Boolean(value) && typeof value[Symbol.iterator] === "function";
+}
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function coerceHeaderValue(value) {
+  return String(value);
+}
+var Headers = class _Headers {
+  store = /* @__PURE__ */ new Map();
+  constructor(init) {
+    if (init) {
+      this.applyInit(init);
+    }
+  }
+  applyInit(init) {
+    if (init instanceof _Headers) {
+      for (const [name, value] of init) {
+        this.append(name, value);
+      }
+      return;
+    }
+    if (Array.isArray(init) || isIterable(init)) {
+      for (const tuple of init) {
+        if (!tuple) {
+          continue;
+        }
+        const [name, value] = tuple;
+        this.append(name, value);
+      }
+      return;
+    }
+    if (isPlainObject(init)) {
+      for (const [name, value] of Object.entries(init)) {
+        if (value === void 0 || value === null) {
+          continue;
+        }
+        this.set(name, coerceHeaderValue(value));
+      }
+    }
+  }
+  normalizeName(name) {
+    if (typeof name !== "string") {
+      throw new TypeError("Header name must be a string");
+    }
+    const trimmed = name.trim();
+    if (!trimmed) {
+      throw new TypeError("Header name must not be empty");
+    }
+    return { key: trimmed.toLowerCase(), display: trimmed };
+  }
+  assertValue(value) {
+    if (value === void 0 || value === null) {
+      throw new TypeError("Header value must not be null or undefined");
+    }
+    return coerceHeaderValue(value);
+  }
+  append(name, value) {
+    const normalized = this.normalizeName(name);
+    const existing = this.store.get(normalized.key);
+    const coercedValue = this.assertValue(value);
+    if (existing) {
+      existing.values.push(coercedValue);
+      return;
+    }
+    this.store.set(normalized.key, {
+      name: normalized.display,
+      values: [coercedValue]
+    });
+  }
+  set(name, value) {
+    const normalized = this.normalizeName(name);
+    const coercedValue = this.assertValue(value);
+    this.store.set(normalized.key, {
+      name: normalized.display,
+      values: [coercedValue]
+    });
+  }
+  get(name) {
+    const normalized = this.normalizeName(name);
+    const entry = this.store.get(normalized.key);
+    return entry ? entry.values.join(", ") : null;
+  }
+  has(name) {
+    const normalized = this.normalizeName(name);
+    return this.store.has(normalized.key);
+  }
+  delete(name) {
+    const normalized = this.normalizeName(name);
+    this.store.delete(normalized.key);
+  }
+  entries() {
+    return this[Symbol.iterator]();
+  }
+  *keys() {
+    for (const [name] of this) {
+      yield name;
+    }
+  }
+  *values() {
+    for (const [, value] of this) {
+      yield value;
+    }
+  }
+  forEach(callback, thisArg) {
+    for (const [name, value] of this) {
+      callback.call(thisArg, value, name, this);
+    }
+  }
+  [Symbol.iterator]() {
+    const generator = function* (store) {
+      for (const entry of store.values()) {
+        yield [entry.name, entry.values.join(", ")];
+      }
+    };
+    return generator(this.store);
+  }
+  toObject() {
+    const result = {};
+    for (const [name, value] of this) {
+      result[name] = value;
+    }
+    return result;
+  }
+  toTuples() {
+    const result = [];
+    for (const [name, value] of this) {
+      result.push([name, value]);
+    }
+    return result;
+  }
+};
+function headersToTuples(init) {
+  if (Array.isArray(init)) {
+    return init;
+  }
+  if (init instanceof Headers) {
+    return init.toTuples();
+  }
+  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)]);
+    }
+    return out;
+  }
+  if (isIterable(init)) {
+    for (const tuple of init) {
+      if (!tuple) {
+        continue;
+      }
+      const [name, value] = tuple;
+      out.push([name, value]);
+    }
+    return out;
+  }
+  return out;
+}
+function cloneNativeResponse(payload) {
+  return {
+    status: payload.status,
+    headers: payload.headers.map(([name, value]) => [name, value]),
+    bodyHandle: payload.bodyHandle,
+    bodyBytes: payload.bodyBytes,
+    contentLength: payload.contentLength,
+    cookies: payload.cookies.map(([name, value]) => [name, value]),
+    url: payload.url
+  };
+}
+function releaseNativeBody(handle) {
+  if (handle.released) {
+    return;
+  }
+  handle.released = true;
+  try {
+    nativeBinding.cancelBody(handle.id);
+  } catch {
+  }
+  bodyHandleFinalizer?.unregister(handle);
+}
+function createNativeBodyStream(handleId) {
+  const handle = { id: handleId, released: false };
+  const stream = new import_web.ReadableStream({
+    async pull(controller) {
+      try {
+        const chunk = await nativeBinding.readBodyChunk(handle.id);
+        if (chunk === null) {
+          releaseNativeBody(handle);
+          controller.close();
+          return;
+        }
+        controller.enqueue(chunk);
+      } catch (error) {
+        releaseNativeBody(handle);
+        controller.error(error);
+      }
+    },
+    cancel() {
+      releaseNativeBody(handle);
+    }
+  });
+  bodyHandleFinalizer?.register(stream, handle, handle);
+  return stream;
+}
+function wrapBodyStream(source, onFirstUse) {
+  let started = false;
+  const reader = source.getReader();
+  return new import_web.ReadableStream({
+    async pull(controller) {
+      if (!started) {
+        started = true;
+        onFirstUse();
+      }
+      try {
+        const { done, value } = await reader.read();
+        if (done) {
+          controller.close();
+          return;
+        }
+        controller.enqueue(value);
+      } catch (error) {
+        controller.error(error);
+      }
+    },
+    cancel(reason) {
+      return reader.cancel(reason);
+    }
+  });
+}
+var Response = class _Response {
+  status;
+  ok;
+  contentLength;
+  url;
+  type = "basic";
+  bodyUsed = false;
+  payload;
+  requestUrl;
+  redirectedMemo;
+  headersInit;
+  headersInstance;
+  cookiesInit;
+  cookiesRecord;
+  inlineBody;
+  bodySource;
+  bodyStream;
+  // Track if we can use the fast path (native handle not yet wrapped in a stream)
+  nativeHandleAvailable;
+  constructor(payload, requestUrl, bodySource) {
+    this.payload = payload;
+    this.requestUrl = requestUrl;
+    this.status = this.payload.status;
+    this.ok = this.status >= 200 && this.status < 300;
+    this.headersInit = this.payload.headers;
+    this.headersInstance = null;
+    this.url = this.payload.url;
+    this.cookiesInit = this.payload.cookies;
+    this.cookiesRecord = null;
+    this.contentLength = this.payload.contentLength ?? null;
+    this.inlineBody = this.payload.bodyBytes ?? null;
+    if (typeof bodySource !== "undefined") {
+      this.bodySource = bodySource;
+      this.nativeHandleAvailable = false;
+    } else if (this.inlineBody !== null) {
+      this.bodySource = null;
+      this.nativeHandleAvailable = false;
+    } else if (this.payload.bodyHandle !== null) {
+      this.bodySource = null;
+      this.nativeHandleAvailable = true;
+    } else {
+      this.bodySource = null;
+      this.nativeHandleAvailable = false;
+    }
+    this.bodyStream = void 0;
+  }
+  get redirected() {
+    if (this.redirectedMemo !== void 0) {
+      return this.redirectedMemo;
+    }
+    if (this.url === this.requestUrl) {
+      this.redirectedMemo = false;
+      return false;
+    }
+    const normalizedRequestUrl = normalizeUrlForComparison(this.requestUrl);
+    this.redirectedMemo = normalizedRequestUrl ? this.url !== normalizedRequestUrl : true;
+    return this.redirectedMemo;
+  }
+  get statusText() {
+    return import_node_http.STATUS_CODES[this.status] ?? "";
+  }
+  get headers() {
+    if (!this.headersInstance) {
+      this.headersInstance = new Headers(this.headersInit);
+    }
+    return this.headersInstance;
+  }
+  get cookies() {
+    if (!this.cookiesRecord) {
+      const record = /* @__PURE__ */ Object.create(null);
+      for (const [name, value] of this.cookiesInit) {
+        const existing = record[name];
+        if (existing === void 0) {
+          record[name] = value;
+        } else if (Array.isArray(existing)) {
+          existing.push(value);
+        } else {
+          record[name] = [existing, value];
+        }
+      }
+      this.cookiesRecord = record;
+    }
+    return this.cookiesRecord;
+  }
+  get body() {
+    if (this.inlineBody && this.bodySource === null) {
+      const bytes = this.inlineBody;
+      this.inlineBody = null;
+      this.bodySource = new import_web.ReadableStream({
+        start(controller) {
+          controller.enqueue(bytes);
+          controller.close();
+        }
+      });
+    }
+    if (this.inlineBody === null && this.payload.bodyHandle === null && this.bodySource === null) {
+      return null;
+    }
+    if (this.bodySource === null && this.nativeHandleAvailable && this.payload.bodyHandle !== null) {
+      this.bodySource = createNativeBodyStream(this.payload.bodyHandle);
+      this.nativeHandleAvailable = false;
+    }
+    if (this.bodySource === null) {
+      return null;
+    }
+    if (this.bodyStream === void 0) {
+      this.bodyStream = wrapBodyStream(this.bodySource, () => {
+        this.bodyUsed = true;
+      });
+    }
+    return this.bodyStream;
+  }
+  async json() {
+    const text = await this.text();
+    return JSON.parse(text);
+  }
+  async arrayBuffer() {
+    const bytes = await this.consumeBody();
+    const { buffer, byteOffset, byteLength } = bytes;
+    if (buffer instanceof ArrayBuffer) {
+      return buffer.slice(byteOffset, byteOffset + byteLength);
+    }
+    const view = new Uint8Array(byteLength);
+    view.set(bytes);
+    return view.buffer;
+  }
+  async text() {
+    const bytes = await this.consumeBody();
+    return UTF8_DECODER.decode(bytes);
+  }
+  clone() {
+    if (this.bodyUsed || this.bodyStream) {
+      throw new TypeError("Cannot clone a Response whose body is already used");
+    }
+    if (this.nativeHandleAvailable && this.payload.bodyHandle !== null) {
+      this.bodySource = createNativeBodyStream(this.payload.bodyHandle);
+      this.nativeHandleAvailable = false;
+    }
+    if (this.bodySource === null) {
+      return new _Response(cloneNativeResponse(this.payload), this.requestUrl, null);
+    }
+    const [branchA, branchB] = this.bodySource.tee();
+    this.bodySource = branchA;
+    this.bodyStream = void 0;
+    return new _Response(cloneNativeResponse(this.payload), this.requestUrl, branchB);
+  }
+  assertBodyAvailable() {
+    if (this.bodyUsed) {
+      throw new TypeError("Response body is already used");
+    }
+  }
+  async consumeBody() {
+    this.assertBodyAvailable();
+    this.bodyUsed = true;
+    if (this.inlineBody) {
+      const bytes = this.inlineBody;
+      this.inlineBody = null;
+      return bytes;
+    }
+    if (this.nativeHandleAvailable && this.payload.bodyHandle !== null) {
+      this.nativeHandleAvailable = false;
+      try {
+        return await nativeBinding.readBodyAll(this.payload.bodyHandle);
+      } catch (error) {
+        if (String(error).includes("not found")) {
+          return Buffer.alloc(0);
+        }
+        throw error;
+      }
+    }
+    const stream = this.body;
+    if (!stream) {
+      return Buffer.alloc(0);
+    }
+    const reader = stream.getReader();
+    const chunks = [];
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          break;
+        }
+        if (value && value.byteLength > 0) {
+          if (Buffer.isBuffer(value)) {
+            chunks.push(value);
+          } else {
+            chunks.push(Buffer.from(value.buffer, value.byteOffset, value.byteLength));
+          }
+        }
+      }
+    } finally {
+    }
+    return chunks.length === 0 ? Buffer.alloc(0) : Buffer.concat(chunks);
+  }
+};
+var Session = class {
+  id;
+  disposed = false;
+  defaults;
+  constructor(id, defaults) {
+    this.id = id;
+    this.defaults = defaults;
+  }
+  get closed() {
+    return this.disposed;
+  }
+  ensureActive() {
+    if (this.disposed) {
+      throw new RequestError("Session has been closed");
+    }
+  }
+  /** @internal */
+  getDefaults() {
+    return { ...this.defaults };
+  }
+  /** @internal */
+  _defaultsRef() {
+    return this.defaults;
+  }
+  async fetch(input, init) {
+    this.ensureActive();
+    return fetchWithSession(this, input, init);
+  }
+  async clearCookies() {
+    this.ensureActive();
+    try {
+      nativeBinding.clearSession(this.id);
+    } catch (error) {
+      throw new RequestError(String(error));
+    }
+  }
+  async close() {
+    if (this.disposed) {
+      return;
+    }
+    this.disposed = true;
+    try {
+      nativeBinding.dropSession(this.id);
+    } catch (error) {
+      throw new RequestError(String(error));
+    }
+  }
+};
+function resolveSessionContext(config) {
+  const requestedMode = config.cookieMode ?? "ephemeral";
+  const sessionCandidate = config.session;
+  const providedSessionId = typeof config.sessionId === "string" ? config.sessionId.trim() : void 0;
+  if (sessionCandidate && providedSessionId) {
+    throw new RequestError("Provide either `session` or `sessionId`, not both.");
+  }
+  if (sessionCandidate) {
+    if (!(sessionCandidate instanceof Session)) {
+      throw new RequestError("`session` must be created via createSession()");
+    }
+    if (sessionCandidate.closed) {
+      throw new RequestError("Session has been closed");
+    }
+    return {
+      sessionId: sessionCandidate.id,
+      cookieMode: "session",
+      dropAfterRequest: false,
+      defaults: sessionCandidate._defaultsRef()
+    };
+  }
+  if (providedSessionId) {
+    if (!providedSessionId) {
+      throw new RequestError("sessionId must not be empty");
+    }
+    if (requestedMode === "ephemeral") {
+      throw new RequestError("cookieMode 'ephemeral' cannot be combined with sessionId");
+    }
+    return {
+      sessionId: providedSessionId,
+      cookieMode: "session",
+      dropAfterRequest: false
+    };
+  }
+  if (requestedMode === "session") {
+    throw new RequestError("cookieMode 'session' requires a session or sessionId");
+  }
+  return {
+    sessionId: generateSessionId(),
+    cookieMode: "ephemeral",
+    dropAfterRequest: true
+  };
+}
+function createAbortError(reason) {
+  const fallbackMessage = typeof reason === "string" ? reason : "The operation was aborted";
+  if (typeof DOMException !== "undefined" && reason instanceof DOMException) {
+    return reason.name === "AbortError" ? reason : new DOMException(reason.message || fallbackMessage, "AbortError");
+  }
+  if (reason instanceof Error) {
+    reason.name = "AbortError";
+    return reason;
+  }
+  if (typeof DOMException !== "undefined") {
+    return new DOMException(fallbackMessage, "AbortError");
+  }
+  const error = new Error(fallbackMessage);
+  error.name = "AbortError";
+  return error;
+}
+function isAbortError(error) {
+  return Boolean(error) && typeof error.name === "string" && error.name === "AbortError";
+}
+var REQUEST_ID_MAX = 2 ** 48;
+var requestIdCounter = Math.trunc(Number(process.hrtime.bigint() % BigInt(REQUEST_ID_MAX - 1))) + 1;
+function generateRequestId() {
+  requestIdCounter += 1;
+  if (requestIdCounter >= REQUEST_ID_MAX) {
+    requestIdCounter = 1;
+  }
+  return requestIdCounter;
+}
+function setupAbort(signal, cancelNative) {
+  if (!signal) {
+    return null;
+  }
+  if (signal.aborted) {
+    cancelNative();
+    throw createAbortError(signal.reason);
+  }
+  let onAbortListener;
+  const promise = new Promise((_, reject) => {
+    onAbortListener = () => {
+      cancelNative();
+      reject(createAbortError(signal.reason));
+    };
+    signal.addEventListener("abort", onAbortListener, { once: true });
+  });
+  const cleanup = () => {
+    if (onAbortListener) {
+      signal.removeEventListener("abort", onAbortListener);
+      onAbortListener = void 0;
+    }
+  };
+  return { promise, cleanup };
+}
+function coerceUrlInput(input) {
+  const value = typeof input === "string" ? input.trim() : input.href;
+  if (!value) {
+    throw new RequestError("URL is required");
+  }
+  return value;
+}
+function normalizeUrlForComparison(value) {
+  try {
+    return new URL(value).toString();
+  } catch {
+    return null;
+  }
+}
+function validateRedirectMode(mode) {
+  if (mode === void 0 || mode === "follow" || mode === "manual" || mode === "error") {
+    return;
+  }
+  throw new RequestError(`Redirect mode '${mode}' is not supported`);
+}
+function serializeBody(body) {
+  if (body === null || body === void 0) {
+    return void 0;
+  }
+  if (typeof body === "string") {
+    return Buffer.from(body, "utf8");
+  }
+  if (Buffer.isBuffer(body)) {
+    return body;
+  }
+  if (body instanceof URLSearchParams) {
+    return Buffer.from(body.toString(), "utf8");
+  }
+  if (body instanceof ArrayBuffer) {
+    return Buffer.from(body);
+  }
+  if (ArrayBuffer.isView(body)) {
+    return Buffer.from(body.buffer, body.byteOffset, body.byteLength);
+  }
+  throw new TypeError("Unsupported body type; expected string, Buffer, ArrayBuffer, or URLSearchParams");
+}
+function ensureMethod(method) {
+  const normalized = method?.trim().toUpperCase();
+  return normalized && normalized.length > 0 ? normalized : "GET";
+}
+function ensureBodyAllowed(method, body) {
+  if (body === void 0) {
+    return;
+  }
+  if (method === "GET" || method === "HEAD") {
+    throw new RequestError(`Request with ${method} method cannot have a body`);
+  }
+}
+function validateBrowserProfile(browser) {
+  if (!browser) {
+    return;
+  }
+  const profiles = getProfiles();
+  if (!profiles.includes(browser)) {
+    throw new RequestError(`Invalid browser profile: ${browser}. Available profiles: ${profiles.join(", ")}`);
+  }
+}
+function validateOperatingSystem(os) {
+  if (!os) {
+    return;
+  }
+  const operatingSystems = getOperatingSystems();
+  if (!operatingSystems.includes(os)) {
+    throw new RequestError(`Invalid operating system: ${os}. Available options: ${operatingSystems.join(", ")}`);
+  }
+}
+function validateTimeout(timeout) {
+  if (timeout === void 0) {
+    return;
+  }
+  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");
+  }
+}
+async function fetchWithSession(session, input, init) {
+  const providedSessionId = typeof init?.sessionId === "string" ? init.sessionId.trim() : void 0;
+  if (providedSessionId) {
+    throw new RequestError("Provide either `session` or `sessionId`, not both.");
+  }
+  const url = coerceUrlInput(input);
+  const method = ensureMethod(init?.method);
+  const body = serializeBody(init?.body ?? null);
+  ensureBodyAllowed(method, body);
+  validateRedirectMode(init?.redirect);
+  const defaults = session._defaultsRef();
+  if (init?.browser != null && init.browser !== defaults.browser) {
+    throw new RequestError("Session browser cannot be changed after creation");
+  }
+  if (init?.os != null && init.os !== defaults.os) {
+    throw new RequestError("Session operating system cannot be changed after creation");
+  }
+  const initHasProxy = Boolean(init) && Object.hasOwn(init, "proxy");
+  const requestedProxy = initHasProxy ? init.proxy : void 0;
+  if (initHasProxy && requestedProxy !== void 0 && (defaults.proxy ?? null) !== (requestedProxy ?? null)) {
+    throw new RequestError("Session proxy cannot be changed after creation");
+  }
+  const timeout = init?.timeout ?? defaults.timeout;
+  if (Boolean(init) && init.timeout !== void 0) {
+    validateTimeout(timeout);
+  }
+  const insecure = init?.insecure ?? defaults.insecure;
+  const headerTuples = init?.headers === void 0 ? void 0 : headersToTuples(init.headers);
+  const requestOptions = {
+    url,
+    method,
+    browser: defaults.browser,
+    os: defaults.os,
+    sessionId: session.id,
+    ephemeral: false
+  };
+  if (body !== void 0) {
+    requestOptions.body = body;
+  }
+  const proxy = requestedProxy ?? defaults.proxy;
+  if (proxy !== void 0) {
+    requestOptions.proxy = proxy;
+  }
+  if (timeout !== void 0) {
+    requestOptions.timeout = timeout;
+  }
+  if (init?.redirect !== void 0) {
+    requestOptions.redirect = init.redirect;
+  }
+  if (init?.disableDefaultHeaders !== void 0) {
+    requestOptions.disableDefaultHeaders = init.disableDefaultHeaders;
+  }
+  if (insecure !== void 0) {
+    requestOptions.insecure = insecure;
+  }
+  if (headerTuples && headerTuples.length > 0) {
+    requestOptions.headers = headerTuples;
+  }
+  return dispatchRequest(requestOptions, url, init?.signal ?? null);
+}
+async function dispatchRequest(options, requestUrl, signal) {
+  if (!signal) {
+    const requestId2 = generateRequestId();
+    let payload2;
+    try {
+      payload2 = await nativeBinding.request(options, requestId2, false);
+    } catch (error) {
+      if (error instanceof RequestError) {
+        throw error;
+      }
+      throw new RequestError(String(error));
+    }
+    return new Response(payload2, requestUrl);
+  }
+  const requestId = generateRequestId();
+  const cancelNative = () => {
+    try {
+      nativeBinding.cancelRequest(requestId);
+    } catch {
+    }
+  };
+  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 {
+    payload = await pending;
+  } catch (error) {
+    if (isAbortError(error)) {
+      throw error;
+    }
+    if (error instanceof RequestError) {
+      throw error;
+    }
+    throw new RequestError(String(error));
+  } finally {
+    abortHandler.cleanup();
+  }
+  return new Response(payload, requestUrl);
+}
+async function fetch(input, init) {
+  const url = coerceUrlInput(input);
+  const config = init ?? {};
+  const sessionContext = resolveSessionContext(config);
+  const sessionDefaults = sessionContext.defaults;
+  const browser = config.browser ?? sessionDefaults?.browser ?? DEFAULT_BROWSER;
+  const os = config.os ?? sessionDefaults?.os ?? DEFAULT_OS;
+  const proxy = config.proxy ?? sessionDefaults?.proxy;
+  const timeout = config.timeout ?? sessionDefaults?.timeout;
+  const insecure = config.insecure ?? sessionDefaults?.insecure;
+  validateRedirectMode(config.redirect);
+  if (!sessionDefaults || config.browser !== void 0) {
+    validateBrowserProfile(browser);
+  }
+  if (!sessionDefaults || config.os !== void 0) {
+    validateOperatingSystem(os);
+  }
+  if (!sessionDefaults || config.timeout !== void 0) {
+    validateTimeout(timeout);
+  }
+  if (sessionDefaults) {
+    if (browser !== sessionDefaults.browser) {
+      throw new RequestError("Session browser cannot be changed after creation");
+    }
+    if (os !== sessionDefaults.os) {
+      throw new RequestError("Session operating system cannot be changed after creation");
+    }
+    if (config.proxy !== void 0 && config.proxy !== sessionDefaults.proxy) {
+      throw new RequestError("Session proxy cannot be changed after creation");
+    }
+  }
+  const method = ensureMethod(config.method);
+  const body = serializeBody(config.body ?? null);
+  ensureBodyAllowed(method, body);
+  const headerTuples = config.headers === void 0 ? void 0 : headersToTuples(config.headers);
+  const requestOptions = {
+    url,
+    method,
+    browser,
+    os,
+    sessionId: sessionContext.sessionId,
+    ephemeral: sessionContext.dropAfterRequest
+  };
+  if (body !== void 0) {
+    requestOptions.body = body;
+  }
+  if (proxy !== void 0) {
+    requestOptions.proxy = proxy;
+  }
+  if (timeout !== void 0) {
+    requestOptions.timeout = timeout;
+  }
+  if (config.redirect !== void 0) {
+    requestOptions.redirect = config.redirect;
+  }
+  if (config.disableDefaultHeaders !== void 0) {
+    requestOptions.disableDefaultHeaders = config.disableDefaultHeaders;
+  }
+  if (insecure !== void 0) {
+    requestOptions.insecure = insecure;
+  }
+  if (headerTuples && headerTuples.length > 0) {
+    requestOptions.headers = headerTuples;
+  }
+  return dispatchRequest(requestOptions, url, config.signal ?? null);
+}
+async function createSession(options) {
+  const { sessionId, defaults } = normalizeSessionOptions(options);
+  validateBrowserProfile(defaults.browser);
+  validateOperatingSystem(defaults.os);
+  let createdId;
+  try {
+    createdId = nativeBinding.createSession({
+      sessionId,
+      browser: defaults.browser,
+      os: defaults.os,
+      ...defaults.proxy !== void 0 && { proxy: defaults.proxy },
+      ...defaults.insecure !== void 0 && { insecure: defaults.insecure }
+    });
+  } catch (error) {
+    throw new RequestError(String(error));
+  }
+  return new Session(createdId, defaults);
+}
+async function withSession(fn, options) {
+  const session = await createSession(options);
+  try {
+    return await fn(session);
+  } finally {
+    await session.close();
+  }
+}
+async function request(options) {
+  if (!options.url) {
+    throw new RequestError("URL is required");
+  }
+  const { url, ...rest } = options;
+  const init = {};
+  if (rest.method !== void 0) {
+    init.method = rest.method;
+  }
+  if (rest.headers !== void 0) {
+    init.headers = rest.headers;
+  }
+  if (rest.body !== void 0) {
+    init.body = rest.body;
+  }
+  if (rest.browser !== void 0) {
+    init.browser = rest.browser;
+  }
+  if (rest.os !== void 0) {
+    init.os = rest.os;
+  }
+  if (rest.proxy !== void 0) {
+    init.proxy = rest.proxy;
+  }
+  if (rest.timeout !== void 0) {
+    init.timeout = rest.timeout;
+  }
+  if (rest.sessionId !== void 0) {
+    init.sessionId = rest.sessionId;
+  }
+  if (rest.disableDefaultHeaders !== void 0) {
+    init.disableDefaultHeaders = rest.disableDefaultHeaders;
+  }
+  if (rest.redirect !== void 0) {
+    init.redirect = rest.redirect;
+  }
+  return fetch(url, init);
+}
+function getProfiles() {
+  if (!cachedProfiles) {
+    cachedProfiles = nativeBinding.getProfiles();
+  }
+  return cachedProfiles;
+}
+function getOperatingSystems() {
+  if (!cachedOperatingSystems) {
+    const fromNative = nativeBinding.getOperatingSystems?.();
+    cachedOperatingSystems = fromNative && fromNative.length > 0 ? fromNative : [...SUPPORTED_OSES];
+  }
+  return cachedOperatingSystems;
+}
+async function get(url, init) {
+  const config = {};
+  if (init) {
+    Object.assign(config, init);
+  }
+  config.method = "GET";
+  return fetch(url, config);
+}
+async function post(url, body, init) {
+  const config = {};
+  if (init) {
+    Object.assign(config, init);
+  }
+  config.method = "POST";
+  if (body !== void 0) {
+    config.body = body;
+  }
+  return fetch(url, config);
+}
+var WebSocket = class {
+  _connection;
+  _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) {
+    try {
+      await nativeBinding.websocketSend(this._connection, data);
+    } catch (error) {
+      throw new RequestError(String(error));
+    }
+  }
+  /**
+   * Close the WebSocket connection
+   */
+  async close() {
+    if (this._closed) {
+      return;
+    }
+    this._closed = true;
+    if (this._finalizerToken && websocketFinalizer) {
+      websocketFinalizer.unregister(this._finalizerToken);
+      this._finalizerToken = void 0;
+    }
+    try {
+      await nativeBinding.websocketClose(this._connection);
+    } catch (error) {
+      throw new RequestError(String(error));
+    }
+  }
+};
+async function websocket(options) {
+  if (!options.url) {
+    throw new RequestError("URL is required");
+  }
+  if (!options.onMessage) {
+    throw new RequestError("onMessage callback is required");
+  }
+  validateBrowserProfile(options.browser);
+  const os = options.os ?? DEFAULT_OS;
+  validateOperatingSystem(os);
+  const browser = options.browser ?? DEFAULT_BROWSER;
+  try {
+    const connection = await nativeBinding.websocketConnect({
+      url: options.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));
+  }
+}
+var wreq_js_default = {
+  fetch,
+  request,
+  get,
+  post,
+  getProfiles,
+  getOperatingSystems,
+  createSession,
+  withSession,
+  websocket,
+  WebSocket,
+  Headers,
+  Response,
+  Session
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Headers,
+  RequestError,
+  Response,
+  Session,
+  WebSocket,
+  createSession,
+  fetch,
+  get,
+  getOperatingSystems,
+  getProfiles,
+  post,
+  request,
+  websocket,
+  withSession
+});
+//# sourceMappingURL=wreq-js.cjs.map