lightclawbot 1.0.0 → 1.0.2

package/node_modules/engine.io-client/build/esm/transports/websocket.node.js

@@ -0,0 +1,41 @@
+import * as ws from "ws";
+import { BaseWS } from "./websocket.js";
+/**
+ * WebSocket transport based on the `WebSocket` object provided by the `ws` package.
+ *
+ * Usage: Node.js, Deno (compat), Bun (compat)
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/WebSocket
+ * @see https://caniuse.com/mdn-api_websocket
+ */
+export class WS extends BaseWS {
+    createSocket(uri, protocols, opts) {
+        var _a;
+        if ((_a = this.socket) === null || _a === void 0 ? void 0 : _a._cookieJar) {
+            opts.headers = opts.headers || {};
+            opts.headers.cookie =
+                typeof opts.headers.cookie === "string"
+                    ? [opts.headers.cookie]
+                    : opts.headers.cookie || [];
+            for (const [name, cookie] of this.socket._cookieJar.cookies) {
+                opts.headers.cookie.push(`${name}=${cookie.value}`);
+            }
+        }
+        return new ws.WebSocket(uri, protocols, opts);
+    }
+    doWrite(packet, data) {
+        const opts = {};
+        if (packet.options) {
+            opts.compress = packet.options.compress;
+        }
+        if (this.opts.perMessageDeflate) {
+            const len = 
+            // @ts-ignore
+            "string" === typeof data ? Buffer.byteLength(data) : data.length;
+            if (len < this.opts.perMessageDeflate.threshold) {
+                opts.compress = false;
+            }
+        }
+        this.ws.send(data, opts);
+    }
+}

package/node_modules/engine.io-client/build/esm/transports/webtransport.d.ts

@@ -0,0 +1,18 @@
+import { Transport } from "../transport.js";
+import { Packet } from "engine.io-parser";
+/**
+ * WebTransport transport based on the built-in `WebTransport` object.
+ *
+ * Usage: browser, Node.js (with the `@fails-components/webtransport` package)
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/WebTransport
+ * @see https://caniuse.com/webtransport
+ */
+export declare class WT extends Transport {
+    private _transport;
+    private _writer;
+    get name(): string;
+    protected doOpen(): this;
+    protected write(packets: Packet[]): void;
+    protected doClose(): void;
+}

package/node_modules/engine.io-client/build/esm/transports/webtransport.js

@@ -0,0 +1,80 @@
+import { Transport } from "../transport.js";
+import { nextTick } from "../globals.node.js";
+import { createPacketDecoderStream, createPacketEncoderStream, } from "engine.io-parser";
+/**
+ * WebTransport transport based on the built-in `WebTransport` object.
+ *
+ * Usage: browser, Node.js (with the `@fails-components/webtransport` package)
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/WebTransport
+ * @see https://caniuse.com/webtransport
+ */
+export class WT extends Transport {
+    get name() {
+        return "webtransport";
+    }
+    doOpen() {
+        try {
+            // @ts-ignore
+            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);
+        });
+        // note: we could have used async/await, but that would require some additional polyfills
+        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 }) => {
+                        if (done) {
+                            return;
+                        }
+                        this.onPacket(value);
+                        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();
+    }
+}

package/node_modules/engine.io-client/build/esm/util.d.ts

@@ -0,0 +1,7 @@
+export declare function pick(obj: any, ...attr: any[]): any;
+export declare function installTimerFunctions(obj: any, opts: any): void;
+export declare function byteLength(obj: any): number;
+/**
+ * Generates a random 8-characters string.
+ */
+export declare function randomString(): string;

package/node_modules/engine.io-client/build/esm/util.js

