rsshub
Version:
Make RSS Great Again!
1,536 lines (1,522 loc) • 156 kB
JavaScript
import { a as __toESM, i as __require, n as init_esm_shims, r as __commonJS, t as __dirname } from "./esm-shims-CzJ_djXG.mjs";
import ie from "http";
import W from "https";
import { fileURLToPath } from "url";
import { dirname, resolve } from "path";
import { Writable } from "stream";
import y from "node:zlib";
import { isUtf8 } from "node:buffer";
import de from "net";
import T from "fs";
import { fork } from "child_process";
import v from "undici";
//#region node_modules/.pnpm/node-network-devtools@1.0.29_undici@7.16.0_utf-8-validate@5.0.10/node_modules/node-network-devtools/dist/common-BUk9ORDJ.mjs
var u = class u {
constructor(e) {
typeof e == "string" && this.parse(e), e instanceof u && Object.assign(this, e);
}
parse(e) {
if (e.match(/^\s*[-]{4,}$/)) return this.fileName = e, this;
const t = e.match(/at (?:(.+?)\s+\()?(?:(.+?):(\d+)(?::(\d+))?|([^)]+))\)?/);
if (!t) return this;
let r = null, o = null, i = null, m = null, c = null, f = t[5] === "native";
if (t[1]) {
i = t[1];
let a = i.lastIndexOf(".");
if (i[a - 1] == "." && a--, a > 0) {
r = i.substr(0, a), o = i.substr(a + 1);
const l = r.indexOf(".Module");
l > 0 && (i = i.substr(l + 1), r = r.substr(0, l));
}
}
o && (m = r, c = o), o === "<anonymous>" && (c = null, i = null);
const h = {
fileName: t[2] || null,
lineNumber: parseInt(t[3], 10) || null,
functionName: i,
typeName: m,
methodName: c,
columnNumber: parseInt(t[4], 10) || null,
native: f
};
return Object.assign(this, h), this;
}
valueOf() {
return {
fileName: this.fileName,
lineNumber: this.lineNumber,
functionName: this.functionName,
typeName: this.typeName,
methodName: this.methodName,
columnNumber: this.columnNumber,
native: this.native
};
}
toString() {
return JSON.stringify(this.valueOf());
}
};
const p = [
/\((internal\/)?async_hooks\.js:/,
/\(\//,
/node_modules/
];
function N$1(s) {
const e = /* @__PURE__ */ Object.create(null);
return s ? e.stack = s : (Error.stackTraceLimit = Infinity, Error.captureStackTrace(e)), e.stack.split(`
`).slice(1).map((r) => new u(r));
}
function b$1(s) {
return s.filter((n) => !p.some((t) => t.test(n.fileName || "")));
}
const T$1 = console.log.bind(console, "\x1B[36m[node-network-debugger]:", "\x1B[32m"), _ = console.warn.bind(console, "\x1B[36m[node-network-debugger](warn):", "\x1B[33m"), k$1 = (s, e) => s + Object.entries(e).map(([n, t]) => `${n}: ${String(t)}`).join(`\r
`), y$1 = (s) => s.reduce((e, n, t, r) => t % 2 === 0 ? {
...e,
[r[t]]: r[t + 1]
} : e, {}), g$1 = (s) => Object.keys(s).reduce((e, n) => {
const t = s[n];
return e[n] = typeof t == "object" && t !== null ? g$1(t) : String(t), e;
}, {}), w = () => (/* @__PURE__ */ new Date()).getTime() / 1e3;
function E$1() {
let s = (/* @__PURE__ */ new Date()).getTime();
return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(n) {
const t = (s + Math.random() * 16) % 16 | 0;
return s = Math.floor(s / 16), (n === "x" ? t : t & 3 | 8).toString(16);
});
}
function v$1(s) {
let e = 0, n, t;
if (s.length === 0) return e.toString(36);
for (n = 0; n < s.length; n++) t = s.charCodeAt(n), e = (e << 5) - e + t, e |= 0;
return e.toString(36);
}
var j = class {
constructor(e) {
e ? (this.id = e.id, this.responseInfo = e.responseInfo, Object.assign(this, e)) : (this.id = E$1(), this.responseInfo = {});
}
loadCallFrames(e) {
const t = b$1(N$1(e)).map((r) => {
const o = r.fileName || "";
return {
columnNumber: r.columnNumber || 0,
functionName: r.functionName || "",
lineNumber: r.lineNumber || 0,
url: o.startsWith("/") ? `file://${o}` : o
};
});
t.length > 0 && (this.initiator = {
type: "script",
stack: { callFrames: t }
});
}
isHiden() {
return this.isWebSocket() && ["http://localhost/", "ws://localhost/"].includes(this.url);
}
isWebSocket() {
return this.requestHeaders?.Upgrade === "websocket" || this.requestHeaders?.upgrade === "websocket";
}
};
const D = Number(process.env.NETWORK_PORT || 5270), I = Number(process.env.NETWORK_SERVER_PORT || 5271), M$1 = Number(process.env.REMOTE_DEBUGGER_PORT || 9333), P$1 = process.env.NETWORK_DEBUG_MODE === "true", B = "ready", H = dirname(fileURLToPath(import.meta.url));
//#endregion
//#region node_modules/.pnpm/ws@8.18.3_bufferutil@4.0.9_utf-8-validate@5.0.10/node_modules/ws/lib/constants.js
var require_constants = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/ws@8.18.3_bufferutil@4.0.9_utf-8-validate@5.0.10/node_modules/ws/lib/constants.js": ((exports, module) => {
const BINARY_TYPES$2 = [
"nodebuffer",
"arraybuffer",
"fragments"
];
const hasBlob$1 = typeof Blob !== "undefined";
if (hasBlob$1) BINARY_TYPES$2.push("blob");
module.exports = {
BINARY_TYPES: BINARY_TYPES$2,
EMPTY_BUFFER: Buffer.alloc(0),
GUID: "258EAFA5-E914-47DA-95CA-C5AB0DC85B11",
hasBlob: hasBlob$1,
kForOnEventAttribute: Symbol("kIsForOnEventAttribute"),
kListener: Symbol("kListener"),
kStatusCode: Symbol("status-code"),
kWebSocket: Symbol("websocket"),
NOOP: () => {}
};
}) });
//#endregion
//#region node_modules/.pnpm/node-gyp-build@4.8.4/node_modules/node-gyp-build/node-gyp-build.js
var require_node_gyp_build$1 = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/node-gyp-build@4.8.4/node_modules/node-gyp-build/node-gyp-build.js": ((exports, module) => {
var fs = __require("fs");
var path = __require("path");
var os = __require("os");
var runtimeRequire$1 = typeof __webpack_require__ === "function" ? __non_webpack_require__ : __require;
var vars = process.config && process.config.variables || {};
var prebuildsOnly = !!process.env.PREBUILDS_ONLY;
var abi = process.versions.modules;
var runtime = isElectron() ? "electron" : isNwjs() ? "node-webkit" : "node";
var arch = process.env.npm_config_arch || os.arch();
var platform = process.env.npm_config_platform || os.platform();
var libc = process.env.LIBC || (isAlpine(platform) ? "musl" : "glibc");
var armv = process.env.ARM_VERSION || (arch === "arm64" ? "8" : vars.arm_version) || "";
var uv = (process.versions.uv || "").split(".")[0];
module.exports = load;
function load(dir) {
return runtimeRequire$1(load.resolve(dir));
}
load.resolve = load.path = function(dir) {
dir = path.resolve(dir || ".");
try {
var name = runtimeRequire$1(path.join(dir, "package.json")).name.toUpperCase().replace(/-/g, "_");
if (process.env[name + "_PREBUILD"]) dir = process.env[name + "_PREBUILD"];
} catch (err) {}
if (!prebuildsOnly) {
var release = getFirst(path.join(dir, "build/Release"), matchBuild);
if (release) return release;
var debug = getFirst(path.join(dir, "build/Debug"), matchBuild);
if (debug) return debug;
}
var prebuild = resolve$1(dir);
if (prebuild) return prebuild;
var nearby = resolve$1(path.dirname(process.execPath));
if (nearby) return nearby;
var target = [
"platform=" + platform,
"arch=" + arch,
"runtime=" + runtime,
"abi=" + abi,
"uv=" + uv,
armv ? "armv=" + armv : "",
"libc=" + libc,
"node=" + process.versions.node,
process.versions.electron ? "electron=" + process.versions.electron : "",
typeof __webpack_require__ === "function" ? "webpack=true" : ""
].filter(Boolean).join(" ");
throw new Error("No native build was found for " + target + "\n loaded from: " + dir + "\n");
function resolve$1(dir$1) {
var tuple = readdirSync(path.join(dir$1, "prebuilds")).map(parseTuple).filter(matchTuple(platform, arch)).sort(compareTuples)[0];
if (!tuple) return;
var prebuilds = path.join(dir$1, "prebuilds", tuple.name);
var winner = readdirSync(prebuilds).map(parseTags).filter(matchTags(runtime, abi)).sort(compareTags(runtime))[0];
if (winner) return path.join(prebuilds, winner.file);
}
};
function readdirSync(dir) {
try {
return fs.readdirSync(dir);
} catch (err) {
return [];
}
}
function getFirst(dir, filter) {
var files = readdirSync(dir).filter(filter);
return files[0] && path.join(dir, files[0]);
}
function matchBuild(name) {
return /\.node$/.test(name);
}
function parseTuple(name) {
var arr = name.split("-");
if (arr.length !== 2) return;
var platform$1 = arr[0];
var architectures = arr[1].split("+");
if (!platform$1) return;
if (!architectures.length) return;
if (!architectures.every(Boolean)) return;
return {
name,
platform: platform$1,
architectures
};
}
function matchTuple(platform$1, arch$1) {
return function(tuple) {
if (tuple == null) return false;
if (tuple.platform !== platform$1) return false;
return tuple.architectures.includes(arch$1);
};
}
function compareTuples(a, b$2) {
return a.architectures.length - b$2.architectures.length;
}
function parseTags(file) {
var arr = file.split(".");
var extension$1 = arr.pop();
var tags = {
file,
specificity: 0
};
if (extension$1 !== "node") return;
for (var i = 0; i < arr.length; i++) {
var tag = arr[i];
if (tag === "node" || tag === "electron" || tag === "node-webkit") tags.runtime = tag;
else if (tag === "napi") tags.napi = true;
else if (tag.slice(0, 3) === "abi") tags.abi = tag.slice(3);
else if (tag.slice(0, 2) === "uv") tags.uv = tag.slice(2);
else if (tag.slice(0, 4) === "armv") tags.armv = tag.slice(4);
else if (tag === "glibc" || tag === "musl") tags.libc = tag;
else continue;
tags.specificity++;
}
return tags;
}
function matchTags(runtime$1, abi$1) {
return function(tags) {
if (tags == null) return false;
if (tags.runtime && tags.runtime !== runtime$1 && !runtimeAgnostic(tags)) return false;
if (tags.abi && tags.abi !== abi$1 && !tags.napi) return false;
if (tags.uv && tags.uv !== uv) return false;
if (tags.armv && tags.armv !== armv) return false;
if (tags.libc && tags.libc !== libc) return false;
return true;
};
}
function runtimeAgnostic(tags) {
return tags.runtime === "node" && tags.napi;
}
function compareTags(runtime$1) {
return function(a, b$2) {
if (a.runtime !== b$2.runtime) return a.runtime === runtime$1 ? -1 : 1;
else if (a.abi !== b$2.abi) return a.abi ? -1 : 1;
else if (a.specificity !== b$2.specificity) return a.specificity > b$2.specificity ? -1 : 1;
else return 0;
};
}
function isNwjs() {
return !!(process.versions && process.versions.nw);
}
function isElectron() {
if (process.versions && process.versions.electron) return true;
if (process.env.ELECTRON_RUN_AS_NODE) return true;
return typeof window !== "undefined" && window.process && window.process.type === "renderer";
}
function isAlpine(platform$1) {
return platform$1 === "linux" && fs.existsSync("/etc/alpine-release");
}
load.parseTags = parseTags;
load.matchTags = matchTags;
load.compareTags = compareTags;
load.parseTuple = parseTuple;
load.matchTuple = matchTuple;
load.compareTuples = compareTuples;
}) });
//#endregion
//#region node_modules/.pnpm/node-gyp-build@4.8.4/node_modules/node-gyp-build/index.js
var require_node_gyp_build = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/node-gyp-build@4.8.4/node_modules/node-gyp-build/index.js": ((exports, module) => {
const runtimeRequire = typeof __webpack_require__ === "function" ? __non_webpack_require__ : __require;
if (typeof runtimeRequire.addon === "function") module.exports = runtimeRequire.addon.bind(runtimeRequire);
else module.exports = require_node_gyp_build$1();
}) });
//#endregion
//#region node_modules/.pnpm/bufferutil@4.0.9/node_modules/bufferutil/fallback.js
var require_fallback$1 = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/bufferutil@4.0.9/node_modules/bufferutil/fallback.js": ((exports, module) => {
/**
* Masks a buffer using the given mask.
*
* @param {Buffer} source The buffer to mask
* @param {Buffer} mask The mask to use
* @param {Buffer} output The buffer where to store the result
* @param {Number} offset The offset at which to start writing
* @param {Number} length The number of bytes to mask.
* @public
*/
const mask = (source, mask$1, output, offset, length) => {
for (var i = 0; i < length; i++) output[offset + i] = source[i] ^ mask$1[i & 3];
};
/**
* Unmasks a buffer using the given mask.
*
* @param {Buffer} buffer The buffer to unmask
* @param {Buffer} mask The mask to use
* @public
*/
const unmask$1 = (buffer, mask$1) => {
const length = buffer.length;
for (var i = 0; i < length; i++) buffer[i] ^= mask$1[i & 3];
};
module.exports = {
mask,
unmask: unmask$1
};
}) });
//#endregion
//#region node_modules/.pnpm/bufferutil@4.0.9/node_modules/bufferutil/index.js
var require_bufferutil = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/bufferutil@4.0.9/node_modules/bufferutil/index.js": ((exports, module) => {
init_esm_shims();
try {
module.exports = require_node_gyp_build()(__dirname);
} catch (e) {
module.exports = require_fallback$1();
}
}) });
//#endregion
//#region node_modules/.pnpm/ws@8.18.3_bufferutil@4.0.9_utf-8-validate@5.0.10/node_modules/ws/lib/buffer-util.js
var require_buffer_util = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/ws@8.18.3_bufferutil@4.0.9_utf-8-validate@5.0.10/node_modules/ws/lib/buffer-util.js": ((exports, module) => {
const { EMPTY_BUFFER: EMPTY_BUFFER$3 } = require_constants();
const FastBuffer$2 = Buffer[Symbol.species];
/**
* Merges an array of buffers into a new buffer.
*
* @param {Buffer[]} list The array of buffers to concat
* @param {Number} totalLength The total length of buffers in the list
* @return {Buffer} The resulting buffer
* @public
*/
function concat$1(list, totalLength) {
if (list.length === 0) return EMPTY_BUFFER$3;
if (list.length === 1) return list[0];
const target = Buffer.allocUnsafe(totalLength);
let offset = 0;
for (let i = 0; i < list.length; i++) {
const buf = list[i];
target.set(buf, offset);
offset += buf.length;
}
if (offset < totalLength) return new FastBuffer$2(target.buffer, target.byteOffset, offset);
return target;
}
/**
* Masks a buffer using the given mask.
*
* @param {Buffer} source The buffer to mask
* @param {Buffer} mask The mask to use
* @param {Buffer} output The buffer where to store the result
* @param {Number} offset The offset at which to start writing
* @param {Number} length The number of bytes to mask.
* @public
*/
function _mask(source, mask$1, output, offset, length) {
for (let i = 0; i < length; i++) output[offset + i] = source[i] ^ mask$1[i & 3];
}
/**
* Unmasks a buffer using the given mask.
*
* @param {Buffer} buffer The buffer to unmask
* @param {Buffer} mask The mask to use
* @public
*/
function _unmask(buffer, mask$1) {
for (let i = 0; i < buffer.length; i++) buffer[i] ^= mask$1[i & 3];
}
/**
* Converts a buffer to an `ArrayBuffer`.
*
* @param {Buffer} buf The buffer to convert
* @return {ArrayBuffer} Converted buffer
* @public
*/
function toArrayBuffer$1(buf) {
if (buf.length === buf.buffer.byteLength) return buf.buffer;
return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.length);
}
/**
* Converts `data` to a `Buffer`.
*
* @param {*} data The data to convert
* @return {Buffer} The buffer
* @throws {TypeError}
* @public
*/
function toBuffer$2(data) {
toBuffer$2.readOnly = true;
if (Buffer.isBuffer(data)) return data;
let buf;
if (data instanceof ArrayBuffer) buf = new FastBuffer$2(data);
else if (ArrayBuffer.isView(data)) buf = new FastBuffer$2(data.buffer, data.byteOffset, data.byteLength);
else {
buf = Buffer.from(data);
toBuffer$2.readOnly = false;
}
return buf;
}
module.exports = {
concat: concat$1,
mask: _mask,
toArrayBuffer: toArrayBuffer$1,
toBuffer: toBuffer$2,
unmask: _unmask
};
/* istanbul ignore else */
if (!process.env.WS_NO_BUFFER_UTIL) try {
const bufferUtil$1 = require_bufferutil();
module.exports.mask = function(source, mask$1, output, offset, length) {
if (length < 48) _mask(source, mask$1, output, offset, length);
else bufferUtil$1.mask(source, mask$1, output, offset, length);
};
module.exports.unmask = function(buffer, mask$1) {
if (buffer.length < 32) _unmask(buffer, mask$1);
else bufferUtil$1.unmask(buffer, mask$1);
};
} catch (e) {}
}) });
//#endregion
//#region node_modules/.pnpm/ws@8.18.3_bufferutil@4.0.9_utf-8-validate@5.0.10/node_modules/ws/lib/limiter.js
var require_limiter = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/ws@8.18.3_bufferutil@4.0.9_utf-8-validate@5.0.10/node_modules/ws/lib/limiter.js": ((exports, module) => {
const kDone = Symbol("kDone");
const kRun = Symbol("kRun");
/**
* A very simple job queue with adjustable concurrency. Adapted from
* https://github.com/STRML/async-limiter
*/
var Limiter$1 = class {
/**
* Creates a new `Limiter`.
*
* @param {Number} [concurrency=Infinity] The maximum number of jobs allowed
* to run concurrently
*/
constructor(concurrency) {
this[kDone] = () => {
this.pending--;
this[kRun]();
};
this.concurrency = concurrency || Infinity;
this.jobs = [];
this.pending = 0;
}
/**
* Adds a job to the queue.
*
* @param {Function} job The job to run
* @public
*/
add(job) {
this.jobs.push(job);
this[kRun]();
}
/**
* Removes a job from the queue and runs it if possible.
*
* @private
*/
[kRun]() {
if (this.pending === this.concurrency) return;
if (this.jobs.length) {
const job = this.jobs.shift();
this.pending++;
job(this[kDone]);
}
}
};
module.exports = Limiter$1;
}) });
//#endregion
//#region node_modules/.pnpm/ws@8.18.3_bufferutil@4.0.9_utf-8-validate@5.0.10/node_modules/ws/lib/permessage-deflate.js
var require_permessage_deflate = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/ws@8.18.3_bufferutil@4.0.9_utf-8-validate@5.0.10/node_modules/ws/lib/permessage-deflate.js": ((exports, module) => {
const zlib = __require("zlib");
const bufferUtil = require_buffer_util();
const Limiter = require_limiter();
const { kStatusCode: kStatusCode$2 } = require_constants();
const FastBuffer$1 = Buffer[Symbol.species];
const TRAILER = Buffer.from([
0,
0,
255,
255
]);
const kPerMessageDeflate = Symbol("permessage-deflate");
const kTotalLength = Symbol("total-length");
const kCallback = Symbol("callback");
const kBuffers = Symbol("buffers");
const kError$1 = Symbol("error");
let zlibLimiter;
/**
* permessage-deflate implementation.
*/
var PerMessageDeflate$4 = class {
/**
* Creates a PerMessageDeflate instance.
*
* @param {Object} [options] Configuration options
* @param {(Boolean|Number)} [options.clientMaxWindowBits] Advertise support
* for, or request, a custom client window size
* @param {Boolean} [options.clientNoContextTakeover=false] Advertise/
* acknowledge disabling of client context takeover
* @param {Number} [options.concurrencyLimit=10] The number of concurrent
* calls to zlib
* @param {(Boolean|Number)} [options.serverMaxWindowBits] Request/confirm the
* use of a custom server window size
* @param {Boolean} [options.serverNoContextTakeover=false] Request/accept
* disabling of server context takeover
* @param {Number} [options.threshold=1024] Size (in bytes) below which
* messages should not be compressed if context takeover is disabled
* @param {Object} [options.zlibDeflateOptions] Options to pass to zlib on
* deflate
* @param {Object} [options.zlibInflateOptions] Options to pass to zlib on
* inflate
* @param {Boolean} [isServer=false] Create the instance in either server or
* client mode
* @param {Number} [maxPayload=0] The maximum allowed message length
*/
constructor(options, isServer, maxPayload) {
this._maxPayload = maxPayload | 0;
this._options = options || {};
this._threshold = this._options.threshold !== void 0 ? this._options.threshold : 1024;
this._isServer = !!isServer;
this._deflate = null;
this._inflate = null;
this.params = null;
if (!zlibLimiter) zlibLimiter = new Limiter(this._options.concurrencyLimit !== void 0 ? this._options.concurrencyLimit : 10);
}
/**
* @type {String}
*/
static get extensionName() {
return "permessage-deflate";
}
/**
* Create an extension negotiation offer.
*
* @return {Object} Extension parameters
* @public
*/
offer() {
const params = {};
if (this._options.serverNoContextTakeover) params.server_no_context_takeover = true;
if (this._options.clientNoContextTakeover) params.client_no_context_takeover = true;
if (this._options.serverMaxWindowBits) params.server_max_window_bits = this._options.serverMaxWindowBits;
if (this._options.clientMaxWindowBits) params.client_max_window_bits = this._options.clientMaxWindowBits;
else if (this._options.clientMaxWindowBits == null) params.client_max_window_bits = true;
return params;
}
/**
* Accept an extension negotiation offer/response.
*
* @param {Array} configurations The extension negotiation offers/reponse
* @return {Object} Accepted configuration
* @public
*/
accept(configurations) {
configurations = this.normalizeParams(configurations);
this.params = this._isServer ? this.acceptAsServer(configurations) : this.acceptAsClient(configurations);
return this.params;
}
/**
* Releases all resources used by the extension.
*
* @public
*/
cleanup() {
if (this._inflate) {
this._inflate.close();
this._inflate = null;
}
if (this._deflate) {
const callback = this._deflate[kCallback];
this._deflate.close();
this._deflate = null;
if (callback) callback(/* @__PURE__ */ new Error("The deflate stream was closed while data was being processed"));
}
}
/**
* Accept an extension negotiation offer.
*
* @param {Array} offers The extension negotiation offers
* @return {Object} Accepted configuration
* @private
*/
acceptAsServer(offers) {
const opts = this._options;
const accepted = offers.find((params) => {
if (opts.serverNoContextTakeover === false && params.server_no_context_takeover || params.server_max_window_bits && (opts.serverMaxWindowBits === false || typeof opts.serverMaxWindowBits === "number" && opts.serverMaxWindowBits > params.server_max_window_bits) || typeof opts.clientMaxWindowBits === "number" && !params.client_max_window_bits) return false;
return true;
});
if (!accepted) throw new Error("None of the extension offers can be accepted");
if (opts.serverNoContextTakeover) accepted.server_no_context_takeover = true;
if (opts.clientNoContextTakeover) accepted.client_no_context_takeover = true;
if (typeof opts.serverMaxWindowBits === "number") accepted.server_max_window_bits = opts.serverMaxWindowBits;
if (typeof opts.clientMaxWindowBits === "number") accepted.client_max_window_bits = opts.clientMaxWindowBits;
else if (accepted.client_max_window_bits === true || opts.clientMaxWindowBits === false) delete accepted.client_max_window_bits;
return accepted;
}
/**
* Accept the extension negotiation response.
*
* @param {Array} response The extension negotiation response
* @return {Object} Accepted configuration
* @private
*/
acceptAsClient(response) {
const params = response[0];
if (this._options.clientNoContextTakeover === false && params.client_no_context_takeover) throw new Error("Unexpected parameter \"client_no_context_takeover\"");
if (!params.client_max_window_bits) {
if (typeof this._options.clientMaxWindowBits === "number") params.client_max_window_bits = this._options.clientMaxWindowBits;
} else if (this._options.clientMaxWindowBits === false || typeof this._options.clientMaxWindowBits === "number" && params.client_max_window_bits > this._options.clientMaxWindowBits) throw new Error("Unexpected or invalid parameter \"client_max_window_bits\"");
return params;
}
/**
* Normalize parameters.
*
* @param {Array} configurations The extension negotiation offers/reponse
* @return {Array} The offers/response with normalized parameters
* @private
*/
normalizeParams(configurations) {
configurations.forEach((params) => {
Object.keys(params).forEach((key) => {
let value = params[key];
if (value.length > 1) throw new Error(`Parameter "${key}" must have only a single value`);
value = value[0];
if (key === "client_max_window_bits") {
if (value !== true) {
const num = +value;
if (!Number.isInteger(num) || num < 8 || num > 15) throw new TypeError(`Invalid value for parameter "${key}": ${value}`);
value = num;
} else if (!this._isServer) throw new TypeError(`Invalid value for parameter "${key}": ${value}`);
} else if (key === "server_max_window_bits") {
const num = +value;
if (!Number.isInteger(num) || num < 8 || num > 15) throw new TypeError(`Invalid value for parameter "${key}": ${value}`);
value = num;
} else if (key === "client_no_context_takeover" || key === "server_no_context_takeover") {
if (value !== true) throw new TypeError(`Invalid value for parameter "${key}": ${value}`);
} else throw new Error(`Unknown parameter "${key}"`);
params[key] = value;
});
});
return configurations;
}
/**
* Decompress data. Concurrency limited.
*
* @param {Buffer} data Compressed data
* @param {Boolean} fin Specifies whether or not this is the last fragment
* @param {Function} callback Callback
* @public
*/
decompress(data, fin, callback) {
zlibLimiter.add((done) => {
this._decompress(data, fin, (err, result) => {
done();
callback(err, result);
});
});
}
/**
* Compress data. Concurrency limited.
*
* @param {(Buffer|String)} data Data to compress
* @param {Boolean} fin Specifies whether or not this is the last fragment
* @param {Function} callback Callback
* @public
*/
compress(data, fin, callback) {
zlibLimiter.add((done) => {
this._compress(data, fin, (err, result) => {
done();
callback(err, result);
});
});
}
/**
* Decompress data.
*
* @param {Buffer} data Compressed data
* @param {Boolean} fin Specifies whether or not this is the last fragment
* @param {Function} callback Callback
* @private
*/
_decompress(data, fin, callback) {
const endpoint = this._isServer ? "client" : "server";
if (!this._inflate) {
const key = `${endpoint}_max_window_bits`;
const windowBits = typeof this.params[key] !== "number" ? zlib.Z_DEFAULT_WINDOWBITS : this.params[key];
this._inflate = zlib.createInflateRaw({
...this._options.zlibInflateOptions,
windowBits
});
this._inflate[kPerMessageDeflate] = this;
this._inflate[kTotalLength] = 0;
this._inflate[kBuffers] = [];
this._inflate.on("error", inflateOnError);
this._inflate.on("data", inflateOnData);
}
this._inflate[kCallback] = callback;
this._inflate.write(data);
if (fin) this._inflate.write(TRAILER);
this._inflate.flush(() => {
const err = this._inflate[kError$1];
if (err) {
this._inflate.close();
this._inflate = null;
callback(err);
return;
}
const data$1 = bufferUtil.concat(this._inflate[kBuffers], this._inflate[kTotalLength]);
if (this._inflate._readableState.endEmitted) {
this._inflate.close();
this._inflate = null;
} else {
this._inflate[kTotalLength] = 0;
this._inflate[kBuffers] = [];
if (fin && this.params[`${endpoint}_no_context_takeover`]) this._inflate.reset();
}
callback(null, data$1);
});
}
/**
* Compress data.
*
* @param {(Buffer|String)} data Data to compress
* @param {Boolean} fin Specifies whether or not this is the last fragment
* @param {Function} callback Callback
* @private
*/
_compress(data, fin, callback) {
const endpoint = this._isServer ? "server" : "client";
if (!this._deflate) {
const key = `${endpoint}_max_window_bits`;
const windowBits = typeof this.params[key] !== "number" ? zlib.Z_DEFAULT_WINDOWBITS : this.params[key];
this._deflate = zlib.createDeflateRaw({
...this._options.zlibDeflateOptions,
windowBits
});
this._deflate[kTotalLength] = 0;
this._deflate[kBuffers] = [];
this._deflate.on("data", deflateOnData);
}
this._deflate[kCallback] = callback;
this._deflate.write(data);
this._deflate.flush(zlib.Z_SYNC_FLUSH, () => {
if (!this._deflate) return;
let data$1 = bufferUtil.concat(this._deflate[kBuffers], this._deflate[kTotalLength]);
if (fin) data$1 = new FastBuffer$1(data$1.buffer, data$1.byteOffset, data$1.length - 4);
this._deflate[kCallback] = null;
this._deflate[kTotalLength] = 0;
this._deflate[kBuffers] = [];
if (fin && this.params[`${endpoint}_no_context_takeover`]) this._deflate.reset();
callback(null, data$1);
});
}
};
module.exports = PerMessageDeflate$4;
/**
* The listener of the `zlib.DeflateRaw` stream `'data'` event.
*
* @param {Buffer} chunk A chunk of data
* @private
*/
function deflateOnData(chunk) {
this[kBuffers].push(chunk);
this[kTotalLength] += chunk.length;
}
/**
* The listener of the `zlib.InflateRaw` stream `'data'` event.
*
* @param {Buffer} chunk A chunk of data
* @private
*/
function inflateOnData(chunk) {
this[kTotalLength] += chunk.length;
if (this[kPerMessageDeflate]._maxPayload < 1 || this[kTotalLength] <= this[kPerMessageDeflate]._maxPayload) {
this[kBuffers].push(chunk);
return;
}
this[kError$1] = /* @__PURE__ */ new RangeError("Max payload size exceeded");
this[kError$1].code = "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH";
this[kError$1][kStatusCode$2] = 1009;
this.removeListener("data", inflateOnData);
this.reset();
}
/**
* The listener of the `zlib.InflateRaw` stream `'error'` event.
*
* @param {Error} err The emitted error
* @private
*/
function inflateOnError(err) {
this[kPerMessageDeflate]._inflate = null;
if (this[kError$1]) {
this[kCallback](this[kError$1]);
return;
}
err[kStatusCode$2] = 1007;
this[kCallback](err);
}
}) });
//#endregion
//#region node_modules/.pnpm/utf-8-validate@5.0.10/node_modules/utf-8-validate/fallback.js
var require_fallback = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/utf-8-validate@5.0.10/node_modules/utf-8-validate/fallback.js": ((exports, module) => {
/**
* Checks if a given buffer contains only correct UTF-8.
* Ported from https://www.cl.cam.ac.uk/%7Emgk25/ucs/utf8_check.c by
* Markus Kuhn.
*
* @param {Buffer} buf The buffer to check
* @return {Boolean} `true` if `buf` contains only correct UTF-8, else `false`
* @public
*/
function isValidUTF8$1(buf) {
const len = buf.length;
let i = 0;
while (i < len) if ((buf[i] & 128) === 0) i++;
else if ((buf[i] & 224) === 192) {
if (i + 1 === len || (buf[i + 1] & 192) !== 128 || (buf[i] & 254) === 192) return false;
i += 2;
} else if ((buf[i] & 240) === 224) {
if (i + 2 >= len || (buf[i + 1] & 192) !== 128 || (buf[i + 2] & 192) !== 128 || buf[i] === 224 && (buf[i + 1] & 224) === 128 || buf[i] === 237 && (buf[i + 1] & 224) === 160) return false;
i += 3;
} else if ((buf[i] & 248) === 240) {
if (i + 3 >= len || (buf[i + 1] & 192) !== 128 || (buf[i + 2] & 192) !== 128 || (buf[i + 3] & 192) !== 128 || buf[i] === 240 && (buf[i + 1] & 240) === 128 || buf[i] === 244 && buf[i + 1] > 143 || buf[i] > 244) return false;
i += 4;
} else return false;
return true;
}
module.exports = isValidUTF8$1;
}) });
//#endregion
//#region node_modules/.pnpm/utf-8-validate@5.0.10/node_modules/utf-8-validate/index.js
var require_utf_8_validate = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/utf-8-validate@5.0.10/node_modules/utf-8-validate/index.js": ((exports, module) => {
init_esm_shims();
try {
module.exports = require_node_gyp_build()(__dirname);
} catch (e) {
module.exports = require_fallback();
}
}) });
//#endregion
//#region node_modules/.pnpm/ws@8.18.3_bufferutil@4.0.9_utf-8-validate@5.0.10/node_modules/ws/lib/validation.js
var require_validation = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/ws@8.18.3_bufferutil@4.0.9_utf-8-validate@5.0.10/node_modules/ws/lib/validation.js": ((exports, module) => {
const { isUtf8: isUtf8$1 } = __require("buffer");
const { hasBlob } = require_constants();
const tokenChars$2 = [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
1,
1,
1,
1,
1,
0,
0,
1,
1,
0,
1,
1,
0,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
1,
0,
1,
0
];
/**
* Checks if a status code is allowed in a close frame.
*
* @param {Number} code The status code
* @return {Boolean} `true` if the status code is valid, else `false`
* @public
*/
function isValidStatusCode$2(code) {
return code >= 1e3 && code <= 1014 && code !== 1004 && code !== 1005 && code !== 1006 || code >= 3e3 && code <= 4999;
}
/**
* Checks if a given buffer contains only correct UTF-8.
* Ported from https://www.cl.cam.ac.uk/%7Emgk25/ucs/utf8_check.c by
* Markus Kuhn.
*
* @param {Buffer} buf The buffer to check
* @return {Boolean} `true` if `buf` contains only correct UTF-8, else `false`
* @public
*/
function _isValidUTF8(buf) {
const len = buf.length;
let i = 0;
while (i < len) if ((buf[i] & 128) === 0) i++;
else if ((buf[i] & 224) === 192) {
if (i + 1 === len || (buf[i + 1] & 192) !== 128 || (buf[i] & 254) === 192) return false;
i += 2;
} else if ((buf[i] & 240) === 224) {
if (i + 2 >= len || (buf[i + 1] & 192) !== 128 || (buf[i + 2] & 192) !== 128 || buf[i] === 224 && (buf[i + 1] & 224) === 128 || buf[i] === 237 && (buf[i + 1] & 224) === 160) return false;
i += 3;
} else if ((buf[i] & 248) === 240) {
if (i + 3 >= len || (buf[i + 1] & 192) !== 128 || (buf[i + 2] & 192) !== 128 || (buf[i + 3] & 192) !== 128 || buf[i] === 240 && (buf[i + 1] & 240) === 128 || buf[i] === 244 && buf[i + 1] > 143 || buf[i] > 244) return false;
i += 4;
} else return false;
return true;
}
/**
* Determines whether a value is a `Blob`.
*
* @param {*} value The value to be tested
* @return {Boolean} `true` if `value` is a `Blob`, else `false`
* @private
*/
function isBlob$2(value) {
return hasBlob && typeof value === "object" && typeof value.arrayBuffer === "function" && typeof value.type === "string" && typeof value.stream === "function" && (value[Symbol.toStringTag] === "Blob" || value[Symbol.toStringTag] === "File");
}
module.exports = {
isBlob: isBlob$2,
isValidStatusCode: isValidStatusCode$2,
isValidUTF8: _isValidUTF8,
tokenChars: tokenChars$2
};
if (isUtf8$1) module.exports.isValidUTF8 = function(buf) {
return buf.length < 24 ? _isValidUTF8(buf) : isUtf8$1(buf);
};
else if (!process.env.WS_NO_UTF_8_VALIDATE) try {
const isValidUTF8$2 = require_utf_8_validate();
module.exports.isValidUTF8 = function(buf) {
return buf.length < 32 ? _isValidUTF8(buf) : isValidUTF8$2(buf);
};
} catch (e) {}
}) });
//#endregion
//#region node_modules/.pnpm/ws@8.18.3_bufferutil@4.0.9_utf-8-validate@5.0.10/node_modules/ws/lib/receiver.js
var require_receiver = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/ws@8.18.3_bufferutil@4.0.9_utf-8-validate@5.0.10/node_modules/ws/lib/receiver.js": ((exports, module) => {
const { Writable: Writable$1 } = __require("stream");
const PerMessageDeflate$3 = require_permessage_deflate();
const { BINARY_TYPES: BINARY_TYPES$1, EMPTY_BUFFER: EMPTY_BUFFER$2, kStatusCode: kStatusCode$1, kWebSocket: kWebSocket$3 } = require_constants();
const { concat, toArrayBuffer, unmask } = require_buffer_util();
const { isValidStatusCode: isValidStatusCode$1, isValidUTF8 } = require_validation();
const FastBuffer = Buffer[Symbol.species];
const GET_INFO = 0;
const GET_PAYLOAD_LENGTH_16 = 1;
const GET_PAYLOAD_LENGTH_64 = 2;
const GET_MASK = 3;
const GET_DATA = 4;
const INFLATING = 5;
const DEFER_EVENT = 6;
/**
* HyBi Receiver implementation.
*
* @extends Writable
*/
var Receiver$2 = class extends Writable$1 {
/**
* Creates a Receiver instance.
*
* @param {Object} [options] Options object
* @param {Boolean} [options.allowSynchronousEvents=true] Specifies whether
* any of the `'message'`, `'ping'`, and `'pong'` events can be emitted
* multiple times in the same tick
* @param {String} [options.binaryType=nodebuffer] The type for binary data
* @param {Object} [options.extensions] An object containing the negotiated
* extensions
* @param {Boolean} [options.isServer=false] Specifies whether to operate in
* client or server mode
* @param {Number} [options.maxPayload=0] The maximum allowed message length
* @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
* not to skip UTF-8 validation for text and close messages
*/
constructor(options = {}) {
super();
this._allowSynchronousEvents = options.allowSynchronousEvents !== void 0 ? options.allowSynchronousEvents : true;
this._binaryType = options.binaryType || BINARY_TYPES$1[0];
this._extensions = options.extensions || {};
this._isServer = !!options.isServer;
this._maxPayload = options.maxPayload | 0;
this._skipUTF8Validation = !!options.skipUTF8Validation;
this[kWebSocket$3] = void 0;
this._bufferedBytes = 0;
this._buffers = [];
this._compressed = false;
this._payloadLength = 0;
this._mask = void 0;
this._fragmented = 0;
this._masked = false;
this._fin = false;
this._opcode = 0;
this._totalPayloadLength = 0;
this._messageLength = 0;
this._fragments = [];
this._errored = false;
this._loop = false;
this._state = GET_INFO;
}
/**
* Implements `Writable.prototype._write()`.
*
* @param {Buffer} chunk The chunk of data to write
* @param {String} encoding The character encoding of `chunk`
* @param {Function} cb Callback
* @private
*/
_write(chunk, encoding, cb) {
if (this._opcode === 8 && this._state == GET_INFO) return cb();
this._bufferedBytes += chunk.length;
this._buffers.push(chunk);
this.startLoop(cb);
}
/**
* Consumes `n` bytes from the buffered data.
*
* @param {Number} n The number of bytes to consume
* @return {Buffer} The consumed bytes
* @private
*/
consume(n) {
this._bufferedBytes -= n;
if (n === this._buffers[0].length) return this._buffers.shift();
if (n < this._buffers[0].length) {
const buf = this._buffers[0];
this._buffers[0] = new FastBuffer(buf.buffer, buf.byteOffset + n, buf.length - n);
return new FastBuffer(buf.buffer, buf.byteOffset, n);
}
const dst = Buffer.allocUnsafe(n);
do {
const buf = this._buffers[0];
const offset = dst.length - n;
if (n >= buf.length) dst.set(this._buffers.shift(), offset);
else {
dst.set(new Uint8Array(buf.buffer, buf.byteOffset, n), offset);
this._buffers[0] = new FastBuffer(buf.buffer, buf.byteOffset + n, buf.length - n);
}
n -= buf.length;
} while (n > 0);
return dst;
}
/**
* Starts the parsing loop.
*
* @param {Function} cb Callback
* @private
*/
startLoop(cb) {
this._loop = true;
do
switch (this._state) {
case GET_INFO:
this.getInfo(cb);
break;
case GET_PAYLOAD_LENGTH_16:
this.getPayloadLength16(cb);
break;
case GET_PAYLOAD_LENGTH_64:
this.getPayloadLength64(cb);
break;
case GET_MASK:
this.getMask();
break;
case GET_DATA:
this.getData(cb);
break;
case INFLATING:
case DEFER_EVENT:
this._loop = false;
return;
}
while (this._loop);
if (!this._errored) cb();
}
/**
* Reads the first two bytes of a frame.
*
* @param {Function} cb Callback
* @private
*/
getInfo(cb) {
if (this._bufferedBytes < 2) {
this._loop = false;
return;
}
const buf = this.consume(2);
if ((buf[0] & 48) !== 0) {
cb(this.createError(RangeError, "RSV2 and RSV3 must be clear", true, 1002, "WS_ERR_UNEXPECTED_RSV_2_3"));
return;
}
const compressed = (buf[0] & 64) === 64;
if (compressed && !this._extensions[PerMessageDeflate$3.extensionName]) {
cb(this.createError(RangeError, "RSV1 must be clear", true, 1002, "WS_ERR_UNEXPECTED_RSV_1"));
return;
}
this._fin = (buf[0] & 128) === 128;
this._opcode = buf[0] & 15;
this._payloadLength = buf[1] & 127;
if (this._opcode === 0) {
if (compressed) {
cb(this.createError(RangeError, "RSV1 must be clear", true, 1002, "WS_ERR_UNEXPECTED_RSV_1"));
return;
}
if (!this._fragmented) {
cb(this.createError(RangeError, "invalid opcode 0", true, 1002, "WS_ERR_INVALID_OPCODE"));
return;
}
this._opcode = this._fragmented;
} else if (this._opcode === 1 || this._opcode === 2) {
if (this._fragmented) {
cb(this.createError(RangeError, `invalid opcode ${this._opcode}`, true, 1002, "WS_ERR_INVALID_OPCODE"));
return;
}
this._compressed = compressed;
} else if (this._opcode > 7 && this._opcode < 11) {
if (!this._fin) {
cb(this.createError(RangeError, "FIN must be set", true, 1002, "WS_ERR_EXPECTED_FIN"));
return;
}
if (compressed) {
cb(this.createError(RangeError, "RSV1 must be clear", true, 1002, "WS_ERR_UNEXPECTED_RSV_1"));
return;
}
if (this._payloadLength > 125 || this._opcode === 8 && this._payloadLength === 1) {
cb(this.createError(RangeError, `invalid payload length ${this._payloadLength}`, true, 1002, "WS_ERR_INVALID_CONTROL_PAYLOAD_LENGTH"));
return;
}
} else {
cb(this.createError(RangeError, `invalid opcode ${this._opcode}`, true, 1002, "WS_ERR_INVALID_OPCODE"));
return;
}
if (!this._fin && !this._fragmented) this._fragmented = this._opcode;
this._masked = (buf[1] & 128) === 128;
if (this._isServer) {
if (!this._masked) {
cb(this.createError(RangeError, "MASK must be set", true, 1002, "WS_ERR_EXPECTED_MASK"));
return;
}
} else if (this._masked) {
cb(this.createError(RangeError, "MASK must be clear", true, 1002, "WS_ERR_UNEXPECTED_MASK"));
return;
}
if (this._payloadLength === 126) this._state = GET_PAYLOAD_LENGTH_16;
else if (this._payloadLength === 127) this._state = GET_PAYLOAD_LENGTH_64;
else this.haveLength(cb);
}
/**
* Gets extended payload length (7+16).
*
* @param {Function} cb Callback
* @private
*/
getPayloadLength16(cb) {
if (this._bufferedBytes < 2) {
this._loop = false;
return;
}
this._payloadLength = this.consume(2).readUInt16BE(0);
this.haveLength(cb);
}
/**
* Gets extended payload length (7+64).
*
* @param {Function} cb Callback
* @private
*/
getPayloadLength64(cb) {
if (this._bufferedBytes < 8) {
this._loop = false;
return;
}
const buf = this.consume(8);
const num = buf.readUInt32BE(0);
if (num > Math.pow(2, 21) - 1) {
cb(this.createError(RangeError, "Unsupported WebSocket frame: payload length > 2^53 - 1", false, 1009, "WS_ERR_UNSUPPORTED_DATA_PAYLOAD_LENGTH"));
return;
}
this._payloadLength = num * Math.pow(2, 32) + buf.readUInt32BE(4);
this.haveLength(cb);
}
/**
* Payload length has been read.
*
* @param {Function} cb Callback
* @private
*/
haveLength(cb) {
if (this._payloadLength && this._opcode < 8) {
this._totalPayloadLength += this._payloadLength;
if (this._totalPayloadLength > this._maxPayload && this._maxPayload > 0) {
cb(this.createError(RangeError, "Max payload size exceeded", false, 1009, "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH"));
return;
}
}
if (this._masked) this._state = GET_MASK;
else this._state = GET_DATA;
}
/**
* Reads mask bytes.
*
* @private
*/
getMask() {
if (this._bufferedBytes < 4) {
this._loop = false;
return;
}
this._mask = this.consume(4);
this._state = GET_DATA;
}
/**
* Reads data bytes.
*
* @param {Function} cb Callback
* @private
*/
getData(cb) {
let data = EMPTY_BUFFER$2;
if (this._payloadLength) {
if (this._bufferedBytes < this._payloadLength) {
this._loop = false;
return;
}
data = this.consume(this._payloadLength);
if (this._masked && (this._mask[0] | this._mask[1] | this._mask[2] | this._mask[3]) !== 0) unmask(data, this._mask);
}
if (this._opcode > 7) {
this.controlMessage(data, cb);
return;
}
if (this._compressed) {
this._state = INFLATING;
this.decompress(data, cb);
return;
}
if (data.length) {
this._messageLength = this._totalPayloadLength;
this._fragments.push(data);
}
this.dataMessage(cb);
}
/**
* Decompresses data.
*
* @param {Buffer} data Compressed data
* @param {Function} cb Callback
* @private
*/
decompress(data, cb) {
this._extensions[PerMessageDeflate$3.extensionName].decompress(data, this._fin, (err, buf) => {
if (err) return cb(err);
if (buf.length) {
this._messageLength += buf.length;
if (this._messageLength > this._maxPayload && this._maxPayload > 0) {
cb(this.createError(RangeError, "Max payload size exceeded", false, 1009, "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH"));
return;
}
this._fragments.push(buf);
}
this.dataMessage(cb);
if (this._state === GET_INFO) this.startLoop(cb);
});
}
/**
* Handles a data message.
*
* @param {Function} cb Callback
* @private
*/
dataMessage(cb) {
if (!this._fin) {
this._state = GET_INFO;
return;
}
const messageLength = this._messageLength;
const fragments = this._fragments;
this._totalPayloadLength = 0;
this._messageLength = 0;
this._fragmented = 0;
this._fragments = [];
if (this._opcode === 2) {
let data;
if (this._binaryType === "nodebuffer") data = concat(fragments, messageLength);
else if (this._binaryType === "arraybuffer") data = toArrayBuffer(concat(fragments, messageLength));
else if (this._binaryType === "blob") data = new Blob(fragments);
else data = fragments;
if (this._allowSynchronousEvents) {
this.emit("message", data, true);
this._state = GET_INFO;
} else {
this._state = DEFER_EVENT;
setImmediate(() => {
this.emit("message", data, true);
this._state = GET_INFO;
this.startLoop(cb);
});
}
} else {
const buf = concat(fragments, messageLength);
if (!this._skipUTF8Validation && !isValidUTF8(buf)) {
cb(this.createError(Error, "invalid UTF-8 sequence", true, 1007, "WS_ERR_INVALID_UTF8"));
return;
}
if (this._state === INFLATING || this._allowSynchronousEvents) {
this.emit("message", buf, false);
this._state = GET_INFO;
} else {
this._state = DEFER_EVENT;
setImmediate(() => {
this.emit("message", buf, false);
this._state = GET_INFO;
this.startLoop(cb);
});
}
}
}
/**
* Handles a control message.
*
* @param {Buffer} data Data to handle
* @return {(Error|RangeError|undefined)} A possible error
* @private
*/
controlMessage(data, cb) {
if (this._opcode === 8) {
if (data.length === 0) {
this._loop = false;
this.emit("conclude", 1005, EMPTY_BUFFER$2);
this.end();
} else {
const code = data.readUInt16BE(0);
if (!isValidStatusCode$1(code)) {
cb(this.createError(RangeError, `invalid status code ${code}`, true, 1002, "WS_ERR_INVALID_CLOSE_CODE"));
return;
}
const buf = new FastBuffer(data.buffer, data.byteOffset + 2, data.length - 2);
if (!this._skipUTF8Validation && !isValidUTF8(buf)) {
cb(this.createError(Error, "invalid UTF-8 sequence", true, 1007, "WS_ERR_INVALID_UTF8"));
return;
}
this._loop = false;
this.emit("conclude", code, buf);
this.end();
}
this._state = GET_INFO;
return;
}
if (this._allowSynchronousEvents) {
this.emit(this._opcode === 9 ? "ping" : "pong", data);
this._state = GET_INFO;
} else {
this._state = DEFER_EVENT;
setImmediate(() => {
this.emit(this._opcode === 9 ? "ping" : "pong", data);
this._state = GET_INFO;
this.startLoop(cb);
});
}
}
/**
* Builds an error object.
*
* @param {function(new:Error|RangeError)} ErrorCtor The error constructor
* @param {String} message The error message
* @param {Boolean} prefix Specifies whether or not to add a default prefix to
* `message`
* @param {Number} statusCode The status code
* @param {String} errorCode The exposed error code
* @return {(Error|RangeError)} The error
* @private
*/
createError(ErrorCtor, message, prefix, statusCode, errorCode) {
this._loop = false;
this._errored = true;
const err = new ErrorCtor(prefix ? `Invalid WebSocket frame: ${message}` : message);
Error.captureStackTrace(err, this.createError);
err.code = errorCode;
err[kStatusCode$1] = statusCode;
return err;
}
};
module.exports = Receiver$2;
}) });
//#endregion
//#region node_modules/.pnpm/ws@8.18.3_bufferutil@4.0.9_utf-8-validate@5.0.10/node_modules/ws/lib/sender.js
var require_sender = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/ws@8.18.3_bufferutil@4.0.9_utf-8-validate@5.0.10/node_modules/ws/lib/sender.js": ((exports, module) => {
const { Duplex: Duplex$3 } = __require("stream");
const { randomFillSync } = __require("crypto");
const PerMessageDeflate$2 = require_permessage_deflate();
const { EMPTY_BUFFER: EMPTY_BUFFER$1, kWebSocket: kWebSocket$2, NOOP: NOOP$1 } = require_constants();
const { isBlob: isBlob$1, isValidStatusCode } = require_validation();
const { mask: applyMask, toBuf