From 2679296838dbd1a52119af38ea9452db4d949160 Mon Sep 17 00:00:00 2001 From: yellowsink Date: Tue, 10 Dec 2024 20:54:16 +0000 Subject: [PATCH] deploy: dd4a406fad3a82f214436aa1a0d24bc089815a25 --- lastfm/plugin.js | 4112 ++++++++++++++++++++++++++++++++++-- lastfm/plugin.json | 2 +- snazzy-shelter/plugin.js | 6 +- snazzy-shelter/plugin.json | 2 +- 4 files changed, 3980 insertions(+), 142 deletions(-) diff --git a/lastfm/plugin.js b/lastfm/plugin.js index 3c890ee..f7afab9 100644 --- a/lastfm/plugin.js +++ b/lastfm/plugin.js @@ -54,31 +54,3929 @@ // plugins/lastfm/assets.ts var { post } = shelter.http; var cache = /* @__PURE__ */ new Map(); - async function getAsset(url) { - if (cache.has(url)) { - return cache.get(url); + async function getAsset(url2) { + if (cache.has(url2)) { + return cache.get(url2); } const res = await post({ url: `/applications/${DISCORD_APP_ID}/external-assets`, - body: { urls: [url] }, + body: { urls: [url2] }, oldFormErrors: false }); if (res.ok) { const path = "mp:" + res.body[0].external_asset_path; - cache.set(url, path); + cache.set(url2, path); return path; } - cache.set(url, void 0); + cache.set(url2, void 0); } + // node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_freeGlobal.js + var freeGlobal = typeof global == "object" && global && global.Object === Object && global; + var freeGlobal_default = freeGlobal; + + // node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_root.js + var freeSelf = typeof self == "object" && self && self.Object === Object && self; + var root = freeGlobal_default || freeSelf || Function("return this")(); + var root_default = root; + + // node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_Symbol.js + var Symbol2 = root_default.Symbol; + var Symbol_default = Symbol2; + + // node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_getRawTag.js + var objectProto = Object.prototype; + var hasOwnProperty = objectProto.hasOwnProperty; + var nativeObjectToString = objectProto.toString; + var symToStringTag = Symbol_default ? Symbol_default.toStringTag : void 0; + function getRawTag(value2) { + var isOwn = hasOwnProperty.call(value2, symToStringTag), tag = value2[symToStringTag]; + try { + value2[symToStringTag] = void 0; + var unmasked = true; + } catch (e) { + } + var result = nativeObjectToString.call(value2); + if (unmasked) { + if (isOwn) { + value2[symToStringTag] = tag; + } else { + delete value2[symToStringTag]; + } + } + return result; + } + var getRawTag_default = getRawTag; + + // node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_objectToString.js + var objectProto2 = Object.prototype; + var nativeObjectToString2 = objectProto2.toString; + function objectToString(value2) { + return nativeObjectToString2.call(value2); + } + var objectToString_default = objectToString; + + // node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseGetTag.js + var nullTag = "[object Null]"; + var undefinedTag = "[object Undefined]"; + var symToStringTag2 = Symbol_default ? Symbol_default.toStringTag : void 0; + function baseGetTag(value2) { + if (value2 == null) { + return value2 === void 0 ? undefinedTag : nullTag; + } + return symToStringTag2 && symToStringTag2 in Object(value2) ? getRawTag_default(value2) : objectToString_default(value2); + } + var baseGetTag_default = baseGetTag; + + // node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/isObject.js + function isObject(value2) { + var type = typeof value2; + return value2 != null && (type == "object" || type == "function"); + } + var isObject_default = isObject; + + // node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/isFunction.js + var asyncTag = "[object AsyncFunction]"; + var funcTag = "[object Function]"; + var genTag = "[object GeneratorFunction]"; + var proxyTag = "[object Proxy]"; + function isFunction(value2) { + if (!isObject_default(value2)) { + return false; + } + var tag = baseGetTag_default(value2); + return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag; + } + var isFunction_default = isFunction; + + // node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_coreJsData.js + var coreJsData = root_default["__core-js_shared__"]; + var coreJsData_default = coreJsData; + + // node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_isMasked.js + var maskSrcKey = function() { + var uid = /[^.]+$/.exec(coreJsData_default && coreJsData_default.keys && coreJsData_default.keys.IE_PROTO || ""); + return uid ? "Symbol(src)_1." + uid : ""; + }(); + function isMasked(func) { + return !!maskSrcKey && maskSrcKey in func; + } + var isMasked_default = isMasked; + + // node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_toSource.js + var funcProto = Function.prototype; + var funcToString = funcProto.toString; + function toSource(func) { + if (func != null) { + try { + return funcToString.call(func); + } catch (e) { + } + try { + return func + ""; + } catch (e) { + } + } + return ""; + } + var toSource_default = toSource; + + // node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseIsNative.js + var reRegExpChar = /[\\^$.*+?()[\]{}|]/g; + var reIsHostCtor = /^\[object .+?Constructor\]$/; + var funcProto2 = Function.prototype; + var objectProto3 = Object.prototype; + var funcToString2 = funcProto2.toString; + var hasOwnProperty2 = objectProto3.hasOwnProperty; + var reIsNative = RegExp( + "^" + funcToString2.call(hasOwnProperty2).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$" + ); + function baseIsNative(value2) { + if (!isObject_default(value2) || isMasked_default(value2)) { + return false; + } + var pattern = isFunction_default(value2) ? reIsNative : reIsHostCtor; + return pattern.test(toSource_default(value2)); + } + var baseIsNative_default = baseIsNative; + + // node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_getValue.js + function getValue(object, key) { + return object == null ? void 0 : object[key]; + } + var getValue_default = getValue; + + // node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_getNative.js + function getNative(object, key) { + var value2 = getValue_default(object, key); + return baseIsNative_default(value2) ? value2 : void 0; + } + var getNative_default = getNative; + + // node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_nativeCreate.js + var nativeCreate = getNative_default(Object, "create"); + var nativeCreate_default = nativeCreate; + + // node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_hashClear.js + function hashClear() { + this.__data__ = nativeCreate_default ? nativeCreate_default(null) : {}; + this.size = 0; + } + var hashClear_default = hashClear; + + // node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_hashDelete.js + function hashDelete(key) { + var result = this.has(key) && delete this.__data__[key]; + this.size -= result ? 1 : 0; + return result; + } + var hashDelete_default = hashDelete; + + // node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_hashGet.js + var HASH_UNDEFINED = "__lodash_hash_undefined__"; + var objectProto4 = Object.prototype; + var hasOwnProperty3 = objectProto4.hasOwnProperty; + function hashGet(key) { + var data = this.__data__; + if (nativeCreate_default) { + var result = data[key]; + return result === HASH_UNDEFINED ? void 0 : result; + } + return hasOwnProperty3.call(data, key) ? data[key] : void 0; + } + var hashGet_default = hashGet; + + // node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_hashHas.js + var objectProto5 = Object.prototype; + var hasOwnProperty4 = objectProto5.hasOwnProperty; + function hashHas(key) { + var data = this.__data__; + return nativeCreate_default ? data[key] !== void 0 : hasOwnProperty4.call(data, key); + } + var hashHas_default = hashHas; + + // node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_hashSet.js + var HASH_UNDEFINED2 = "__lodash_hash_undefined__"; + function hashSet(key, value2) { + var data = this.__data__; + this.size += this.has(key) ? 0 : 1; + data[key] = nativeCreate_default && value2 === void 0 ? HASH_UNDEFINED2 : value2; + return this; + } + var hashSet_default = hashSet; + + // node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_Hash.js + function Hash(entries) { + var index = -1, length = entries == null ? 0 : entries.length; + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } + } + Hash.prototype.clear = hashClear_default; + Hash.prototype["delete"] = hashDelete_default; + Hash.prototype.get = hashGet_default; + Hash.prototype.has = hashHas_default; + Hash.prototype.set = hashSet_default; + var Hash_default = Hash; + + // node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_listCacheClear.js + function listCacheClear() { + this.__data__ = []; + this.size = 0; + } + var listCacheClear_default = listCacheClear; + + // node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/eq.js + function eq(value2, other) { + return value2 === other || value2 !== value2 && other !== other; + } + var eq_default = eq; + + // node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_assocIndexOf.js + function assocIndexOf(array, key) { + var length = array.length; + while (length--) { + if (eq_default(array[length][0], key)) { + return length; + } + } + return -1; + } + var assocIndexOf_default = assocIndexOf; + + // node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_listCacheDelete.js + var arrayProto = Array.prototype; + var splice = arrayProto.splice; + function listCacheDelete(key) { + var data = this.__data__, index = assocIndexOf_default(data, key); + if (index < 0) { + return false; + } + var lastIndex = data.length - 1; + if (index == lastIndex) { + data.pop(); + } else { + splice.call(data, index, 1); + } + --this.size; + return true; + } + var listCacheDelete_default = listCacheDelete; + + // node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_listCacheGet.js + function listCacheGet(key) { + var data = this.__data__, index = assocIndexOf_default(data, key); + return index < 0 ? void 0 : data[index][1]; + } + var listCacheGet_default = listCacheGet; + + // node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_listCacheHas.js + function listCacheHas(key) { + return assocIndexOf_default(this.__data__, key) > -1; + } + var listCacheHas_default = listCacheHas; + + // node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_listCacheSet.js + function listCacheSet(key, value2) { + var data = this.__data__, index = assocIndexOf_default(data, key); + if (index < 0) { + ++this.size; + data.push([key, value2]); + } else { + data[index][1] = value2; + } + return this; + } + var listCacheSet_default = listCacheSet; + + // node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_ListCache.js + function ListCache(entries) { + var index = -1, length = entries == null ? 0 : entries.length; + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } + } + ListCache.prototype.clear = listCacheClear_default; + ListCache.prototype["delete"] = listCacheDelete_default; + ListCache.prototype.get = listCacheGet_default; + ListCache.prototype.has = listCacheHas_default; + ListCache.prototype.set = listCacheSet_default; + var ListCache_default = ListCache; + + // node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_Map.js + var Map2 = getNative_default(root_default, "Map"); + var Map_default = Map2; + + // node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_mapCacheClear.js + function mapCacheClear() { + this.size = 0; + this.__data__ = { + "hash": new Hash_default(), + "map": new (Map_default || ListCache_default)(), + "string": new Hash_default() + }; + } + var mapCacheClear_default = mapCacheClear; + + // node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_isKeyable.js + function isKeyable(value2) { + var type = typeof value2; + return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value2 !== "__proto__" : value2 === null; + } + var isKeyable_default = isKeyable; + + // node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_getMapData.js + function getMapData(map, key) { + var data = map.__data__; + return isKeyable_default(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map; + } + var getMapData_default = getMapData; + + // node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_mapCacheDelete.js + function mapCacheDelete(key) { + var result = getMapData_default(this, key)["delete"](key); + this.size -= result ? 1 : 0; + return result; + } + var mapCacheDelete_default = mapCacheDelete; + + // node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_mapCacheGet.js + function mapCacheGet(key) { + return getMapData_default(this, key).get(key); + } + var mapCacheGet_default = mapCacheGet; + + // node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_mapCacheHas.js + function mapCacheHas(key) { + return getMapData_default(this, key).has(key); + } + var mapCacheHas_default = mapCacheHas; + + // node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_mapCacheSet.js + function mapCacheSet(key, value2) { + var data = getMapData_default(this, key), size = data.size; + data.set(key, value2); + this.size += data.size == size ? 0 : 1; + return this; + } + var mapCacheSet_default = mapCacheSet; + + // node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_MapCache.js + function MapCache(entries) { + var index = -1, length = entries == null ? 0 : entries.length; + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } + } + MapCache.prototype.clear = mapCacheClear_default; + MapCache.prototype["delete"] = mapCacheDelete_default; + MapCache.prototype.get = mapCacheGet_default; + MapCache.prototype.has = mapCacheHas_default; + MapCache.prototype.set = mapCacheSet_default; + var MapCache_default = MapCache; + + // node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/memoize.js + var FUNC_ERROR_TEXT = "Expected a function"; + function memoize(func, resolver) { + if (typeof func != "function" || resolver != null && typeof resolver != "function") { + throw new TypeError(FUNC_ERROR_TEXT); + } + var memoized = function() { + var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache3 = memoized.cache; + if (cache3.has(key)) { + return cache3.get(key); + } + var result = func.apply(this, args); + memoized.cache = cache3.set(key, result) || cache3; + return result; + }; + memoized.cache = new (memoize.Cache || MapCache_default)(); + return memoized; + } + memoize.Cache = MapCache_default; + var memoize_default = memoize; + + // node_modules/.pnpm/engine.io-parser@5.2.3/node_modules/engine.io-parser/build/esm/commons.js + var PACKET_TYPES = /* @__PURE__ */ Object.create(null); + PACKET_TYPES["open"] = "0"; + PACKET_TYPES["close"] = "1"; + PACKET_TYPES["ping"] = "2"; + PACKET_TYPES["pong"] = "3"; + PACKET_TYPES["message"] = "4"; + PACKET_TYPES["upgrade"] = "5"; + PACKET_TYPES["noop"] = "6"; + var PACKET_TYPES_REVERSE = /* @__PURE__ */ Object.create(null); + Object.keys(PACKET_TYPES).forEach((key) => { + PACKET_TYPES_REVERSE[PACKET_TYPES[key]] = key; + }); + var ERROR_PACKET = { type: "error", data: "parser error" }; + + // node_modules/.pnpm/engine.io-parser@5.2.3/node_modules/engine.io-parser/build/esm/encodePacket.browser.js + var withNativeBlob = typeof Blob === "function" || typeof Blob !== "undefined" && Object.prototype.toString.call(Blob) === "[object BlobConstructor]"; + var withNativeArrayBuffer = typeof ArrayBuffer === "function"; + var isView = (obj) => { + return typeof ArrayBuffer.isView === "function" ? ArrayBuffer.isView(obj) : obj && obj.buffer instanceof ArrayBuffer; + }; + var encodePacket = ({ type, data }, supportsBinary, callback) => { + if (withNativeBlob && data instanceof Blob) { + if (supportsBinary) { + return callback(data); + } else { + return encodeBlobAsBase64(data, callback); + } + } else if (withNativeArrayBuffer && (data instanceof ArrayBuffer || isView(data))) { + if (supportsBinary) { + return callback(data); + } else { + return encodeBlobAsBase64(new Blob([data]), callback); + } + } + return callback(PACKET_TYPES[type] + (data || "")); + }; + var encodeBlobAsBase64 = (data, callback) => { + const fileReader = new FileReader(); + fileReader.onload = function() { + const content = fileReader.result.split(",")[1]; + callback("b" + (content || "")); + }; + return fileReader.readAsDataURL(data); + }; + function toArray(data) { + if (data instanceof Uint8Array) { + return data; + } else if (data instanceof ArrayBuffer) { + return new Uint8Array(data); + } else { + return new Uint8Array(data.buffer, data.byteOffset, data.byteLength); + } + } + var TEXT_ENCODER; + function encodePacketToBinary(packet, callback) { + if (withNativeBlob && packet.data instanceof Blob) { + return packet.data.arrayBuffer().then(toArray).then(callback); + } else if (withNativeArrayBuffer && (packet.data instanceof ArrayBuffer || isView(packet.data))) { + return callback(toArray(packet.data)); + } + encodePacket(packet, false, (encoded) => { + if (!TEXT_ENCODER) { + TEXT_ENCODER = new TextEncoder(); + } + callback(TEXT_ENCODER.encode(encoded)); + }); + } + + // node_modules/.pnpm/engine.io-parser@5.2.3/node_modules/engine.io-parser/build/esm/contrib/base64-arraybuffer.js + var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + var lookup = typeof Uint8Array === "undefined" ? [] : new Uint8Array(256); + for (let i = 0; i < chars.length; i++) { + lookup[chars.charCodeAt(i)] = i; + } + var decode = (base64) => { + let bufferLength = base64.length * 0.75, len = base64.length, i, p = 0, encoded1, encoded2, encoded3, encoded4; + if (base64[base64.length - 1] === "=") { + bufferLength--; + if (base64[base64.length - 2] === "=") { + bufferLength--; + } + } + const arraybuffer = new ArrayBuffer(bufferLength), bytes = new Uint8Array(arraybuffer); + for (i = 0; i < len; i += 4) { + encoded1 = lookup[base64.charCodeAt(i)]; + encoded2 = lookup[base64.charCodeAt(i + 1)]; + encoded3 = lookup[base64.charCodeAt(i + 2)]; + encoded4 = lookup[base64.charCodeAt(i + 3)]; + bytes[p++] = encoded1 << 2 | encoded2 >> 4; + bytes[p++] = (encoded2 & 15) << 4 | encoded3 >> 2; + bytes[p++] = (encoded3 & 3) << 6 | encoded4 & 63; + } + return arraybuffer; + }; + + // node_modules/.pnpm/engine.io-parser@5.2.3/node_modules/engine.io-parser/build/esm/decodePacket.browser.js + var withNativeArrayBuffer2 = typeof ArrayBuffer === "function"; + var decodePacket = (encodedPacket, binaryType) => { + if (typeof encodedPacket !== "string") { + return { + type: "message", + data: mapBinary(encodedPacket, binaryType) + }; + } + const type = encodedPacket.charAt(0); + if (type === "b") { + return { + type: "message", + data: decodeBase64Packet(encodedPacket.substring(1), binaryType) + }; + } + const packetType = PACKET_TYPES_REVERSE[type]; + if (!packetType) { + return ERROR_PACKET; + } + return encodedPacket.length > 1 ? { + type: PACKET_TYPES_REVERSE[type], + data: encodedPacket.substring(1) + } : { + type: PACKET_TYPES_REVERSE[type] + }; + }; + var decodeBase64Packet = (data, binaryType) => { + if (withNativeArrayBuffer2) { + const decoded = decode(data); + return mapBinary(decoded, binaryType); + } else { + return { base64: true, data }; + } + }; + var mapBinary = (data, binaryType) => { + switch (binaryType) { + case "blob": + if (data instanceof Blob) { + return data; + } else { + return new Blob([data]); + } + case "arraybuffer": + default: + if (data instanceof ArrayBuffer) { + return data; + } else { + return data.buffer; + } + } + }; + + // node_modules/.pnpm/engine.io-parser@5.2.3/node_modules/engine.io-parser/build/esm/index.js + var SEPARATOR = String.fromCharCode(30); + var encodePayload = (packets, callback) => { + const length = packets.length; + const encodedPackets = new Array(length); + let count = 0; + packets.forEach((packet, i) => { + encodePacket(packet, false, (encodedPacket) => { + encodedPackets[i] = encodedPacket; + if (++count === length) { + callback(encodedPackets.join(SEPARATOR)); + } + }); + }); + }; + var decodePayload = (encodedPayload, binaryType) => { + const encodedPackets = encodedPayload.split(SEPARATOR); + const packets = []; + for (let i = 0; i < encodedPackets.length; i++) { + const decodedPacket = decodePacket(encodedPackets[i], binaryType); + packets.push(decodedPacket); + if (decodedPacket.type === "error") { + break; + } + } + return packets; + }; + function createPacketEncoderStream() { + return new TransformStream({ + transform(packet, controller) { + encodePacketToBinary(packet, (encodedPacket) => { + const payloadLength = encodedPacket.length; + let header; + if (payloadLength < 126) { + header = new Uint8Array(1); + new DataView(header.buffer).setUint8(0, payloadLength); + } else if (payloadLength < 65536) { + header = new Uint8Array(3); + const view = new DataView(header.buffer); + view.setUint8(0, 126); + view.setUint16(1, payloadLength); + } else { + header = new Uint8Array(9); + const view = new DataView(header.buffer); + view.setUint8(0, 127); + view.setBigUint64(1, BigInt(payloadLength)); + } + if (packet.data && typeof packet.data !== "string") { + header[0] |= 128; + } + controller.enqueue(header); + controller.enqueue(encodedPacket); + }); + } + }); + } + var TEXT_DECODER; + function totalLength(chunks) { + return chunks.reduce((acc, chunk) => acc + chunk.length, 0); + } + function concatChunks(chunks, size) { + if (chunks[0].length === size) { + return chunks.shift(); + } + const buffer = new Uint8Array(size); + let j = 0; + for (let i = 0; i < size; i++) { + buffer[i] = chunks[0][j++]; + if (j === chunks[0].length) { + chunks.shift(); + j = 0; + } + } + if (chunks.length && j < chunks[0].length) { + chunks[0] = chunks[0].slice(j); + } + return buffer; + } + function createPacketDecoderStream(maxPayload, binaryType) { + if (!TEXT_DECODER) { + TEXT_DECODER = new TextDecoder(); + } + const chunks = []; + let state = 0; + let expectedLength = -1; + let isBinary2 = false; + return new TransformStream({ + transform(chunk, controller) { + chunks.push(chunk); + while (true) { + if (state === 0) { + if (totalLength(chunks) < 1) { + break; + } + const header = concatChunks(chunks, 1); + isBinary2 = (header[0] & 128) === 128; + expectedLength = header[0] & 127; + if (expectedLength < 126) { + state = 3; + } else if (expectedLength === 126) { + state = 1; + } else { + state = 2; + } + } else if (state === 1) { + if (totalLength(chunks) < 2) { + break; + } + const headerArray = concatChunks(chunks, 2); + expectedLength = new DataView(headerArray.buffer, headerArray.byteOffset, headerArray.length).getUint16(0); + state = 3; + } else if (state === 2) { + if (totalLength(chunks) < 8) { + break; + } + const headerArray = concatChunks(chunks, 8); + const view = new DataView(headerArray.buffer, headerArray.byteOffset, headerArray.length); + const n = view.getUint32(0); + if (n > Math.pow(2, 53 - 32) - 1) { + controller.enqueue(ERROR_PACKET); + break; + } + expectedLength = n * Math.pow(2, 32) + view.getUint32(4); + state = 3; + } else { + if (totalLength(chunks) < expectedLength) { + break; + } + const data = concatChunks(chunks, expectedLength); + controller.enqueue(decodePacket(isBinary2 ? data : TEXT_DECODER.decode(data), binaryType)); + state = 0; + } + if (expectedLength === 0 || expectedLength > maxPayload) { + controller.enqueue(ERROR_PACKET); + break; + } + } + } + }); + } + var protocol = 4; + + // node_modules/.pnpm/@socket.io+component-emitter@3.1.2/node_modules/@socket.io/component-emitter/lib/esm/index.js + function Emitter(obj) { + if (obj) + return mixin(obj); + } + function mixin(obj) { + for (var key in Emitter.prototype) { + obj[key] = Emitter.prototype[key]; + } + return obj; + } + Emitter.prototype.on = Emitter.prototype.addEventListener = function(event, fn) { + this._callbacks = this._callbacks || {}; + (this._callbacks["$" + event] = this._callbacks["$" + event] || []).push(fn); + return this; + }; + Emitter.prototype.once = function(event, fn) { + function on2() { + this.off(event, on2); + fn.apply(this, arguments); + } + on2.fn = fn; + this.on(event, on2); + return this; + }; + Emitter.prototype.off = Emitter.prototype.removeListener = Emitter.prototype.removeAllListeners = Emitter.prototype.removeEventListener = function(event, fn) { + this._callbacks = this._callbacks || {}; + if (0 == arguments.length) { + this._callbacks = {}; + return this; + } + var callbacks = this._callbacks["$" + event]; + if (!callbacks) + return this; + if (1 == arguments.length) { + delete this._callbacks["$" + event]; + return this; + } + var cb; + for (var i = 0; i < callbacks.length; i++) { + cb = callbacks[i]; + if (cb === fn || cb.fn === fn) { + callbacks.splice(i, 1); + break; + } + } + if (callbacks.length === 0) { + delete this._callbacks["$" + event]; + } + return this; + }; + Emitter.prototype.emit = function(event) { + this._callbacks = this._callbacks || {}; + var args = new Array(arguments.length - 1), callbacks = this._callbacks["$" + event]; + for (var i = 1; i < arguments.length; i++) { + args[i - 1] = arguments[i]; + } + if (callbacks) { + callbacks = callbacks.slice(0); + for (var i = 0, len = callbacks.length; i < len; ++i) { + callbacks[i].apply(this, args); + } + } + return this; + }; + Emitter.prototype.emitReserved = Emitter.prototype.emit; + Emitter.prototype.listeners = function(event) { + this._callbacks = this._callbacks || {}; + return this._callbacks["$" + event] || []; + }; + Emitter.prototype.hasListeners = function(event) { + return !!this.listeners(event).length; + }; + + // node_modules/.pnpm/engine.io-client@6.6.2/node_modules/engine.io-client/build/esm/globals.js + var nextTick = (() => { + const isPromiseAvailable = typeof Promise === "function" && typeof Promise.resolve === "function"; + if (isPromiseAvailable) { + return (cb) => Promise.resolve().then(cb); + } else { + return (cb, setTimeoutFn) => setTimeoutFn(cb, 0); + } + })(); + var globalThisShim = (() => { + if (typeof self !== "undefined") { + return self; + } else if (typeof window !== "undefined") { + return window; + } else { + return Function("return this")(); + } + })(); + var defaultBinaryType = "arraybuffer"; + function createCookieJar() { + } + + // node_modules/.pnpm/engine.io-client@6.6.2/node_modules/engine.io-client/build/esm/util.js + function pick(obj, ...attr) { + return attr.reduce((acc, k) => { + if (obj.hasOwnProperty(k)) { + acc[k] = obj[k]; + } + return acc; + }, {}); + } + var NATIVE_SET_TIMEOUT = globalThisShim.setTimeout; + var NATIVE_CLEAR_TIMEOUT = globalThisShim.clearTimeout; + function installTimerFunctions(obj, opts) { + if (opts.useNativeTimers) { + obj.setTimeoutFn = NATIVE_SET_TIMEOUT.bind(globalThisShim); + obj.clearTimeoutFn = NATIVE_CLEAR_TIMEOUT.bind(globalThisShim); + } else { + obj.setTimeoutFn = globalThisShim.setTimeout.bind(globalThisShim); + obj.clearTimeoutFn = globalThisShim.clearTimeout.bind(globalThisShim); + } + } + var BASE64_OVERHEAD = 1.33; + function byteLength(obj) { + if (typeof obj === "string") { + return utf8Length(obj); + } + return Math.ceil((obj.byteLength || obj.size) * BASE64_OVERHEAD); + } + function utf8Length(str) { + let c = 0, length = 0; + for (let i = 0, l = str.length; i < l; i++) { + c = str.charCodeAt(i); + if (c < 128) { + length += 1; + } else if (c < 2048) { + length += 2; + } else if (c < 55296 || c >= 57344) { + length += 3; + } else { + i++; + length += 4; + } + } + return length; + } + function randomString() { + return Date.now().toString(36).substring(3) + Math.random().toString(36).substring(2, 5); + } + + // node_modules/.pnpm/engine.io-client@6.6.2/node_modules/engine.io-client/build/esm/contrib/parseqs.js + function encode(obj) { + let str = ""; + for (let i in obj) { + if (obj.hasOwnProperty(i)) { + if (str.length) + str += "&"; + str += encodeURIComponent(i) + "=" + encodeURIComponent(obj[i]); + } + } + return str; + } + function decode2(qs) { + let qry = {}; + let pairs = qs.split("&"); + for (let i = 0, l = pairs.length; i < l; i++) { + let pair = pairs[i].split("="); + qry[decodeURIComponent(pair[0])] = decodeURIComponent(pair[1]); + } + return qry; + } + + // node_modules/.pnpm/engine.io-client@6.6.2/node_modules/engine.io-client/build/esm/transport.js + var TransportError = class extends Error { + constructor(reason, description, context) { + super(reason); + this.description = description; + this.context = context; + this.type = "TransportError"; + } + }; + var Transport = class extends Emitter { + /** + * Transport abstract constructor. + * + * @param {Object} opts - options + * @protected + */ + constructor(opts) { + super(); + this.writable = false; + installTimerFunctions(this, opts); + this.opts = opts; + this.query = opts.query; + this.socket = opts.socket; + this.supportsBinary = !opts.forceBase64; + } + /** + * Emits an error. + * + * @param {String} reason + * @param description + * @param context - the error context + * @return {Transport} for chaining + * @protected + */ + onError(reason, description, context) { + super.emitReserved("error", new TransportError(reason, description, context)); + return this; + } + /** + * Opens the transport. + */ + open() { + this.readyState = "opening"; + this.doOpen(); + return this; + } + /** + * Closes the transport. + */ + close() { + if (this.readyState === "opening" || this.readyState === "open") { + this.doClose(); + this.onClose(); + } + return this; + } + /** + * Sends multiple packets. + * + * @param {Array} packets + */ + send(packets) { + if (this.readyState === "open") { + this.write(packets); + } else { + } + } + /** + * Called upon open + * + * @protected + */ + onOpen() { + this.readyState = "open"; + this.writable = true; + super.emitReserved("open"); + } + /** + * Called with data. + * + * @param {String} data + * @protected + */ + onData(data) { + const packet = decodePacket(data, this.socket.binaryType); + this.onPacket(packet); + } + /** + * Called with a decoded packet. + * + * @protected + */ + onPacket(packet) { + super.emitReserved("packet", packet); + } + /** + * Called upon close. + * + * @protected + */ + onClose(details) { + this.readyState = "closed"; + super.emitReserved("close", details); + } + /** + * Pauses the transport, in order not to lose packets during an upgrade. + * + * @param onPause + */ + pause(onPause) { + } + createUri(schema, query = {}) { + return schema + "://" + this._hostname() + this._port() + this.opts.path + this._query(query); + } + _hostname() { + const hostname = this.opts.hostname; + return hostname.indexOf(":") === -1 ? hostname : "[" + hostname + "]"; + } + _port() { + if (this.opts.port && (this.opts.secure && Number(this.opts.port !== 443) || !this.opts.secure && Number(this.opts.port) !== 80)) { + return ":" + this.opts.port; + } else { + return ""; + } + } + _query(query) { + const encodedQuery = encode(query); + return encodedQuery.length ? "?" + encodedQuery : ""; + } + }; + + // node_modules/.pnpm/engine.io-client@6.6.2/node_modules/engine.io-client/build/esm/transports/polling.js + var Polling = class extends Transport { + constructor() { + super(...arguments); + this._polling = false; + } + get name() { + return "polling"; + } + /** + * Opens the socket (triggers polling). We write a PING message to determine + * when the transport is open. + * + * @protected + */ + doOpen() { + this._poll(); + } + /** + * Pauses polling. + * + * @param {Function} onPause - callback upon buffers are flushed and transport is paused + * @package + */ + pause(onPause) { + this.readyState = "pausing"; + const pause = () => { + this.readyState = "paused"; + onPause(); + }; + if (this._polling || !this.writable) { + let total = 0; + if (this._polling) { + total++; + this.once("pollComplete", function() { + --total || pause(); + }); + } + if (!this.writable) { + total++; + this.once("drain", function() { + --total || pause(); + }); + } + } else { + pause(); + } + } + /** + * Starts polling cycle. + * + * @private + */ + _poll() { + this._polling = true; + this.doPoll(); + this.emitReserved("poll"); + } + /** + * Overloads onData to detect payloads. + * + * @protected + */ + onData(data) { + const callback = (packet) => { + if ("opening" === this.readyState && packet.type === "open") { + this.onOpen(); + } + if ("close" === packet.type) { + this.onClose({ description: "transport closed by the server" }); + return false; + } + this.onPacket(packet); + }; + decodePayload(data, this.socket.binaryType).forEach(callback); + if ("closed" !== this.readyState) { + this._polling = false; + this.emitReserved("pollComplete"); + if ("open" === this.readyState) { + this._poll(); + } else { + } + } + } + /** + * For polling, send a close packet. + * + * @protected + */ + doClose() { + const close = () => { + this.write([{ type: "close" }]); + }; + if ("open" === this.readyState) { + close(); + } else { + this.once("open", close); + } + } + /** + * Writes a packets payload. + * + * @param {Array} packets - data packets + * @protected + */ + write(packets) { + this.writable = false; + encodePayload(packets, (data) => { + this.doWrite(data, () => { + this.writable = true; + this.emitReserved("drain"); + }); + }); + } + /** + * Generates uri for connection. + * + * @private + */ + uri() { + const schema = this.opts.secure ? "https" : "http"; + const query = this.query || {}; + if (false !== this.opts.timestampRequests) { + query[this.opts.timestampParam] = randomString(); + } + if (!this.supportsBinary && !query.sid) { + query.b64 = 1; + } + return this.createUri(schema, query); + } + }; + + // node_modules/.pnpm/engine.io-client@6.6.2/node_modules/engine.io-client/build/esm/contrib/has-cors.js + var value = false; + try { + value = typeof XMLHttpRequest !== "undefined" && "withCredentials" in new XMLHttpRequest(); + } catch (err) { + } + var hasCORS = value; + + // node_modules/.pnpm/engine.io-client@6.6.2/node_modules/engine.io-client/build/esm/transports/polling-xhr.js + function empty() { + } + var BaseXHR = class extends Polling { + /** + * XHR Polling constructor. + * + * @param {Object} opts + * @package + */ + constructor(opts) { + super(opts); + if (typeof location !== "undefined") { + const isSSL = "https:" === location.protocol; + let port = location.port; + if (!port) { + port = isSSL ? "443" : "80"; + } + this.xd = typeof location !== "undefined" && opts.hostname !== location.hostname || port !== opts.port; + } + } + /** + * Sends data. + * + * @param {String} data to send. + * @param {Function} called upon flush. + * @private + */ + doWrite(data, fn) { + const req = this.request({ + method: "POST", + data + }); + req.on("success", fn); + req.on("error", (xhrStatus, context) => { + this.onError("xhr post error", xhrStatus, context); + }); + } + /** + * Starts a poll cycle. + * + * @private + */ + doPoll() { + const req = this.request(); + req.on("data", this.onData.bind(this)); + req.on("error", (xhrStatus, context) => { + this.onError("xhr poll error", xhrStatus, context); + }); + this.pollXhr = req; + } + }; + var Request = class extends Emitter { + /** + * Request constructor + * + * @param {Object} options + * @package + */ + constructor(createRequest, uri, opts) { + super(); + this.createRequest = createRequest; + installTimerFunctions(this, opts); + this._opts = opts; + this._method = opts.method || "GET"; + this._uri = uri; + this._data = void 0 !== opts.data ? opts.data : null; + this._create(); + } + /** + * Creates the XHR object and sends the request. + * + * @private + */ + _create() { + var _a; + const opts = pick(this._opts, "agent", "pfx", "key", "passphrase", "cert", "ca", "ciphers", "rejectUnauthorized", "autoUnref"); + opts.xdomain = !!this._opts.xd; + const xhr = this._xhr = this.createRequest(opts); + try { + xhr.open(this._method, this._uri, true); + try { + if (this._opts.extraHeaders) { + xhr.setDisableHeaderCheck && xhr.setDisableHeaderCheck(true); + for (let i in this._opts.extraHeaders) { + if (this._opts.extraHeaders.hasOwnProperty(i)) { + xhr.setRequestHeader(i, this._opts.extraHeaders[i]); + } + } + } + } catch (e) { + } + if ("POST" === this._method) { + try { + xhr.setRequestHeader("Content-type", "text/plain;charset=UTF-8"); + } catch (e) { + } + } + try { + xhr.setRequestHeader("Accept", "*/*"); + } catch (e) { + } + (_a = this._opts.cookieJar) === null || _a === void 0 ? void 0 : _a.addCookies(xhr); + if ("withCredentials" in xhr) { + xhr.withCredentials = this._opts.withCredentials; + } + if (this._opts.requestTimeout) { + xhr.timeout = this._opts.requestTimeout; + } + xhr.onreadystatechange = () => { + var _a2; + if (xhr.readyState === 3) { + (_a2 = this._opts.cookieJar) === null || _a2 === void 0 ? void 0 : _a2.parseCookies( + // @ts-ignore + xhr.getResponseHeader("set-cookie") + ); + } + if (4 !== xhr.readyState) + return; + if (200 === xhr.status || 1223 === xhr.status) { + this._onLoad(); + } else { + this.setTimeoutFn(() => { + this._onError(typeof xhr.status === "number" ? xhr.status : 0); + }, 0); + } + }; + xhr.send(this._data); + } catch (e) { + this.setTimeoutFn(() => { + this._onError(e); + }, 0); + return; + } + if (typeof document !== "undefined") { + this._index = Request.requestsCount++; + Request.requests[this._index] = this; + } + } + /** + * Called upon error. + * + * @private + */ + _onError(err) { + this.emitReserved("error", err, this._xhr); + this._cleanup(true); + } + /** + * Cleans up house. + * + * @private + */ + _cleanup(fromError) { + if ("undefined" === typeof this._xhr || null === this._xhr) { + return; + } + this._xhr.onreadystatechange = empty; + if (fromError) { + try { + this._xhr.abort(); + } catch (e) { + } + } + if (typeof document !== "undefined") { + delete Request.requests[this._index]; + } + this._xhr = null; + } + /** + * Called upon load. + * + * @private + */ + _onLoad() { + const data = this._xhr.responseText; + if (data !== null) { + this.emitReserved("data", data); + this.emitReserved("success"); + this._cleanup(); + } + } + /** + * Aborts the request. + * + * @package + */ + abort() { + this._cleanup(); + } + }; + Request.requestsCount = 0; + Request.requests = {}; + if (typeof document !== "undefined") { + if (typeof attachEvent === "function") { + attachEvent("onunload", unloadHandler); + } else if (typeof addEventListener === "function") { + const terminationEvent = "onpagehide" in globalThisShim ? "pagehide" : "unload"; + addEventListener(terminationEvent, unloadHandler, false); + } + } + function unloadHandler() { + for (let i in Request.requests) { + if (Request.requests.hasOwnProperty(i)) { + Request.requests[i].abort(); + } + } + } + var hasXHR2 = function() { + const xhr = newRequest({ + xdomain: false + }); + return xhr && xhr.responseType !== null; + }(); + var XHR = class extends BaseXHR { + constructor(opts) { + super(opts); + const forceBase64 = opts && opts.forceBase64; + this.supportsBinary = hasXHR2 && !forceBase64; + } + request(opts = {}) { + Object.assign(opts, { xd: this.xd }, this.opts); + return new Request(newRequest, this.uri(), opts); + } + }; + function newRequest(opts) { + const xdomain = opts.xdomain; + try { + if ("undefined" !== typeof XMLHttpRequest && (!xdomain || hasCORS)) { + return new XMLHttpRequest(); + } + } catch (e) { + } + if (!xdomain) { + try { + return new globalThisShim[["Active"].concat("Object").join("X")]("Microsoft.XMLHTTP"); + } catch (e) { + } + } + } + + // node_modules/.pnpm/engine.io-client@6.6.2/node_modules/engine.io-client/build/esm/transports/websocket.js + var isReactNative = typeof navigator !== "undefined" && typeof navigator.product === "string" && navigator.product.toLowerCase() === "reactnative"; + var BaseWS = class extends Transport { + get name() { + return "websocket"; + } + doOpen() { + const uri = this.uri(); + const protocols = this.opts.protocols; + const opts = isReactNative ? {} : pick(this.opts, "agent", "perMessageDeflate", "pfx", "key", "passphrase", "cert", "ca", "ciphers", "rejectUnauthorized", "localAddress", "protocolVersion", "origin", "maxPayload", "family", "checkServerIdentity"); + if (this.opts.extraHeaders) { + opts.headers = this.opts.extraHeaders; + } + try { + this.ws = this.createSocket(uri, protocols, opts); + } catch (err) { + return this.emitReserved("error", err); + } + this.ws.binaryType = this.socket.binaryType; + this.addEventListeners(); + } + /** + * Adds event listeners to the socket + * + * @private + */ + addEventListeners() { + this.ws.onopen = () => { + if (this.opts.autoUnref) { + this.ws._socket.unref(); + } + this.onOpen(); + }; + this.ws.onclose = (closeEvent) => this.onClose({ + description: "websocket connection closed", + context: closeEvent + }); + this.ws.onmessage = (ev) => this.onData(ev.data); + this.ws.onerror = (e) => this.onError("websocket error", e); + } + write(packets) { + this.writable = false; + for (let i = 0; i < packets.length; i++) { + const packet = packets[i]; + const lastPacket = i === packets.length - 1; + encodePacket(packet, this.supportsBinary, (data) => { + try { + this.doWrite(packet, data); + } catch (e) { + } + if (lastPacket) { + nextTick(() => { + this.writable = true; + this.emitReserved("drain"); + }, this.setTimeoutFn); + } + }); + } + } + doClose() { + if (typeof this.ws !== "undefined") { + this.ws.onerror = () => { + }; + this.ws.close(); + this.ws = null; + } + } + /** + * Generates uri for connection. + * + * @private + */ + uri() { + const schema = this.opts.secure ? "wss" : "ws"; + const query = this.query || {}; + if (this.opts.timestampRequests) { + query[this.opts.timestampParam] = randomString(); + } + if (!this.supportsBinary) { + query.b64 = 1; + } + return this.createUri(schema, query); + } + }; + var WebSocketCtor = globalThisShim.WebSocket || globalThisShim.MozWebSocket; + var WS = class extends BaseWS { + createSocket(uri, protocols, opts) { + return !isReactNative ? protocols ? new WebSocketCtor(uri, protocols) : new WebSocketCtor(uri) : new WebSocketCtor(uri, protocols, opts); + } + doWrite(_packet, data) { + this.ws.send(data); + } + }; + + // node_modules/.pnpm/engine.io-client@6.6.2/node_modules/engine.io-client/build/esm/transports/webtransport.js + var WT = class extends Transport { + get name() { + return "webtransport"; + } + doOpen() { + try { + this._transport = new WebTransport(this.createUri("https"), this.opts.transportOptions[this.name]); + } catch (err) { + return this.emitReserved("error", err); + } + this._transport.closed.then(() => { + this.onClose(); + }).catch((err) => { + this.onError("webtransport error", err); + }); + this._transport.ready.then(() => { + this._transport.createBidirectionalStream().then((stream) => { + const decoderStream = createPacketDecoderStream(Number.MAX_SAFE_INTEGER, this.socket.binaryType); + const reader = stream.readable.pipeThrough(decoderStream).getReader(); + const encoderStream = createPacketEncoderStream(); + encoderStream.readable.pipeTo(stream.writable); + this._writer = encoderStream.writable.getWriter(); + const read = () => { + reader.read().then(({ done, value: value2 }) => { + if (done) { + return; + } + this.onPacket(value2); + read(); + }).catch((err) => { + }); + }; + read(); + const packet = { type: "open" }; + if (this.query.sid) { + packet.data = `{"sid":"${this.query.sid}"}`; + } + this._writer.write(packet).then(() => this.onOpen()); + }); + }); + } + write(packets) { + this.writable = false; + for (let i = 0; i < packets.length; i++) { + const packet = packets[i]; + const lastPacket = i === packets.length - 1; + this._writer.write(packet).then(() => { + if (lastPacket) { + nextTick(() => { + this.writable = true; + this.emitReserved("drain"); + }, this.setTimeoutFn); + } + }); + } + } + doClose() { + var _a; + (_a = this._transport) === null || _a === void 0 ? void 0 : _a.close(); + } + }; + + // node_modules/.pnpm/engine.io-client@6.6.2/node_modules/engine.io-client/build/esm/transports/index.js + var transports = { + websocket: WS, + webtransport: WT, + polling: XHR + }; + + // node_modules/.pnpm/engine.io-client@6.6.2/node_modules/engine.io-client/build/esm/contrib/parseuri.js + var re = /^(?:(?![^:@\/?#]+:[^:@\/]*@)(http|https|ws|wss):\/\/)?((?:(([^:@\/?#]*)(?::([^:@\/?#]*))?)?@)?((?:[a-f0-9]{0,4}:){2,7}[a-f0-9]{0,4}|[^:\/?#]*)(?::(\d*))?)(((\/(?:[^?#](?![^?#\/]*\.[^?#\/.]+(?:[?#]|$)))*\/?)?([^?#\/]*))(?:\?([^#]*))?(?:#(.*))?)/; + var parts = [ + "source", + "protocol", + "authority", + "userInfo", + "user", + "password", + "host", + "port", + "relative", + "path", + "directory", + "file", + "query", + "anchor" + ]; + function parse(str) { + if (str.length > 8e3) { + throw "URI too long"; + } + const src = str, b = str.indexOf("["), e = str.indexOf("]"); + if (b != -1 && e != -1) { + str = str.substring(0, b) + str.substring(b, e).replace(/:/g, ";") + str.substring(e, str.length); + } + let m = re.exec(str || ""), uri = {}, i = 14; + while (i--) { + uri[parts[i]] = m[i] || ""; + } + if (b != -1 && e != -1) { + uri.source = src; + uri.host = uri.host.substring(1, uri.host.length - 1).replace(/;/g, ":"); + uri.authority = uri.authority.replace("[", "").replace("]", "").replace(/;/g, ":"); + uri.ipv6uri = true; + } + uri.pathNames = pathNames(uri, uri["path"]); + uri.queryKey = queryKey(uri, uri["query"]); + return uri; + } + function pathNames(obj, path) { + const regx = /\/{2,9}/g, names = path.replace(regx, "/").split("/"); + if (path.slice(0, 1) == "/" || path.length === 0) { + names.splice(0, 1); + } + if (path.slice(-1) == "/") { + names.splice(names.length - 1, 1); + } + return names; + } + function queryKey(uri, query) { + const data = {}; + query.replace(/(?:^|&)([^&=]*)=?([^&]*)/g, function($0, $1, $2) { + if ($1) { + data[$1] = $2; + } + }); + return data; + } + + // node_modules/.pnpm/engine.io-client@6.6.2/node_modules/engine.io-client/build/esm/socket.js + var withEventListeners = typeof addEventListener === "function" && typeof removeEventListener === "function"; + var OFFLINE_EVENT_LISTENERS = []; + if (withEventListeners) { + addEventListener("offline", () => { + OFFLINE_EVENT_LISTENERS.forEach((listener) => listener()); + }, false); + } + var SocketWithoutUpgrade = class extends Emitter { + /** + * Socket constructor. + * + * @param {String|Object} uri - uri or options + * @param {Object} opts - options + */ + constructor(uri, opts) { + super(); + this.binaryType = defaultBinaryType; + this.writeBuffer = []; + this._prevBufferLen = 0; + this._pingInterval = -1; + this._pingTimeout = -1; + this._maxPayload = -1; + this._pingTimeoutTime = Infinity; + if (uri && "object" === typeof uri) { + opts = uri; + uri = null; + } + if (uri) { + const parsedUri = parse(uri); + opts.hostname = parsedUri.host; + opts.secure = parsedUri.protocol === "https" || parsedUri.protocol === "wss"; + opts.port = parsedUri.port; + if (parsedUri.query) + opts.query = parsedUri.query; + } else if (opts.host) { + opts.hostname = parse(opts.host).host; + } + installTimerFunctions(this, opts); + this.secure = null != opts.secure ? opts.secure : typeof location !== "undefined" && "https:" === location.protocol; + if (opts.hostname && !opts.port) { + opts.port = this.secure ? "443" : "80"; + } + this.hostname = opts.hostname || (typeof location !== "undefined" ? location.hostname : "localhost"); + this.port = opts.port || (typeof location !== "undefined" && location.port ? location.port : this.secure ? "443" : "80"); + this.transports = []; + this._transportsByName = {}; + opts.transports.forEach((t) => { + const transportName = t.prototype.name; + this.transports.push(transportName); + this._transportsByName[transportName] = t; + }); + this.opts = Object.assign({ + path: "/engine.io", + agent: false, + withCredentials: false, + upgrade: true, + timestampParam: "t", + rememberUpgrade: false, + addTrailingSlash: true, + rejectUnauthorized: true, + perMessageDeflate: { + threshold: 1024 + }, + transportOptions: {}, + closeOnBeforeunload: false + }, opts); + this.opts.path = this.opts.path.replace(/\/$/, "") + (this.opts.addTrailingSlash ? "/" : ""); + if (typeof this.opts.query === "string") { + this.opts.query = decode2(this.opts.query); + } + if (withEventListeners) { + if (this.opts.closeOnBeforeunload) { + this._beforeunloadEventListener = () => { + if (this.transport) { + this.transport.removeAllListeners(); + this.transport.close(); + } + }; + addEventListener("beforeunload", this._beforeunloadEventListener, false); + } + if (this.hostname !== "localhost") { + this._offlineEventListener = () => { + this._onClose("transport close", { + description: "network connection lost" + }); + }; + OFFLINE_EVENT_LISTENERS.push(this._offlineEventListener); + } + } + if (this.opts.withCredentials) { + this._cookieJar = createCookieJar(); + } + this._open(); + } + /** + * Creates transport of the given type. + * + * @param {String} name - transport name + * @return {Transport} + * @private + */ + createTransport(name) { + const query = Object.assign({}, this.opts.query); + query.EIO = protocol; + query.transport = name; + if (this.id) + query.sid = this.id; + const opts = Object.assign({}, this.opts, { + query, + socket: this, + hostname: this.hostname, + secure: this.secure, + port: this.port + }, this.opts.transportOptions[name]); + return new this._transportsByName[name](opts); + } + /** + * Initializes transport to use and starts probe. + * + * @private + */ + _open() { + if (this.transports.length === 0) { + this.setTimeoutFn(() => { + this.emitReserved("error", "No transports available"); + }, 0); + return; + } + const transportName = this.opts.rememberUpgrade && SocketWithoutUpgrade.priorWebsocketSuccess && this.transports.indexOf("websocket") !== -1 ? "websocket" : this.transports[0]; + this.readyState = "opening"; + const transport = this.createTransport(transportName); + transport.open(); + this.setTransport(transport); + } + /** + * Sets the current transport. Disables the existing one (if any). + * + * @private + */ + setTransport(transport) { + if (this.transport) { + this.transport.removeAllListeners(); + } + this.transport = transport; + transport.on("drain", this._onDrain.bind(this)).on("packet", this._onPacket.bind(this)).on("error", this._onError.bind(this)).on("close", (reason) => this._onClose("transport close", reason)); + } + /** + * Called when connection is deemed open. + * + * @private + */ + onOpen() { + this.readyState = "open"; + SocketWithoutUpgrade.priorWebsocketSuccess = "websocket" === this.transport.name; + this.emitReserved("open"); + this.flush(); + } + /** + * Handles a packet. + * + * @private + */ + _onPacket(packet) { + if ("opening" === this.readyState || "open" === this.readyState || "closing" === this.readyState) { + this.emitReserved("packet", packet); + this.emitReserved("heartbeat"); + switch (packet.type) { + case "open": + this.onHandshake(JSON.parse(packet.data)); + break; + case "ping": + this._sendPacket("pong"); + this.emitReserved("ping"); + this.emitReserved("pong"); + this._resetPingTimeout(); + break; + case "error": + const err = new Error("server error"); + err.code = packet.data; + this._onError(err); + break; + case "message": + this.emitReserved("data", packet.data); + this.emitReserved("message", packet.data); + break; + } + } else { + } + } + /** + * Called upon handshake completion. + * + * @param {Object} data - handshake obj + * @private + */ + onHandshake(data) { + this.emitReserved("handshake", data); + this.id = data.sid; + this.transport.query.sid = data.sid; + this._pingInterval = data.pingInterval; + this._pingTimeout = data.pingTimeout; + this._maxPayload = data.maxPayload; + this.onOpen(); + if ("closed" === this.readyState) + return; + this._resetPingTimeout(); + } + /** + * Sets and resets ping timeout timer based on server pings. + * + * @private + */ + _resetPingTimeout() { + this.clearTimeoutFn(this._pingTimeoutTimer); + const delay = this._pingInterval + this._pingTimeout; + this._pingTimeoutTime = Date.now() + delay; + this._pingTimeoutTimer = this.setTimeoutFn(() => { + this._onClose("ping timeout"); + }, delay); + if (this.opts.autoUnref) { + this._pingTimeoutTimer.unref(); + } + } + /** + * Called on `drain` event + * + * @private + */ + _onDrain() { + this.writeBuffer.splice(0, this._prevBufferLen); + this._prevBufferLen = 0; + if (0 === this.writeBuffer.length) { + this.emitReserved("drain"); + } else { + this.flush(); + } + } + /** + * Flush write buffers. + * + * @private + */ + flush() { + if ("closed" !== this.readyState && this.transport.writable && !this.upgrading && this.writeBuffer.length) { + const packets = this._getWritablePackets(); + this.transport.send(packets); + this._prevBufferLen = packets.length; + this.emitReserved("flush"); + } + } + /** + * Ensure the encoded size of the writeBuffer is below the maxPayload value sent by the server (only for HTTP + * long-polling) + * + * @private + */ + _getWritablePackets() { + const shouldCheckPayloadSize = this._maxPayload && this.transport.name === "polling" && this.writeBuffer.length > 1; + if (!shouldCheckPayloadSize) { + return this.writeBuffer; + } + let payloadSize = 1; + for (let i = 0; i < this.writeBuffer.length; i++) { + const data = this.writeBuffer[i].data; + if (data) { + payloadSize += byteLength(data); + } + if (i > 0 && payloadSize > this._maxPayload) { + return this.writeBuffer.slice(0, i); + } + payloadSize += 2; + } + return this.writeBuffer; + } + /** + * Checks whether the heartbeat timer has expired but the socket has not yet been notified. + * + * Note: this method is private for now because it does not really fit the WebSocket API, but if we put it in the + * `write()` method then the message would not be buffered by the Socket.IO client. + * + * @return {boolean} + * @private + */ + /* private */ + _hasPingExpired() { + if (!this._pingTimeoutTime) + return true; + const hasExpired = Date.now() > this._pingTimeoutTime; + if (hasExpired) { + this._pingTimeoutTime = 0; + nextTick(() => { + this._onClose("ping timeout"); + }, this.setTimeoutFn); + } + return hasExpired; + } + /** + * Sends a message. + * + * @param {String} msg - message. + * @param {Object} options. + * @param {Function} fn - callback function. + * @return {Socket} for chaining. + */ + write(msg, options, fn) { + this._sendPacket("message", msg, options, fn); + return this; + } + /** + * Sends a message. Alias of {@link Socket#write}. + * + * @param {String} msg - message. + * @param {Object} options. + * @param {Function} fn - callback function. + * @return {Socket} for chaining. + */ + send(msg, options, fn) { + this._sendPacket("message", msg, options, fn); + return this; + } + /** + * Sends a packet. + * + * @param {String} type: packet type. + * @param {String} data. + * @param {Object} options. + * @param {Function} fn - callback function. + * @private + */ + _sendPacket(type, data, options, fn) { + if ("function" === typeof data) { + fn = data; + data = void 0; + } + if ("function" === typeof options) { + fn = options; + options = null; + } + if ("closing" === this.readyState || "closed" === this.readyState) { + return; + } + options = options || {}; + options.compress = false !== options.compress; + const packet = { + type, + data, + options + }; + this.emitReserved("packetCreate", packet); + this.writeBuffer.push(packet); + if (fn) + this.once("flush", fn); + this.flush(); + } + /** + * Closes the connection. + */ + close() { + const close = () => { + this._onClose("forced close"); + this.transport.close(); + }; + const cleanupAndClose = () => { + this.off("upgrade", cleanupAndClose); + this.off("upgradeError", cleanupAndClose); + close(); + }; + const waitForUpgrade = () => { + this.once("upgrade", cleanupAndClose); + this.once("upgradeError", cleanupAndClose); + }; + if ("opening" === this.readyState || "open" === this.readyState) { + this.readyState = "closing"; + if (this.writeBuffer.length) { + this.once("drain", () => { + if (this.upgrading) { + waitForUpgrade(); + } else { + close(); + } + }); + } else if (this.upgrading) { + waitForUpgrade(); + } else { + close(); + } + } + return this; + } + /** + * Called upon transport error + * + * @private + */ + _onError(err) { + SocketWithoutUpgrade.priorWebsocketSuccess = false; + if (this.opts.tryAllTransports && this.transports.length > 1 && this.readyState === "opening") { + this.transports.shift(); + return this._open(); + } + this.emitReserved("error", err); + this._onClose("transport error", err); + } + /** + * Called upon transport close. + * + * @private + */ + _onClose(reason, description) { + if ("opening" === this.readyState || "open" === this.readyState || "closing" === this.readyState) { + this.clearTimeoutFn(this._pingTimeoutTimer); + this.transport.removeAllListeners("close"); + this.transport.close(); + this.transport.removeAllListeners(); + if (withEventListeners) { + if (this._beforeunloadEventListener) { + removeEventListener("beforeunload", this._beforeunloadEventListener, false); + } + if (this._offlineEventListener) { + const i = OFFLINE_EVENT_LISTENERS.indexOf(this._offlineEventListener); + if (i !== -1) { + OFFLINE_EVENT_LISTENERS.splice(i, 1); + } + } + } + this.readyState = "closed"; + this.id = null; + this.emitReserved("close", reason, description); + this.writeBuffer = []; + this._prevBufferLen = 0; + } + } + }; + SocketWithoutUpgrade.protocol = protocol; + var SocketWithUpgrade = class extends SocketWithoutUpgrade { + constructor() { + super(...arguments); + this._upgrades = []; + } + onOpen() { + super.onOpen(); + if ("open" === this.readyState && this.opts.upgrade) { + for (let i = 0; i < this._upgrades.length; i++) { + this._probe(this._upgrades[i]); + } + } + } + /** + * Probes a transport. + * + * @param {String} name - transport name + * @private + */ + _probe(name) { + let transport = this.createTransport(name); + let failed = false; + SocketWithoutUpgrade.priorWebsocketSuccess = false; + const onTransportOpen = () => { + if (failed) + return; + transport.send([{ type: "ping", data: "probe" }]); + transport.once("packet", (msg) => { + if (failed) + return; + if ("pong" === msg.type && "probe" === msg.data) { + this.upgrading = true; + this.emitReserved("upgrading", transport); + if (!transport) + return; + SocketWithoutUpgrade.priorWebsocketSuccess = "websocket" === transport.name; + this.transport.pause(() => { + if (failed) + return; + if ("closed" === this.readyState) + return; + cleanup(); + this.setTransport(transport); + transport.send([{ type: "upgrade" }]); + this.emitReserved("upgrade", transport); + transport = null; + this.upgrading = false; + this.flush(); + }); + } else { + const err = new Error("probe error"); + err.transport = transport.name; + this.emitReserved("upgradeError", err); + } + }); + }; + function freezeTransport() { + if (failed) + return; + failed = true; + cleanup(); + transport.close(); + transport = null; + } + const onerror = (err) => { + const error = new Error("probe error: " + err); + error.transport = transport.name; + freezeTransport(); + this.emitReserved("upgradeError", error); + }; + function onTransportClose() { + onerror("transport closed"); + } + function onclose() { + onerror("socket closed"); + } + function onupgrade(to) { + if (transport && to.name !== transport.name) { + freezeTransport(); + } + } + const cleanup = () => { + transport.removeListener("open", onTransportOpen); + transport.removeListener("error", onerror); + transport.removeListener("close", onTransportClose); + this.off("close", onclose); + this.off("upgrading", onupgrade); + }; + transport.once("open", onTransportOpen); + transport.once("error", onerror); + transport.once("close", onTransportClose); + this.once("close", onclose); + this.once("upgrading", onupgrade); + if (this._upgrades.indexOf("webtransport") !== -1 && name !== "webtransport") { + this.setTimeoutFn(() => { + if (!failed) { + transport.open(); + } + }, 200); + } else { + transport.open(); + } + } + onHandshake(data) { + this._upgrades = this._filterUpgrades(data.upgrades); + super.onHandshake(data); + } + /** + * Filters upgrades, returning only those matching client transports. + * + * @param {Array} upgrades - server upgrades + * @private + */ + _filterUpgrades(upgrades) { + const filteredUpgrades = []; + for (let i = 0; i < upgrades.length; i++) { + if (~this.transports.indexOf(upgrades[i])) + filteredUpgrades.push(upgrades[i]); + } + return filteredUpgrades; + } + }; + var Socket = class extends SocketWithUpgrade { + constructor(uri, opts = {}) { + const o = typeof uri === "object" ? uri : opts; + if (!o.transports || o.transports && typeof o.transports[0] === "string") { + o.transports = (o.transports || ["polling", "websocket", "webtransport"]).map((transportName) => transports[transportName]).filter((t) => !!t); + } + super(uri, o); + } + }; + + // node_modules/.pnpm/engine.io-client@6.6.2/node_modules/engine.io-client/build/esm/index.js + var protocol2 = Socket.protocol; + + // node_modules/.pnpm/socket.io-client@4.8.1/node_modules/socket.io-client/build/esm/url.js + function url(uri, path = "", loc) { + let obj = uri; + loc = loc || typeof location !== "undefined" && location; + if (null == uri) + uri = loc.protocol + "//" + loc.host; + if (typeof uri === "string") { + if ("/" === uri.charAt(0)) { + if ("/" === uri.charAt(1)) { + uri = loc.protocol + uri; + } else { + uri = loc.host + uri; + } + } + if (!/^(https?|wss?):\/\//.test(uri)) { + if ("undefined" !== typeof loc) { + uri = loc.protocol + "//" + uri; + } else { + uri = "https://" + uri; + } + } + obj = parse(uri); + } + if (!obj.port) { + if (/^(http|ws)$/.test(obj.protocol)) { + obj.port = "80"; + } else if (/^(http|ws)s$/.test(obj.protocol)) { + obj.port = "443"; + } + } + obj.path = obj.path || "/"; + const ipv6 = obj.host.indexOf(":") !== -1; + const host = ipv6 ? "[" + obj.host + "]" : obj.host; + obj.id = obj.protocol + "://" + host + ":" + obj.port + path; + obj.href = obj.protocol + "://" + host + (loc && loc.port === obj.port ? "" : ":" + obj.port); + return obj; + } + + // node_modules/.pnpm/socket.io-parser@4.2.4/node_modules/socket.io-parser/build/esm/index.js + var esm_exports = {}; + __export(esm_exports, { + Decoder: () => Decoder, + Encoder: () => Encoder, + PacketType: () => PacketType, + protocol: () => protocol3 + }); + + // node_modules/.pnpm/socket.io-parser@4.2.4/node_modules/socket.io-parser/build/esm/is-binary.js + var withNativeArrayBuffer3 = typeof ArrayBuffer === "function"; + var isView2 = (obj) => { + return typeof ArrayBuffer.isView === "function" ? ArrayBuffer.isView(obj) : obj.buffer instanceof ArrayBuffer; + }; + var toString = Object.prototype.toString; + var withNativeBlob2 = typeof Blob === "function" || typeof Blob !== "undefined" && toString.call(Blob) === "[object BlobConstructor]"; + var withNativeFile = typeof File === "function" || typeof File !== "undefined" && toString.call(File) === "[object FileConstructor]"; + function isBinary(obj) { + return withNativeArrayBuffer3 && (obj instanceof ArrayBuffer || isView2(obj)) || withNativeBlob2 && obj instanceof Blob || withNativeFile && obj instanceof File; + } + function hasBinary(obj, toJSON) { + if (!obj || typeof obj !== "object") { + return false; + } + if (Array.isArray(obj)) { + for (let i = 0, l = obj.length; i < l; i++) { + if (hasBinary(obj[i])) { + return true; + } + } + return false; + } + if (isBinary(obj)) { + return true; + } + if (obj.toJSON && typeof obj.toJSON === "function" && arguments.length === 1) { + return hasBinary(obj.toJSON(), true); + } + for (const key in obj) { + if (Object.prototype.hasOwnProperty.call(obj, key) && hasBinary(obj[key])) { + return true; + } + } + return false; + } + + // node_modules/.pnpm/socket.io-parser@4.2.4/node_modules/socket.io-parser/build/esm/binary.js + function deconstructPacket(packet) { + const buffers = []; + const packetData = packet.data; + const pack = packet; + pack.data = _deconstructPacket(packetData, buffers); + pack.attachments = buffers.length; + return { packet: pack, buffers }; + } + function _deconstructPacket(data, buffers) { + if (!data) + return data; + if (isBinary(data)) { + const placeholder = { _placeholder: true, num: buffers.length }; + buffers.push(data); + return placeholder; + } else if (Array.isArray(data)) { + const newData = new Array(data.length); + for (let i = 0; i < data.length; i++) { + newData[i] = _deconstructPacket(data[i], buffers); + } + return newData; + } else if (typeof data === "object" && !(data instanceof Date)) { + const newData = {}; + for (const key in data) { + if (Object.prototype.hasOwnProperty.call(data, key)) { + newData[key] = _deconstructPacket(data[key], buffers); + } + } + return newData; + } + return data; + } + function reconstructPacket(packet, buffers) { + packet.data = _reconstructPacket(packet.data, buffers); + delete packet.attachments; + return packet; + } + function _reconstructPacket(data, buffers) { + if (!data) + return data; + if (data && data._placeholder === true) { + const isIndexValid = typeof data.num === "number" && data.num >= 0 && data.num < buffers.length; + if (isIndexValid) { + return buffers[data.num]; + } else { + throw new Error("illegal attachments"); + } + } else if (Array.isArray(data)) { + for (let i = 0; i < data.length; i++) { + data[i] = _reconstructPacket(data[i], buffers); + } + } else if (typeof data === "object") { + for (const key in data) { + if (Object.prototype.hasOwnProperty.call(data, key)) { + data[key] = _reconstructPacket(data[key], buffers); + } + } + } + return data; + } + + // node_modules/.pnpm/socket.io-parser@4.2.4/node_modules/socket.io-parser/build/esm/index.js + var RESERVED_EVENTS = [ + "connect", + "connect_error", + "disconnect", + "disconnecting", + "newListener", + "removeListener" + // used by the Node.js EventEmitter + ]; + var protocol3 = 5; + var PacketType; + (function(PacketType2) { + PacketType2[PacketType2["CONNECT"] = 0] = "CONNECT"; + PacketType2[PacketType2["DISCONNECT"] = 1] = "DISCONNECT"; + PacketType2[PacketType2["EVENT"] = 2] = "EVENT"; + PacketType2[PacketType2["ACK"] = 3] = "ACK"; + PacketType2[PacketType2["CONNECT_ERROR"] = 4] = "CONNECT_ERROR"; + PacketType2[PacketType2["BINARY_EVENT"] = 5] = "BINARY_EVENT"; + PacketType2[PacketType2["BINARY_ACK"] = 6] = "BINARY_ACK"; + })(PacketType || (PacketType = {})); + var Encoder = class { + /** + * Encoder constructor + * + * @param {function} replacer - custom replacer to pass down to JSON.parse + */ + constructor(replacer) { + this.replacer = replacer; + } + /** + * Encode a packet as a single string if non-binary, or as a + * buffer sequence, depending on packet type. + * + * @param {Object} obj - packet object + */ + encode(obj) { + if (obj.type === PacketType.EVENT || obj.type === PacketType.ACK) { + if (hasBinary(obj)) { + return this.encodeAsBinary({ + type: obj.type === PacketType.EVENT ? PacketType.BINARY_EVENT : PacketType.BINARY_ACK, + nsp: obj.nsp, + data: obj.data, + id: obj.id + }); + } + } + return [this.encodeAsString(obj)]; + } + /** + * Encode packet as string. + */ + encodeAsString(obj) { + let str = "" + obj.type; + if (obj.type === PacketType.BINARY_EVENT || obj.type === PacketType.BINARY_ACK) { + str += obj.attachments + "-"; + } + if (obj.nsp && "/" !== obj.nsp) { + str += obj.nsp + ","; + } + if (null != obj.id) { + str += obj.id; + } + if (null != obj.data) { + str += JSON.stringify(obj.data, this.replacer); + } + return str; + } + /** + * Encode packet as 'buffer sequence' by removing blobs, and + * deconstructing packet into object with placeholders and + * a list of buffers. + */ + encodeAsBinary(obj) { + const deconstruction = deconstructPacket(obj); + const pack = this.encodeAsString(deconstruction.packet); + const buffers = deconstruction.buffers; + buffers.unshift(pack); + return buffers; + } + }; + function isObject2(value2) { + return Object.prototype.toString.call(value2) === "[object Object]"; + } + var Decoder = class extends Emitter { + /** + * Decoder constructor + * + * @param {function} reviver - custom reviver to pass down to JSON.stringify + */ + constructor(reviver) { + super(); + this.reviver = reviver; + } + /** + * Decodes an encoded packet string into packet JSON. + * + * @param {String} obj - encoded packet + */ + add(obj) { + let packet; + if (typeof obj === "string") { + if (this.reconstructor) { + throw new Error("got plaintext data when reconstructing a packet"); + } + packet = this.decodeString(obj); + const isBinaryEvent = packet.type === PacketType.BINARY_EVENT; + if (isBinaryEvent || packet.type === PacketType.BINARY_ACK) { + packet.type = isBinaryEvent ? PacketType.EVENT : PacketType.ACK; + this.reconstructor = new BinaryReconstructor(packet); + if (packet.attachments === 0) { + super.emitReserved("decoded", packet); + } + } else { + super.emitReserved("decoded", packet); + } + } else if (isBinary(obj) || obj.base64) { + if (!this.reconstructor) { + throw new Error("got binary data when not reconstructing a packet"); + } else { + packet = this.reconstructor.takeBinaryData(obj); + if (packet) { + this.reconstructor = null; + super.emitReserved("decoded", packet); + } + } + } else { + throw new Error("Unknown type: " + obj); + } + } + /** + * Decode a packet String (JSON data) + * + * @param {String} str + * @return {Object} packet + */ + decodeString(str) { + let i = 0; + const p = { + type: Number(str.charAt(0)) + }; + if (PacketType[p.type] === void 0) { + throw new Error("unknown packet type " + p.type); + } + if (p.type === PacketType.BINARY_EVENT || p.type === PacketType.BINARY_ACK) { + const start = i + 1; + while (str.charAt(++i) !== "-" && i != str.length) { + } + const buf = str.substring(start, i); + if (buf != Number(buf) || str.charAt(i) !== "-") { + throw new Error("Illegal attachments"); + } + p.attachments = Number(buf); + } + if ("/" === str.charAt(i + 1)) { + const start = i + 1; + while (++i) { + const c = str.charAt(i); + if ("," === c) + break; + if (i === str.length) + break; + } + p.nsp = str.substring(start, i); + } else { + p.nsp = "/"; + } + const next = str.charAt(i + 1); + if ("" !== next && Number(next) == next) { + const start = i + 1; + while (++i) { + const c = str.charAt(i); + if (null == c || Number(c) != c) { + --i; + break; + } + if (i === str.length) + break; + } + p.id = Number(str.substring(start, i + 1)); + } + if (str.charAt(++i)) { + const payload = this.tryParse(str.substr(i)); + if (Decoder.isPayloadValid(p.type, payload)) { + p.data = payload; + } else { + throw new Error("invalid payload"); + } + } + return p; + } + tryParse(str) { + try { + return JSON.parse(str, this.reviver); + } catch (e) { + return false; + } + } + static isPayloadValid(type, payload) { + switch (type) { + case PacketType.CONNECT: + return isObject2(payload); + case PacketType.DISCONNECT: + return payload === void 0; + case PacketType.CONNECT_ERROR: + return typeof payload === "string" || isObject2(payload); + case PacketType.EVENT: + case PacketType.BINARY_EVENT: + return Array.isArray(payload) && (typeof payload[0] === "number" || typeof payload[0] === "string" && RESERVED_EVENTS.indexOf(payload[0]) === -1); + case PacketType.ACK: + case PacketType.BINARY_ACK: + return Array.isArray(payload); + } + } + /** + * Deallocates a parser's resources + */ + destroy() { + if (this.reconstructor) { + this.reconstructor.finishedReconstruction(); + this.reconstructor = null; + } + } + }; + var BinaryReconstructor = class { + constructor(packet) { + this.packet = packet; + this.buffers = []; + this.reconPack = packet; + } + /** + * Method to be called when binary data received from connection + * after a BINARY_EVENT packet. + * + * @param {Buffer | ArrayBuffer} binData - the raw binary data received + * @return {null | Object} returns null if more binary data is expected or + * a reconstructed packet object if all buffers have been received. + */ + takeBinaryData(binData) { + this.buffers.push(binData); + if (this.buffers.length === this.reconPack.attachments) { + const packet = reconstructPacket(this.reconPack, this.buffers); + this.finishedReconstruction(); + return packet; + } + return null; + } + /** + * Cleans up binary packet reconstruction variables. + */ + finishedReconstruction() { + this.reconPack = null; + this.buffers = []; + } + }; + + // node_modules/.pnpm/socket.io-client@4.8.1/node_modules/socket.io-client/build/esm/on.js + function on(obj, ev, fn) { + obj.on(ev, fn); + return function subDestroy() { + obj.off(ev, fn); + }; + } + + // node_modules/.pnpm/socket.io-client@4.8.1/node_modules/socket.io-client/build/esm/socket.js + var RESERVED_EVENTS2 = Object.freeze({ + connect: 1, + connect_error: 1, + disconnect: 1, + disconnecting: 1, + // EventEmitter reserved events: https://nodejs.org/api/events.html#events_event_newlistener + newListener: 1, + removeListener: 1 + }); + var Socket2 = class extends Emitter { + /** + * `Socket` constructor. + */ + constructor(io, nsp, opts) { + super(); + this.connected = false; + this.recovered = false; + this.receiveBuffer = []; + this.sendBuffer = []; + this._queue = []; + this._queueSeq = 0; + this.ids = 0; + this.acks = {}; + this.flags = {}; + this.io = io; + this.nsp = nsp; + if (opts && opts.auth) { + this.auth = opts.auth; + } + this._opts = Object.assign({}, opts); + if (this.io._autoConnect) + this.open(); + } + /** + * Whether the socket is currently disconnected + * + * @example + * const socket = io(); + * + * socket.on("connect", () => { + * console.log(socket.disconnected); // false + * }); + * + * socket.on("disconnect", () => { + * console.log(socket.disconnected); // true + * }); + */ + get disconnected() { + return !this.connected; + } + /** + * Subscribe to open, close and packet events + * + * @private + */ + subEvents() { + if (this.subs) + return; + const io = this.io; + this.subs = [ + on(io, "open", this.onopen.bind(this)), + on(io, "packet", this.onpacket.bind(this)), + on(io, "error", this.onerror.bind(this)), + on(io, "close", this.onclose.bind(this)) + ]; + } + /** + * Whether the Socket will try to reconnect when its Manager connects or reconnects. + * + * @example + * const socket = io(); + * + * console.log(socket.active); // true + * + * socket.on("disconnect", (reason) => { + * if (reason === "io server disconnect") { + * // the disconnection was initiated by the server, you need to manually reconnect + * console.log(socket.active); // false + * } + * // else the socket will automatically try to reconnect + * console.log(socket.active); // true + * }); + */ + get active() { + return !!this.subs; + } + /** + * "Opens" the socket. + * + * @example + * const socket = io({ + * autoConnect: false + * }); + * + * socket.connect(); + */ + connect() { + if (this.connected) + return this; + this.subEvents(); + if (!this.io["_reconnecting"]) + this.io.open(); + if ("open" === this.io._readyState) + this.onopen(); + return this; + } + /** + * Alias for {@link connect()}. + */ + open() { + return this.connect(); + } + /** + * Sends a `message` event. + * + * This method mimics the WebSocket.send() method. + * + * @see https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/send + * + * @example + * socket.send("hello"); + * + * // this is equivalent to + * socket.emit("message", "hello"); + * + * @return self + */ + send(...args) { + args.unshift("message"); + this.emit.apply(this, args); + return this; + } + /** + * Override `emit`. + * If the event is in `events`, it's emitted normally. + * + * @example + * socket.emit("hello", "world"); + * + * // all serializable datastructures are supported (no need to call JSON.stringify) + * socket.emit("hello", 1, "2", { 3: ["4"], 5: Uint8Array.from([6]) }); + * + * // with an acknowledgement from the server + * socket.emit("hello", "world", (val) => { + * // ... + * }); + * + * @return self + */ + emit(ev, ...args) { + var _a, _b, _c; + if (RESERVED_EVENTS2.hasOwnProperty(ev)) { + throw new Error('"' + ev.toString() + '" is a reserved event name'); + } + args.unshift(ev); + if (this._opts.retries && !this.flags.fromQueue && !this.flags.volatile) { + this._addToQueue(args); + return this; + } + const packet = { + type: PacketType.EVENT, + data: args + }; + packet.options = {}; + packet.options.compress = this.flags.compress !== false; + if ("function" === typeof args[args.length - 1]) { + const id = this.ids++; + const ack = args.pop(); + this._registerAckCallback(id, ack); + packet.id = id; + } + const isTransportWritable = (_b = (_a = this.io.engine) === null || _a === void 0 ? void 0 : _a.transport) === null || _b === void 0 ? void 0 : _b.writable; + const isConnected = this.connected && !((_c = this.io.engine) === null || _c === void 0 ? void 0 : _c._hasPingExpired()); + const discardPacket = this.flags.volatile && !isTransportWritable; + if (discardPacket) { + } else if (isConnected) { + this.notifyOutgoingListeners(packet); + this.packet(packet); + } else { + this.sendBuffer.push(packet); + } + this.flags = {}; + return this; + } + /** + * @private + */ + _registerAckCallback(id, ack) { + var _a; + const timeout = (_a = this.flags.timeout) !== null && _a !== void 0 ? _a : this._opts.ackTimeout; + if (timeout === void 0) { + this.acks[id] = ack; + return; + } + const timer = this.io.setTimeoutFn(() => { + delete this.acks[id]; + for (let i = 0; i < this.sendBuffer.length; i++) { + if (this.sendBuffer[i].id === id) { + this.sendBuffer.splice(i, 1); + } + } + ack.call(this, new Error("operation has timed out")); + }, timeout); + const fn = (...args) => { + this.io.clearTimeoutFn(timer); + ack.apply(this, args); + }; + fn.withError = true; + this.acks[id] = fn; + } + /** + * Emits an event and waits for an acknowledgement + * + * @example + * // without timeout + * const response = await socket.emitWithAck("hello", "world"); + * + * // with a specific timeout + * try { + * const response = await socket.timeout(1000).emitWithAck("hello", "world"); + * } catch (err) { + * // the server did not acknowledge the event in the given delay + * } + * + * @return a Promise that will be fulfilled when the server acknowledges the event + */ + emitWithAck(ev, ...args) { + return new Promise((resolve, reject) => { + const fn = (arg1, arg2) => { + return arg1 ? reject(arg1) : resolve(arg2); + }; + fn.withError = true; + args.push(fn); + this.emit(ev, ...args); + }); + } + /** + * Add the packet to the queue. + * @param args + * @private + */ + _addToQueue(args) { + let ack; + if (typeof args[args.length - 1] === "function") { + ack = args.pop(); + } + const packet = { + id: this._queueSeq++, + tryCount: 0, + pending: false, + args, + flags: Object.assign({ fromQueue: true }, this.flags) + }; + args.push((err, ...responseArgs) => { + if (packet !== this._queue[0]) { + return; + } + const hasError = err !== null; + if (hasError) { + if (packet.tryCount > this._opts.retries) { + this._queue.shift(); + if (ack) { + ack(err); + } + } + } else { + this._queue.shift(); + if (ack) { + ack(null, ...responseArgs); + } + } + packet.pending = false; + return this._drainQueue(); + }); + this._queue.push(packet); + this._drainQueue(); + } + /** + * Send the first packet of the queue, and wait for an acknowledgement from the server. + * @param force - whether to resend a packet that has not been acknowledged yet + * + * @private + */ + _drainQueue(force = false) { + if (!this.connected || this._queue.length === 0) { + return; + } + const packet = this._queue[0]; + if (packet.pending && !force) { + return; + } + packet.pending = true; + packet.tryCount++; + this.flags = packet.flags; + this.emit.apply(this, packet.args); + } + /** + * Sends a packet. + * + * @param packet + * @private + */ + packet(packet) { + packet.nsp = this.nsp; + this.io._packet(packet); + } + /** + * Called upon engine `open`. + * + * @private + */ + onopen() { + if (typeof this.auth == "function") { + this.auth((data) => { + this._sendConnectPacket(data); + }); + } else { + this._sendConnectPacket(this.auth); + } + } + /** + * Sends a CONNECT packet to initiate the Socket.IO session. + * + * @param data + * @private + */ + _sendConnectPacket(data) { + this.packet({ + type: PacketType.CONNECT, + data: this._pid ? Object.assign({ pid: this._pid, offset: this._lastOffset }, data) : data + }); + } + /** + * Called upon engine or manager `error`. + * + * @param err + * @private + */ + onerror(err) { + if (!this.connected) { + this.emitReserved("connect_error", err); + } + } + /** + * Called upon engine `close`. + * + * @param reason + * @param description + * @private + */ + onclose(reason, description) { + this.connected = false; + delete this.id; + this.emitReserved("disconnect", reason, description); + this._clearAcks(); + } + /** + * Clears the acknowledgement handlers upon disconnection, since the client will never receive an acknowledgement from + * the server. + * + * @private + */ + _clearAcks() { + Object.keys(this.acks).forEach((id) => { + const isBuffered = this.sendBuffer.some((packet) => String(packet.id) === id); + if (!isBuffered) { + const ack = this.acks[id]; + delete this.acks[id]; + if (ack.withError) { + ack.call(this, new Error("socket has been disconnected")); + } + } + }); + } + /** + * Called with socket packet. + * + * @param packet + * @private + */ + onpacket(packet) { + const sameNamespace = packet.nsp === this.nsp; + if (!sameNamespace) + return; + switch (packet.type) { + case PacketType.CONNECT: + if (packet.data && packet.data.sid) { + this.onconnect(packet.data.sid, packet.data.pid); + } else { + this.emitReserved("connect_error", new Error("It seems you are trying to reach a Socket.IO server in v2.x with a v3.x client, but they are not compatible (more information here: https://socket.io/docs/v3/migrating-from-2-x-to-3-0/)")); + } + break; + case PacketType.EVENT: + case PacketType.BINARY_EVENT: + this.onevent(packet); + break; + case PacketType.ACK: + case PacketType.BINARY_ACK: + this.onack(packet); + break; + case PacketType.DISCONNECT: + this.ondisconnect(); + break; + case PacketType.CONNECT_ERROR: + this.destroy(); + const err = new Error(packet.data.message); + err.data = packet.data.data; + this.emitReserved("connect_error", err); + break; + } + } + /** + * Called upon a server event. + * + * @param packet + * @private + */ + onevent(packet) { + const args = packet.data || []; + if (null != packet.id) { + args.push(this.ack(packet.id)); + } + if (this.connected) { + this.emitEvent(args); + } else { + this.receiveBuffer.push(Object.freeze(args)); + } + } + emitEvent(args) { + if (this._anyListeners && this._anyListeners.length) { + const listeners = this._anyListeners.slice(); + for (const listener of listeners) { + listener.apply(this, args); + } + } + super.emit.apply(this, args); + if (this._pid && args.length && typeof args[args.length - 1] === "string") { + this._lastOffset = args[args.length - 1]; + } + } + /** + * Produces an ack callback to emit with an event. + * + * @private + */ + ack(id) { + const self2 = this; + let sent = false; + return function(...args) { + if (sent) + return; + sent = true; + self2.packet({ + type: PacketType.ACK, + id, + data: args + }); + }; + } + /** + * Called upon a server acknowledgement. + * + * @param packet + * @private + */ + onack(packet) { + const ack = this.acks[packet.id]; + if (typeof ack !== "function") { + return; + } + delete this.acks[packet.id]; + if (ack.withError) { + packet.data.unshift(null); + } + ack.apply(this, packet.data); + } + /** + * Called upon server connect. + * + * @private + */ + onconnect(id, pid) { + this.id = id; + this.recovered = pid && this._pid === pid; + this._pid = pid; + this.connected = true; + this.emitBuffered(); + this.emitReserved("connect"); + this._drainQueue(true); + } + /** + * Emit buffered events (received and emitted). + * + * @private + */ + emitBuffered() { + this.receiveBuffer.forEach((args) => this.emitEvent(args)); + this.receiveBuffer = []; + this.sendBuffer.forEach((packet) => { + this.notifyOutgoingListeners(packet); + this.packet(packet); + }); + this.sendBuffer = []; + } + /** + * Called upon server disconnect. + * + * @private + */ + ondisconnect() { + this.destroy(); + this.onclose("io server disconnect"); + } + /** + * Called upon forced client/server side disconnections, + * this method ensures the manager stops tracking us and + * that reconnections don't get triggered for this. + * + * @private + */ + destroy() { + if (this.subs) { + this.subs.forEach((subDestroy) => subDestroy()); + this.subs = void 0; + } + this.io["_destroy"](this); + } + /** + * Disconnects the socket manually. In that case, the socket will not try to reconnect. + * + * If this is the last active Socket instance of the {@link Manager}, the low-level connection will be closed. + * + * @example + * const socket = io(); + * + * socket.on("disconnect", (reason) => { + * // console.log(reason); prints "io client disconnect" + * }); + * + * socket.disconnect(); + * + * @return self + */ + disconnect() { + if (this.connected) { + this.packet({ type: PacketType.DISCONNECT }); + } + this.destroy(); + if (this.connected) { + this.onclose("io client disconnect"); + } + return this; + } + /** + * Alias for {@link disconnect()}. + * + * @return self + */ + close() { + return this.disconnect(); + } + /** + * Sets the compress flag. + * + * @example + * socket.compress(false).emit("hello"); + * + * @param compress - if `true`, compresses the sending data + * @return self + */ + compress(compress) { + this.flags.compress = compress; + return this; + } + /** + * Sets a modifier for a subsequent event emission that the event message will be dropped when this socket is not + * ready to send messages. + * + * @example + * socket.volatile.emit("hello"); // the server may or may not receive it + * + * @returns self + */ + get volatile() { + this.flags.volatile = true; + return this; + } + /** + * Sets a modifier for a subsequent event emission that the callback will be called with an error when the + * given number of milliseconds have elapsed without an acknowledgement from the server: + * + * @example + * socket.timeout(5000).emit("my-event", (err) => { + * if (err) { + * // the server did not acknowledge the event in the given delay + * } + * }); + * + * @returns self + */ + timeout(timeout) { + this.flags.timeout = timeout; + return this; + } + /** + * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the + * callback. + * + * @example + * socket.onAny((event, ...args) => { + * console.log(`got ${event}`); + * }); + * + * @param listener + */ + onAny(listener) { + this._anyListeners = this._anyListeners || []; + this._anyListeners.push(listener); + return this; + } + /** + * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the + * callback. The listener is added to the beginning of the listeners array. + * + * @example + * socket.prependAny((event, ...args) => { + * console.log(`got event ${event}`); + * }); + * + * @param listener + */ + prependAny(listener) { + this._anyListeners = this._anyListeners || []; + this._anyListeners.unshift(listener); + return this; + } + /** + * Removes the listener that will be fired when any event is emitted. + * + * @example + * const catchAllListener = (event, ...args) => { + * console.log(`got event ${event}`); + * } + * + * socket.onAny(catchAllListener); + * + * // remove a specific listener + * socket.offAny(catchAllListener); + * + * // or remove all listeners + * socket.offAny(); + * + * @param listener + */ + offAny(listener) { + if (!this._anyListeners) { + return this; + } + if (listener) { + const listeners = this._anyListeners; + for (let i = 0; i < listeners.length; i++) { + if (listener === listeners[i]) { + listeners.splice(i, 1); + return this; + } + } + } else { + this._anyListeners = []; + } + return this; + } + /** + * Returns an array of listeners that are listening for any event that is specified. This array can be manipulated, + * e.g. to remove listeners. + */ + listenersAny() { + return this._anyListeners || []; + } + /** + * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the + * callback. + * + * Note: acknowledgements sent to the server are not included. + * + * @example + * socket.onAnyOutgoing((event, ...args) => { + * console.log(`sent event ${event}`); + * }); + * + * @param listener + */ + onAnyOutgoing(listener) { + this._anyOutgoingListeners = this._anyOutgoingListeners || []; + this._anyOutgoingListeners.push(listener); + return this; + } + /** + * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the + * callback. The listener is added to the beginning of the listeners array. + * + * Note: acknowledgements sent to the server are not included. + * + * @example + * socket.prependAnyOutgoing((event, ...args) => { + * console.log(`sent event ${event}`); + * }); + * + * @param listener + */ + prependAnyOutgoing(listener) { + this._anyOutgoingListeners = this._anyOutgoingListeners || []; + this._anyOutgoingListeners.unshift(listener); + return this; + } + /** + * Removes the listener that will be fired when any event is emitted. + * + * @example + * const catchAllListener = (event, ...args) => { + * console.log(`sent event ${event}`); + * } + * + * socket.onAnyOutgoing(catchAllListener); + * + * // remove a specific listener + * socket.offAnyOutgoing(catchAllListener); + * + * // or remove all listeners + * socket.offAnyOutgoing(); + * + * @param [listener] - the catch-all listener (optional) + */ + offAnyOutgoing(listener) { + if (!this._anyOutgoingListeners) { + return this; + } + if (listener) { + const listeners = this._anyOutgoingListeners; + for (let i = 0; i < listeners.length; i++) { + if (listener === listeners[i]) { + listeners.splice(i, 1); + return this; + } + } + } else { + this._anyOutgoingListeners = []; + } + return this; + } + /** + * Returns an array of listeners that are listening for any event that is specified. This array can be manipulated, + * e.g. to remove listeners. + */ + listenersAnyOutgoing() { + return this._anyOutgoingListeners || []; + } + /** + * Notify the listeners for each packet sent + * + * @param packet + * + * @private + */ + notifyOutgoingListeners(packet) { + if (this._anyOutgoingListeners && this._anyOutgoingListeners.length) { + const listeners = this._anyOutgoingListeners.slice(); + for (const listener of listeners) { + listener.apply(this, packet.data); + } + } + } + }; + + // node_modules/.pnpm/socket.io-client@4.8.1/node_modules/socket.io-client/build/esm/contrib/backo2.js + function Backoff(opts) { + opts = opts || {}; + this.ms = opts.min || 100; + this.max = opts.max || 1e4; + this.factor = opts.factor || 2; + this.jitter = opts.jitter > 0 && opts.jitter <= 1 ? opts.jitter : 0; + this.attempts = 0; + } + Backoff.prototype.duration = function() { + var ms = this.ms * Math.pow(this.factor, this.attempts++); + if (this.jitter) { + var rand = Math.random(); + var deviation = Math.floor(rand * this.jitter * ms); + ms = (Math.floor(rand * 10) & 1) == 0 ? ms - deviation : ms + deviation; + } + return Math.min(ms, this.max) | 0; + }; + Backoff.prototype.reset = function() { + this.attempts = 0; + }; + Backoff.prototype.setMin = function(min) { + this.ms = min; + }; + Backoff.prototype.setMax = function(max) { + this.max = max; + }; + Backoff.prototype.setJitter = function(jitter) { + this.jitter = jitter; + }; + + // node_modules/.pnpm/socket.io-client@4.8.1/node_modules/socket.io-client/build/esm/manager.js + var Manager = class extends Emitter { + constructor(uri, opts) { + var _a; + super(); + this.nsps = {}; + this.subs = []; + if (uri && "object" === typeof uri) { + opts = uri; + uri = void 0; + } + opts = opts || {}; + opts.path = opts.path || "/socket.io"; + this.opts = opts; + installTimerFunctions(this, opts); + this.reconnection(opts.reconnection !== false); + this.reconnectionAttempts(opts.reconnectionAttempts || Infinity); + this.reconnectionDelay(opts.reconnectionDelay || 1e3); + this.reconnectionDelayMax(opts.reconnectionDelayMax || 5e3); + this.randomizationFactor((_a = opts.randomizationFactor) !== null && _a !== void 0 ? _a : 0.5); + this.backoff = new Backoff({ + min: this.reconnectionDelay(), + max: this.reconnectionDelayMax(), + jitter: this.randomizationFactor() + }); + this.timeout(null == opts.timeout ? 2e4 : opts.timeout); + this._readyState = "closed"; + this.uri = uri; + const _parser = opts.parser || esm_exports; + this.encoder = new _parser.Encoder(); + this.decoder = new _parser.Decoder(); + this._autoConnect = opts.autoConnect !== false; + if (this._autoConnect) + this.open(); + } + reconnection(v) { + if (!arguments.length) + return this._reconnection; + this._reconnection = !!v; + if (!v) { + this.skipReconnect = true; + } + return this; + } + reconnectionAttempts(v) { + if (v === void 0) + return this._reconnectionAttempts; + this._reconnectionAttempts = v; + return this; + } + reconnectionDelay(v) { + var _a; + if (v === void 0) + return this._reconnectionDelay; + this._reconnectionDelay = v; + (_a = this.backoff) === null || _a === void 0 ? void 0 : _a.setMin(v); + return this; + } + randomizationFactor(v) { + var _a; + if (v === void 0) + return this._randomizationFactor; + this._randomizationFactor = v; + (_a = this.backoff) === null || _a === void 0 ? void 0 : _a.setJitter(v); + return this; + } + reconnectionDelayMax(v) { + var _a; + if (v === void 0) + return this._reconnectionDelayMax; + this._reconnectionDelayMax = v; + (_a = this.backoff) === null || _a === void 0 ? void 0 : _a.setMax(v); + return this; + } + timeout(v) { + if (!arguments.length) + return this._timeout; + this._timeout = v; + return this; + } + /** + * Starts trying to reconnect if reconnection is enabled and we have not + * started reconnecting yet + * + * @private + */ + maybeReconnectOnOpen() { + if (!this._reconnecting && this._reconnection && this.backoff.attempts === 0) { + this.reconnect(); + } + } + /** + * Sets the current transport `socket`. + * + * @param {Function} fn - optional, callback + * @return self + * @public + */ + open(fn) { + if (~this._readyState.indexOf("open")) + return this; + this.engine = new Socket(this.uri, this.opts); + const socket = this.engine; + const self2 = this; + this._readyState = "opening"; + this.skipReconnect = false; + const openSubDestroy = on(socket, "open", function() { + self2.onopen(); + fn && fn(); + }); + const onError = (err) => { + this.cleanup(); + this._readyState = "closed"; + this.emitReserved("error", err); + if (fn) { + fn(err); + } else { + this.maybeReconnectOnOpen(); + } + }; + const errorSub = on(socket, "error", onError); + if (false !== this._timeout) { + const timeout = this._timeout; + const timer = this.setTimeoutFn(() => { + openSubDestroy(); + onError(new Error("timeout")); + socket.close(); + }, timeout); + if (this.opts.autoUnref) { + timer.unref(); + } + this.subs.push(() => { + this.clearTimeoutFn(timer); + }); + } + this.subs.push(openSubDestroy); + this.subs.push(errorSub); + return this; + } + /** + * Alias for open() + * + * @return self + * @public + */ + connect(fn) { + return this.open(fn); + } + /** + * Called upon transport open. + * + * @private + */ + onopen() { + this.cleanup(); + this._readyState = "open"; + this.emitReserved("open"); + const socket = this.engine; + this.subs.push( + on(socket, "ping", this.onping.bind(this)), + on(socket, "data", this.ondata.bind(this)), + on(socket, "error", this.onerror.bind(this)), + on(socket, "close", this.onclose.bind(this)), + // @ts-ignore + on(this.decoder, "decoded", this.ondecoded.bind(this)) + ); + } + /** + * Called upon a ping. + * + * @private + */ + onping() { + this.emitReserved("ping"); + } + /** + * Called with data. + * + * @private + */ + ondata(data) { + try { + this.decoder.add(data); + } catch (e) { + this.onclose("parse error", e); + } + } + /** + * Called when parser fully decodes a packet. + * + * @private + */ + ondecoded(packet) { + nextTick(() => { + this.emitReserved("packet", packet); + }, this.setTimeoutFn); + } + /** + * Called upon socket error. + * + * @private + */ + onerror(err) { + this.emitReserved("error", err); + } + /** + * Creates a new socket for the given `nsp`. + * + * @return {Socket} + * @public + */ + socket(nsp, opts) { + let socket = this.nsps[nsp]; + if (!socket) { + socket = new Socket2(this, nsp, opts); + this.nsps[nsp] = socket; + } else if (this._autoConnect && !socket.active) { + socket.connect(); + } + return socket; + } + /** + * Called upon a socket close. + * + * @param socket + * @private + */ + _destroy(socket) { + const nsps = Object.keys(this.nsps); + for (const nsp of nsps) { + const socket2 = this.nsps[nsp]; + if (socket2.active) { + return; + } + } + this._close(); + } + /** + * Writes a packet. + * + * @param packet + * @private + */ + _packet(packet) { + const encodedPackets = this.encoder.encode(packet); + for (let i = 0; i < encodedPackets.length; i++) { + this.engine.write(encodedPackets[i], packet.options); + } + } + /** + * Clean up transport subscriptions and packet buffer. + * + * @private + */ + cleanup() { + this.subs.forEach((subDestroy) => subDestroy()); + this.subs.length = 0; + this.decoder.destroy(); + } + /** + * Close the current socket. + * + * @private + */ + _close() { + this.skipReconnect = true; + this._reconnecting = false; + this.onclose("forced close"); + } + /** + * Alias for close() + * + * @private + */ + disconnect() { + return this._close(); + } + /** + * Called when: + * + * - the low-level engine is closed + * - the parser encountered a badly formatted packet + * - all sockets are disconnected + * + * @private + */ + onclose(reason, description) { + var _a; + this.cleanup(); + (_a = this.engine) === null || _a === void 0 ? void 0 : _a.close(); + this.backoff.reset(); + this._readyState = "closed"; + this.emitReserved("close", reason, description); + if (this._reconnection && !this.skipReconnect) { + this.reconnect(); + } + } + /** + * Attempt a reconnection. + * + * @private + */ + reconnect() { + if (this._reconnecting || this.skipReconnect) + return this; + const self2 = this; + if (this.backoff.attempts >= this._reconnectionAttempts) { + this.backoff.reset(); + this.emitReserved("reconnect_failed"); + this._reconnecting = false; + } else { + const delay = this.backoff.duration(); + this._reconnecting = true; + const timer = this.setTimeoutFn(() => { + if (self2.skipReconnect) + return; + this.emitReserved("reconnect_attempt", self2.backoff.attempts); + if (self2.skipReconnect) + return; + self2.open((err) => { + if (err) { + self2._reconnecting = false; + self2.reconnect(); + this.emitReserved("reconnect_error", err); + } else { + self2.onreconnect(); + } + }); + }, delay); + if (this.opts.autoUnref) { + timer.unref(); + } + this.subs.push(() => { + this.clearTimeoutFn(timer); + }); + } + } + /** + * Called upon successful reconnect. + * + * @private + */ + onreconnect() { + const attempt = this.backoff.attempts; + this._reconnecting = false; + this.backoff.reset(); + this.emitReserved("reconnect", attempt); + } + }; + + // node_modules/.pnpm/socket.io-client@4.8.1/node_modules/socket.io-client/build/esm/index.js + var cache2 = {}; + function lookup2(uri, opts) { + if (typeof uri === "object") { + opts = uri; + uri = void 0; + } + opts = opts || {}; + const parsed = url(uri, opts.path || "/socket.io"); + const source = parsed.source; + const id = parsed.id; + const path = parsed.path; + const sameNamespace = cache2[id] && path in cache2[id]["nsps"]; + const newConnection = opts.forceNew || opts["force new connection"] || false === opts.multiplex || sameNamespace; + let io; + if (newConnection) { + io = new Manager(source, opts); + } else { + if (!cache2[id]) { + cache2[id] = new Manager(source, opts); + } + io = cache2[id]; + } + if (parsed.query && !opts.query) { + opts.query = parsed.queryKey; + } + return io.socket(parsed.path, opts); + } + Object.assign(lookup2, { + Manager, + Socket: Socket2, + io: lookup2, + connect: lookup2 + }); + + // plugins/lastfm/listenbrainz.ts + var { store } = shelter.plugin; + var { createEffect, createRoot } = shelter.solid; + var FETCH_SHPROX_UA_HEADER = { + "X-Shprox-UA": "ShelterLastFm/0.0.0 ( https://github.com/yellowsink/shelter-plugins )" + }; + var listenBrainzLookupAdditional = async (basicTrack) => { + if (!store.lbLookup) + return; + if (basicTrack.additional_info?.release_mbid) + return; + try { + const metaRes = await fetch( + `https://shcors.uwu.network/https://api.listenbrainz.org/1/metadata/lookup/?${new URLSearchParams( + { + recording_name: basicTrack.track_name, + artist_name: basicTrack.artist_name, + metadata: "true", + inc: "artist tag release" + } + )}`, + { headers: FETCH_SHPROX_UA_HEADER } + ).then((r) => r.json()); + basicTrack.additional_info = { ...basicTrack?.additional_info, ...metaRes }; + } catch (e) { + console.error( + "SHELTER LASTFM: finding listenbrainz MBID for track", + basicTrack, + "failed, ", + e + ); + } + }; + var listenBrainzAlbumArtLookup = async (track2) => { + let albumArtUrl; + if (track2.additional_info?.release_mbid) { + const relArtCheck = await fetch( + `https://coverartarchive.org/release/${track2.additional_info?.release_mbid}/front`, + { method: "HEAD", redirect: "manual" } + ); + if (relArtCheck.status !== 404) { + albumArtUrl = `https://aart.yellows.ink/release/${track2.additional_info.release_mbid}.webp`; + } else { + const rgLookup = await fetch( + `https://shcors.uwu.network/https://musicbrainz.org/ws/2/release/${track2.additional_info.release_mbid}?fmt=json&inc=release-groups`, + { headers: FETCH_SHPROX_UA_HEADER } + ); + if (rgLookup.ok) { + const releaseJson = await rgLookup.json(); + albumArtUrl = `https://aart.yellows.ink/release-group/${releaseJson["release-group"].id}.webp`; + } + } + } + if (albumArtUrl) { + const testRes = await fetch(albumArtUrl, { method: "HEAD" }); + if (!testRes.ok) + albumArtUrl = void 0; + } + return albumArtUrl; + }; + var cacheKeySel = (song) => `${song.track_name}|${song.artist_name}|${song.release_name}`; + var additionalMemoized = memoize_default(listenBrainzLookupAdditional, cacheKeySel); + var aartMemoized = memoize_default(listenBrainzAlbumArtLookup, cacheKeySel); + var lbResToTrack = (res, aart, playNow) => ({ + name: res.track_name, + artist: res.artist_name, + album: res.release_name, + albumArt: aart, + url: res.additional_info?.recording_mbid ? `https://musicbrainz.org/recording/${res.additional_info.recording_mbid}` : `NOURL_${res.track_name}:${res.artist_name}:${res.release_name}`, + //date: "now", // not returned by api + nowPlaying: playNow + }); + var getScrobbleListenbrainz = async () => { + const nowPlayingRes = await fetch( + `https://shcors.uwu.network/https://api.listenbrainz.org/1/user/${store.user}/playing-now`, + { headers: FETCH_SHPROX_UA_HEADER } + ).then((r) => r.json()); + if (!nowPlayingRes?.payload?.count) + return; + const track2 = nowPlayingRes.payload.listens[0].track_metadata; + await additionalMemoized(track2); + const albumArtUrl = await aartMemoized(track2); + return lbResToTrack( + track2, + albumArtUrl, + nowPlayingRes.payload.listens[0].playing_now + ); + }; + var LbWebsocket = class { + #socket; + #pendingSocket; + #lastUsername; + #dispose; + handler; + constructor(handler) { + this.handler = handler; + createRoot((DISPOSE) => { + this.#dispose = DISPOSE; + createEffect(() => { + const nextUser = store.user?.toLowerCase?.(); + if (store.service !== "lbz") + this.tearDownSocket(false); + else if (this.#lastUsername !== nextUser || !this.#socket && !this.#pendingSocket) { + getScrobbleListenbrainz().then(this.handler).then(() => this.#startSocket(nextUser)); + } + }); + }); + } + #startSocket(nextUser) { + if (this.#pendingSocket) + this.#pendingSocket.close(); + this.#pendingSocket = lookup2("https://shcors.uwu.network", { + path: "/https://listenbrainz.org/socket.io", + transports: ["websocket"] + }); + this.#pendingSocket.on("connect", () => this.#onConnect(nextUser)); + this.#pendingSocket.on("playing_now", (pn) => this.#playingNowHandler(pn)); + } + #onConnect(nextUser) { + this.#socket?.close(); + this.#socket = this.#pendingSocket; + this.#pendingSocket = void 0; + this.#lastUsername = nextUser; + this.#socket.emit("json", { user: nextUser }); + } + async #playingNowHandler(pn) { + const res = JSON.parse(pn); + const playingNowObject = res?.track_metadata; + if (!playingNowObject) + return; + await additionalMemoized(playingNowObject); + const albumArt = await aartMemoized(playingNowObject); + this.handler?.(lbResToTrack(playingNowObject, albumArt, res.playing_now)); + } + tearDownSocket(dispose = true) { + this.#socket?.close(); + this.#pendingSocket?.close(); + this.#socket = void 0; + this.#pendingSocket = void 0; + if (dispose) + this.#dispose?.(); + } + }; + // plugins/lastfm/Settings.tsx - var import_web = __toESM(require_web(), 1); - var import_web2 = __toESM(require_web(), 1); - var import_web3 = __toESM(require_web(), 1); - var import_web4 = __toESM(require_web(), 1); + var import_web = __toESM(require_web()); + var import_web2 = __toESM(require_web()); + var import_web3 = __toESM(require_web()); + var import_web4 = __toESM(require_web()); var _tmpl$ = /* @__PURE__ */ (0, import_web.template)(`
`, 2); var { - store + store: store2 } = shelter.plugin; var { TextBox, @@ -99,9 +3997,9 @@ } = shelter.solid; var ServiceButton = (props) => (0, import_web3.createComponent)(Button, { grow: true, - onClick: () => store.service = props.service, + onClick: () => store2.service = props.service, get color() { - return store.service === props.service ? ButtonColors.BRAND : ButtonColors.SECONDARY; + return store2.service === props.service ? ButtonColors.BRAND : ButtonColors.SECONDARY; }, get look() { return ButtonLooks.OUTLINED; @@ -121,9 +4019,9 @@ }), (0, import_web3.createComponent)(TextBox, { placeholder: DEFAULT_NAME, get value() { - return store.appName ?? ""; + return store2.appName ?? ""; }, - onInput: (v) => store.appName = v + onInput: (v) => store2.appName = v }), (0, import_web3.createComponent)(Header, { get tag() { return HeaderTags.H3; @@ -145,23 +4043,23 @@ return HeaderTags.H3; }, get children() { - return [(0, import_web4.memo)(() => store.service === "lbz" ? "Listenbrainz" : "Last.fm"), " username (required)"]; + return [(0, import_web4.memo)(() => store2.service === "lbz" ? "Listenbrainz" : "Last.fm"), " username (required)"]; } }), (0, import_web3.createComponent)(TextBox, { get value() { - return store.user ?? ""; + return store2.user ?? ""; }, - onInput: (v) => store.user = v + onInput: (v) => store2.user = v }), (0, import_web3.createComponent)(Show, { get when() { - return store.service === "lbz"; + return store2.service === "lbz"; }, get children() { return (0, import_web3.createComponent)(SwitchItem, { get value() { - return store.lbLookup; + return store2.lbLookup; }, - onChange: (v) => store.lbLookup = v, + onChange: (v) => store2.lbLookup = v, note: "Depending on the scrobbler, Listenbrainz may not be able to return a release ID with the current track. If this happens, we can't fetch an album cover. This option will search musicbrainz for a matching release if this happens, to attempt to find a (hopefully correct) cover. If you get incorrect album art, turn this off. If you get missing album art, turn this on.", children: "Search Musicbrainz for missing releases" }); @@ -174,31 +4072,31 @@ }), (0, import_web3.createComponent)(TextBox, { placeholder: DEFAULT_INTERVAL / 1e3 + "", get value() { - return store.interval ? store.interval / 1e3 + "" : ""; + return store2.interval ? store2.interval / 1e3 + "" : ""; }, - onInput: (v) => (!v || !isNaN(parseFloat(v))) && (store.interval = !v ? void 0 : parseFloat(v) * 1e3 || DEFAULT_INTERVAL) + onInput: (v) => (!v || !isNaN(parseFloat(v))) && (store2.interval = !v ? void 0 : parseFloat(v) * 1e3 || DEFAULT_INTERVAL) }), (0, import_web3.createComponent)(Divider, { mt: true, mb: true }), (0, import_web3.createComponent)(SwitchItem, { get value() { - return store.stamp; + return store2.stamp; }, - onChange: (v) => store.stamp = v, + onChange: (v) => store2.stamp = v, note: "Show time since song started playing", children: "Show time elapsed" }), (0, import_web3.createComponent)(SwitchItem, { get value() { - return store.ignoreSpotify; + return store2.ignoreSpotify; }, - onChange: (v) => store.ignoreSpotify = v, + onChange: (v) => store2.ignoreSpotify = v, note: "Hide the status if Spotify is playing", children: "Hide when using Spotify" }), (0, import_web3.createComponent)(SwitchItem, { get value() { - return store.alwaysShare; + return store2.alwaysShare; }, - onChange: (v) => store.alwaysShare = v, + onChange: (v) => store2.alwaysShare = v, note: "Share activity even if you have activities disabled", children: "Always show activity" }), (0, import_web3.createComponent)(Text, { @@ -214,19 +4112,16 @@ // plugins/lastfm/index.ts var { - plugin: { store: store2 }, + plugin: { store: store3 }, flux: { storesFlat, dispatcher } } = shelter; - store2.stamp ??= true; - store2.ignoreSpotify ??= true; - store2.service ??= "lfm"; - store2.lbLookup ??= true; - store2.alwaysShare ??= false; + store3.stamp ??= true; + store3.ignoreSpotify ??= true; + store3.service ??= "lfm"; + store3.lbLookup ??= true; + store3.alwaysShare ??= false; var UserStore = storesFlat.UserStore; var PresenceStore = storesFlat.PresenceStore; - var FETCH_SHPROX_UA_HEADER = { - "X-Shprox-UA": "ShelterLastFm/0.0.0 ( https://github.com/yellowsink/shelter-plugins )" - }; var setPresence = async (name = "", activity, start) => dispatcher.dispatch({ type: "LOCAL_ACTIVITY_UPDATE", activity: activity ? { @@ -236,7 +4131,7 @@ details: activity.name, state: activity.artist, application_id: DISCORD_APP_ID, - timestamps: store2.stamp ? { start } : void 0, + timestamps: store3.stamp ? { start } : void 0, assets: { large_image: activity.albumArt && await getAsset(activity.albumArt), large_text: activity.album @@ -247,7 +4142,7 @@ var getScrobbleLastfm = async () => { const params = new URLSearchParams({ method: "user.getrecenttracks", - user: store2.user, + user: store3.user, api_key: LFM_API_KEY, format: "json", limit: "1", @@ -256,125 +4151,67 @@ const res = await fetch(`https://ws.audioscrobbler.com/2.0/?${params}`); if (!res.ok) return; - const lastTrack2 = (await res.json())?.recenttracks?.track?.[0]; - if (!lastTrack2) + const lastTrack = (await res.json())?.recenttracks?.track?.[0]; + if (!lastTrack) return; return { - name: lastTrack2.name, - artist: lastTrack2.artist.name, - album: lastTrack2.album["#text"], - albumArt: lastTrack2.image[3]["#text"], - url: lastTrack2.url, + name: lastTrack.name, + artist: lastTrack.artist.name, + album: lastTrack.album["#text"], + albumArt: lastTrack.image[3]["#text"], + url: lastTrack.url, //date: lastTrack.date?.["#text"] ?? "now", - nowPlaying: !!lastTrack2["@attr"]?.nowplaying + nowPlaying: !!lastTrack["@attr"]?.nowplaying }; }; - var listenBrainzLookupAdditional = async (basicTrack) => { - if (!store2.lbLookup) - return; - if (basicTrack.additional_info?.release_mbid) - return; - try { - const metaRes = await fetch( - `https://shcors.uwu.network/https://api.listenbrainz.org/1/metadata/lookup/?${new URLSearchParams( - { - recording_name: basicTrack.track_name, - artist_name: basicTrack.artist_name, - metadata: "true", - inc: "artist tag release" - } - )}`, - { headers: FETCH_SHPROX_UA_HEADER } - ).then((r) => r.json()); - basicTrack.additional_info = { ...basicTrack?.additional_info, ...metaRes }; - } catch (e) { - console.error( - "SHELTER LASTFM: finding listenbrainz MBID for track", - basicTrack, - "failed, ", - e - ); - } - }; - var getScrobbleListenbrainz = async () => { - const nowPlayingRes = await fetch( - `https://shcors.uwu.network/https://api.listenbrainz.org/1/user/${store2.user}/playing-now`, - { headers: FETCH_SHPROX_UA_HEADER } - ).then((r) => r.json()); - if (!nowPlayingRes.payload.count) - return; - const track = nowPlayingRes.payload.listens[0].track_metadata; - await listenBrainzLookupAdditional(track); - let albumArtUrl; - if (track.additional_info?.release_mbid) { - const relArtCheck = await fetch( - `https://coverartarchive.org/release/${track.additional_info?.release_mbid}/front`, - { method: "HEAD", redirect: "manual" } - ); - if (relArtCheck.status !== 404) { - albumArtUrl = `https://aart.yellows.ink/release/${track.additional_info.release_mbid}.webp`; - } else { - const rgLookup = await fetch( - `https://shcors.uwu.network/https://musicbrainz.org/ws/2/release/${track.additional_info.release_mbid}?fmt=json&inc=release-groups`, - { headers: FETCH_SHPROX_UA_HEADER } - ); - if (rgLookup.ok) { - const releaseJson = await rgLookup.json(); - albumArtUrl = `https://aart.yellows.ink/release-group/${releaseJson["release-group"].id}.webp`; - } - } - } - if (albumArtUrl) { - const testRes = await fetch(albumArtUrl, { method: "HEAD" }); - if (!testRes.ok) - albumArtUrl = void 0; - } - return { - name: track.track_name, - artist: track.artist_name, - album: track.release_name, - albumArt: albumArtUrl, - url: track.additional_info?.recording_mbid ? `https://musicbrainz.org/recording/${track.additional_info.recording_mbid}` : `NOURL_${track.track_name}:${track.artist_name}:${track.release_name}`, - //date: "now", // not returned by api - nowPlaying: nowPlayingRes.payload.listens[0].playing_now - }; + var isSpotifyPlaying = () => { + for (const activity of PresenceStore.getActivities( + UserStore.getCurrentUser().id + )) + if (activity?.type === ACTIVITY_TYPE_LISTENING && activity.application_id !== DISCORD_APP_ID) + return true; + return false; }; var lastUrl; var startTimestamp; - var updateStatus = async () => { - if (!store2.user) + var handleNewStatus = (track) => { + if (!store3.user) + return setPresence(); + if (store3.ignoreSpotify && isSpotifyPlaying()) return setPresence(); - if (store2.ignoreSpotify) { - for (const activity of PresenceStore.getActivities( - UserStore.getCurrentUser().id - )) - if (activity?.type === ACTIVITY_TYPE_LISTENING && activity.application_id !== DISCORD_APP_ID) - return setPresence(); - } - const getFn = store2.service === "lbz" ? getScrobbleListenbrainz : getScrobbleLastfm; - const lastTrack = await getFn(); - if (!lastTrack?.nowPlaying) { + if (!track?.nowPlaying) { startTimestamp = null; return setPresence(); } - if (lastTrack.url !== lastUrl || !startTimestamp) { + if (track.url !== lastUrl || !startTimestamp) { startTimestamp = Date.now(); } - lastUrl = lastTrack.url; - let appName = store2.appName || DEFAULT_NAME; + lastUrl = track.url; + let appName = store3.appName || DEFAULT_NAME; appName = appName.replaceAll( /{{(.+)}}/g, - (_, code) => eval(`(c)=>{with(c){try{return ${code}}catch(e){return e}}}`)(lastTrack) + (_, code) => eval(`(c)=>{with(c){try{return ${code}}catch(e){return e}}}`)(track) ); - await setPresence(appName, lastTrack, startTimestamp); + return setPresence(appName, track, startTimestamp); + }; + var updateStatusInterval = async () => { + if (!store3.user) + return setPresence(); + if (store3.ignoreSpotify && isSpotifyPlaying()) + return setPresence(); + if (store3.service !== "lbz") + await handleNewStatus(await getScrobbleLastfm()); }; var interval; - var restartLoop = () => (interval && clearInterval(interval), interval = setInterval(updateStatus, store2.interval || DEFAULT_INTERVAL)); + var restartLoop = () => (interval && clearInterval(interval), interval = setInterval( + updateStatusInterval, + store3.interval || DEFAULT_INTERVAL + )); var unpatch = shelter.patcher.after( "getActivities", shelter.flux.stores.LocalActivityStore, (_2, res) => { - if (!store2.alwaysShare) + if (!store3.alwaysShare) return; res.filter = function(predicate) { if (!predicate.toString().includes("shouldShowActivity")) { @@ -391,6 +4228,7 @@ } ); restartLoop(); - var onUnload = () => (clearInterval(interval), setPresence(), unpatch()); + var lbSocket = new LbWebsocket(handleNewStatus); + var onUnload = () => (clearInterval(interval), setPresence(), unpatch(), lbSocket.tearDownSocket()); return __toCommonJS(lastfm_exports); })(); diff --git a/lastfm/plugin.json b/lastfm/plugin.json index e7ae617..b64db49 100644 --- a/lastfm/plugin.json +++ b/lastfm/plugin.json @@ -1 +1 @@ -{"name":"Last.fm Presence","author":"Yellowsink","description":"Shows your Last.fm now listening as a presence","hash":"2fc56d292ba858505fa37ca3962a1556"} \ No newline at end of file +{"name":"Last.fm Presence","author":"Yellowsink","description":"Shows your Last.fm now listening as a presence","hash":"3919c886a7fe095f01e5340dc84c0140"} \ No newline at end of file diff --git a/snazzy-shelter/plugin.js b/snazzy-shelter/plugin.js index 8d4f9f0..60e2b94 100644 --- a/snazzy-shelter/plugin.js +++ b/snazzy-shelter/plugin.js @@ -3559,7 +3559,7 @@ var import_web47 = __toESM(require_web()); var import_web48 = __toESM(require_web()); - // node_modules/.pnpm/@uwu+monaco-solid@1.1.0_solid-js@1.6.16/node_modules/@uwu/monaco-solid/dist/index.jsx + // node_modules/.pnpm/@uwu+monaco-solid@1.1.0_solid-js@1.8.15/node_modules/@uwu/monaco-solid/dist/index.jsx var import_web42 = __toESM(require_web()); var import_web43 = __toESM(require_web()); var import_web44 = __toESM(require_web()); @@ -4091,7 +4091,7 @@ }; var loader_default = loader; - // node_modules/.pnpm/@uwu+monaco-solid@1.1.0_solid-js@1.6.16/node_modules/@uwu/monaco-solid/dist/monaco.js + // node_modules/.pnpm/@uwu+monaco-solid@1.1.0_solid-js@1.8.15/node_modules/@uwu/monaco-solid/dist/monaco.js var monaco; var monacoLoaded; var loadedThemes = /* @__PURE__ */ new Set(); @@ -4115,7 +4115,7 @@ await monacoLoaded; } - // node_modules/.pnpm/@uwu+monaco-solid@1.1.0_solid-js@1.6.16/node_modules/@uwu/monaco-solid/dist/index.jsx + // node_modules/.pnpm/@uwu+monaco-solid@1.1.0_solid-js@1.8.15/node_modules/@uwu/monaco-solid/dist/index.jsx var _tmpl$12 = /* @__PURE__ */ (0, import_web42.template)(`
`, 2); var dist_default = (props) => { let dispose; diff --git a/snazzy-shelter/plugin.json b/snazzy-shelter/plugin.json index 8158247..fa4e646 100644 --- a/snazzy-shelter/plugin.json +++ b/snazzy-shelter/plugin.json @@ -1 +1 @@ -{"name":"Snazzy Shelter","description":"A theme loader for shelter","author":"Yellowsink","hash":"cae31e80ca3a5af0b3d47e9cb947ccf2"} \ No newline at end of file +{"name":"Snazzy Shelter","description":"A theme loader for shelter","author":"Yellowsink","hash":"f61bb63c86e13d5c176f054c2de9b1f2"} \ No newline at end of file