@@ -0,0 +1,59 @@
+import { globalThisShim as globalThis } from "./globals.node.js";
+export function pick(obj, ...attr) {
+    return attr.reduce((acc, k) => {
+        if (obj.hasOwnProperty(k)) {
+            acc[k] = obj[k];
+        }
+        return acc;
+    }, {});
+}
+// Keep a reference to the real timeout functions so they can be used when overridden
+const NATIVE_SET_TIMEOUT = globalThis.setTimeout;
+const NATIVE_CLEAR_TIMEOUT = globalThis.clearTimeout;
+export function installTimerFunctions(obj, opts) {
+    if (opts.useNativeTimers) {
+        obj.setTimeoutFn = NATIVE_SET_TIMEOUT.bind(globalThis);
+        obj.clearTimeoutFn = NATIVE_CLEAR_TIMEOUT.bind(globalThis);
+    }
+    else {
+        obj.setTimeoutFn = globalThis.setTimeout.bind(globalThis);
+        obj.clearTimeoutFn = globalThis.clearTimeout.bind(globalThis);
+    }
+}
+// base64 encoded buffers are about 33% bigger (https://en.wikipedia.org/wiki/Base64)
+const BASE64_OVERHEAD = 1.33;
+// we could also have used `new Blob([obj]).size`, but it isn't supported in IE9
+export function byteLength(obj) {
+    if (typeof obj === "string") {
+        return utf8Length(obj);
+    }
+    // arraybuffer or blob
+    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 < 0x80) {
+            length += 1;
+        }
+        else if (c < 0x800) {
+            length += 2;
+        }
+        else if (c < 0xd800 || c >= 0xe000) {
+            length += 3;
+        }
+        else {
+            i++;
+            length += 4;
+        }
+    }
+    return length;
+}
+/**
+ * Generates a random 8-characters string.
+ */
+export function randomString() {
+    return (Date.now().toString(36).substring(3) +
+        Math.random().toString(36).substring(2, 5));
+}

package/node_modules/engine.io-client/build/esm-debug/browser-entrypoint.d.ts

@@ -0,0 +1,3 @@
+import { Socket } from "./socket.js";
+declare const _default: (uri: any, opts: any) => Socket;
+export default _default;

package/node_modules/engine.io-client/build/esm-debug/browser-entrypoint.js

@@ -0,0 +1,2 @@
+import { Socket } from "./socket.js";
+export default (uri, opts) => new Socket(uri, opts);

package/node_modules/engine.io-client/build/esm-debug/contrib/has-cors.d.ts

@@ -0,0 +1 @@
+export declare const hasCORS: boolean;

package/node_modules/engine.io-client/build/esm-debug/contrib/has-cors.js

@@ -0,0 +1,11 @@
+// imported from https://github.com/component/has-cors
+let value = false;
+try {
+    value = typeof XMLHttpRequest !== 'undefined' &&
+        'withCredentials' in new XMLHttpRequest();
+}
+catch (err) {
+    // if XMLHttp support is disabled in IE then it will throw
+    // when trying to create
+}
+export const hasCORS = value;

package/node_modules/engine.io-client/build/esm-debug/contrib/parseqs.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Compiles a querystring
+ * Returns string representation of the object
+ *
+ * @param {Object}
+ * @api private
+ */
+export declare function encode(obj: any): string;
+/**
+ * Parses a simple querystring into an object
+ *
+ * @param {String} qs
+ * @api private
+ */
+export declare function decode(qs: any): {};

package/node_modules/engine.io-client/build/esm-debug/contrib/parseqs.js

@@ -0,0 +1,34 @@
+// imported from https://github.com/galkn/querystring
+/**
+ * Compiles a querystring
+ * Returns string representation of the object
+ *
+ * @param {Object}
+ * @api private
+ */
+export 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;
+}
+/**
+ * Parses a simple querystring into an object
+ *
+ * @param {String} qs
+ * @api private
+ */
+export function decode(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;
+}

package/node_modules/engine.io-client/build/esm-debug/contrib/parseuri.d.ts

@@ -0,0 +1 @@
+export declare function parse(str: string): any;

package/node_modules/engine.io-client/build/esm-debug/contrib/parseuri.js

