lightclawbot 1.1.2 → 1.2.0-beta.0

package/node_modules/engine.io-parser/build/esm/decodePacket.js

@@ -1,55 +0,0 @@
-import { ERROR_PACKET, PACKET_TYPES_REVERSE, } from "./commons.js";
-export const decodePacket = (encodedPacket, binaryType) => {
-    if (typeof encodedPacket !== "string") {
-        return {
-            type: "message",
-            data: mapBinary(encodedPacket, binaryType),
-        };
-    }
-    const type = encodedPacket.charAt(0);
-    if (type === "b") {
-        const buffer = Buffer.from(encodedPacket.substring(1), "base64");
-        return {
-            type: "message",
-            data: mapBinary(buffer, binaryType),
-        };
-    }
-    if (!PACKET_TYPES_REVERSE[type]) {
-        return ERROR_PACKET;
-    }
-    return encodedPacket.length > 1
-        ? {
-            type: PACKET_TYPES_REVERSE[type],
-            data: encodedPacket.substring(1),
-        }
-        : {
-            type: PACKET_TYPES_REVERSE[type],
-        };
-};
-const mapBinary = (data, binaryType) => {
-    switch (binaryType) {
-        case "arraybuffer":
-            if (data instanceof ArrayBuffer) {
-                // from WebSocket & binaryType "arraybuffer"
-                return data;
-            }
-            else if (Buffer.isBuffer(data)) {
-                // from HTTP long-polling
-                return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
-            }
-            else {
-                // from WebTransport (Uint8Array)
-                return data.buffer;
-            }
-        case "nodebuffer":
-        default:
-            if (Buffer.isBuffer(data)) {
-                // from HTTP long-polling or WebSocket & binaryType "nodebuffer" (default)
-                return data;
-            }
-            else {
-                // from WebTransport (Uint8Array)
-                return Buffer.from(data);
-            }
-    }
-};

package/node_modules/engine.io-parser/build/esm/encodePacket.browser.d.ts

@@ -1,4 +0,0 @@
-import { Packet, RawData } from "./commons.js";
-declare const encodePacket: ({ type, data }: Packet, supportsBinary: boolean, callback: (encodedPacket: RawData) => void) => void;
-export declare function encodePacketToBinary(packet: Packet, callback: (encodedPacket: RawData) => void): void | Promise<void>;
-export { encodePacket };

package/node_modules/engine.io-parser/build/esm/encodePacket.browser.js

@@ -1,68 +0,0 @@
-import { PACKET_TYPES } from "./commons.js";
-const withNativeBlob = typeof Blob === "function" ||
-    (typeof Blob !== "undefined" &&
-        Object.prototype.toString.call(Blob) === "[object BlobConstructor]");
-const withNativeArrayBuffer = typeof ArrayBuffer === "function";
-// ArrayBuffer.isView method is not defined in IE10
-const isView = (obj) => {
-    return typeof ArrayBuffer.isView === "function"
-        ? ArrayBuffer.isView(obj)
-        : obj && obj.buffer instanceof ArrayBuffer;
-};
-const 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);
-        }
-    }
-    // plain string
-    return callback(PACKET_TYPES[type] + (data || ""));
-};
-const 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);
-    }
-}
-let TEXT_ENCODER;
-export 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));
-    });
-}
-export { encodePacket };

package/node_modules/engine.io-parser/build/esm/encodePacket.d.ts

@@ -1,3 +0,0 @@
-import { Packet, RawData } from "./commons.js";
-export declare const encodePacket: ({ type, data }: Packet, supportsBinary: boolean, callback: (encodedPacket: RawData) => void) => void;
-export declare function encodePacketToBinary(packet: Packet, callback: (encodedPacket: RawData) => void): void;

package/node_modules/engine.io-parser/build/esm/encodePacket.js

