steelseries-sonar-sdk 0.3.4 → 0.4.0

package/dist/index.js

@@ -4915,1753 +4915,1750 @@ function convertVolumeToUser(value) {
   return result;
 }
 
-// src/functions/custom-fetch.ts
-import https2 from "node:https";
-
-// node_modules/node-fetch/src/index.js
-import http2 from "node:http";
-import https from "node:https";
-import zlib from "node:zlib";
-import Stream2, { PassThrough as PassThrough2, pipeline as pump } from "node:stream";
-import { Buffer as Buffer3 } from "node:buffer";
-
-// node_modules/data-uri-to-buffer/dist/index.js
-function dataUriToBuffer(uri) {
-  if (!/^data:/i.test(uri)) {
-    throw new TypeError('`uri` does not appear to be a Data URI (must begin with "data:")');
-  }
-  uri = uri.replace(/\r?\n/g, "");
-  const firstComma = uri.indexOf(",");
-  if (firstComma === -1 || firstComma <= 4) {
-    throw new TypeError("malformed data: URI");
+// src/sonar/requests/volume-settings/request-volume-settings-classic.ts
+async function requestVolumeSettingsClassic(sonarEndpoint) {
+  let response;
+  try {
+    const url = new URL(`${sonarEndpoint}/volumeSettings/classic`);
+    response = await fetch(url);
+  } catch (error) {
+    throw new SonarRequestException({ innerException: error });
   }
-  const meta = uri.substring(5, firstComma).split(";");
-  let charset = "";
-  let base64 = false;
-  const type = meta[0] || "text/plain";
-  let typeFull = type;
-  for (let i = 1;i < meta.length; i++) {
-    if (meta[i] === "base64") {
-      base64 = true;
-    } else if (meta[i]) {
-      typeFull += `;${meta[i]}`;
-      if (meta[i].indexOf("charset=") === 0) {
-        charset = meta[i].substring(8);
-      }
+  if (response.ok) {
+    const data = await response.json();
+    if (data?.masters?.classic == null) {
+      throw new SonarRequestException({ innerException: new Error("Missing required data in response.") });
     }
+    return data;
+  } else {
+    const data = await response.json();
+    throw new SonarRequestException({ innerException: new Error(data?.error ?? data) });
   }
-  if (!meta[0] && !charset.length) {
-    typeFull += ";charset=US-ASCII";
-    charset = "US-ASCII";
+}
+
+// src/functions/audio/get-audio-data-classic.ts
+async function getAudioDataClassic(sonarEndpoint) {
+  const data = await requestVolumeSettingsClassic(sonarEndpoint);
+  const volumeData = {
+    ["master" /* Master */]: createResponseVolumeData(data.masters.classic),
+    ["game" /* Game */]: data.devices.game && createResponseVolumeData(data.devices.game.classic),
+    ["chat" /* Chat */]: data.devices.chatRender && createResponseVolumeData(data.devices.chatRender.classic),
+    ["media" /* Media */]: data.devices.media && createResponseVolumeData(data.devices.media.classic),
+    ["aux" /* Aux */]: data.devices.aux && createResponseVolumeData(data.devices.aux.classic),
+    ["mic" /* Mic */]: data.devices.chatCapture && createResponseVolumeData(data.devices.chatCapture.classic)
+  };
+  return volumeData;
+}
+function createResponseVolumeData(volumeData) {
+  return {
+    volume: convertVolumeToUser(volumeData.volume),
+    isMuted: volumeData.muted
+  };
+}
+// src/sonar/requests/volume-settings/request-volume-settings-streamer.ts
+async function requestVolumeSettingsStreamer(sonarEndpoint) {
+  let response;
+  try {
+    const url = new URL(`${sonarEndpoint}/volumeSettings/streamer`);
+    response = await fetch(url);
+  } catch (error) {
+    throw new SonarRequestException({ innerException: error });
+  }
+  if (response.ok) {
+    const data = await response.json();
+    if (data?.masters?.stream == null) {
+      throw new SonarRequestException({ innerException: new Error("Missing required data in response.") });
+    }
+    return data;
+  } else {
+    const data = await response.json();
+    throw new SonarRequestException({ innerException: new Error(data?.error ?? data) });
   }
-  const encoding = base64 ? "base64" : "ascii";
-  const data = unescape(uri.substring(firstComma + 1));
-  const buffer = Buffer.from(data, encoding);
-  buffer.type = type;
-  buffer.typeFull = typeFull;
-  buffer.charset = charset;
-  return buffer;
 }
-var dist_default = dataUriToBuffer;
 
-// node_modules/node-fetch/src/body.js
-init_fetch_blob();
-init_esm_min();
-import Stream, { PassThrough } from "node:stream";
-import { types, deprecate, promisify } from "node:util";
-import { Buffer as Buffer2 } from "node:buffer";
+// src/functions/audio/get-audio-data-stream.ts
+async function getAudioDataStream(sonarEndpoint) {
+  const data = await requestVolumeSettingsStreamer(sonarEndpoint);
+  const volumeData = {
+    ["master" /* Master */]: createResponseVolumeData2(data.masters.stream),
+    ["game" /* Game */]: data.devices.game && createResponseVolumeData2(data.devices.game.stream),
+    ["chat" /* Chat */]: data.devices.chatRender && createResponseVolumeData2(data.devices.chatRender.stream),
+    ["media" /* Media */]: data.devices.media && createResponseVolumeData2(data.devices.media.stream),
+    ["aux" /* Aux */]: data.devices.aux && createResponseVolumeData2(data.devices.aux.stream),
+    ["mic" /* Mic */]: data.devices.chatCapture && createResponseVolumeData2(data.devices.chatCapture.stream)
+  };
+  return volumeData;
+}
+function createResponseVolumeData2(volumeData) {
+  return {
+    ["streaming" /* Streaming */]: {
+      volume: convertVolumeToUser(volumeData.streaming.volume),
+      isMuted: volumeData.streaming.muted
+    },
+    ["monitoring" /* Monitoring */]: {
+      volume: convertVolumeToUser(volumeData.monitoring.volume),
+      isMuted: volumeData.monitoring.muted
+    }
+  };
+}
+// src/sonar/models/audio-settings/enums/audio-mode.ts
+var AudioMode2;
+((AudioMode3) => {
+  AudioMode3["Classic"] = "classic";
+  AudioMode3["Streamer"] = "stream";
+})(AudioMode2 ||= {});
 
-// node_modules/node-fetch/src/errors/base.js
-class FetchBaseError extends Error {
-  constructor(message, type) {
-    super(message);
-    Error.captureStackTrace(this, this.constructor);
-    this.type = type;
-  }
-  get name() {
-    return this.constructor.name;
+// src/sonar/requests/mode/request-audio-mode.ts
+async function requestAudioMode(sonarEndpoint) {
+  let response;
+  const url = new URL(`${sonarEndpoint}/mode`);
+  try {
+    response = await fetch(url);
+  } catch (error) {
+    throw new SonarRequestException({ innerException: error });
   }
-  get [Symbol.toStringTag]() {
-    return this.constructor.name;
+  if (response.ok) {
+    const data = await response.json();
+    if (Object.values(AudioMode2).includes(data)) {
+      return data;
+    }
+    throw new SonarRequestException({ message: "Received unhandled audio mode from Sonar server" });
+  } else {
+    const data = await response.text();
+    throw new SonarRequestException({ innerException: new Error(data) });
   }
 }
 
-// node_modules/node-fetch/src/errors/fetch-error.js
-class FetchError extends FetchBaseError {
-  constructor(message, type, systemError) {
-    super(message, type);
-    if (systemError) {
-      this.code = this.errno = systemError.code;
-      this.erroredSysCall = systemError.syscall;
+// src/functions/audio/get-audio-mode.ts
+async function getAudioMode(sonarEndpoint) {
+  return await requestAudioMode(sonarEndpoint);
+}
+// src/sonar/requests/mode/change-audio-mode.ts
+async function changeAudioMode(sonarEndpoint, audioMode) {
+  let response;
+  const url = new URL(`${sonarEndpoint}/mode/${audioMode}`);
+  try {
+    response = await fetch(url, {
+      method: "PUT"
+    });
+  } catch (error) {
+    throw new SonarRequestException({ innerException: error });
+  }
+  if (response.ok) {
+    const data = await response.json();
+    if (data !== audioMode) {
+      throw new SonarRequestException({ message: "Returned audio mode does not match requested mode" });
     }
+    return data;
+  } else {
+    const data = await response.text();
+    throw new SonarRequestException({ innerException: new Error(data) });
   }
 }
 
-// node_modules/node-fetch/src/utils/is.js
-var NAME = Symbol.toStringTag;
-var isURLSearchParameters = (object) => {
-  return typeof object === "object" && typeof object.append === "function" && typeof object.delete === "function" && typeof object.get === "function" && typeof object.getAll === "function" && typeof object.has === "function" && typeof object.set === "function" && typeof object.sort === "function" && object[NAME] === "URLSearchParams";
-};
-var isBlob = (object) => {
-  return object && typeof object === "object" && typeof object.arrayBuffer === "function" && typeof object.type === "string" && typeof object.stream === "function" && typeof object.constructor === "function" && /^(Blob|File)$/.test(object[NAME]);
-};
-var isAbortSignal = (object) => {
-  return typeof object === "object" && (object[NAME] === "AbortSignal" || object[NAME] === "EventTarget");
-};
-var isDomainOrSubdomain = (destination, original) => {
-  const orig = new URL(original).hostname;
-  const dest = new URL(destination).hostname;
-  return orig === dest || orig.endsWith(`.${dest}`);
-};
-var isSameProtocol = (destination, original) => {
-  const orig = new URL(original).protocol;
-  const dest = new URL(destination).protocol;
-  return orig === dest;
-};
+// src/functions/audio/set-audio-mode.ts
+async function setAudioMode(sonarEndpoint, audioMode) {
+  return await changeAudioMode(sonarEndpoint, audioMode);
+}
+// src/functions/converters/convert-channel-to-api.ts
+function convertChannelToApi(channel) {
+  switch (channel) {
+    case "master" /* Master */:
+      return "master" /* Master */;
+    case "game" /* Game */:
+      return "chatRender" /* ChatRender */;
+    case "media" /* Media */:
+      return "media" /* Media */;
+    case "aux" /* Aux */:
+      return "aux" /* Aux */;
+    case "mic" /* Mic */:
+      return "chatCapture" /* ChatCapture */;
+    default:
+      throw new Error(`Unsupported AudioChannel: ${channel}`);
+  }
+}
 
-// node_modules/node-fetch/src/body.js
-var pipeline = promisify(Stream.pipeline);
-var INTERNALS = Symbol("Body internals");
+// src/sonar/requests/volume-settings/change-volume-mute-classic.ts
+async function changeVolumeMuteClassic(sonarEndpoint, isMuted, deviceRole) {
+  let response;
+  try {
+    const url = new URL(`${sonarEndpoint}/volumeSettings/classic/${deviceRole}/mute/${isMuted}`);
+    response = await fetch(url, { method: "PUT" });
+  } catch (error) {
+    throw new SonarRequestException({ innerException: error });
+  }
+  if (response.ok) {
+    const data = await response.json();
+    if (data?.masters?.classic == null) {
+      throw new SonarRequestException({ innerException: new Error("Missing required data in response.") });
+    }
+    return data;
+  } else {
+    const data = await response.json();
+    throw new SonarRequestException({ innerException: new Error(data?.error ?? data) });
+  }
+}
 
-class Body {
-  constructor(body, {
-    size = 0
-  } = {}) {
-    let boundary = null;
-    if (body === null) {
-      body = null;
-    } else if (isURLSearchParameters(body)) {
-      body = Buffer2.from(body.toString());
-    } else if (isBlob(body)) {} else if (Buffer2.isBuffer(body)) {} else if (types.isAnyArrayBuffer(body)) {
-      body = Buffer2.from(body);
-    } else if (ArrayBuffer.isView(body)) {
-      body = Buffer2.from(body.buffer, body.byteOffset, body.byteLength);
-    } else if (body instanceof Stream) {} else if (body instanceof FormData) {
-      body = formDataToBlob(body);
-      boundary = body.type.split("=")[1];
-    } else {
-      body = Buffer2.from(String(body));
-    }
-    let stream = body;
-    if (Buffer2.isBuffer(body)) {
-      stream = Stream.Readable.from(body);
-    } else if (isBlob(body)) {
-      stream = Stream.Readable.from(body.stream());
-    }
-    this[INTERNALS] = {
-      body,
-      stream,
-      boundary,
-      disturbed: false,
-      error: null
-    };
-    this.size = size;
-    if (body instanceof Stream) {
-      body.on("error", (error_) => {
-        const error = error_ instanceof FetchBaseError ? error_ : new FetchError(`Invalid response body while trying to fetch ${this.url}: ${error_.message}`, "system", error_);
-        this[INTERNALS].error = error;
-      });
-    }
-  }
-  get body() {
-    return this[INTERNALS].stream;
-  }
-  get bodyUsed() {
-    return this[INTERNALS].disturbed;
+// src/functions/audio/set-channel-mute-classic.ts
+async function setChannelMuteClassic(sonarEndpoint, isMuted, channel) {
+  const sonarChannel = convertChannelToApi(channel);
+  const data = await changeVolumeMuteClassic(sonarEndpoint, isMuted, sonarChannel);
+  const device = sonarChannel === "master" /* Master */ ? data.masters.classic : data.devices[sonarChannel]?.classic;
+  if (!device) {
+    throw new SonarRequestException({ message: `Missing device data in response.` });
   }
-  async arrayBuffer() {
-    const { buffer, byteOffset, byteLength } = await consumeBody(this);
-    return buffer.slice(byteOffset, byteOffset + byteLength);
+  const result = {
+    volume: convertVolumeToUser(device.volume),
+    isMuted: device.muted
+  };
+  return result;
+}
+// src/sonar/requests/volume-settings/change-volume-mute-streamer.ts
+async function changeVolumeMuteStreamer(sonarEndpoint, isMuted, deviceRole, path) {
+  let response;
+  try {
+    const url = new URL(`${sonarEndpoint}/volumeSettings/streamer/${path}/${deviceRole}/isMuted/${isMuted}`);
+    response = await fetch(url, { method: "PUT" });
+  } catch (error) {
+    throw new SonarRequestException({ innerException: error });
   }
-  async formData() {
-    const ct = this.headers.get("content-type");
-    if (ct.startsWith("application/x-www-form-urlencoded")) {
-      const formData = new FormData;
-      const parameters = new URLSearchParams(await this.text());
-      for (const [name, value] of parameters) {
-        formData.append(name, value);
-      }
-      return formData;
+  if (response.ok) {
+    const data = await response.json();
+    if (data?.masters?.stream == null) {
+      throw new SonarRequestException({ innerException: new Error("Missing required data in response.") });
     }
-    const { toFormData: toFormData2 } = await Promise.resolve().then(() => (init_multipart_parser(), exports_multipart_parser));
-    return toFormData2(this.body, ct);
-  }
-  async blob() {
-    const ct = this.headers && this.headers.get("content-type") || this[INTERNALS].body && this[INTERNALS].body.type || "";
-    const buf = await this.arrayBuffer();
-    return new fetch_blob_default([buf], {
-      type: ct
-    });
+    return data;
+  } else {
+    const data = await response.json();
+    throw new SonarRequestException({ innerException: new Error(data?.error ?? data) });
   }
-  async json() {
-    const text = await this.text();
-    return JSON.parse(text);
+}
+
+// src/functions/audio/set-channel-mute-streamer.ts
+async function setChannelMuteStreamer(sonarEndpoint, isMuted, channel, path) {
+  const sonarChannel = convertChannelToApi(channel);
+  const streamPath = path === "streaming" /* Streaming */ ? "streaming" /* Streaming */ : "monitoring" /* Monitoring */;
+  const data = await changeVolumeMuteStreamer(sonarEndpoint, isMuted, sonarChannel, streamPath);
+  const device = sonarChannel === "master" /* Master */ ? data.masters.stream : data.devices[sonarChannel]?.stream;
+  if (!device) {
+    throw new SonarRequestException({ message: `Missing device data in response.` });
   }
-  async text() {
-    const buffer = await consumeBody(this);
-    return new TextDecoder().decode(buffer);
+  const devicePath = path === "streaming" /* Streaming */ ? device.streaming : device.monitoring;
+  const result = {
+    volume: convertVolumeToUser(devicePath.volume),
+    isMuted: devicePath.muted
+  };
+  return result;
+}
+// src/functions/converters/convert-volume-to-api.ts
+function convertVolumeToApi(value) {
+  let result = value / 100;
+  result = Math.min(Math.max(result, 0), 1);
+  return result;
+}
+
+// src/sonar/requests/volume-settings/change-volume-level-classic.ts
+async function changeVolumeLevelClassic(sonarEndpoint, volume, deviceRole) {
+  let response;
+  try {
+    const url = new URL(`${sonarEndpoint}/volumeSettings/classic/${deviceRole}/volume/${volume}`);
+    response = await fetch(url, { method: "PUT" });
+  } catch (error) {
+    throw new SonarRequestException({ innerException: error });
   }
-  buffer() {
-    return consumeBody(this);
+  if (response.ok) {
+    const data = await response.json();
+    if (data?.masters?.classic == null) {
+      throw new SonarRequestException({ innerException: new Error("Missing required data in response.") });
+    }
+    return data;
+  } else {
+    const data = await response.json();
+    throw new SonarRequestException({ innerException: new Error(data?.error ?? data) });
   }
 }
-Body.prototype.buffer = deprecate(Body.prototype.buffer, "Please use 'response.arrayBuffer()' instead of 'response.buffer()'", "node-fetch#buffer");
-Object.defineProperties(Body.prototype, {
-  body: { enumerable: true },
-  bodyUsed: { enumerable: true },
-  arrayBuffer: { enumerable: true },
-  blob: { enumerable: true },
-  json: { enumerable: true },
-  text: { enumerable: true },
-  data: { get: deprecate(() => {}, "data doesn't exist, use json(), text(), arrayBuffer(), or body instead", "https://github.com/node-fetch/node-fetch/issues/1000 (response)") }
-});
-async function consumeBody(data) {
-  if (data[INTERNALS].disturbed) {
-    throw new TypeError(`body used already for: ${data.url}`);
+
+// src/functions/audio/set-channel-volume-classic.ts
+async function setChannelVolumeClassic(sonarEndpoint, volumePercent, channel) {
+  const sonarChannel = convertChannelToApi(channel);
+  const formattedVolume = convertVolumeToApi(volumePercent);
+  const data = await changeVolumeLevelClassic(sonarEndpoint, formattedVolume, sonarChannel);
+  const device = sonarChannel === "master" /* Master */ ? data.masters.classic : data.devices[sonarChannel]?.classic;
+  if (!device) {
+    throw new SonarRequestException({ message: `Missing device data in response.` });
   }
-  data[INTERNALS].disturbed = true;
-  if (data[INTERNALS].error) {
-    throw data[INTERNALS].error;
+  const result = {
+    volume: convertVolumeToUser(device.volume),
+    isMuted: device.muted
+  };
+  return result;
+}
+// src/sonar/requests/volume-settings/change-volume-level-streamer.ts
+async function changeVolumeLevelStreamer(sonarEndpoint, volume, channel, path) {
+  let response;
+  try {
+    const url = new URL(`${sonarEndpoint}/volumeSettings/streamer/${path}/${channel}/volume/${volume}`);
+    response = await fetch(url, { method: "PUT" });
+  } catch (error) {
+    throw new SonarRequestException({ innerException: error });
   }
-  const { body } = data;
-  if (body === null) {
-    return Buffer2.alloc(0);
+  if (response.ok) {
+    const data = await response.json();
+    if (data?.masters?.stream == null) {
+      throw new SonarRequestException({ innerException: new Error("Missing required data in response.") });
+    }
+    return data;
+  } else {
+    const data = await response.json();
+    throw new SonarRequestException({ innerException: new Error(data?.error ?? data) });
   }
-  if (!(body instanceof Stream)) {
-    return Buffer2.alloc(0);
+}
+
+// src/functions/audio/set-channel-volume-streamer.ts
+async function setChannelVolumeStreamer(sonarEndpoint, volumePercent, channel, path) {
+  const sonarChannel = convertChannelToApi(channel);
+  const formattedVolume = convertVolumeToApi(volumePercent);
+  const streamPath = path === "streaming" /* Streaming */ ? "streaming" /* Streaming */ : "monitoring" /* Monitoring */;
+  const data = await changeVolumeLevelStreamer(sonarEndpoint, formattedVolume, sonarChannel, streamPath);
+  const device = sonarChannel === "master" /* Master */ ? data.masters.stream : data.devices[sonarChannel]?.stream;
+  if (!device) {
+    throw new SonarRequestException({ message: `Missing device data in response.` });
   }
-  const accum = [];
-  let accumBytes = 0;
+  const devicePath = path === "streaming" /* Streaming */ ? device.streaming : device.monitoring;
+  const result = {
+    volume: convertVolumeToUser(devicePath.volume),
+    isMuted: devicePath.muted
+  };
+  return result;
+}
+// src/functions/converters/convert-chat-mix-balance-to-user.ts
+function convertChatMixBalanceToUser(balance) {
+  let result = (balance + 1) / 2 * 100;
+  result = Math.floor(result);
+  result = Math.min(Math.max(result, 0), 100);
+  return result;
+}
+
+// src/sonar/requests/chatmix/request-chat-mix-state.ts
+async function requestChatMixState(sonarEndpoint) {
+  const url = new URL(`${sonarEndpoint}/chatMix`);
+  let response;
   try {
-    for await (const chunk of body) {
-      if (data.size > 0 && accumBytes + chunk.length > data.size) {
-        const error = new FetchError(`content size at ${data.url} over limit: ${data.size}`, "max-size");
-        body.destroy(error);
-        throw error;
-      }
-      accumBytes += chunk.length;
-      accum.push(chunk);
-    }
+    response = await fetch(url);
   } catch (error) {
-    const error_ = error instanceof FetchBaseError ? error : new FetchError(`Invalid response body while trying to fetch ${data.url}: ${error.message}`, "system", error);
-    throw error_;
+    throw new SonarRequestException({ innerException: error });
   }
-  if (body.readableEnded === true || body._readableState.ended === true) {
-    try {
-      if (accum.every((c) => typeof c === "string")) {
-        return Buffer2.from(accum.join(""));
-      }
-      return Buffer2.concat(accum, accumBytes);
-    } catch (error) {
-      throw new FetchError(`Could not create Buffer from response body for ${data.url}: ${error.message}`, "system", error);
+  if (response.ok) {
+    const data = await response.json();
+    if (data?.balance == null || data?.state == null) {
+      throw new SonarRequestException({ message: "Missing required data in response" });
     }
+    return data;
   } else {
-    throw new FetchError(`Premature close of server response while trying to fetch ${data.url}`);
+    const data = await response.text();
+    throw new SonarRequestException({ innerException: new Error(data) });
   }
 }
-var clone = (instance, highWaterMark) => {
-  let p1;
-  let p2;
-  let { body } = instance[INTERNALS];
-  if (instance.bodyUsed) {
-    throw new Error("cannot clone body after it is used");
+
+// src/functions/chatmix/get-chat-mix-state.ts
+async function getChatMixState(sonarEndpoint) {
+  const data = await requestChatMixState(sonarEndpoint);
+  const chatMixData = {
+    chatBalance: convertChatMixBalanceToUser(data.balance),
+    state: data.state,
+    isEnabled: data.state === "enabled" /* Enabled */
+  };
+  return chatMixData;
+}
+// src/functions/converters/convert-chat-mix-balance-to-api.ts
+function convertChatMixBalanceToApi(balance) {
+  let result = balance / 100 * 2 - 1;
+  result = Math.min(Math.max(result, -1), 1);
+  return result;
+}
+
+// src/sonar/requests/chatmix/change-chat-mix-balance.ts
+async function changeChatMixBalance(sonarEndpoint, chatBalance) {
+  const url = new URL(`${sonarEndpoint}/chatMix?balance=${chatBalance}`);
+  let response;
+  try {
+    response = await fetch(url, {
+      method: "PUT"
+    });
+  } catch (error) {
+    throw new SonarRequestException({ innerException: error });
   }
-  if (body instanceof Stream && typeof body.getBoundary !== "function") {
-    p1 = new PassThrough({ highWaterMark });
-    p2 = new PassThrough({ highWaterMark });
-    body.pipe(p1);
-    body.pipe(p2);
-    instance[INTERNALS].stream = p1;
-    body = p2;
+  if (response.ok) {
+    const data = await response.json();
+    if (data?.balance == null || data?.state == null) {
+      throw new SonarRequestException({ message: "Missing required data in response" });
+    }
+    return data;
+  } else {
+    const data = await response.json();
+    throw new SonarRequestException({ message: data.Message });
   }
-  return body;
-};
-var getNonSpecFormDataBoundary = deprecate((body) => body.getBoundary(), "form-data doesn't follow the spec and requires special treatment. Use alternative package", "https://github.com/node-fetch/node-fetch/issues/1167");
-var extractContentType = (body, request) => {
-  if (body === null) {
-    return null;
+}
+
+// src/functions/chatmix/set-chat-mix-balance.ts
+async function setChatMixBalance(sonarEndpoint, chatBalance) {
+  const balance = convertChatMixBalanceToApi(chatBalance);
+  const data = await changeChatMixBalance(sonarEndpoint, balance);
+  const chatMixData = {
+    chatBalance: convertChatMixBalanceToUser(data.balance),
+    state: data.state,
+    isEnabled: data.state === "enabled" /* Enabled */
+  };
+  return chatMixData;
+}
+// src/sonar/requests/audio-devices/request-audio-devices.ts
+async function requestAudioDevices(sonarEndpoint, params) {
+  const { deviceDataFlow, onlySteelSeriesVAD = false, removeSteelSeriesVAD = false } = params;
+  const url = new URL(`${sonarEndpoint}/audioDevices`);
+  url.searchParams.append("onlySteelSeriesVAD", String(onlySteelSeriesVAD));
+  url.searchParams.append("removeSteelSeriesVAD", String(removeSteelSeriesVAD));
+  if (deviceDataFlow !== undefined) {
+    url.searchParams.append("deviceDataFlow", deviceDataFlow.toString());
   }
-  if (typeof body === "string") {
-    return "text/plain;charset=UTF-8";
+  let response;
+  try {
+    response = await fetch(url);
+  } catch (error) {
+    throw new SonarRequestException({
+      innerException: error
+    });
   }
-  if (isURLSearchParameters(body)) {
-    return "application/x-www-form-urlencoded;charset=UTF-8";
+  if (!response.ok) {
+    const error = await response.text();
+    throw new SonarRequestException({ message: `Failed to get audio devices: ${error}` });
   }
-  if (isBlob(body)) {
-    return body.type || null;
+  const data = await response.json();
+  if (!Array.isArray(data)) {
+    throw new SonarRequestException({ message: "Invalid audio devices response format." });
   }
-  if (Buffer2.isBuffer(body) || types.isAnyArrayBuffer(body) || ArrayBuffer.isView(body)) {
-    return null;
+  return data;
+}
+
+// src/functions/devices/get-audio-devices.ts
+async function getAudioDevices(sonarEndpoint, deviceType) {
+  let deviceDataFlow;
+  switch (deviceType) {
+    case "input" /* Input */:
+      deviceDataFlow = "capture" /* Capture */;
+      break;
+    case "output" /* Output */:
+      deviceDataFlow = "render" /* Render */;
+      break;
+    case undefined:
+      deviceDataFlow = "all" /* All */;
+      break;
   }
-  if (body instanceof FormData) {
-    return `multipart/form-data; boundary=${request[INTERNALS].boundary}`;
+  const data = await requestAudioDevices(sonarEndpoint, { deviceDataFlow, removeSteelSeriesVAD: true });
+  const audioDevices = data.map((device) => ({
+    id: device.id,
+    name: device.friendlyName,
+    type: getDeviceTypeFromDataFlow(device.dataFlow)
+  }));
+  return audioDevices;
+}
+function getDeviceTypeFromDataFlow(dataFlow) {
+  switch (dataFlow) {
+    case "capture" /* Capture */:
+      return "input" /* Input */;
+    case "render" /* Render */:
+      return "output" /* Output */;
+    default:
+      throw new SonarRequestException({ message: `Unknown device data flow: ${dataFlow}` });
   }
-  if (body && typeof body.getBoundary === "function") {
-    return `multipart/form-data;boundary=${getNonSpecFormDataBoundary(body)}`;
+}
+// src/sonar/requests/audio-devices/change-audio-device.ts
+async function changeAudioDevice(sonarEndpoint, deviceChannel, deviceId) {
+  let response;
+  const url = new URL(`${sonarEndpoint}/classicRedirections/${deviceChannel}/deviceId/${deviceId}`);
+  try {
+    response = await fetch(url, { method: "PUT" });
+  } catch (error) {
+    throw new SonarRequestException({
+      innerException: error
+    });
   }
-  if (body instanceof Stream) {
-    return null;
+  if (!response.ok) {
+    const error = await response.text();
+    throw new SonarRequestException({ message: `Failed to get audio devices: ${error}` });
   }
-  return "text/plain;charset=UTF-8";
-};
-var getTotalBytes = (request) => {
-  const { body } = request[INTERNALS];
-  if (body === null) {
-    return 0;
+  const unknownData = await response.json();
+  const data = Array.isArray(unknownData) ? unknownData : [unknownData];
+  const devices = data.filter((x) => x?.deviceId === deviceId);
+  if (devices.length === 0) {
+    throw new SonarRequestException({ message: "The changed audio devices list is empty." });
   }
-  if (isBlob(body)) {
-    return body.size;
+  return devices;
+}
+
+// src/functions/devices/set-audio-device.ts
+async function setAudioDevice(sonarEndpoint, deviceChannel, deviceId) {
+  const data = await changeAudioDevice(sonarEndpoint, deviceChannel, deviceId);
+  const result = data.map((x) => ({
+    deviceId: x.deviceId,
+    deviceChannel: x.id,
+    isRunning: x.isRunning
+  }));
+  return result;
+}
+// src/functions/endpoint/get-app-endpoint.ts
+import { promises as fsAsync } from "node:fs";
+import { platform as getPlatform } from "node:os";
+import { join as joinPath } from "node:path";
+var WINDOWS_PATHS = ["SteelSeries", "SteelSeries Engine 3", "coreProps.json"];
+async function getAppEndpoint() {
+  const appDataPath = getPath();
+  const fileContents = await getContents(appDataPath);
+  const data = parseContents(fileContents);
+  if (data.ggEncryptedAddress) {
+    return `https://${data.ggEncryptedAddress}`;
   }
-  if (Buffer2.isBuffer(body)) {
-    return body.length;
+  throw new SonarInitializationException({
+    reason: "Bad Config" /* BadConfig */
+  });
+}
+function getPath() {
+  const os = getPlatform();
+  switch (os) {
+    case "win32": {
+      const programData = process.env.ProgramData ?? "C:\\ProgramData";
+      return joinPath(programData, ...WINDOWS_PATHS);
+    }
+    default:
+      throw new SonarInitializationException({
+        reason: "OS Unsupported" /* OSUnsupported */
+      });
   }
-  if (body && typeof body.getLengthSync === "function") {
-    return body.hasKnownLength && body.hasKnownLength() ? body.getLengthSync() : null;
+}
+async function getContents(path) {
+  try {
+    return await fsAsync.readFile(path, "utf8");
+  } catch (error) {
+    throw new SonarInitializationException({
+      reason: "Bad Config" /* BadConfig */,
+      innerException: error
+    });
   }
-  return null;
-};
-var writeToStream = async (dest, { body }) => {
-  if (body === null) {
-    dest.end();
-  } else {
-    await pipeline(body, dest);
+}
+function parseContents(contents) {
+  try {
+    return JSON.parse(contents);
+  } catch (error) {
+    throw new SonarInitializationException({
+      reason: "Bad Config" /* BadConfig */,
+      innerException: error
+    });
   }
-};
+}
+// src/functions/endpoint/get-sonar-endpoint.ts
+import https2 from "node:https";
 
-// node_modules/node-fetch/src/headers.js
-import { types as types2 } from "node:util";
-import http from "node:http";
-var validateHeaderName = typeof http.validateHeaderName === "function" ? http.validateHeaderName : (name) => {
-  if (!/^[\^`\-\w!#$%&'*+.|~]+$/.test(name)) {
-    const error = new TypeError(`Header name must be a valid HTTP token [${name}]`);
-    Object.defineProperty(error, "code", { value: "ERR_INVALID_HTTP_TOKEN" });
-    throw error;
+// node_modules/node-fetch/src/index.js
+import http2 from "node:http";
+import https from "node:https";
+import zlib from "node:zlib";
+import Stream2, { PassThrough as PassThrough2, pipeline as pump } from "node:stream";
+import { Buffer as Buffer3 } from "node:buffer";
+
+// node_modules/data-uri-to-buffer/dist/index.js
+function dataUriToBuffer(uri) {
+  if (!/^data:/i.test(uri)) {
+    throw new TypeError('`uri` does not appear to be a Data URI (must begin with "data:")');
   }
-};
-var validateHeaderValue = typeof http.validateHeaderValue === "function" ? http.validateHeaderValue : (name, value) => {
-  if (/[^\t\u0020-\u007E\u0080-\u00FF]/.test(value)) {
-    const error = new TypeError(`Invalid character in header content ["${name}"]`);
-    Object.defineProperty(error, "code", { value: "ERR_INVALID_CHAR" });
-    throw error;
+  uri = uri.replace(/\r?\n/g, "");
+  const firstComma = uri.indexOf(",");
+  if (firstComma === -1 || firstComma <= 4) {
+    throw new TypeError("malformed data: URI");
   }
-};
-
-class Headers extends URLSearchParams {
-  constructor(init) {
-    let result = [];
-    if (init instanceof Headers) {
-      const raw = init.raw();
-      for (const [name, values] of Object.entries(raw)) {
-        result.push(...values.map((value) => [name, value]));
-      }
-    } else if (init == null) {} else if (typeof init === "object" && !types2.isBoxedPrimitive(init)) {
-      const method = init[Symbol.iterator];
-      if (method == null) {
-        result.push(...Object.entries(init));
-      } else {
-        if (typeof method !== "function") {
-          throw new TypeError("Header pairs must be iterable");
-        }
-        result = [...init].map((pair) => {
-          if (typeof pair !== "object" || types2.isBoxedPrimitive(pair)) {
-            throw new TypeError("Each header pair must be an iterable object");
-          }
-          return [...pair];
-        }).map((pair) => {
-          if (pair.length !== 2) {
-            throw new TypeError("Each header pair must be a name/value tuple");
-          }
-          return [...pair];
-        });
+  const meta = uri.substring(5, firstComma).split(";");
+  let charset = "";
+  let base64 = false;
+  const type = meta[0] || "text/plain";
+  let typeFull = type;
+  for (let i = 1;i < meta.length; i++) {
+    if (meta[i] === "base64") {
+      base64 = true;
+    } else if (meta[i]) {
+      typeFull += `;${meta[i]}`;
+      if (meta[i].indexOf("charset=") === 0) {
+        charset = meta[i].substring(8);
       }
-    } else {
-      throw new TypeError("Failed to construct 'Headers': The provided value is not of type '(sequence<sequence<ByteString>> or record<ByteString, ByteString>)");
     }
-    result = result.length > 0 ? result.map(([name, value]) => {
-      validateHeaderName(name);
-      validateHeaderValue(name, String(value));
-      return [String(name).toLowerCase(), String(value)];
-    }) : undefined;
-    super(result);
-    return new Proxy(this, {
-      get(target, p, receiver) {
-        switch (p) {
-          case "append":
-          case "set":
-            return (name, value) => {
-              validateHeaderName(name);
-              validateHeaderValue(name, String(value));
-              return URLSearchParams.prototype[p].call(target, String(name).toLowerCase(), String(value));
-            };
-          case "delete":
-          case "has":
-          case "getAll":
-            return (name) => {
-              validateHeaderName(name);
-              return URLSearchParams.prototype[p].call(target, String(name).toLowerCase());
-            };
-          case "keys":
-            return () => {
-              target.sort();
-              return new Set(URLSearchParams.prototype.keys.call(target)).keys();
-            };
-          default:
-            return Reflect.get(target, p, receiver);
-        }
-      }
-    });
+  }
+  if (!meta[0] && !charset.length) {
+    typeFull += ";charset=US-ASCII";
+    charset = "US-ASCII";
+  }
+  const encoding = base64 ? "base64" : "ascii";
+  const data = unescape(uri.substring(firstComma + 1));
+  const buffer = Buffer.from(data, encoding);
+  buffer.type = type;
+  buffer.typeFull = typeFull;
+  buffer.charset = charset;
+  return buffer;
+}
+var dist_default = dataUriToBuffer;
+
+// node_modules/node-fetch/src/body.js
+init_fetch_blob();
+init_esm_min();
+import Stream, { PassThrough } from "node:stream";
+import { types, deprecate, promisify } from "node:util";
+import { Buffer as Buffer2 } from "node:buffer";
+
+// node_modules/node-fetch/src/errors/base.js
+class FetchBaseError extends Error {
+  constructor(message, type) {
+    super(message);
+    Error.captureStackTrace(this, this.constructor);
+    this.type = type;
+  }
+  get name() {
+    return this.constructor.name;
   }
   get [Symbol.toStringTag]() {
     return this.constructor.name;
   }
-  toString() {
-    return Object.prototype.toString.call(this);
+}
+
+// node_modules/node-fetch/src/errors/fetch-error.js
+class FetchError extends FetchBaseError {
+  constructor(message, type, systemError) {
+    super(message, type);
+    if (systemError) {
+      this.code = this.errno = systemError.code;
+      this.erroredSysCall = systemError.syscall;
+    }
   }
-  get(name) {
-    const values = this.getAll(name);
-    if (values.length === 0) {
-      return null;
+}
+
+// node_modules/node-fetch/src/utils/is.js
+var NAME = Symbol.toStringTag;
+var isURLSearchParameters = (object) => {
+  return typeof object === "object" && typeof object.append === "function" && typeof object.delete === "function" && typeof object.get === "function" && typeof object.getAll === "function" && typeof object.has === "function" && typeof object.set === "function" && typeof object.sort === "function" && object[NAME] === "URLSearchParams";
+};
+var isBlob = (object) => {
+  return object && typeof object === "object" && typeof object.arrayBuffer === "function" && typeof object.type === "string" && typeof object.stream === "function" && typeof object.constructor === "function" && /^(Blob|File)$/.test(object[NAME]);
+};
+var isAbortSignal = (object) => {
+  return typeof object === "object" && (object[NAME] === "AbortSignal" || object[NAME] === "EventTarget");
+};
+var isDomainOrSubdomain = (destination, original) => {
+  const orig = new URL(original).hostname;
+  const dest = new URL(destination).hostname;
+  return orig === dest || orig.endsWith(`.${dest}`);
+};
+var isSameProtocol = (destination, original) => {
+  const orig = new URL(original).protocol;
+  const dest = new URL(destination).protocol;
+  return orig === dest;
+};
+
+// node_modules/node-fetch/src/body.js
+var pipeline = promisify(Stream.pipeline);
+var INTERNALS = Symbol("Body internals");
+
+class Body {
+  constructor(body, {
+    size = 0
+  } = {}) {
+    let boundary = null;
+    if (body === null) {
+      body = null;
+    } else if (isURLSearchParameters(body)) {
+      body = Buffer2.from(body.toString());
+    } else if (isBlob(body)) {} else if (Buffer2.isBuffer(body)) {} else if (types.isAnyArrayBuffer(body)) {
+      body = Buffer2.from(body);
+    } else if (ArrayBuffer.isView(body)) {
+      body = Buffer2.from(body.buffer, body.byteOffset, body.byteLength);
+    } else if (body instanceof Stream) {} else if (body instanceof FormData) {
+      body = formDataToBlob(body);
+      boundary = body.type.split("=")[1];
+    } else {
+      body = Buffer2.from(String(body));
     }
-    let value = values.join(", ");
-    if (/^content-encoding$/i.test(name)) {
-      value = value.toLowerCase();
+    let stream = body;
+    if (Buffer2.isBuffer(body)) {
+      stream = Stream.Readable.from(body);
+    } else if (isBlob(body)) {
+      stream = Stream.Readable.from(body.stream());
     }
-    return value;
-  }
-  forEach(callback, thisArg = undefined) {
-    for (const name of this.keys()) {
-      Reflect.apply(callback, thisArg, [this.get(name), name, this]);
+    this[INTERNALS] = {
+      body,
+      stream,
+      boundary,
+      disturbed: false,
+      error: null
+    };
+    this.size = size;
+    if (body instanceof Stream) {
+      body.on("error", (error_) => {
+        const error = error_ instanceof FetchBaseError ? error_ : new FetchError(`Invalid response body while trying to fetch ${this.url}: ${error_.message}`, "system", error_);
+        this[INTERNALS].error = error;
+      });
     }
   }
-  *values() {
-    for (const name of this.keys()) {
-      yield this.get(name);
-    }
+  get body() {
+    return this[INTERNALS].stream;
   }
-  *entries() {
-    for (const name of this.keys()) {
-      yield [name, this.get(name)];
+  get bodyUsed() {
+    return this[INTERNALS].disturbed;
+  }
+  async arrayBuffer() {
+    const { buffer, byteOffset, byteLength } = await consumeBody(this);
+    return buffer.slice(byteOffset, byteOffset + byteLength);
+  }
+  async formData() {
+    const ct = this.headers.get("content-type");
+    if (ct.startsWith("application/x-www-form-urlencoded")) {
+      const formData = new FormData;
+      const parameters = new URLSearchParams(await this.text());
+      for (const [name, value] of parameters) {
+        formData.append(name, value);
+      }
+      return formData;
     }
+    const { toFormData: toFormData2 } = await Promise.resolve().then(() => (init_multipart_parser(), exports_multipart_parser));
+    return toFormData2(this.body, ct);
   }
-  [Symbol.iterator]() {
-    return this.entries();
+  async blob() {
+    const ct = this.headers && this.headers.get("content-type") || this[INTERNALS].body && this[INTERNALS].body.type || "";
+    const buf = await this.arrayBuffer();
+    return new fetch_blob_default([buf], {
+      type: ct
+    });
   }
-  raw() {
-    return [...this.keys()].reduce((result, key) => {
-      result[key] = this.getAll(key);
-      return result;
-    }, {});
+  async json() {
+    const text = await this.text();
+    return JSON.parse(text);
   }
-  [Symbol.for("nodejs.util.inspect.custom")]() {
-    return [...this.keys()].reduce((result, key) => {
-      const values = this.getAll(key);
-      if (key === "host") {
-        result[key] = values[0];
-      } else {
-        result[key] = values.length > 1 ? values : values[0];
-      }
-      return result;
-    }, {});
+  async text() {
+    const buffer = await consumeBody(this);
+    return new TextDecoder().decode(buffer);
+  }
+  buffer() {
+    return consumeBody(this);
   }
 }
-Object.defineProperties(Headers.prototype, ["get", "entries", "forEach", "values"].reduce((result, property) => {
-  result[property] = { enumerable: true };
-  return result;
-}, {}));
-function fromRawHeaders(headers = []) {
-  return new Headers(headers.reduce((result, value, index, array) => {
-    if (index % 2 === 0) {
-      result.push(array.slice(index, index + 2));
+Body.prototype.buffer = deprecate(Body.prototype.buffer, "Please use 'response.arrayBuffer()' instead of 'response.buffer()'", "node-fetch#buffer");
+Object.defineProperties(Body.prototype, {
+  body: { enumerable: true },
+  bodyUsed: { enumerable: true },
+  arrayBuffer: { enumerable: true },
+  blob: { enumerable: true },
+  json: { enumerable: true },
+  text: { enumerable: true },
+  data: { get: deprecate(() => {}, "data doesn't exist, use json(), text(), arrayBuffer(), or body instead", "https://github.com/node-fetch/node-fetch/issues/1000 (response)") }
+});
+async function consumeBody(data) {
+  if (data[INTERNALS].disturbed) {
+    throw new TypeError(`body used already for: ${data.url}`);
+  }
+  data[INTERNALS].disturbed = true;
+  if (data[INTERNALS].error) {
+    throw data[INTERNALS].error;
+  }
+  const { body } = data;
+  if (body === null) {
+    return Buffer2.alloc(0);
+  }
+  if (!(body instanceof Stream)) {
+    return Buffer2.alloc(0);
+  }
+  const accum = [];
+  let accumBytes = 0;
+  try {
+    for await (const chunk of body) {
+      if (data.size > 0 && accumBytes + chunk.length > data.size) {
+        const error = new FetchError(`content size at ${data.url} over limit: ${data.size}`, "max-size");
+        body.destroy(error);
+        throw error;
+      }
+      accumBytes += chunk.length;
+      accum.push(chunk);
     }
-    return result;
-  }, []).filter(([name, value]) => {
+  } catch (error) {
+    const error_ = error instanceof FetchBaseError ? error : new FetchError(`Invalid response body while trying to fetch ${data.url}: ${error.message}`, "system", error);
+    throw error_;
+  }
+  if (body.readableEnded === true || body._readableState.ended === true) {
     try {
-      validateHeaderName(name);
-      validateHeaderValue(name, String(value));
-      return true;
-    } catch {
-      return false;
-    }
-  }));
-}
-
-// node_modules/node-fetch/src/utils/is-redirect.js
-var redirectStatus = new Set([301, 302, 303, 307, 308]);
-var isRedirect = (code) => {
-  return redirectStatus.has(code);
-};
-
-// node_modules/node-fetch/src/response.js
-var INTERNALS2 = Symbol("Response internals");
-
-class Response extends Body {
-  constructor(body = null, options = {}) {
-    super(body, options);
-    const status = options.status != null ? options.status : 200;
-    const headers = new Headers(options.headers);
-    if (body !== null && !headers.has("Content-Type")) {
-      const contentType = extractContentType(body, this);
-      if (contentType) {
-        headers.append("Content-Type", contentType);
+      if (accum.every((c) => typeof c === "string")) {
+        return Buffer2.from(accum.join(""));
       }
+      return Buffer2.concat(accum, accumBytes);
+    } catch (error) {
+      throw new FetchError(`Could not create Buffer from response body for ${data.url}: ${error.message}`, "system", error);
     }
-    this[INTERNALS2] = {
-      type: "default",
-      url: options.url,
-      status,
-      statusText: options.statusText || "",
-      headers,
-      counter: options.counter,
-      highWaterMark: options.highWaterMark
-    };
+  } else {
+    throw new FetchError(`Premature close of server response while trying to fetch ${data.url}`);
   }
-  get type() {
-    return this[INTERNALS2].type;
+}
+var clone = (instance, highWaterMark) => {
+  let p1;
+  let p2;
+  let { body } = instance[INTERNALS];
+  if (instance.bodyUsed) {
+    throw new Error("cannot clone body after it is used");
   }
-  get url() {
-    return this[INTERNALS2].url || "";
+  if (body instanceof Stream && typeof body.getBoundary !== "function") {
+    p1 = new PassThrough({ highWaterMark });
+    p2 = new PassThrough({ highWaterMark });
+    body.pipe(p1);
+    body.pipe(p2);
+    instance[INTERNALS].stream = p1;
+    body = p2;
   }
-  get status() {
-    return this[INTERNALS2].status;
+  return body;
+};
+var getNonSpecFormDataBoundary = deprecate((body) => body.getBoundary(), "form-data doesn't follow the spec and requires special treatment. Use alternative package", "https://github.com/node-fetch/node-fetch/issues/1167");
+var extractContentType = (body, request) => {
+  if (body === null) {
+    return null;
   }
-  get ok() {
-    return this[INTERNALS2].status >= 200 && this[INTERNALS2].status < 300;
+  if (typeof body === "string") {
+    return "text/plain;charset=UTF-8";
   }
-  get redirected() {
-    return this[INTERNALS2].counter > 0;
+  if (isURLSearchParameters(body)) {
+    return "application/x-www-form-urlencoded;charset=UTF-8";
   }
-  get statusText() {
-    return this[INTERNALS2].statusText;
+  if (isBlob(body)) {
+    return body.type || null;
   }
-  get headers() {
-    return this[INTERNALS2].headers;
+  if (Buffer2.isBuffer(body) || types.isAnyArrayBuffer(body) || ArrayBuffer.isView(body)) {
+    return null;
   }
-  get highWaterMark() {
-    return this[INTERNALS2].highWaterMark;
+  if (body instanceof FormData) {
+    return `multipart/form-data; boundary=${request[INTERNALS].boundary}`;
   }
-  clone() {
-    return new Response(clone(this, this.highWaterMark), {
-      type: this.type,
-      url: this.url,
-      status: this.status,
-      statusText: this.statusText,
-      headers: this.headers,
-      ok: this.ok,
-      redirected: this.redirected,
-      size: this.size,
-      highWaterMark: this.highWaterMark
-    });
+  if (body && typeof body.getBoundary === "function") {
+    return `multipart/form-data;boundary=${getNonSpecFormDataBoundary(body)}`;
   }
-  static redirect(url, status = 302) {
-    if (!isRedirect(status)) {
-      throw new RangeError('Failed to execute "redirect" on "response": Invalid status code');
-    }
-    return new Response(null, {
-      headers: {
-        location: new URL(url).toString()
-      },
-      status
-    });
+  if (body instanceof Stream) {
+    return null;
   }
-  static error() {
-    const response = new Response(null, { status: 0, statusText: "" });
-    response[INTERNALS2].type = "error";
-    return response;
+  return "text/plain;charset=UTF-8";
+};
+var getTotalBytes = (request) => {
+  const { body } = request[INTERNALS];
+  if (body === null) {
+    return 0;
   }
-  static json(data = undefined, init = {}) {
-    const body = JSON.stringify(data);
-    if (body === undefined) {
-      throw new TypeError("data is not JSON serializable");
-    }
-    const headers = new Headers(init && init.headers);
-    if (!headers.has("content-type")) {
-      headers.set("content-type", "application/json");
-    }
-    return new Response(body, {
-      ...init,
-      headers
-    });
+  if (isBlob(body)) {
+    return body.size;
   }
-  get [Symbol.toStringTag]() {
-    return "Response";
+  if (Buffer2.isBuffer(body)) {
+    return body.length;
   }
-}
-Object.defineProperties(Response.prototype, {
-  type: { enumerable: true },
-  url: { enumerable: true },
-  status: { enumerable: true },
-  ok: { enumerable: true },
-  redirected: { enumerable: true },
-  statusText: { enumerable: true },
-  headers: { enumerable: true },
-  clone: { enumerable: true }
-});
-
-// node_modules/node-fetch/src/request.js
-import { format as formatUrl } from "node:url";
-import { deprecate as deprecate2 } from "node:util";
-
-// node_modules/node-fetch/src/utils/get-search.js
-var getSearch = (parsedURL) => {
-  if (parsedURL.search) {
-    return parsedURL.search;
+  if (body && typeof body.getLengthSync === "function") {
+    return body.hasKnownLength && body.hasKnownLength() ? body.getLengthSync() : null;
   }
-  const lastOffset = parsedURL.href.length - 1;
-  const hash = parsedURL.hash || (parsedURL.href[lastOffset] === "#" ? "#" : "");
-  return parsedURL.href[lastOffset - hash.length] === "?" ? "?" : "";
+  return null;
 };
-
-// node_modules/node-fetch/src/utils/referrer.js
-import { isIP } from "node:net";
-function stripURLForUseAsAReferrer(url, originOnly = false) {
-  if (url == null) {
-    return "no-referrer";
+var writeToStream = async (dest, { body }) => {
+  if (body === null) {
+    dest.end();
+  } else {
+    await pipeline(body, dest);
   }
-  url = new URL(url);
-  if (/^(about|blob|data):$/.test(url.protocol)) {
-    return "no-referrer";
+};
+
+// node_modules/node-fetch/src/headers.js
+import { types as types2 } from "node:util";
+import http from "node:http";
+var validateHeaderName = typeof http.validateHeaderName === "function" ? http.validateHeaderName : (name) => {
+  if (!/^[\^`\-\w!#$%&'*+.|~]+$/.test(name)) {
+    const error = new TypeError(`Header name must be a valid HTTP token [${name}]`);
+    Object.defineProperty(error, "code", { value: "ERR_INVALID_HTTP_TOKEN" });
+    throw error;
   }
-  url.username = "";
-  url.password = "";
-  url.hash = "";
-  if (originOnly) {
-    url.pathname = "";
-    url.search = "";
+};
+var validateHeaderValue = typeof http.validateHeaderValue === "function" ? http.validateHeaderValue : (name, value) => {
+  if (/[^\t\u0020-\u007E\u0080-\u00FF]/.test(value)) {
+    const error = new TypeError(`Invalid character in header content ["${name}"]`);
+    Object.defineProperty(error, "code", { value: "ERR_INVALID_CHAR" });
+    throw error;
   }
-  return url;
-}
-var ReferrerPolicy = new Set([
-  "",
-  "no-referrer",
-  "no-referrer-when-downgrade",
-  "same-origin",
-  "origin",
-  "strict-origin",
-  "origin-when-cross-origin",
-  "strict-origin-when-cross-origin",
-  "unsafe-url"
-]);
-var DEFAULT_REFERRER_POLICY = "strict-origin-when-cross-origin";
-function validateReferrerPolicy(referrerPolicy) {
-  if (!ReferrerPolicy.has(referrerPolicy)) {
-    throw new TypeError(`Invalid referrerPolicy: ${referrerPolicy}`);
-  }
-  return referrerPolicy;
-}
-function isOriginPotentiallyTrustworthy(url) {
-  if (/^(http|ws)s:$/.test(url.protocol)) {
-    return true;
-  }
-  const hostIp = url.host.replace(/(^\[)|(]$)/g, "");
-  const hostIPVersion = isIP(hostIp);
-  if (hostIPVersion === 4 && /^127\./.test(hostIp)) {
-    return true;
-  }
-  if (hostIPVersion === 6 && /^(((0+:){7})|(::(0+:){0,6}))0*1$/.test(hostIp)) {
-    return true;
-  }
-  if (url.host === "localhost" || url.host.endsWith(".localhost")) {
-    return false;
-  }
-  if (url.protocol === "file:") {
-    return true;
+};
+
+class Headers extends URLSearchParams {
+  constructor(init) {
+    let result = [];
+    if (init instanceof Headers) {
+      const raw = init.raw();
+      for (const [name, values] of Object.entries(raw)) {
+        result.push(...values.map((value) => [name, value]));
+      }
+    } else if (init == null) {} else if (typeof init === "object" && !types2.isBoxedPrimitive(init)) {
+      const method = init[Symbol.iterator];
+      if (method == null) {
+        result.push(...Object.entries(init));
+      } else {
+        if (typeof method !== "function") {
+          throw new TypeError("Header pairs must be iterable");
+        }
+        result = [...init].map((pair) => {
+          if (typeof pair !== "object" || types2.isBoxedPrimitive(pair)) {
+            throw new TypeError("Each header pair must be an iterable object");
+          }
+          return [...pair];
+        }).map((pair) => {
+          if (pair.length !== 2) {
+            throw new TypeError("Each header pair must be a name/value tuple");
+          }
+          return [...pair];
+        });
+      }
+    } else {
+      throw new TypeError("Failed to construct 'Headers': The provided value is not of type '(sequence<sequence<ByteString>> or record<ByteString, ByteString>)");
+    }
+    result = result.length > 0 ? result.map(([name, value]) => {
+      validateHeaderName(name);
+      validateHeaderValue(name, String(value));
+      return [String(name).toLowerCase(), String(value)];
+    }) : undefined;
+    super(result);
+    return new Proxy(this, {
+      get(target, p, receiver) {
+        switch (p) {
+          case "append":
+          case "set":
+            return (name, value) => {
+              validateHeaderName(name);
+              validateHeaderValue(name, String(value));
+              return URLSearchParams.prototype[p].call(target, String(name).toLowerCase(), String(value));
+            };
+          case "delete":
+          case "has":
+          case "getAll":
+            return (name) => {
+              validateHeaderName(name);
+              return URLSearchParams.prototype[p].call(target, String(name).toLowerCase());
+            };
+          case "keys":
+            return () => {
+              target.sort();
+              return new Set(URLSearchParams.prototype.keys.call(target)).keys();
+            };
+          default:
+            return Reflect.get(target, p, receiver);
+        }
+      }
+    });
   }
-  return false;
-}
-function isUrlPotentiallyTrustworthy(url) {
-  if (/^about:(blank|srcdoc)$/.test(url)) {
-    return true;
+  get [Symbol.toStringTag]() {
+    return this.constructor.name;
   }
-  if (url.protocol === "data:") {
-    return true;
+  toString() {
+    return Object.prototype.toString.call(this);
   }
-  if (/^(blob|filesystem):$/.test(url.protocol)) {
-    return true;
+  get(name) {
+    const values = this.getAll(name);
+    if (values.length === 0) {
+      return null;
+    }
+    let value = values.join(", ");
+    if (/^content-encoding$/i.test(name)) {
+      value = value.toLowerCase();
+    }
+    return value;
   }
-  return isOriginPotentiallyTrustworthy(url);
-}
-function determineRequestsReferrer(request, { referrerURLCallback, referrerOriginCallback } = {}) {
-  if (request.referrer === "no-referrer" || request.referrerPolicy === "") {
-    return null;
+  forEach(callback, thisArg = undefined) {
+    for (const name of this.keys()) {
+      Reflect.apply(callback, thisArg, [this.get(name), name, this]);
+    }
   }
-  const policy = request.referrerPolicy;
-  if (request.referrer === "about:client") {
-    return "no-referrer";
+  *values() {
+    for (const name of this.keys()) {
+      yield this.get(name);
+    }
   }
-  const referrerSource = request.referrer;
-  let referrerURL = stripURLForUseAsAReferrer(referrerSource);
-  let referrerOrigin = stripURLForUseAsAReferrer(referrerSource, true);
-  if (referrerURL.toString().length > 4096) {
-    referrerURL = referrerOrigin;
+  *entries() {
+    for (const name of this.keys()) {
+      yield [name, this.get(name)];
+    }
   }
-  if (referrerURLCallback) {
-    referrerURL = referrerURLCallback(referrerURL);
+  [Symbol.iterator]() {
+    return this.entries();
   }
-  if (referrerOriginCallback) {
-    referrerOrigin = referrerOriginCallback(referrerOrigin);
+  raw() {
+    return [...this.keys()].reduce((result, key) => {
+      result[key] = this.getAll(key);
+      return result;
+    }, {});
   }
-  const currentURL = new URL(request.url);
-  switch (policy) {
-    case "no-referrer":
-      return "no-referrer";
-    case "origin":
-      return referrerOrigin;
-    case "unsafe-url":
-      return referrerURL;
-    case "strict-origin":
-      if (isUrlPotentiallyTrustworthy(referrerURL) && !isUrlPotentiallyTrustworthy(currentURL)) {
-        return "no-referrer";
-      }
-      return referrerOrigin.toString();
-    case "strict-origin-when-cross-origin":
-      if (referrerURL.origin === currentURL.origin) {
-        return referrerURL;
-      }
-      if (isUrlPotentiallyTrustworthy(referrerURL) && !isUrlPotentiallyTrustworthy(currentURL)) {
-        return "no-referrer";
-      }
-      return referrerOrigin;
-    case "same-origin":
-      if (referrerURL.origin === currentURL.origin) {
-        return referrerURL;
-      }
-      return "no-referrer";
-    case "origin-when-cross-origin":
-      if (referrerURL.origin === currentURL.origin) {
-        return referrerURL;
-      }
-      return referrerOrigin;
-    case "no-referrer-when-downgrade":
-      if (isUrlPotentiallyTrustworthy(referrerURL) && !isUrlPotentiallyTrustworthy(currentURL)) {
-        return "no-referrer";
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return [...this.keys()].reduce((result, key) => {
+      const values = this.getAll(key);
+      if (key === "host") {
+        result[key] = values[0];
+      } else {
+        result[key] = values.length > 1 ? values : values[0];
       }
-      return referrerURL;
-    default:
-      throw new TypeError(`Invalid referrerPolicy: ${policy}`);
+      return result;
+    }, {});
   }
 }
-function parseReferrerPolicyFromHeader(headers) {
-  const policyTokens = (headers.get("referrer-policy") || "").split(/[,\s]+/);
-  let policy = "";
-  for (const token of policyTokens) {
-    if (token && ReferrerPolicy.has(token)) {
-      policy = token;
+Object.defineProperties(Headers.prototype, ["get", "entries", "forEach", "values"].reduce((result, property) => {
+  result[property] = { enumerable: true };
+  return result;
+}, {}));
+function fromRawHeaders(headers = []) {
+  return new Headers(headers.reduce((result, value, index, array) => {
+    if (index % 2 === 0) {
+      result.push(array.slice(index, index + 2));
     }
-  }
-  return policy;
+    return result;
+  }, []).filter(([name, value]) => {
+    try {
+      validateHeaderName(name);
+      validateHeaderValue(name, String(value));
+      return true;
+    } catch {
+      return false;
+    }
+  }));
 }
 
-// node_modules/node-fetch/src/request.js
-var INTERNALS3 = Symbol("Request internals");
-var isRequest = (object) => {
-  return typeof object === "object" && typeof object[INTERNALS3] === "object";
+// node_modules/node-fetch/src/utils/is-redirect.js
+var redirectStatus = new Set([301, 302, 303, 307, 308]);
+var isRedirect = (code) => {
+  return redirectStatus.has(code);
 };
-var doBadDataWarn = deprecate2(() => {}, ".data is not a valid RequestInit property, use .body instead", "https://github.com/node-fetch/node-fetch/issues/1000 (request)");
 
-class Request extends Body {
-  constructor(input, init = {}) {
-    let parsedURL;
-    if (isRequest(input)) {
-      parsedURL = new URL(input.url);
-    } else {
-      parsedURL = new URL(input);
-      input = {};
-    }
-    if (parsedURL.username !== "" || parsedURL.password !== "") {
-      throw new TypeError(`${parsedURL} is an url with embedded credentials.`);
-    }
-    let method = init.method || input.method || "GET";
-    if (/^(delete|get|head|options|post|put)$/i.test(method)) {
-      method = method.toUpperCase();
-    }
-    if (!isRequest(init) && "data" in init) {
-      doBadDataWarn();
-    }
-    if ((init.body != null || isRequest(input) && input.body !== null) && (method === "GET" || method === "HEAD")) {
-      throw new TypeError("Request with GET/HEAD method cannot have body");
-    }
-    const inputBody = init.body ? init.body : isRequest(input) && input.body !== null ? clone(input) : null;
-    super(inputBody, {
-      size: init.size || input.size || 0
-    });
-    const headers = new Headers(init.headers || input.headers || {});
-    if (inputBody !== null && !headers.has("Content-Type")) {
-      const contentType = extractContentType(inputBody, this);
+// node_modules/node-fetch/src/response.js
+var INTERNALS2 = Symbol("Response internals");
+
+class Response extends Body {
+  constructor(body = null, options = {}) {
+    super(body, options);
+    const status = options.status != null ? options.status : 200;
+    const headers = new Headers(options.headers);
+    if (body !== null && !headers.has("Content-Type")) {
+      const contentType = extractContentType(body, this);
       if (contentType) {
-        headers.set("Content-Type", contentType);
+        headers.append("Content-Type", contentType);
       }
     }
-    let signal = isRequest(input) ? input.signal : null;
-    if ("signal" in init) {
-      signal = init.signal;
-    }
-    if (signal != null && !isAbortSignal(signal)) {
-      throw new TypeError("Expected signal to be an instanceof AbortSignal or EventTarget");
-    }
-    let referrer = init.referrer == null ? input.referrer : init.referrer;
-    if (referrer === "") {
-      referrer = "no-referrer";
-    } else if (referrer) {
-      const parsedReferrer = new URL(referrer);
-      referrer = /^about:(\/\/)?client$/.test(parsedReferrer) ? "client" : parsedReferrer;
-    } else {
-      referrer = undefined;
-    }
-    this[INTERNALS3] = {
-      method,
-      redirect: init.redirect || input.redirect || "follow",
+    this[INTERNALS2] = {
+      type: "default",
+      url: options.url,
+      status,
+      statusText: options.statusText || "",
       headers,
-      parsedURL,
-      signal,
-      referrer
+      counter: options.counter,
+      highWaterMark: options.highWaterMark
     };
-    this.follow = init.follow === undefined ? input.follow === undefined ? 20 : input.follow : init.follow;
-    this.compress = init.compress === undefined ? input.compress === undefined ? true : input.compress : init.compress;
-    this.counter = init.counter || input.counter || 0;
-    this.agent = init.agent || input.agent;
-    this.highWaterMark = init.highWaterMark || input.highWaterMark || 16384;
-    this.insecureHTTPParser = init.insecureHTTPParser || input.insecureHTTPParser || false;
-    this.referrerPolicy = init.referrerPolicy || input.referrerPolicy || "";
   }
-  get method() {
-    return this[INTERNALS3].method;
+  get type() {
+    return this[INTERNALS2].type;
   }
   get url() {
-    return formatUrl(this[INTERNALS3].parsedURL);
+    return this[INTERNALS2].url || "";
   }
-  get headers() {
-    return this[INTERNALS3].headers;
+  get status() {
+    return this[INTERNALS2].status;
   }
-  get redirect() {
-    return this[INTERNALS3].redirect;
+  get ok() {
+    return this[INTERNALS2].status >= 200 && this[INTERNALS2].status < 300;
   }
-  get signal() {
-    return this[INTERNALS3].signal;
+  get redirected() {
+    return this[INTERNALS2].counter > 0;
   }
-  get referrer() {
-    if (this[INTERNALS3].referrer === "no-referrer") {
-      return "";
-    }
-    if (this[INTERNALS3].referrer === "client") {
-      return "about:client";
-    }
-    if (this[INTERNALS3].referrer) {
-      return this[INTERNALS3].referrer.toString();
-    }
-    return;
+  get statusText() {
+    return this[INTERNALS2].statusText;
   }
-  get referrerPolicy() {
-    return this[INTERNALS3].referrerPolicy;
+  get headers() {
+    return this[INTERNALS2].headers;
   }
-  set referrerPolicy(referrerPolicy) {
-    this[INTERNALS3].referrerPolicy = validateReferrerPolicy(referrerPolicy);
+  get highWaterMark() {
+    return this[INTERNALS2].highWaterMark;
   }
   clone() {
-    return new Request(this);
+    return new Response(clone(this, this.highWaterMark), {
+      type: this.type,
+      url: this.url,
+      status: this.status,
+      statusText: this.statusText,
+      headers: this.headers,
+      ok: this.ok,
+      redirected: this.redirected,
+      size: this.size,
+      highWaterMark: this.highWaterMark
+    });
+  }
+  static redirect(url, status = 302) {
+    if (!isRedirect(status)) {
+      throw new RangeError('Failed to execute "redirect" on "response": Invalid status code');
+    }
+    return new Response(null, {
+      headers: {
+        location: new URL(url).toString()
+      },
+      status
+    });
+  }
+  static error() {
+    const response = new Response(null, { status: 0, statusText: "" });
+    response[INTERNALS2].type = "error";
+    return response;
+  }
+  static json(data = undefined, init = {}) {
+    const body = JSON.stringify(data);
+    if (body === undefined) {
+      throw new TypeError("data is not JSON serializable");
+    }
+    const headers = new Headers(init && init.headers);
+    if (!headers.has("content-type")) {
+      headers.set("content-type", "application/json");
+    }
+    return new Response(body, {
+      ...init,
+      headers
+    });
   }
   get [Symbol.toStringTag]() {
-    return "Request";
+    return "Response";
   }
 }
-Object.defineProperties(Request.prototype, {
-  method: { enumerable: true },
+Object.defineProperties(Response.prototype, {
+  type: { enumerable: true },
   url: { enumerable: true },
+  status: { enumerable: true },
+  ok: { enumerable: true },
+  redirected: { enumerable: true },
+  statusText: { enumerable: true },
   headers: { enumerable: true },
-  redirect: { enumerable: true },
-  clone: { enumerable: true },
-  signal: { enumerable: true },
-  referrer: { enumerable: true },
-  referrerPolicy: { enumerable: true }
+  clone: { enumerable: true }
 });
-var getNodeRequestOptions = (request) => {
-  const { parsedURL } = request[INTERNALS3];
-  const headers = new Headers(request[INTERNALS3].headers);
-  if (!headers.has("Accept")) {
-    headers.set("Accept", "*/*");
+
+// node_modules/node-fetch/src/request.js
+import { format as formatUrl } from "node:url";
+import { deprecate as deprecate2 } from "node:util";
+
+// node_modules/node-fetch/src/utils/get-search.js
+var getSearch = (parsedURL) => {
+  if (parsedURL.search) {
+    return parsedURL.search;
   }
-  let contentLengthValue = null;
-  if (request.body === null && /^(post|put)$/i.test(request.method)) {
-    contentLengthValue = "0";
+  const lastOffset = parsedURL.href.length - 1;
+  const hash = parsedURL.hash || (parsedURL.href[lastOffset] === "#" ? "#" : "");
+  return parsedURL.href[lastOffset - hash.length] === "?" ? "?" : "";
+};
+
+// node_modules/node-fetch/src/utils/referrer.js
+import { isIP } from "node:net";
+function stripURLForUseAsAReferrer(url, originOnly = false) {
+  if (url == null) {
+    return "no-referrer";
   }
-  if (request.body !== null) {
-    const totalBytes = getTotalBytes(request);
-    if (typeof totalBytes === "number" && !Number.isNaN(totalBytes)) {
-      contentLengthValue = String(totalBytes);
-    }
+  url = new URL(url);
+  if (/^(about|blob|data):$/.test(url.protocol)) {
+    return "no-referrer";
   }
-  if (contentLengthValue) {
-    headers.set("Content-Length", contentLengthValue);
+  url.username = "";
+  url.password = "";
+  url.hash = "";
+  if (originOnly) {
+    url.pathname = "";
+    url.search = "";
   }
-  if (request.referrerPolicy === "") {
-    request.referrerPolicy = DEFAULT_REFERRER_POLICY;
+  return url;
+}
+var ReferrerPolicy = new Set([
+  "",
+  "no-referrer",
+  "no-referrer-when-downgrade",
+  "same-origin",
+  "origin",
+  "strict-origin",
+  "origin-when-cross-origin",
+  "strict-origin-when-cross-origin",
+  "unsafe-url"
+]);
+var DEFAULT_REFERRER_POLICY = "strict-origin-when-cross-origin";
+function validateReferrerPolicy(referrerPolicy) {
+  if (!ReferrerPolicy.has(referrerPolicy)) {
+    throw new TypeError(`Invalid referrerPolicy: ${referrerPolicy}`);
   }
-  if (request.referrer && request.referrer !== "no-referrer") {
-    request[INTERNALS3].referrer = determineRequestsReferrer(request);
-  } else {
-    request[INTERNALS3].referrer = "no-referrer";
+  return referrerPolicy;
+}
+function isOriginPotentiallyTrustworthy(url) {
+  if (/^(http|ws)s:$/.test(url.protocol)) {
+    return true;
   }
-  if (request[INTERNALS3].referrer instanceof URL) {
-    headers.set("Referer", request.referrer);
+  const hostIp = url.host.replace(/(^\[)|(]$)/g, "");
+  const hostIPVersion = isIP(hostIp);
+  if (hostIPVersion === 4 && /^127\./.test(hostIp)) {
+    return true;
   }
-  if (!headers.has("User-Agent")) {
-    headers.set("User-Agent", "node-fetch");
+  if (hostIPVersion === 6 && /^(((0+:){7})|(::(0+:){0,6}))0*1$/.test(hostIp)) {
+    return true;
   }
-  if (request.compress && !headers.has("Accept-Encoding")) {
-    headers.set("Accept-Encoding", "gzip, deflate, br");
+  if (url.host === "localhost" || url.host.endsWith(".localhost")) {
+    return false;
   }
-  let { agent } = request;
-  if (typeof agent === "function") {
-    agent = agent(parsedURL);
+  if (url.protocol === "file:") {
+    return true;
   }
-  const search = getSearch(parsedURL);
-  const options = {
-    path: parsedURL.pathname + search,
-    method: request.method,
-    headers: headers[Symbol.for("nodejs.util.inspect.custom")](),
-    insecureHTTPParser: request.insecureHTTPParser,
-    agent
-  };
-  return {
-    parsedURL,
-    options
-  };
-};
-
-// node_modules/node-fetch/src/errors/abort-error.js
-class AbortError extends FetchBaseError {
-  constructor(message, type = "aborted") {
-    super(message, type);
-  }
-}
-
-// node_modules/node-fetch/src/index.js
-init_esm_min();
-init_from();
-var supportedSchemas = new Set(["data:", "http:", "https:"]);
-async function fetch2(url, options_) {
-  return new Promise((resolve, reject) => {
-    const request = new Request(url, options_);
-    const { parsedURL, options } = getNodeRequestOptions(request);
-    if (!supportedSchemas.has(parsedURL.protocol)) {
-      throw new TypeError(`node-fetch cannot load ${url}. URL scheme "${parsedURL.protocol.replace(/:$/, "")}" is not supported.`);
-    }
-    if (parsedURL.protocol === "data:") {
-      const data = dist_default(request.url);
-      const response2 = new Response(data, { headers: { "Content-Type": data.typeFull } });
-      resolve(response2);
-      return;
-    }
-    const send = (parsedURL.protocol === "https:" ? https : http2).request;
-    const { signal } = request;
-    let response = null;
-    const abort = () => {
-      const error = new AbortError("The operation was aborted.");
-      reject(error);
-      if (request.body && request.body instanceof Stream2.Readable) {
-        request.body.destroy(error);
-      }
-      if (!response || !response.body) {
-        return;
-      }
-      response.body.emit("error", error);
-    };
-    if (signal && signal.aborted) {
-      abort();
-      return;
-    }
-    const abortAndFinalize = () => {
-      abort();
-      finalize();
-    };
-    const request_ = send(parsedURL.toString(), options);
-    if (signal) {
-      signal.addEventListener("abort", abortAndFinalize);
-    }
-    const finalize = () => {
-      request_.abort();
-      if (signal) {
-        signal.removeEventListener("abort", abortAndFinalize);
-      }
-    };
-    request_.on("error", (error) => {
-      reject(new FetchError(`request to ${request.url} failed, reason: ${error.message}`, "system", error));
-      finalize();
-    });
-    fixResponseChunkedTransferBadEnding(request_, (error) => {
-      if (response && response.body) {
-        response.body.destroy(error);
-      }
-    });
-    if (process.version < "v14") {
-      request_.on("socket", (s2) => {
-        let endedWithEventsCount;
-        s2.prependListener("end", () => {
-          endedWithEventsCount = s2._eventsCount;
-        });
-        s2.prependListener("close", (hadError) => {
-          if (response && endedWithEventsCount < s2._eventsCount && !hadError) {
-            const error = new Error("Premature close");
-            error.code = "ERR_STREAM_PREMATURE_CLOSE";
-            response.body.emit("error", error);
-          }
-        });
-      });
-    }
-    request_.on("response", (response_) => {
-      request_.setTimeout(0);
-      const headers = fromRawHeaders(response_.rawHeaders);
-      if (isRedirect(response_.statusCode)) {
-        const location = headers.get("Location");
-        let locationURL = null;
-        try {
-          locationURL = location === null ? null : new URL(location, request.url);
-        } catch {
-          if (request.redirect !== "manual") {
-            reject(new FetchError(`uri requested responds with an invalid redirect URL: ${location}`, "invalid-redirect"));
-            finalize();
-            return;
-          }
-        }
-        switch (request.redirect) {
-          case "error":
-            reject(new FetchError(`uri requested responds with a redirect, redirect mode is set to error: ${request.url}`, "no-redirect"));
-            finalize();
-            return;
-          case "manual":
-            break;
-          case "follow": {
-            if (locationURL === null) {
-              break;
-            }
-            if (request.counter >= request.follow) {
-              reject(new FetchError(`maximum redirect reached at: ${request.url}`, "max-redirect"));
-              finalize();
-              return;
-            }
-            const requestOptions = {
-              headers: new Headers(request.headers),
-              follow: request.follow,
-              counter: request.counter + 1,
-              agent: request.agent,
-              compress: request.compress,
-              method: request.method,
-              body: clone(request),
-              signal: request.signal,
-              size: request.size,
-              referrer: request.referrer,
-              referrerPolicy: request.referrerPolicy
-            };
-            if (!isDomainOrSubdomain(request.url, locationURL) || !isSameProtocol(request.url, locationURL)) {
-              for (const name of ["authorization", "www-authenticate", "cookie", "cookie2"]) {
-                requestOptions.headers.delete(name);
-              }
-            }
-            if (response_.statusCode !== 303 && request.body && options_.body instanceof Stream2.Readable) {
-              reject(new FetchError("Cannot follow redirect with body being a readable stream", "unsupported-redirect"));
-              finalize();
-              return;
-            }
-            if (response_.statusCode === 303 || (response_.statusCode === 301 || response_.statusCode === 302) && request.method === "POST") {
-              requestOptions.method = "GET";
-              requestOptions.body = undefined;
-              requestOptions.headers.delete("content-length");
-            }
-            const responseReferrerPolicy = parseReferrerPolicyFromHeader(headers);
-            if (responseReferrerPolicy) {
-              requestOptions.referrerPolicy = responseReferrerPolicy;
-            }
-            resolve(fetch2(new Request(locationURL, requestOptions)));
-            finalize();
-            return;
-          }
-          default:
-            return reject(new TypeError(`Redirect option '${request.redirect}' is not a valid value of RequestRedirect`));
-        }
-      }
-      if (signal) {
-        response_.once("end", () => {
-          signal.removeEventListener("abort", abortAndFinalize);
-        });
-      }
-      let body = pump(response_, new PassThrough2, (error) => {
-        if (error) {
-          reject(error);
-        }
-      });
-      if (process.version < "v12.10") {
-        response_.on("aborted", abortAndFinalize);
-      }
-      const responseOptions = {
-        url: request.url,
-        status: response_.statusCode,
-        statusText: response_.statusMessage,
-        headers,
-        size: request.size,
-        counter: request.counter,
-        highWaterMark: request.highWaterMark
-      };
-      const codings = headers.get("Content-Encoding");
-      if (!request.compress || request.method === "HEAD" || codings === null || response_.statusCode === 204 || response_.statusCode === 304) {
-        response = new Response(body, responseOptions);
-        resolve(response);
-        return;
-      }
-      const zlibOptions = {
-        flush: zlib.Z_SYNC_FLUSH,
-        finishFlush: zlib.Z_SYNC_FLUSH
-      };
-      if (codings === "gzip" || codings === "x-gzip") {
-        body = pump(body, zlib.createGunzip(zlibOptions), (error) => {
-          if (error) {
-            reject(error);
-          }
-        });
-        response = new Response(body, responseOptions);
-        resolve(response);
-        return;
-      }
-      if (codings === "deflate" || codings === "x-deflate") {
-        const raw = pump(response_, new PassThrough2, (error) => {
-          if (error) {
-            reject(error);
-          }
-        });
-        raw.once("data", (chunk) => {
-          if ((chunk[0] & 15) === 8) {
-            body = pump(body, zlib.createInflate(), (error) => {
-              if (error) {
-                reject(error);
-              }
-            });
-          } else {
-            body = pump(body, zlib.createInflateRaw(), (error) => {
-              if (error) {
-                reject(error);
-              }
-            });
-          }
-          response = new Response(body, responseOptions);
-          resolve(response);
-        });
-        raw.once("end", () => {
-          if (!response) {
-            response = new Response(body, responseOptions);
-            resolve(response);
-          }
-        });
-        return;
-      }
-      if (codings === "br") {
-        body = pump(body, zlib.createBrotliDecompress(), (error) => {
-          if (error) {
-            reject(error);
-          }
-        });
-        response = new Response(body, responseOptions);
-        resolve(response);
-        return;
-      }
-      response = new Response(body, responseOptions);
-      resolve(response);
-    });
-    writeToStream(request_, request).catch(reject);
-  });
-}
-function fixResponseChunkedTransferBadEnding(request, errorCallback) {
-  const LAST_CHUNK = Buffer3.from(`0\r
-\r
-`);
-  let isChunkedTransfer = false;
-  let properLastChunkReceived = false;
-  let previousChunk;
-  request.on("response", (response) => {
-    const { headers } = response;
-    isChunkedTransfer = headers["transfer-encoding"] === "chunked" && !headers["content-length"];
-  });
-  request.on("socket", (socket) => {
-    const onSocketClose = () => {
-      if (isChunkedTransfer && !properLastChunkReceived) {
-        const error = new Error("Premature close");
-        error.code = "ERR_STREAM_PREMATURE_CLOSE";
-        errorCallback(error);
-      }
-    };
-    const onData = (buf) => {
-      properLastChunkReceived = Buffer3.compare(buf.slice(-5), LAST_CHUNK) === 0;
-      if (!properLastChunkReceived && previousChunk) {
-        properLastChunkReceived = Buffer3.compare(previousChunk.slice(-3), LAST_CHUNK.slice(0, 3)) === 0 && Buffer3.compare(buf.slice(-2), LAST_CHUNK.slice(3)) === 0;
-      }
-      previousChunk = buf;
-    };
-    socket.prependListener("close", onSocketClose);
-    socket.on("data", onData);
-    request.on("close", () => {
-      socket.removeListener("close", onSocketClose);
-      socket.removeListener("data", onData);
-    });
-  });
+  return false;
 }
-
-// src/functions/custom-fetch.ts
-var httpsAgent = new https2.Agent({
-  rejectUnauthorized: false
-});
-async function customFetch(url, init) {
-  if (typeof Bun !== "undefined") {
-    return await fetch(url.toString(), {
-      method: init?.method,
-      tls: {
-        rejectUnauthorized: false
-      }
-    });
+function isUrlPotentiallyTrustworthy(url) {
+  if (/^about:(blank|srcdoc)$/.test(url)) {
+    return true;
   }
-  return await fetch2(url, { ...init, agent: httpsAgent });
-}
-
-// src/sonar/requests/volume-settings/request-volume-settings-classic.ts
-async function requestVolumeSettingsClassic(sonarEndpoint) {
-  let response;
-  try {
-    const url = new URL(`${sonarEndpoint}/volumeSettings/classic`);
-    response = await customFetch(url);
-  } catch (error) {
-    throw new SonarRequestException({ innerException: error });
+  if (url.protocol === "data:") {
+    return true;
   }
-  if (response.ok) {
-    const data = await response.json();
-    if (data?.masters?.classic == null) {
-      throw new SonarRequestException({ innerException: new Error("Missing required data in response.") });
-    }
-    return data;
-  } else {
-    const data = await response.json();
-    throw new SonarRequestException({ innerException: new Error(data?.error ?? data) });
+  if (/^(blob|filesystem):$/.test(url.protocol)) {
+    return true;
   }
+  return isOriginPotentiallyTrustworthy(url);
 }
-
-// src/functions/audio/get-audio-data-classic.ts
-async function getAudioDataClassic(sonarEndpoint) {
-  const data = await requestVolumeSettingsClassic(sonarEndpoint);
-  const volumeData = {
-    ["master" /* Master */]: createResponseVolumeData(data.masters.classic),
-    ["game" /* Game */]: data.devices.game && createResponseVolumeData(data.devices.game.classic),
-    ["chat" /* Chat */]: data.devices.chatRender && createResponseVolumeData(data.devices.chatRender.classic),
-    ["media" /* Media */]: data.devices.media && createResponseVolumeData(data.devices.media.classic),
-    ["aux" /* Aux */]: data.devices.aux && createResponseVolumeData(data.devices.aux.classic),
-    ["mic" /* Mic */]: data.devices.chatCapture && createResponseVolumeData(data.devices.chatCapture.classic)
-  };
-  return volumeData;
-}
-function createResponseVolumeData(volumeData) {
-  return {
-    volume: convertVolumeToUser(volumeData.volume),
-    isMuted: volumeData.muted
-  };
-}
-// src/sonar/requests/volume-settings/request-volume-settings-streamer.ts
-async function requestVolumeSettingsStreamer(sonarEndpoint) {
-  let response;
-  try {
-    const url = new URL(`${sonarEndpoint}/volumeSettings/streamer`);
-    response = await customFetch(url);
-  } catch (error) {
-    throw new SonarRequestException({ innerException: error });
-  }
-  if (response.ok) {
-    const data = await response.json();
-    if (data?.masters?.stream == null) {
-      throw new SonarRequestException({ innerException: new Error("Missing required data in response.") });
-    }
-    return data;
-  } else {
-    const data = await response.json();
-    throw new SonarRequestException({ innerException: new Error(data?.error ?? data) });
+function determineRequestsReferrer(request, { referrerURLCallback, referrerOriginCallback } = {}) {
+  if (request.referrer === "no-referrer" || request.referrerPolicy === "") {
+    return null;
   }
-}
-
-// src/functions/audio/get-audio-data-stream.ts
-async function getAudioDataStream(sonarEndpoint) {
-  const data = await requestVolumeSettingsStreamer(sonarEndpoint);
-  const volumeData = {
-    ["master" /* Master */]: createResponseVolumeData2(data.masters.stream),
-    ["game" /* Game */]: data.devices.game && createResponseVolumeData2(data.devices.game.stream),
-    ["chat" /* Chat */]: data.devices.chatRender && createResponseVolumeData2(data.devices.chatRender.stream),
-    ["media" /* Media */]: data.devices.media && createResponseVolumeData2(data.devices.media.stream),
-    ["aux" /* Aux */]: data.devices.aux && createResponseVolumeData2(data.devices.aux.stream),
-    ["mic" /* Mic */]: data.devices.chatCapture && createResponseVolumeData2(data.devices.chatCapture.stream)
-  };
-  return volumeData;
-}
-function createResponseVolumeData2(volumeData) {
-  return {
-    ["streaming" /* Streaming */]: {
-      volume: convertVolumeToUser(volumeData.streaming.volume),
-      isMuted: volumeData.streaming.muted
-    },
-    ["monitoring" /* Monitoring */]: {
-      volume: convertVolumeToUser(volumeData.monitoring.volume),
-      isMuted: volumeData.monitoring.muted
-    }
-  };
-}
-// src/sonar/models/audio-settings/enums/audio-mode.ts
-var AudioMode2;
-((AudioMode3) => {
-  AudioMode3["Classic"] = "classic";
-  AudioMode3["Streamer"] = "stream";
-})(AudioMode2 ||= {});
-
-// src/sonar/requests/mode/request-audio-mode.ts
-async function requestAudioMode(sonarEndpoint) {
-  let response;
-  const url = new URL(`${sonarEndpoint}/mode`);
-  try {
-    response = await customFetch(url);
-  } catch (error) {
-    throw new SonarRequestException({ innerException: error });
+  const policy = request.referrerPolicy;
+  if (request.referrer === "about:client") {
+    return "no-referrer";
   }
-  if (response.ok) {
-    const data = await response.json();
-    if (Object.values(AudioMode2).includes(data)) {
-      return data;
-    }
-    throw new SonarRequestException({ message: "Received unhandled audio mode from Sonar server" });
-  } else {
-    const data = await response.text();
-    throw new SonarRequestException({ innerException: new Error(data) });
+  const referrerSource = request.referrer;
+  let referrerURL = stripURLForUseAsAReferrer(referrerSource);
+  let referrerOrigin = stripURLForUseAsAReferrer(referrerSource, true);
+  if (referrerURL.toString().length > 4096) {
+    referrerURL = referrerOrigin;
   }
-}
-
-// src/functions/audio/get-audio-mode.ts
-async function getAudioMode(sonarEndpoint) {
-  return await requestAudioMode(sonarEndpoint);
-}
-// src/sonar/requests/mode/change-audio-mode.ts
-async function changeAudioMode(sonarEndpoint, audioMode) {
-  let response;
-  const url = new URL(`${sonarEndpoint}/mode/${audioMode}`);
-  try {
-    response = await customFetch(url, {
-      method: "PUT"
-    });
-  } catch (error) {
-    throw new SonarRequestException({ innerException: error });
+  if (referrerURLCallback) {
+    referrerURL = referrerURLCallback(referrerURL);
   }
-  if (response.ok) {
-    const data = await response.json();
-    if (data !== audioMode) {
-      throw new SonarRequestException({ message: "Returned audio mode does not match requested mode" });
-    }
-    return data;
-  } else {
-    const data = await response.text();
-    throw new SonarRequestException({ innerException: new Error(data) });
+  if (referrerOriginCallback) {
+    referrerOrigin = referrerOriginCallback(referrerOrigin);
   }
-}
-
-// src/functions/audio/set-audio-mode.ts
-async function setAudioMode(sonarEndpoint, audioMode) {
-  return await changeAudioMode(sonarEndpoint, audioMode);
-}
-// src/functions/converters/convert-channel-to-api.ts
-function convertChannelToApi(channel) {
-  switch (channel) {
-    case "master" /* Master */:
-      return "master" /* Master */;
-    case "game" /* Game */:
-      return "chatRender" /* ChatRender */;
-    case "media" /* Media */:
-      return "media" /* Media */;
-    case "aux" /* Aux */:
-      return "aux" /* Aux */;
-    case "mic" /* Mic */:
-      return "chatCapture" /* ChatCapture */;
+  const currentURL = new URL(request.url);
+  switch (policy) {
+    case "no-referrer":
+      return "no-referrer";
+    case "origin":
+      return referrerOrigin;
+    case "unsafe-url":
+      return referrerURL;
+    case "strict-origin":
+      if (isUrlPotentiallyTrustworthy(referrerURL) && !isUrlPotentiallyTrustworthy(currentURL)) {
+        return "no-referrer";
+      }
+      return referrerOrigin.toString();
+    case "strict-origin-when-cross-origin":
+      if (referrerURL.origin === currentURL.origin) {
+        return referrerURL;
+      }
+      if (isUrlPotentiallyTrustworthy(referrerURL) && !isUrlPotentiallyTrustworthy(currentURL)) {
+        return "no-referrer";
+      }
+      return referrerOrigin;
+    case "same-origin":
+      if (referrerURL.origin === currentURL.origin) {
+        return referrerURL;
+      }
+      return "no-referrer";
+    case "origin-when-cross-origin":
+      if (referrerURL.origin === currentURL.origin) {
+        return referrerURL;
+      }
+      return referrerOrigin;
+    case "no-referrer-when-downgrade":
+      if (isUrlPotentiallyTrustworthy(referrerURL) && !isUrlPotentiallyTrustworthy(currentURL)) {
+        return "no-referrer";
+      }
+      return referrerURL;
     default:
-      throw new Error(`Unsupported AudioChannel: ${channel}`);
-  }
-}
-
-// src/sonar/requests/volume-settings/change-volume-mute-classic.ts
-async function changeVolumeMuteClassic(sonarEndpoint, isMuted, deviceRole) {
-  let response;
-  try {
-    const url = new URL(`${sonarEndpoint}/volumeSettings/classic/${deviceRole}/mute/${isMuted}`);
-    response = await customFetch(url, { method: "PUT" });
-  } catch (error) {
-    throw new SonarRequestException({ innerException: error });
-  }
-  if (response.ok) {
-    const data = await response.json();
-    if (data?.masters?.classic == null) {
-      throw new SonarRequestException({ innerException: new Error("Missing required data in response.") });
-    }
-    return data;
-  } else {
-    const data = await response.json();
-    throw new SonarRequestException({ innerException: new Error(data?.error ?? data) });
-  }
-}
-
-// src/functions/audio/set-channel-mute-classic.ts
-async function setChannelMuteClassic(sonarEndpoint, isMuted, channel) {
-  const sonarChannel = convertChannelToApi(channel);
-  const data = await changeVolumeMuteClassic(sonarEndpoint, isMuted, sonarChannel);
-  const device = sonarChannel === "master" /* Master */ ? data.masters.classic : data.devices[sonarChannel]?.classic;
-  if (!device) {
-    throw new SonarRequestException({ message: `Missing device data in response.` });
+      throw new TypeError(`Invalid referrerPolicy: ${policy}`);
   }
-  const result = {
-    volume: convertVolumeToUser(device.volume),
-    isMuted: device.muted
-  };
-  return result;
 }
-// src/sonar/requests/volume-settings/change-volume-mute-streamer.ts
-async function changeVolumeMuteStreamer(sonarEndpoint, isMuted, deviceRole, path) {
-  let response;
-  try {
-    const url = new URL(`${sonarEndpoint}/volumeSettings/streamer/${path}/${deviceRole}/isMuted/${isMuted}`);
-    response = await customFetch(url, { method: "PUT" });
-  } catch (error) {
-    throw new SonarRequestException({ innerException: error });
-  }
-  if (response.ok) {
-    const data = await response.json();
-    if (data?.masters?.stream == null) {
-      throw new SonarRequestException({ innerException: new Error("Missing required data in response.") });
+function parseReferrerPolicyFromHeader(headers) {
+  const policyTokens = (headers.get("referrer-policy") || "").split(/[,\s]+/);
+  let policy = "";
+  for (const token of policyTokens) {
+    if (token && ReferrerPolicy.has(token)) {
+      policy = token;
     }
-    return data;
-  } else {
-    const data = await response.json();
-    throw new SonarRequestException({ innerException: new Error(data?.error ?? data) });
   }
+  return policy;
 }
 
-// src/functions/audio/set-channel-mute-streamer.ts
-async function setChannelMuteStreamer(sonarEndpoint, isMuted, channel, path) {
-  const sonarChannel = convertChannelToApi(channel);
-  const streamPath = path === "streaming" /* Streaming */ ? "streaming" /* Streaming */ : "monitoring" /* Monitoring */;
-  const data = await changeVolumeMuteStreamer(sonarEndpoint, isMuted, sonarChannel, streamPath);
-  const device = sonarChannel === "master" /* Master */ ? data.masters.stream : data.devices[sonarChannel]?.stream;
-  if (!device) {
-    throw new SonarRequestException({ message: `Missing device data in response.` });
-  }
-  const devicePath = path === "streaming" /* Streaming */ ? device.streaming : device.monitoring;
-  const result = {
-    volume: convertVolumeToUser(devicePath.volume),
-    isMuted: devicePath.muted
-  };
-  return result;
-}
-// src/functions/converters/convert-volume-to-api.ts
-function convertVolumeToApi(value) {
-  let result = value / 100;
-  result = Math.min(Math.max(result, 0), 1);
-  return result;
-}
+// node_modules/node-fetch/src/request.js
+var INTERNALS3 = Symbol("Request internals");
+var isRequest = (object) => {
+  return typeof object === "object" && typeof object[INTERNALS3] === "object";
+};
+var doBadDataWarn = deprecate2(() => {}, ".data is not a valid RequestInit property, use .body instead", "https://github.com/node-fetch/node-fetch/issues/1000 (request)");
 
-// src/sonar/requests/volume-settings/change-volume-level-classic.ts
-async function changeVolumeLevelClassic(sonarEndpoint, volume, deviceRole) {
-  let response;
-  try {
-    const url = new URL(`${sonarEndpoint}/volumeSettings/classic/${deviceRole}/volume/${volume}`);
-    response = await customFetch(url, { method: "PUT" });
-  } catch (error) {
-    throw new SonarRequestException({ innerException: error });
-  }
-  if (response.ok) {
-    const data = await response.json();
-    if (data?.masters?.classic == null) {
-      throw new SonarRequestException({ innerException: new Error("Missing required data in response.") });
+class Request extends Body {
+  constructor(input, init = {}) {
+    let parsedURL;
+    if (isRequest(input)) {
+      parsedURL = new URL(input.url);
+    } else {
+      parsedURL = new URL(input);
+      input = {};
     }
-    return data;
-  } else {
-    const data = await response.json();
-    throw new SonarRequestException({ innerException: new Error(data?.error ?? data) });
+    if (parsedURL.username !== "" || parsedURL.password !== "") {
+      throw new TypeError(`${parsedURL} is an url with embedded credentials.`);
+    }
+    let method = init.method || input.method || "GET";
+    if (/^(delete|get|head|options|post|put)$/i.test(method)) {
+      method = method.toUpperCase();
+    }
+    if (!isRequest(init) && "data" in init) {
+      doBadDataWarn();
+    }
+    if ((init.body != null || isRequest(input) && input.body !== null) && (method === "GET" || method === "HEAD")) {
+      throw new TypeError("Request with GET/HEAD method cannot have body");
+    }
+    const inputBody = init.body ? init.body : isRequest(input) && input.body !== null ? clone(input) : null;
+    super(inputBody, {
+      size: init.size || input.size || 0
+    });
+    const headers = new Headers(init.headers || input.headers || {});
+    if (inputBody !== null && !headers.has("Content-Type")) {
+      const contentType = extractContentType(inputBody, this);
+      if (contentType) {
+        headers.set("Content-Type", contentType);
+      }
+    }
+    let signal = isRequest(input) ? input.signal : null;
+    if ("signal" in init) {
+      signal = init.signal;
+    }
+    if (signal != null && !isAbortSignal(signal)) {
+      throw new TypeError("Expected signal to be an instanceof AbortSignal or EventTarget");
+    }
+    let referrer = init.referrer == null ? input.referrer : init.referrer;
+    if (referrer === "") {
+      referrer = "no-referrer";
+    } else if (referrer) {
+      const parsedReferrer = new URL(referrer);
+      referrer = /^about:(\/\/)?client$/.test(parsedReferrer) ? "client" : parsedReferrer;
+    } else {
+      referrer = undefined;
+    }
+    this[INTERNALS3] = {
+      method,
+      redirect: init.redirect || input.redirect || "follow",
+      headers,
+      parsedURL,
+      signal,
+      referrer
+    };
+    this.follow = init.follow === undefined ? input.follow === undefined ? 20 : input.follow : init.follow;
+    this.compress = init.compress === undefined ? input.compress === undefined ? true : input.compress : init.compress;
+    this.counter = init.counter || input.counter || 0;
+    this.agent = init.agent || input.agent;
+    this.highWaterMark = init.highWaterMark || input.highWaterMark || 16384;
+    this.insecureHTTPParser = init.insecureHTTPParser || input.insecureHTTPParser || false;
+    this.referrerPolicy = init.referrerPolicy || input.referrerPolicy || "";
   }
-}
-
-// src/functions/audio/set-channel-volume-classic.ts
-async function setChannelVolumeClassic(sonarEndpoint, volumePercent, channel) {
-  const sonarChannel = convertChannelToApi(channel);
-  const formattedVolume = convertVolumeToApi(volumePercent);
-  const data = await changeVolumeLevelClassic(sonarEndpoint, formattedVolume, sonarChannel);
-  const device = sonarChannel === "master" /* Master */ ? data.masters.classic : data.devices[sonarChannel]?.classic;
-  if (!device) {
-    throw new SonarRequestException({ message: `Missing device data in response.` });
+  get method() {
+    return this[INTERNALS3].method;
   }
-  const result = {
-    volume: convertVolumeToUser(device.volume),
-    isMuted: device.muted
-  };
-  return result;
-}
-// src/sonar/requests/volume-settings/change-volume-level-streamer.ts
-async function changeVolumeLevelStreamer(sonarEndpoint, volume, channel, path) {
-  let response;
-  try {
-    const url = new URL(`${sonarEndpoint}/volumeSettings/streamer/${path}/${channel}/volume/${volume}`);
-    response = await customFetch(url, { method: "PUT" });
-  } catch (error) {
-    throw new SonarRequestException({ innerException: error });
+  get url() {
+    return formatUrl(this[INTERNALS3].parsedURL);
   }
-  if (response.ok) {
-    const data = await response.json();
-    if (data?.masters?.stream == null) {
-      throw new SonarRequestException({ innerException: new Error("Missing required data in response.") });
-    }
-    return data;
-  } else {
-    const data = await response.json();
-    throw new SonarRequestException({ innerException: new Error(data?.error ?? data) });
+  get headers() {
+    return this[INTERNALS3].headers;
   }
-}
-
-// src/functions/audio/set-channel-volume-streamer.ts
-async function setChannelVolumeStreamer(sonarEndpoint, volumePercent, channel, path) {
-  const sonarChannel = convertChannelToApi(channel);
-  const formattedVolume = convertVolumeToApi(volumePercent);
-  const streamPath = path === "streaming" /* Streaming */ ? "streaming" /* Streaming */ : "monitoring" /* Monitoring */;
-  const data = await changeVolumeLevelStreamer(sonarEndpoint, formattedVolume, sonarChannel, streamPath);
-  const device = sonarChannel === "master" /* Master */ ? data.masters.stream : data.devices[sonarChannel]?.stream;
-  if (!device) {
-    throw new SonarRequestException({ message: `Missing device data in response.` });
+  get redirect() {
+    return this[INTERNALS3].redirect;
   }
-  const devicePath = path === "streaming" /* Streaming */ ? device.streaming : device.monitoring;
-  const result = {
-    volume: convertVolumeToUser(devicePath.volume),
-    isMuted: devicePath.muted
-  };
-  return result;
-}
-// src/functions/converters/convert-chat-mix-balance-to-user.ts
-function convertChatMixBalanceToUser(balance) {
-  let result = (balance + 1) / 2 * 100;
-  result = Math.floor(result);
-  result = Math.min(Math.max(result, 0), 100);
-  return result;
-}
-
-// src/sonar/requests/chatmix/request-chat-mix-state.ts
-async function requestChatMixState(sonarEndpoint) {
-  const url = new URL(`${sonarEndpoint}/chatMix`);
-  let response;
-  try {
-    response = await customFetch(url);
-  } catch (error) {
-    throw new SonarRequestException({ innerException: error });
+  get signal() {
+    return this[INTERNALS3].signal;
   }
-  if (response.ok) {
-    const data = await response.json();
-    if (data?.balance == null || data?.state == null) {
-      throw new SonarRequestException({ message: "Missing required data in response" });
+  get referrer() {
+    if (this[INTERNALS3].referrer === "no-referrer") {
+      return "";
+    }
+    if (this[INTERNALS3].referrer === "client") {
+      return "about:client";
     }
-    return data;
-  } else {
-    const data = await response.text();
-    throw new SonarRequestException({ innerException: new Error(data) });
+    if (this[INTERNALS3].referrer) {
+      return this[INTERNALS3].referrer.toString();
+    }
+    return;
   }
-}
-
-// src/functions/chatmix/get-chat-mix-state.ts
-async function getChatMixState(sonarEndpoint) {
-  const data = await requestChatMixState(sonarEndpoint);
-  const chatMixData = {
-    chatBalance: convertChatMixBalanceToUser(data.balance),
-    state: data.state,
-    isEnabled: data.state === "enabled" /* Enabled */
-  };
-  return chatMixData;
-}
-// src/functions/converters/convert-chat-mix-balance-to-api.ts
-function convertChatMixBalanceToApi(balance) {
-  let result = balance / 100 * 2 - 1;
-  result = Math.min(Math.max(result, -1), 1);
-  return result;
-}
-
-// src/sonar/requests/chatmix/change-chat-mix-balance.ts
-async function changeChatMixBalance(sonarEndpoint, chatBalance) {
-  const url = new URL(`${sonarEndpoint}/chatMix?balance=${chatBalance}`);
-  let response;
-  try {
-    response = await customFetch(url, {
-      method: "PUT"
-    });
-  } catch (error) {
-    throw new SonarRequestException({ innerException: error });
+  get referrerPolicy() {
+    return this[INTERNALS3].referrerPolicy;
   }
-  if (response.ok) {
-    const data = await response.json();
-    if (data?.balance == null || data?.state == null) {
-      throw new SonarRequestException({ message: "Missing required data in response" });
-    }
-    return data;
-  } else {
-    const data = await response.json();
-    throw new SonarRequestException({ message: data.Message });
+  set referrerPolicy(referrerPolicy) {
+    this[INTERNALS3].referrerPolicy = validateReferrerPolicy(referrerPolicy);
+  }
+  clone() {
+    return new Request(this);
+  }
+  get [Symbol.toStringTag]() {
+    return "Request";
   }
 }
-
-// src/functions/chatmix/set-chat-mix-balance.ts
-async function setChatMixBalance(sonarEndpoint, chatBalance) {
-  const balance = convertChatMixBalanceToApi(chatBalance);
-  const data = await changeChatMixBalance(sonarEndpoint, balance);
-  const chatMixData = {
-    chatBalance: convertChatMixBalanceToUser(data.balance),
-    state: data.state,
-    isEnabled: data.state === "enabled" /* Enabled */
-  };
-  return chatMixData;
-}
-// src/sonar/requests/audio-devices/request-audio-devices.ts
-async function requestAudioDevices(sonarEndpoint, params) {
-  const { deviceDataFlow, onlySteelSeriesVAD = false, removeSteelSeriesVAD = false } = params;
-  const url = new URL(`${sonarEndpoint}/audioDevices`);
-  url.searchParams.append("onlySteelSeriesVAD", String(onlySteelSeriesVAD));
-  url.searchParams.append("removeSteelSeriesVAD", String(removeSteelSeriesVAD));
-  if (deviceDataFlow !== undefined) {
-    url.searchParams.append("deviceDataFlow", deviceDataFlow.toString());
+Object.defineProperties(Request.prototype, {
+  method: { enumerable: true },
+  url: { enumerable: true },
+  headers: { enumerable: true },
+  redirect: { enumerable: true },
+  clone: { enumerable: true },
+  signal: { enumerable: true },
+  referrer: { enumerable: true },
+  referrerPolicy: { enumerable: true }
+});
+var getNodeRequestOptions = (request) => {
+  const { parsedURL } = request[INTERNALS3];
+  const headers = new Headers(request[INTERNALS3].headers);
+  if (!headers.has("Accept")) {
+    headers.set("Accept", "*/*");
   }
-  let response;
-  try {
-    response = await customFetch(url);
-  } catch (error) {
-    throw new SonarRequestException({
-      innerException: error
-    });
+  let contentLengthValue = null;
+  if (request.body === null && /^(post|put)$/i.test(request.method)) {
+    contentLengthValue = "0";
   }
-  if (!response.ok) {
-    const error = await response.text();
-    throw new SonarRequestException({ message: `Failed to get audio devices: ${error}` });
+  if (request.body !== null) {
+    const totalBytes = getTotalBytes(request);
+    if (typeof totalBytes === "number" && !Number.isNaN(totalBytes)) {
+      contentLengthValue = String(totalBytes);
+    }
   }
-  const data = await response.json();
-  if (!Array.isArray(data)) {
-    throw new SonarRequestException({ message: "Invalid audio devices response format." });
+  if (contentLengthValue) {
+    headers.set("Content-Length", contentLengthValue);
   }
-  return data;
-}
-
-// src/functions/devices/get-audio-devices.ts
-async function getAudioDevices(sonarEndpoint, deviceType) {
-  let deviceDataFlow;
-  switch (deviceType) {
-    case "input" /* Input */:
-      deviceDataFlow = "capture" /* Capture */;
-      break;
-    case "output" /* Output */:
-      deviceDataFlow = "render" /* Render */;
-      break;
-    case undefined:
-      deviceDataFlow = "all" /* All */;
-      break;
+  if (request.referrerPolicy === "") {
+    request.referrerPolicy = DEFAULT_REFERRER_POLICY;
   }
-  const data = await requestAudioDevices(sonarEndpoint, { deviceDataFlow, removeSteelSeriesVAD: true });
-  const audioDevices = data.map((device) => ({
-    id: device.id,
-    name: device.friendlyName,
-    type: getDeviceTypeFromDataFlow(device.dataFlow)
-  }));
-  return audioDevices;
-}
-function getDeviceTypeFromDataFlow(dataFlow) {
-  switch (dataFlow) {
-    case "capture" /* Capture */:
-      return "input" /* Input */;
-    case "render" /* Render */:
-      return "output" /* Output */;
-    default:
-      throw new SonarRequestException({ message: `Unknown device data flow: ${dataFlow}` });
+  if (request.referrer && request.referrer !== "no-referrer") {
+    request[INTERNALS3].referrer = determineRequestsReferrer(request);
+  } else {
+    request[INTERNALS3].referrer = "no-referrer";
   }
-}
-// src/sonar/requests/audio-devices/change-audio-device.ts
-async function changeAudioDevice(sonarEndpoint, deviceChannel, deviceId) {
-  let response;
-  const url = new URL(`${sonarEndpoint}/classicRedirections/${deviceChannel}/deviceId/${deviceId}`);
-  try {
-    response = await customFetch(url, { method: "PUT" });
-  } catch (error) {
-    throw new SonarRequestException({
-      innerException: error
-    });
+  if (request[INTERNALS3].referrer instanceof URL) {
+    headers.set("Referer", request.referrer);
   }
-  if (!response.ok) {
-    const error = await response.text();
-    throw new SonarRequestException({ message: `Failed to get audio devices: ${error}` });
+  if (!headers.has("User-Agent")) {
+    headers.set("User-Agent", "node-fetch");
   }
-  const unknownData = await response.json();
-  const data = Array.isArray(unknownData) ? unknownData : [unknownData];
-  const devices = data.filter((x2) => x2?.deviceId === deviceId);
-  if (devices.length === 0) {
-    throw new SonarRequestException({ message: "The changed audio devices list is empty." });
+  if (request.compress && !headers.has("Accept-Encoding")) {
+    headers.set("Accept-Encoding", "gzip, deflate, br");
   }
-  return devices;
-}
+  let { agent } = request;
+  if (typeof agent === "function") {
+    agent = agent(parsedURL);
+  }
+  const search = getSearch(parsedURL);
+  const options = {
+    path: parsedURL.pathname + search,
+    method: request.method,
+    headers: headers[Symbol.for("nodejs.util.inspect.custom")](),
+    insecureHTTPParser: request.insecureHTTPParser,
+    agent
+  };
+  return {
+    parsedURL,
+    options
+  };
+};
 
-// src/functions/devices/set-audio-device.ts
-async function setAudioDevice(sonarEndpoint, deviceChannel, deviceId) {
-  const data = await changeAudioDevice(sonarEndpoint, deviceChannel, deviceId);
-  const result = data.map((x2) => ({
-    deviceId: x2.deviceId,
-    deviceChannel: x2.id,
-    isRunning: x2.isRunning
-  }));
-  return result;
-}
-// src/functions/endpoint/get-app-endpoint.ts
-import { promises as fsAsync } from "node:fs";
-import { platform as getPlatform } from "node:os";
-import { join as joinPath } from "node:path";
-var WINDOWS_PATHS = ["SteelSeries", "SteelSeries Engine 3", "coreProps.json"];
-async function getAppEndpoint() {
-  const appDataPath = getPath();
-  const fileContents = await getContents(appDataPath);
-  const data = parseContents(fileContents);
-  if (data.ggEncryptedAddress) {
-    return `https://${data.ggEncryptedAddress}`;
+// node_modules/node-fetch/src/errors/abort-error.js
+class AbortError extends FetchBaseError {
+  constructor(message, type = "aborted") {
+    super(message, type);
   }
-  throw new SonarInitializationException({
-    reason: "Bad Config" /* BadConfig */
-  });
 }
-function getPath() {
-  const os = getPlatform();
-  switch (os) {
-    case "win32": {
-      const programData = process.env.ProgramData ?? "C:\\ProgramData";
-      return joinPath(programData, ...WINDOWS_PATHS);
+
+// node_modules/node-fetch/src/index.js
+init_esm_min();
+init_from();
+var supportedSchemas = new Set(["data:", "http:", "https:"]);
+async function fetch2(url, options_) {
+  return new Promise((resolve, reject) => {
+    const request = new Request(url, options_);
+    const { parsedURL, options } = getNodeRequestOptions(request);
+    if (!supportedSchemas.has(parsedURL.protocol)) {
+      throw new TypeError(`node-fetch cannot load ${url}. URL scheme "${parsedURL.protocol.replace(/:$/, "")}" is not supported.`);
+    }
+    if (parsedURL.protocol === "data:") {
+      const data = dist_default(request.url);
+      const response2 = new Response(data, { headers: { "Content-Type": data.typeFull } });
+      resolve(response2);
+      return;
+    }
+    const send = (parsedURL.protocol === "https:" ? https : http2).request;
+    const { signal } = request;
+    let response = null;
+    const abort = () => {
+      const error = new AbortError("The operation was aborted.");
+      reject(error);
+      if (request.body && request.body instanceof Stream2.Readable) {
+        request.body.destroy(error);
+      }
+      if (!response || !response.body) {
+        return;
+      }
+      response.body.emit("error", error);
+    };
+    if (signal && signal.aborted) {
+      abort();
+      return;
     }
-    default:
-      throw new SonarInitializationException({
-        reason: "OS Unsupported" /* OSUnsupported */
+    const abortAndFinalize = () => {
+      abort();
+      finalize();
+    };
+    const request_ = send(parsedURL.toString(), options);
+    if (signal) {
+      signal.addEventListener("abort", abortAndFinalize);
+    }
+    const finalize = () => {
+      request_.abort();
+      if (signal) {
+        signal.removeEventListener("abort", abortAndFinalize);
+      }
+    };
+    request_.on("error", (error) => {
+      reject(new FetchError(`request to ${request.url} failed, reason: ${error.message}`, "system", error));
+      finalize();
+    });
+    fixResponseChunkedTransferBadEnding(request_, (error) => {
+      if (response && response.body) {
+        response.body.destroy(error);
+      }
+    });
+    if (process.version < "v14") {
+      request_.on("socket", (s2) => {
+        let endedWithEventsCount;
+        s2.prependListener("end", () => {
+          endedWithEventsCount = s2._eventsCount;
+        });
+        s2.prependListener("close", (hadError) => {
+          if (response && endedWithEventsCount < s2._eventsCount && !hadError) {
+            const error = new Error("Premature close");
+            error.code = "ERR_STREAM_PREMATURE_CLOSE";
+            response.body.emit("error", error);
+          }
+        });
       });
-  }
-}
-async function getContents(path) {
-  try {
-    return await fsAsync.readFile(path, "utf8");
-  } catch (error) {
-    throw new SonarInitializationException({
-      reason: "Bad Config" /* BadConfig */,
-      innerException: error
+    }
+    request_.on("response", (response_) => {
+      request_.setTimeout(0);
+      const headers = fromRawHeaders(response_.rawHeaders);
+      if (isRedirect(response_.statusCode)) {
+        const location = headers.get("Location");
+        let locationURL = null;
+        try {
+          locationURL = location === null ? null : new URL(location, request.url);
+        } catch {
+          if (request.redirect !== "manual") {
+            reject(new FetchError(`uri requested responds with an invalid redirect URL: ${location}`, "invalid-redirect"));
+            finalize();
+            return;
+          }
+        }
+        switch (request.redirect) {
+          case "error":
+            reject(new FetchError(`uri requested responds with a redirect, redirect mode is set to error: ${request.url}`, "no-redirect"));
+            finalize();
+            return;
+          case "manual":
+            break;
+          case "follow": {
+            if (locationURL === null) {
+              break;
+            }
+            if (request.counter >= request.follow) {
+              reject(new FetchError(`maximum redirect reached at: ${request.url}`, "max-redirect"));
+              finalize();
+              return;
+            }
+            const requestOptions = {
+              headers: new Headers(request.headers),
+              follow: request.follow,
+              counter: request.counter + 1,
+              agent: request.agent,
+              compress: request.compress,
+              method: request.method,
+              body: clone(request),
+              signal: request.signal,
+              size: request.size,
+              referrer: request.referrer,
+              referrerPolicy: request.referrerPolicy
+            };
+            if (!isDomainOrSubdomain(request.url, locationURL) || !isSameProtocol(request.url, locationURL)) {
+              for (const name of ["authorization", "www-authenticate", "cookie", "cookie2"]) {
+                requestOptions.headers.delete(name);
+              }
+            }
+            if (response_.statusCode !== 303 && request.body && options_.body instanceof Stream2.Readable) {
+              reject(new FetchError("Cannot follow redirect with body being a readable stream", "unsupported-redirect"));
+              finalize();
+              return;
+            }
+            if (response_.statusCode === 303 || (response_.statusCode === 301 || response_.statusCode === 302) && request.method === "POST") {
+              requestOptions.method = "GET";
+              requestOptions.body = undefined;
+              requestOptions.headers.delete("content-length");
+            }
+            const responseReferrerPolicy = parseReferrerPolicyFromHeader(headers);
+            if (responseReferrerPolicy) {
+              requestOptions.referrerPolicy = responseReferrerPolicy;
+            }
+            resolve(fetch2(new Request(locationURL, requestOptions)));
+            finalize();
+            return;
+          }
+          default:
+            return reject(new TypeError(`Redirect option '${request.redirect}' is not a valid value of RequestRedirect`));
+        }
+      }
+      if (signal) {
+        response_.once("end", () => {
+          signal.removeEventListener("abort", abortAndFinalize);
+        });
+      }
+      let body = pump(response_, new PassThrough2, (error) => {
+        if (error) {
+          reject(error);
+        }
+      });
+      if (process.version < "v12.10") {
+        response_.on("aborted", abortAndFinalize);
+      }
+      const responseOptions = {
+        url: request.url,
+        status: response_.statusCode,
+        statusText: response_.statusMessage,
+        headers,
+        size: request.size,
+        counter: request.counter,
+        highWaterMark: request.highWaterMark
+      };
+      const codings = headers.get("Content-Encoding");
+      if (!request.compress || request.method === "HEAD" || codings === null || response_.statusCode === 204 || response_.statusCode === 304) {
+        response = new Response(body, responseOptions);
+        resolve(response);
+        return;
+      }
+      const zlibOptions = {
+        flush: zlib.Z_SYNC_FLUSH,
+        finishFlush: zlib.Z_SYNC_FLUSH
+      };
+      if (codings === "gzip" || codings === "x-gzip") {
+        body = pump(body, zlib.createGunzip(zlibOptions), (error) => {
+          if (error) {
+            reject(error);
+          }
+        });
+        response = new Response(body, responseOptions);
+        resolve(response);
+        return;
+      }
+      if (codings === "deflate" || codings === "x-deflate") {
+        const raw = pump(response_, new PassThrough2, (error) => {
+          if (error) {
+            reject(error);
+          }
+        });
+        raw.once("data", (chunk) => {
+          if ((chunk[0] & 15) === 8) {
+            body = pump(body, zlib.createInflate(), (error) => {
+              if (error) {
+                reject(error);
+              }
+            });
+          } else {
+            body = pump(body, zlib.createInflateRaw(), (error) => {
+              if (error) {
+                reject(error);
+              }
+            });
+          }
+          response = new Response(body, responseOptions);
+          resolve(response);
+        });
+        raw.once("end", () => {
+          if (!response) {
+            response = new Response(body, responseOptions);
+            resolve(response);
+          }
+        });
+        return;
+      }
+      if (codings === "br") {
+        body = pump(body, zlib.createBrotliDecompress(), (error) => {
+          if (error) {
+            reject(error);
+          }
+        });
+        response = new Response(body, responseOptions);
+        resolve(response);
+        return;
+      }
+      response = new Response(body, responseOptions);
+      resolve(response);
     });
-  }
+    writeToStream(request_, request).catch(reject);
+  });
 }
-function parseContents(contents) {
-  try {
-    return JSON.parse(contents);
-  } catch (error) {
-    throw new SonarInitializationException({
-      reason: "Bad Config" /* BadConfig */,
-      innerException: error
+function fixResponseChunkedTransferBadEnding(request, errorCallback) {
+  const LAST_CHUNK = Buffer3.from(`0\r
+\r
+`);
+  let isChunkedTransfer = false;
+  let properLastChunkReceived = false;
+  let previousChunk;
+  request.on("response", (response) => {
+    const { headers } = response;
+    isChunkedTransfer = headers["transfer-encoding"] === "chunked" && !headers["content-length"];
+  });
+  request.on("socket", (socket) => {
+    const onSocketClose = () => {
+      if (isChunkedTransfer && !properLastChunkReceived) {
+        const error = new Error("Premature close");
+        error.code = "ERR_STREAM_PREMATURE_CLOSE";
+        errorCallback(error);
+      }
+    };
+    const onData = (buf) => {
+      properLastChunkReceived = Buffer3.compare(buf.slice(-5), LAST_CHUNK) === 0;
+      if (!properLastChunkReceived && previousChunk) {
+        properLastChunkReceived = Buffer3.compare(previousChunk.slice(-3), LAST_CHUNK.slice(0, 3)) === 0 && Buffer3.compare(buf.slice(-2), LAST_CHUNK.slice(3)) === 0;
+      }
+      previousChunk = buf;
+    };
+    socket.prependListener("close", onSocketClose);
+    socket.on("data", onData);
+    request.on("close", () => {
+      socket.removeListener("close", onSocketClose);
+      socket.removeListener("data", onData);
     });
-  }
+  });
 }
+
 // src/functions/endpoint/get-sonar-endpoint.ts
 async function getSonarEndpoint(appEndpoint) {
   let response;
   try {
-    response = await customFetch(`${appEndpoint}/subApps`);
+    const url = `${appEndpoint}/subApps`;
+    if (typeof Bun !== "undefined") {
+      response = await fetch(url, {
+        tls: {
+          rejectUnauthorized: false
+        }
+      });
+    } else {
+      response = await fetch2(url, {
+        agent: new https2.Agent({
+          rejectUnauthorized: false
+        })
+      });
+    }
   } catch (error) {
     throw new SonarInitializationException({
       reason: "Not Responding" /* NotResponding */,
@@ -6767,7 +6764,7 @@ function convertProfileChannelToUser(channel) {
 async function requestConfigs(sonarAddress, channel) {
   let response;
   try {
-    response = await customFetch(`${sonarAddress}/configs?vad=${channel}`);
+    response = await fetch(`${sonarAddress}/configs?vad=${channel}`);
   } catch (error) {
     throw new SonarRequestException({ innerException: error });
   }
@@ -6803,7 +6800,7 @@ async function getChannelProfiles(sonarAddress, channel, favoritesOnly) {
 async function requestSelectedConfigs(sonarAddress) {
   let response;
   try {
-    response = await customFetch(`${sonarAddress}/configs/selected`);
+    response = await fetch(`${sonarAddress}/configs/selected`);
   } catch (error) {
     throw new SonarRequestException({ innerException: error });
   }
@@ -6837,7 +6834,7 @@ async function getSelectedProfiles(sonarAddress) {
 async function changeSelectedConfig(sonarAddress, configId) {
   let response;
   try {
-    response = await customFetch(`${sonarAddress}/configs/${configId}/select`, {
+    response = await fetch(`${sonarAddress}/configs/${configId}/select`, {
       method: "PUT"
     });
   } catch (error) {