@@ -0,0 +1,64 @@
+// imported from https://github.com/galkn/parseuri
+/**
+ * Parses a URI
+ *
+ * Note: we could also have used the built-in URL object, but it isn't supported on all platforms.
+ *
+ * See:
+ * - https://developer.mozilla.org/en-US/docs/Web/API/URL
+ * - https://caniuse.com/url
+ * - https://www.rfc-editor.org/rfc/rfc3986#appendix-B
+ *
+ * History of the parse() method:
+ * - first commit: https://github.com/socketio/socket.io-client/commit/4ee1d5d94b3906a9c052b459f1a818b15f38f91c
+ * - export into its own module: https://github.com/socketio/engine.io-client/commit/de2c561e4564efeb78f1bdb1ba39ef81b2822cb3
+ * - reimport: https://github.com/socketio/engine.io-client/commit/df32277c3f6d622eec5ed09f493cae3f3391d242
+ *
+ * @author Steven Levithan <stevenlevithan.com> (MIT license)
+ * @api private
+ */
+const re = /^(?:(?![^:@\/?#]+:[^:@\/]*@)(http|https|ws|wss):\/\/)?((?:(([^:@\/?#]*)(?::([^:@\/?#]*))?)?@)?((?:[a-f0-9]{0,4}:){2,7}[a-f0-9]{0,4}|[^:\/?#]*)(?::(\d*))?)(((\/(?:[^?#](?![^?#\/]*\.[^?#\/.]+(?:[?#]|$)))*\/?)?([^?#\/]*))(?:\?([^#]*))?(?:#(.*))?)/;
+const parts = [
+    'source', 'protocol', 'authority', 'userInfo', 'user', 'password', 'host', 'port', 'relative', 'path', 'directory', 'file', 'query', 'anchor'
+];
+export function parse(str) {
+    if (str.length > 8000) {
+        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;
+}

package/node_modules/engine.io-client/build/esm-debug/globals.d.ts

@@ -0,0 +1,4 @@
+export declare const nextTick: (cb: any, setTimeoutFn: any) => any;
+export declare const globalThisShim: any;
+export declare const defaultBinaryType = "arraybuffer";
+export declare function createCookieJar(): void;

package/node_modules/engine.io-client/build/esm-debug/globals.js

@@ -0,0 +1,22 @@
+export const 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);
+    }
+})();
+export const globalThisShim = (() => {
+    if (typeof self !== "undefined") {
+        return self;
+    }
+    else if (typeof window !== "undefined") {
+        return window;
+    }
+    else {
+        return Function("return this")();
+    }
+})();
+export const defaultBinaryType = "arraybuffer";
+export function createCookieJar() { }

package/node_modules/engine.io-client/build/esm-debug/globals.node.d.ts

@@ -0,0 +1,21 @@
+export declare const nextTick: (callback: Function, ...args: any[]) => void;
+export declare const globalThisShim: typeof globalThis;
+export declare const defaultBinaryType = "nodebuffer";
+export declare function createCookieJar(): CookieJar;
+interface Cookie {
+    name: string;
+    value: string;
+    expires?: Date;
+}
+/**
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie
+ */
+export declare function parse(setCookieString: string): Cookie;
+export declare class CookieJar {
+    private _cookies;
+    parseCookies(values: string[]): void;
+    get cookies(): IterableIterator<[string, Cookie]>;
+    addCookies(xhr: any): void;
+    appendCookies(headers: Headers): void;
+}
+export {};

package/node_modules/engine.io-client/build/esm-debug/globals.node.js