@@ -1,33 +0,0 @@
-import { PACKET_TYPES } from "./commons.js";
-export const encodePacket = ({ type, data }, supportsBinary, callback) => {
-    if (data instanceof ArrayBuffer || ArrayBuffer.isView(data)) {
-        return callback(supportsBinary ? data : "b" + toBuffer(data, true).toString("base64"));
-    }
-    // plain string
-    return callback(PACKET_TYPES[type] + (data || ""));
-};
-const toBuffer = (data, forceBufferConversion) => {
-    if (Buffer.isBuffer(data) ||
-        (data instanceof Uint8Array && !forceBufferConversion)) {
-        return data;
-    }
-    else if (data instanceof ArrayBuffer) {
-        return Buffer.from(data);
-    }
-    else {
-        return Buffer.from(data.buffer, data.byteOffset, data.byteLength);
-    }
-};
-let TEXT_ENCODER;
-export function encodePacketToBinary(packet, callback) {
-    if (packet.data instanceof ArrayBuffer || ArrayBuffer.isView(packet.data)) {
-        return callback(toBuffer(packet.data, false));
-    }
-    encodePacket(packet, true, (encoded) => {
-        if (!TEXT_ENCODER) {
-            // lazily created for compatibility with Node.js 10
-            TEXT_ENCODER = new TextEncoder();
-        }
-        callback(TEXT_ENCODER.encode(encoded));
-    });
-}

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

@@ -1,9 +0,0 @@
-import { encodePacket } from "./encodePacket.js";
-import { decodePacket } from "./decodePacket.js";
-import { Packet, PacketType, RawData, BinaryType } from "./commons.js";
-declare const encodePayload: (packets: Packet[], callback: (encodedPayload: string) => void) => void;
-declare const decodePayload: (encodedPayload: string, binaryType?: BinaryType) => Packet[];
-export declare function createPacketEncoderStream(): any;
-export declare function createPacketDecoderStream(maxPayload: number, binaryType: BinaryType): any;
-export declare const protocol = 4;
-export { encodePacket, encodePayload, decodePacket, decodePayload, Packet, PacketType, RawData, BinaryType, };

package/node_modules/engine.io-parser/build/esm/index.js

@@ -1,156 +0,0 @@
-import { encodePacket, encodePacketToBinary } from "./encodePacket.js";
-import { decodePacket } from "./decodePacket.js";
-import { ERROR_PACKET, } from "./commons.js";
-const SEPARATOR = String.fromCharCode(30); // see https://en.wikipedia.org/wiki/Delimiter#ASCII_delimited_text
-const encodePayload = (packets, callback) => {
-    // some packets may be added to the array while encoding, so the initial length must be saved
-    const length = packets.length;
-    const encodedPackets = new Array(length);
-    let count = 0;
-    packets.forEach((packet, i) => {
-        // force base64 encoding for binary packets
-        encodePacket(packet, false, (encodedPacket) => {
-            encodedPackets[i] = encodedPacket;
-            if (++count === length) {
-                callback(encodedPackets.join(SEPARATOR));
-            }
-        });
-    });
-};
-const 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;
-};
-export function createPacketEncoderStream() {
-    return new TransformStream({
-        transform(packet, controller) {
-            encodePacketToBinary(packet, (encodedPacket) => {
-                const payloadLength = encodedPacket.length;
-                let header;
-                // inspired by the WebSocket format: https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API/Writing_WebSocket_servers#decoding_payload_length
-                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));
-                }
-                // first bit indicates whether the payload is plain text (0) or binary (1)
-                if (packet.data && typeof packet.data !== "string") {
-                    header[0] |= 0x80;
-                }
-                controller.enqueue(header);
-                controller.enqueue(encodedPacket);
-            });
-        },
-    });
-}
-let 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;
-}
-export function createPacketDecoderStream(maxPayload, binaryType) {
-    if (!TEXT_DECODER) {
-        TEXT_DECODER = new TextDecoder();
-    }
-    const chunks = [];
-    let state = 0 /* State.READ_HEADER */;
-    let expectedLength = -1;
-    let isBinary = false;
-    return new TransformStream({
-        transform(chunk, controller) {
-            chunks.push(chunk);
-            while (true) {
-                if (state === 0 /* State.READ_HEADER */) {
-                    if (totalLength(chunks) < 1) {
-                        break;
-                    }
-                    const header = concatChunks(chunks, 1);
-                    isBinary = (header[0] & 0x80) === 0x80;
-                    expectedLength = header[0] & 0x7f;
-                    if (expectedLength < 126) {
-                        state = 3 /* State.READ_PAYLOAD */;
-                    }
-                    else if (expectedLength === 126) {
-                        state = 1 /* State.READ_EXTENDED_LENGTH_16 */;
-                    }
-                    else {
-                        state = 2 /* State.READ_EXTENDED_LENGTH_64 */;
-                    }
-                }
-                else if (state === 1 /* State.READ_EXTENDED_LENGTH_16 */) {
-                    if (totalLength(chunks) < 2) {
-                        break;
-                    }
-                    const headerArray = concatChunks(chunks, 2);
-                    expectedLength = new DataView(headerArray.buffer, headerArray.byteOffset, headerArray.length).getUint16(0);
-                    state = 3 /* State.READ_PAYLOAD */;
-                }
-                else if (state === 2 /* State.READ_EXTENDED_LENGTH_64 */) {
-                    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) {
-                        // the maximum safe integer in JavaScript is 2^53 - 1
-                        controller.enqueue(ERROR_PACKET);
-                        break;
-                    }
-                    expectedLength = n * Math.pow(2, 32) + view.getUint32(4);
-                    state = 3 /* State.READ_PAYLOAD */;
-                }
-                else {
-                    if (totalLength(chunks) < expectedLength) {
-                        break;
-                    }
-                    const data = concatChunks(chunks, expectedLength);
-                    controller.enqueue(decodePacket(isBinary ? data : TEXT_DECODER.decode(data), binaryType));
-                    state = 0 /* State.READ_HEADER */;
-                }
-                if (expectedLength === 0 || expectedLength > maxPayload) {
-                    controller.enqueue(ERROR_PACKET);
-                    break;
-                }
-            }
-        },
-    });
-}
-export const protocol = 4;
-export { encodePacket, encodePayload, decodePacket, decodePayload, };

package/node_modules/engine.io-parser/build/esm/package.json

@@ -1,8 +0,0 @@
-{
-  "name": "engine.io-parser",
-  "type": "module",
-  "browser": {
-    "./encodePacket.js": "./encodePacket.browser.js",
-    "./decodePacket.js": "./decodePacket.browser.js"
-  }
-}

package/node_modules/engine.io-parser/package.json

@@ -1,46 +0,0 @@
-{
-  "name": "engine.io-parser",
-  "description": "Parser for the client for the realtime Engine",
-  "license": "MIT",
-  "version": "5.2.3",
-  "main": "./build/cjs/index.js",
-  "module": "./build/esm/index.js",
-  "exports": {
-    "import": "./build/esm/index.js",
-    "require": "./build/cjs/index.js"
-  },
-  "types": "build/esm/index.d.ts",
-  "devDependencies": {
-    "prettier": "^3.3.2"
-  },
-  "scripts": {
-    "compile": "rimraf ./build && tsc && tsc -p tsconfig.esm.json && ./postcompile.sh",
-    "test": "npm run format:check && npm run compile && if test \"$BROWSERS\" = \"1\" ; then npm run test:browser; else npm run test:node; fi",
-    "test:node": "nyc mocha -r ts-node/register test/index.ts",
-    "test:browser": "zuul test/index.ts --no-coverage",
-    "format:check": "prettier --check 'lib/**/*.ts' 'test/**/*.ts'",
-    "format:fix": "prettier --write 'lib/**/*.ts' 'test/**/*.ts'",
-    "prepack": "npm run compile"
-  },
-  "homepage": "https://github.com/socketio/socket.io/tree/main/packages/engine.io-parser#readme",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/socketio/socket.io.git"
-  },
-  "bugs": {
-    "url": "https://github.com/socketio/socket.io/issues"
-  },
-  "files": [
-    "build/"
-  ],
-  "browser": {
-    "./test/node": "./test/browser",
-    "./build/esm/encodePacket.js": "./build/esm/encodePacket.browser.js",
-    "./build/esm/decodePacket.js": "./build/esm/decodePacket.browser.js",
-    "./build/cjs/encodePacket.js": "./build/cjs/encodePacket.browser.js",
-    "./build/cjs/decodePacket.js": "./build/cjs/decodePacket.browser.js"
-  },
-  "engines": {
-    "node": ">=10.0.0"
-  }
-}