@@ -0,0 +1,91 @@
+export const nextTick = process.nextTick;
+export const globalThisShim = global;
+export const defaultBinaryType = "nodebuffer";
+export function createCookieJar() {
+    return new CookieJar();
+}
+/**
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie
+ */
+export function parse(setCookieString) {
+    const parts = setCookieString.split("; ");
+    const i = parts[0].indexOf("=");
+    if (i === -1) {
+        return;
+    }
+    const name = parts[0].substring(0, i).trim();
+    if (!name.length) {
+        return;
+    }
+    let value = parts[0].substring(i + 1).trim();
+    if (value.charCodeAt(0) === 0x22) {
+        // remove double quotes
+        value = value.slice(1, -1);
+    }
+    const cookie = {
+        name,
+        value,
+    };
+    for (let j = 1; j < parts.length; j++) {
+        const subParts = parts[j].split("=");
+        if (subParts.length !== 2) {
+            continue;
+        }
+        const key = subParts[0].trim();
+        const value = subParts[1].trim();
+        switch (key) {
+            case "Expires":
+                cookie.expires = new Date(value);
+                break;
+            case "Max-Age":
+                const expiration = new Date();
+                expiration.setUTCSeconds(expiration.getUTCSeconds() + parseInt(value, 10));
+                cookie.expires = expiration;
+                break;
+            default:
+            // ignore other keys
+        }
+    }
+    return cookie;
+}
+export class CookieJar {
+    constructor() {
+        this._cookies = new Map();
+    }
+    parseCookies(values) {
+        if (!values) {
+            return;
+        }
+        values.forEach((value) => {
+            const parsed = parse(value);
+            if (parsed) {
+                this._cookies.set(parsed.name, parsed);
+            }
+        });
+    }
+    get cookies() {
+        const now = Date.now();
+        this._cookies.forEach((cookie, name) => {
+            var _a;
+            if (((_a = cookie.expires) === null || _a === void 0 ? void 0 : _a.getTime()) < now) {
+                this._cookies.delete(name);
+            }
+        });
+        return this._cookies.entries();
+    }
+    addCookies(xhr) {
+        const cookies = [];
+        for (const [name, cookie] of this.cookies) {
+            cookies.push(`${name}=${cookie.value}`);
+        }
+        if (cookies.length) {
+            xhr.setDisableHeaderCheck(true);
+            xhr.setRequestHeader("cookie", cookies.join("; "));
+        }
+    }
+    appendCookies(headers) {
+        for (const [name, cookie] of this.cookies) {
+            headers.append("cookie", `${name}=${cookie.value}`);
+        }
+    }
+}

package/node_modules/engine.io-client/build/esm-debug/index.d.ts

@@ -0,0 +1,15 @@
+import { Socket } from "./socket.js";
+export { Socket };
+export { SocketOptions, SocketWithoutUpgrade, SocketWithUpgrade, } from "./socket.js";
+export declare const protocol: number;
+export { Transport, TransportError } from "./transport.js";
+export { transports } from "./transports/index.js";
+export { installTimerFunctions } from "./util.js";
+export { parse } from "./contrib/parseuri.js";
+export { nextTick } from "./globals.node.js";
+export { Fetch } from "./transports/polling-fetch.js";
+export { XHR as NodeXHR } from "./transports/polling-xhr.node.js";
+export { XHR } from "./transports/polling-xhr.js";
+export { WS as NodeWebSocket } from "./transports/websocket.node.js";
+export { WS as WebSocket } from "./transports/websocket.js";
+export { WT as WebTransport } from "./transports/webtransport.js";

package/node_modules/engine.io-client/build/esm-debug/index.js

@@ -0,0 +1,15 @@
+import { Socket } from "./socket.js";
+export { Socket };
+export { SocketWithoutUpgrade, SocketWithUpgrade, } from "./socket.js";
+export const protocol = Socket.protocol;
+export { Transport, TransportError } from "./transport.js";
+export { transports } from "./transports/index.js";
+export { installTimerFunctions } from "./util.js";
+export { parse } from "./contrib/parseuri.js";
+export { nextTick } from "./globals.node.js";
+export { Fetch } from "./transports/polling-fetch.js";
+export { XHR as NodeXHR } from "./transports/polling-xhr.node.js";
+export { XHR } from "./transports/polling-xhr.js";
+export { WS as NodeWebSocket } from "./transports/websocket.node.js";
+export { WS as WebSocket } from "./transports/websocket.js";
+export { WT as WebTransport } from "./transports/webtransport.js";

package/node_modules/engine.io-client/build/esm-debug/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "engine.io-client",
+  "type": "module",
+  "browser": {
+    "ws": false,
+    "./transports/polling-xhr.node.js": "./transports/polling-xhr.js",
+    "./transports/websocket.node.js": "./transports/websocket.js",
+    "./globals.node.js": "./globals.js"
+  }
+}