package/node_modules/ms/index.js

@@ -1,162 +0,0 @@
-/**
- * Helpers.
- */
-
-var s = 1000;
-var m = s * 60;
-var h = m * 60;
-var d = h * 24;
-var w = d * 7;
-var y = d * 365.25;
-
-/**
- * Parse or format the given `val`.
- *
- * Options:
- *
- *  - `long` verbose formatting [false]
- *
- * @param {String|Number} val
- * @param {Object} [options]
- * @throws {Error} throw an error if val is not a non-empty string or a number
- * @return {String|Number}
- * @api public
- */
-
-module.exports = function (val, options) {
-  options = options || {};
-  var type = typeof val;
-  if (type === 'string' && val.length > 0) {
-    return parse(val);
-  } else if (type === 'number' && isFinite(val)) {
-    return options.long ? fmtLong(val) : fmtShort(val);
-  }
-  throw new Error(
-    'val is not a non-empty string or a valid number. val=' +
-      JSON.stringify(val)
-  );
-};
-
-/**
- * Parse the given `str` and return milliseconds.
- *
- * @param {String} str
- * @return {Number}
- * @api private
- */
-
-function parse(str) {
-  str = String(str);
-  if (str.length > 100) {
-    return;
-  }
-  var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
-    str
-  );
-  if (!match) {
-    return;
-  }
-  var n = parseFloat(match[1]);
-  var type = (match[2] || 'ms').toLowerCase();
-  switch (type) {
-    case 'years':
-    case 'year':
-    case 'yrs':
-    case 'yr':
-    case 'y':
-      return n * y;
-    case 'weeks':
-    case 'week':
-    case 'w':
-      return n * w;
-    case 'days':
-    case 'day':
-    case 'd':
-      return n * d;
-    case 'hours':
-    case 'hour':
-    case 'hrs':
-    case 'hr':
-    case 'h':
-      return n * h;
-    case 'minutes':
-    case 'minute':
-    case 'mins':
-    case 'min':
-    case 'm':
-      return n * m;
-    case 'seconds':
-    case 'second':
-    case 'secs':
-    case 'sec':
-    case 's':
-      return n * s;
-    case 'milliseconds':
-    case 'millisecond':
-    case 'msecs':
-    case 'msec':
-    case 'ms':
-      return n;
-    default:
-      return undefined;
-  }
-}
-
-/**
- * Short format for `ms`.
- *
- * @param {Number} ms
- * @return {String}
- * @api private
- */
-
-function fmtShort(ms) {
-  var msAbs = Math.abs(ms);
-  if (msAbs >= d) {
-    return Math.round(ms / d) + 'd';
-  }
-  if (msAbs >= h) {
-    return Math.round(ms / h) + 'h';
-  }
-  if (msAbs >= m) {
-    return Math.round(ms / m) + 'm';
-  }
-  if (msAbs >= s) {
-    return Math.round(ms / s) + 's';
-  }
-  return ms + 'ms';
-}
-
-/**
- * Long format for `ms`.
- *
- * @param {Number} ms
- * @return {String}
- * @api private
- */
-
-function fmtLong(ms) {
-  var msAbs = Math.abs(ms);
-  if (msAbs >= d) {
-    return plural(ms, msAbs, d, 'day');
-  }
-  if (msAbs >= h) {
-    return plural(ms, msAbs, h, 'hour');
-  }
-  if (msAbs >= m) {
-    return plural(ms, msAbs, m, 'minute');
-  }
-  if (msAbs >= s) {
-    return plural(ms, msAbs, s, 'second');
-  }
-  return ms + ' ms';
-}
-
-/**
- * Pluralization helper.
- */
-
-function plural(ms, msAbs, n, name) {
-  var isPlural = msAbs >= n * 1.5;
-  return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');
-}

package/node_modules/ms/license.md

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2020 Vercel, Inc.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/node_modules/ms/package.json

@@ -1,38 +0,0 @@
-{
-  "name": "ms",
-  "version": "2.1.3",
-  "description": "Tiny millisecond conversion utility",
-  "repository": "vercel/ms",
-  "main": "./index",
-  "files": [
-    "index.js"
-  ],
-  "scripts": {
-    "precommit": "lint-staged",
-    "lint": "eslint lib/* bin/*",
-    "test": "mocha tests.js"
-  },
-  "eslintConfig": {
-    "extends": "eslint:recommended",
-    "env": {
-      "node": true,
-      "es6": true
-    }
-  },
-  "lint-staged": {
-    "*.js": [
-      "npm run lint",
-      "prettier --single-quote --write",
-      "git add"
-    ]
-  },
-  "license": "MIT",
-  "devDependencies": {
-    "eslint": "4.18.2",
-    "expect.js": "0.3.1",
-    "husky": "0.14.3",
-    "lint-staged": "5.0.0",
-    "mocha": "4.0.1",
-    "prettier": "2.0.5"
-  }
-}

package/node_modules/ms/readme.md

@@ -1,59 +0,0 @@
-# ms
-
-![CI](https://github.com/vercel/ms/workflows/CI/badge.svg)
-
-Use this package to easily convert various time formats to milliseconds.
-
-## Examples
-
-```js
-ms('2 days')  // 172800000
-ms('1d')      // 86400000
-ms('10h')     // 36000000
-ms('2.5 hrs') // 9000000
-ms('2h')      // 7200000
-ms('1m')      // 60000
-ms('5s')      // 5000
-ms('1y')      // 31557600000
-ms('100')     // 100
-ms('-3 days') // -259200000
-ms('-1h')     // -3600000
-ms('-200')    // -200
-```
-
-### Convert from Milliseconds
-
-```js
-ms(60000)             // "1m"
-ms(2 * 60000)         // "2m"
-ms(-3 * 60000)        // "-3m"
-ms(ms('10 hours'))    // "10h"
-```
-
-### Time Format Written-Out
-
-```js
-ms(60000, { long: true })             // "1 minute"
-ms(2 * 60000, { long: true })         // "2 minutes"
-ms(-3 * 60000, { long: true })        // "-3 minutes"
-ms(ms('10 hours'), { long: true })    // "10 hours"
-```
-
-## Features
-
-- Works both in [Node.js](https://nodejs.org) and in the browser
-- If a number is supplied to `ms`, a string with a unit is returned
-- If a string that contains the number is supplied, it returns it as a number (e.g.: it returns `100` for `'100'`)
-- If you pass a string with a number and a valid unit, the number of equivalent milliseconds is returned
-
-## Related Packages
-
-- [ms.macro](https://github.com/knpwrs/ms.macro) - Run `ms` as a macro at build-time.
-
-## Caught a Bug?
-
-1. [Fork](https://help.github.com/articles/fork-a-repo/) this repository to your own GitHub account and then [clone](https://help.github.com/articles/cloning-a-repository/) it to your local device
-2. Link the package to the global module directory: `npm link`
-3. Within the module you want to test your local development instance of ms, just link it to the dependencies: `npm link ms`. Instead of the default one from npm, Node.js will now use your clone of ms!
-
-As always, you can run the tests using: `npm test`