llonebot-dist 7.11.0 → 7.11.2

package/node_modules/file-type/source/index.test-d.ts

@@ -0,0 +1,53 @@
+import {ReadableStream as NodeReadableStream} from 'node:stream/web';
+import {expectType} from 'tsd';
+import {
+	type FileTypeResult,
+	type FileTypeResult as FileTypeResultBrowser,
+	type AnyWebReadableByteStreamWithFileType,
+	fileTypeFromBlob,
+	fileTypeFromBuffer,
+	fileTypeFromFile,
+	fileTypeFromStream,
+	fileTypeStream,
+	FileTypeParser,
+} from './index.js';
+
+// `fileTypeStream`: accepts StreamOptions & FileTypeOptions
+(async () => {
+	const webStream = new ReadableStream<Uint8Array>();
+	expectType<AnyWebReadableByteStreamWithFileType>(await fileTypeStream(webStream, {sampleSize: 256}));
+	expectType<AnyWebReadableByteStreamWithFileType>(await fileTypeStream(webStream, {sampleSize: 256, customDetectors: []}));
+	expectType<AnyWebReadableByteStreamWithFileType>(await fileTypeStream(webStream, {signal: AbortSignal.timeout(1000)}));
+})();
+
+// `FileTypeParser`: tests generic input types and options
+(async () => {
+	const fileTypeParser = new FileTypeParser({customDetectors: [], signal: AbortSignal.timeout(1000)});
+	const fileTypeParserWithMpeg = new FileTypeParser({mpegOffsetTolerance: 10});
+	const webStream = new ReadableStream<Uint8Array>();
+	const nodeWebStream = new NodeReadableStream<Uint8Array>();
+
+	expectType<FileTypeResult | undefined>(await fileTypeParser.fromStream(webStream));
+	expectType<FileTypeResult | undefined>(await fileTypeParser.fromStream(nodeWebStream));
+
+	expectType<AnyWebReadableByteStreamWithFileType>(await fileTypeParser.toDetectionStream(webStream, {sampleSize: 256}));
+})();
+
+// `fileTypeFromStream`: accepts FileTypeOptions
+(async () => {
+	const webStream = new ReadableStream<Uint8Array>();
+	expectType<FileTypeResult | undefined>(await fileTypeFromStream(webStream, {signal: AbortSignal.timeout(1000)}));
+})();
+
+// Test that Blob overload returns browser-specific result
+expectType<Promise<FileTypeResultBrowser | undefined>>(fileTypeFromBlob(new Blob([])));
+
+// `fileTypeFromFile`: accepts a file path and options
+expectType<Promise<FileTypeResult | undefined>>(fileTypeFromFile('file.bin'));
+expectType<Promise<FileTypeResult | undefined>>(fileTypeFromFile('file.bin', {signal: AbortSignal.timeout(1000)}));
+
+// `FileTypeParser#fromFile`: accepts a file path
+(async () => {
+	const fileTypeParser = new FileTypeParser();
+	expectType<Promise<FileTypeResult | undefined>>(fileTypeParser.fromFile('file.bin'));
+})();

package/node_modules/file-type/source/parser.js

@@ -0,0 +1,65 @@
+export const maximumUntrustedSkipSizeInBytes = 16 * 1024 * 1024;
+
+export class ParserHardLimitError extends Error {}
+
+export function getSafeBound(value, maximum, reason) {
+	if (
+		!Number.isFinite(value)
+		|| value < 0
+		|| value > maximum
+	) {
+		throw new ParserHardLimitError(`${reason} has invalid size ${value} (maximum ${maximum} bytes)`);
+	}
+
+	return value;
+}
+
+export async function safeIgnore(tokenizer, length, {maximumLength = maximumUntrustedSkipSizeInBytes, reason = 'skip'} = {}) {
+	const safeLength = getSafeBound(length, maximumLength, reason);
+	await tokenizer.ignore(safeLength);
+}
+
+export async function safeReadBuffer(tokenizer, buffer, options, {maximumLength = buffer.length, reason = 'read'} = {}) {
+	const length = options?.length ?? buffer.length;
+	const safeLength = getSafeBound(length, maximumLength, reason);
+	return tokenizer.readBuffer(buffer, {
+		...options,
+		length: safeLength,
+	});
+}
+
+export function checkBytes(buffer, headers, options) {
+	options = {
+		offset: 0,
+		...options,
+	};
+
+	for (const [index, header] of headers.entries()) {
+		// If a bitmask is set
+		if (options.mask) {
+			// If header doesn't equal `buf` with bits masked off
+			if (header !== (options.mask[index] & buffer[index + options.offset])) {
+				return false;
+			}
+		} else if (header !== buffer[index + options.offset]) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+export function hasUnknownFileSize(tokenizer) {
+	const fileSize = tokenizer.fileInfo.size;
+	return (
+		!Number.isFinite(fileSize)
+		|| fileSize === Number.MAX_SAFE_INTEGER
+	);
+}
+
+export function hasExceededUnknownSizeScanBudget(tokenizer, startOffset, maximumBytes) {
+	return (
+		hasUnknownFileSize(tokenizer)
+		&& tokenizer.position - startOffset > maximumBytes
+	);
+}

package/node_modules/file-type/{supported.js → source/supported.js}

@@ -1,3 +1,5 @@
+// MIME media subtypes prefixed with `x-ft-` are custom and defined by us. They are neither formally registered with IANA nor based on any informal conventions.
+
 export const extensions = [
 	'jpg',
 	'png',
@@ -179,6 +181,9 @@ export const extensions = [
 	'tar.gz',
 	'reg',
 	'dat',
+	'key',
+	'numbers',
+	'pages',
 ];
 
 export const mimeTypes = [
@@ -262,7 +267,7 @@ export const mimeTypes = [
 	'application/x-unix-archive',
 	'application/x-rpm',
 	'application/x-compress',
-	'application/x-lzip',
+	'application/lzip',
 	'application/x-cfb',
 	'application/x-mie',
 	'application/mxf',
@@ -291,8 +296,8 @@ export const mimeTypes = [
 	'model/gltf-binary',
 	'application/vnd.tcpdump.pcap',
 	'audio/x-dsf', // Non-standard
-	'application/x.ms.shortcut', // Invented by us
-	'application/x.apple.alias', // Invented by us
+	'application/x-ms-shortcut', // Informal, used by freedesktop.org shared-mime-info
+	'application/x-ft-apple.alias',
 	'audio/x-voc',
 	'audio/vnd.dolby.dd-raw',
 	'audio/x-m4a',
@@ -332,11 +337,11 @@ export const mimeTypes = [
 	'application/x-ace-compressed',
 	'application/avro',
 	'application/vnd.iccprofile',
-	'application/x.autodesk.fbx', // Invented by us
+	'application/x-ft-fbx',
 	'application/vnd.visio',
 	'application/vnd.android.package-archive',
-	'application/vnd.google.draco', // Invented by us
-	'application/x-lz4', // Invented by us
+	'application/x-ft-draco',
+	'application/x-lz4', // Informal, used by freedesktop.org shared-mime-info
 	'application/vnd.openxmlformats-officedocument.presentationml.template',
 	'application/vnd.openxmlformats-officedocument.spreadsheetml.template',
 	'application/vnd.openxmlformats-officedocument.wordprocessingml.template',
@@ -357,4 +362,7 @@ export const mimeTypes = [
 	'application/x-ms-regedit',
 	'application/x-ft-windows-registry-hive',
 	'application/x-jmp-data',
+	'application/vnd.apple.keynote',
+	'application/vnd.apple.numbers',
+	'application/vnd.apple.pages',
 ];

package/node_modules/file-type/{util.js → source/tokens.js}

@@ -32,7 +32,7 @@ Checks whether the TAR checksum is valid.
 @returns {boolean} `true` if the TAR checksum is valid, otherwise `false`.
 */
 export function tarHeaderChecksumMatches(arrayBuffer, offset = 0) {
-	const readSum = Number.parseInt(new StringType(6).get(arrayBuffer, 148).replace(/\0.*$/, '').trim(), 8); // Read sum in header
+	const readSum = Number.parseInt(new StringType(6).get(arrayBuffer, 148).replace(/\0.*$/v, '').trim(), 8); // Read sum in header
 	if (Number.isNaN(readSum)) {
 		return false;
 	}
@@ -55,6 +55,6 @@ ID3 UINT32 sync-safe tokenizer token.
 28 bits (representing up to 256MB) integer, the msb is 0 to avoid "false syncsignals".
 */
 export const uint32SyncSafeToken = {
-	get: (buffer, offset) => (buffer[offset + 3] & 0x7F) | ((buffer[offset + 2]) << 7) | ((buffer[offset + 1]) << 14) | ((buffer[offset]) << 21),
+	get: (buffer, offset) => (buffer[offset + 3] & 0x7F) | ((buffer[offset + 2] & 0x7F) << 7) | ((buffer[offset + 1] & 0x7F) << 14) | ((buffer[offset] & 0x7F) << 21),
 	len: 4,
 };

package/node_modules/strtok3/LICENSE.txt

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright © 2025 Borewit
+Copyright © 2026 Borewit
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/node_modules/strtok3/README.md

@@ -229,7 +229,7 @@ readBuffer(buffer: Uint8Array, options?: IReadChunkOptions): Promise<number>;
 | Parameter  | Type                                                           | Description                                                                                                                                                                                                                            |
 |------------|----------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
 | buffer     | [Buffer](https://nodejs.org/api/buffer.html) &#124; Uint8Array | Target buffer to write the data read to                                                                                                                                                                                                |
-| options    | [IReadChunkOptions](#ireadchunkoptions)                        | An integer specifying the number of bytes to read                                                                                                                                                                                      |
+| options    | [IReadChunkOptions](#ireadchunkoptions-interface)                        | An integer specifying the number of bytes to read                                                                                                                                                                                      |
 
 Return promise with number of bytes read.
 The number of bytes read may be less than requested if the `mayBeLess` flag is set.
@@ -245,7 +245,7 @@ peekBuffer(uint8Array: Uint8Array, options?: IReadChunkOptions): Promise<number>
 | Parameter  | Type                                    | Description                                         |
 |------------|-----------------------------------------|-----------------------------------------------------|
 | buffer     | Buffer &#124; Uint8Array                | Target buffer to write the data read (peeked) to.   |
-| options    | [IReadChunkOptions](#ireadchunkoptions) | An integer specifying the number of bytes to read.  |                                                                                                                           |
+| options    | [IReadChunkOptions](#ireadchunkoptions-interface) | An integer specifying the number of bytes to read.  |                                                                                                                           |
 
 Return value `Promise<number>` Promise with number of bytes read. The number of bytes read may be less if the `mayBeLess` flag was set.
 

package/node_modules/strtok3/lib/AbstractTokenizer.d.ts

@@ -65,7 +65,7 @@ export declare abstract class AbstractTokenizer implements ITokenizer {
     peekNumber(token: IToken<number>): Promise<number>;
     /**
      * Ignore number of bytes, advances the pointer in under tokenizer-stream.
-     * @param length - Number of bytes to ignore
+     * @param length - Number of bytes to ignore.  Must be ≥ 0.
      * @return resolves the number of bytes ignored, equals length if this available, otherwise the number of bytes available
      */
     ignore(length: number): Promise<number>;

package/node_modules/strtok3/lib/AbstractTokenizer.js

@@ -71,10 +71,13 @@ export class AbstractTokenizer {
     }
     /**
      * Ignore number of bytes, advances the pointer in under tokenizer-stream.
-     * @param length - Number of bytes to ignore
+     * @param length - Number of bytes to ignore.  Must be ≥ 0.
      * @return resolves the number of bytes ignored, equals length if this available, otherwise the number of bytes available
      */
     async ignore(length) {
+        if (length < 0) {
+            throw new RangeError('ignore length must be ≥ 0 bytes');
+        }
         if (this.fileInfo.size !== undefined) {
             const bytesLeft = this.fileInfo.size - this.position;
             if (length > bytesLeft) {

package/node_modules/strtok3/lib/ReadStreamTokenizer.d.ts

@@ -24,6 +24,9 @@ export declare class ReadStreamTokenizer extends AbstractTokenizer {
      * @returns Promise with number of bytes peeked
      */
     peekBuffer(uint8Array: Uint8Array, options?: IReadChunkOptions): Promise<number>;
+    /**
+     * @param length Number of bytes to ignore. Must be ≥ 0.
+     */
     ignore(length: number): Promise<number>;
     abort(): Promise<void>;
     close(): Promise<void>;

package/node_modules/strtok3/lib/ReadStreamTokenizer.js

@@ -75,8 +75,13 @@ export class ReadStreamTokenizer extends AbstractTokenizer {
         }
         return bytesRead;
     }
+    /**
+     * @param length Number of bytes to ignore. Must be ≥ 0.
+     */
     async ignore(length) {
-        // debug(`ignore ${this.position}...${this.position + length - 1}`);
+        if (length < 0) {
+            throw new RangeError('ignore length must be ≥ 0 bytes');
+        }
         const bufSize = Math.min(maxBufferSize, length);
         const buf = new Uint8Array(bufSize);
         let totBytesRead = 0;

package/node_modules/strtok3/lib/stream/WebStreamByobReader.js

@@ -13,7 +13,7 @@ export class WebStreamByobReader extends WebStreamReader {
     async readFromStream(buffer, mayBeLess) {
         if (buffer.length === 0)
             return 0;
-        // @ts-ignore
+        // @ts-expect-error
         const result = await this.reader.read(new Uint8Array(buffer.length), { min: mayBeLess ? undefined : buffer.length });
         if (result.done) {
             this.endOfStream = result.done;

package/node_modules/strtok3/package.json

@@ -1,6 +1,6 @@
 {
   "name": "strtok3",
-  "version": "10.3.4",
+  "version": "10.3.5",
   "description": "A promise based streaming tokenizer",
   "author": {
     "name": "Borewit",
@@ -34,7 +34,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/Borewit/strtok3.git"
+    "url": "git+https://github.com/Borewit/strtok3.git"
   },
   "license": "MIT",
   "type": "module",
@@ -57,21 +57,21 @@
     "@tokenizer/token": "^0.3.0"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.1.2",
+    "@biomejs/biome": "2.4.8",
     "@types/chai": "^5.2.2",
     "@types/chai-as-promised": "^8.0.2",
     "@types/debug": "^4.1.12",
     "@types/mocha": "^10.0.10",
     "@types/node": "^24.1.0",
-    "c8": "^10.1.3",
+    "c8": "^11.0.0",
     "chai": "^5.2.1",
-    "chai-as-promised": "^8.0.1",
-    "del-cli": "^6.0.0",
-    "mocha": "^11.7.1",
+    "chai-as-promised": "^8.0.2",
+    "del-cli": "^7.0.0",
+    "mocha": "^11.7.5",
     "node-readable-to-web-readable-stream": "^0.4.2",
     "remark-cli": "^12.0.1",
     "remark-preset-lint-recommended": "^7.0.1",
-    "token-types": "^6.0.4",
+    "token-types": "^6.1.2",
     "ts-node": "^10.9.2",
     "typescript": "^5.8.3",
     "uint8array-extras": "^1.4.0"

package/node_modules/ws/index.js

@@ -1,13 +1,22 @@
 'use strict';
 
+const createWebSocketStream = require('./lib/stream');
+const extension = require('./lib/extension');
+const PerMessageDeflate = require('./lib/permessage-deflate');
+const Receiver = require('./lib/receiver');
+const Sender = require('./lib/sender');
+const subprotocol = require('./lib/subprotocol');
 const WebSocket = require('./lib/websocket');
+const WebSocketServer = require('./lib/websocket-server');
 
-WebSocket.createWebSocketStream = require('./lib/stream');
-WebSocket.Server = require('./lib/websocket-server');
-WebSocket.Receiver = require('./lib/receiver');
-WebSocket.Sender = require('./lib/sender');
-
+WebSocket.createWebSocketStream = createWebSocketStream;
+WebSocket.extension = extension;
+WebSocket.PerMessageDeflate = PerMessageDeflate;
+WebSocket.Receiver = Receiver;
+WebSocket.Sender = Sender;
+WebSocket.Server = WebSocketServer;
+WebSocket.subprotocol = subprotocol;
 WebSocket.WebSocket = WebSocket;
-WebSocket.WebSocketServer = WebSocket.Server;
+WebSocket.WebSocketServer = WebSocketServer;
 
 module.exports = WebSocket;

package/node_modules/ws/lib/permessage-deflate.js

@@ -37,6 +37,9 @@ class PerMessageDeflate {
    *     acknowledge disabling of client context takeover
    * @param {Number} [options.concurrencyLimit=10] The number of concurrent
    *     calls to zlib
+   * @param {Boolean} [options.isServer=false] Create the instance in either
+   *     server or client mode
+   * @param {Number} [options.maxPayload=0] The maximum allowed message length
    * @param {(Boolean|Number)} [options.serverMaxWindowBits] Request/confirm the
    *     use of a custom server window size
    * @param {Boolean} [options.serverNoContextTakeover=false] Request/accept
@@ -47,16 +50,13 @@ class PerMessageDeflate {
    *     deflate
    * @param {Object} [options.zlibInflateOptions] Options to pass to zlib on
    *     inflate
-   * @param {Boolean} [isServer=false] Create the instance in either server or
-   *     client mode
-   * @param {Number} [maxPayload=0] The maximum allowed message length
    */
-  constructor(options, isServer, maxPayload) {
-    this._maxPayload = maxPayload | 0;
+  constructor(options) {
     this._options = options || {};
     this._threshold =
       this._options.threshold !== undefined ? this._options.threshold : 1024;
-    this._isServer = !!isServer;
+    this._maxPayload = this._options.maxPayload | 0;
+    this._isServer = !!this._options.isServer;
     this._deflate = null;
     this._inflate = null;
 

package/node_modules/ws/lib/websocket-server.js

@@ -293,11 +293,11 @@ class WebSocketServer extends EventEmitter {
       this.options.perMessageDeflate &&
       secWebSocketExtensions !== undefined
     ) {
-      const perMessageDeflate = new PerMessageDeflate(
-        this.options.perMessageDeflate,
-        true,
-        this.options.maxPayload
-      );
+      const perMessageDeflate = new PerMessageDeflate({
+        ...this.options.perMessageDeflate,
+        isServer: true,
+        maxPayload: this.options.maxPayload
+      });
 
       try {
         const offers = extension.parse(secWebSocketExtensions);

package/node_modules/ws/lib/websocket.js

@@ -693,7 +693,7 @@ function initAsClient(websocket, address, protocols, options) {
   } else {
     try {
       parsedUrl = new URL(address);
-    } catch (e) {
+    } catch {
       throw new SyntaxError(`Invalid URL: ${address}`);
     }
   }
@@ -755,11 +755,11 @@ function initAsClient(websocket, address, protocols, options) {
   opts.timeout = opts.handshakeTimeout;
 
   if (opts.perMessageDeflate) {
-    perMessageDeflate = new PerMessageDeflate(
-      opts.perMessageDeflate !== true ? opts.perMessageDeflate : {},
-      false,
-      opts.maxPayload
-    );
+    perMessageDeflate = new PerMessageDeflate({
+      ...opts.perMessageDeflate,
+      isServer: false,
+      maxPayload: opts.maxPayload
+    });
     opts.headers['Sec-WebSocket-Extensions'] = format({
       [PerMessageDeflate.extensionName]: perMessageDeflate.offer()
     });

package/node_modules/ws/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ws",
-  "version": "8.19.0",
+  "version": "8.20.0",
   "description": "Simple to use, blazing fast and thoroughly tested websocket client and server for Node.js",
   "keywords": [
     "HyBi",
@@ -55,12 +55,13 @@
     }
   },
   "devDependencies": {
+    "@eslint/js": "^10.0.1",
     "benchmark": "^2.1.4",
     "bufferutil": "^4.0.1",
-    "eslint": "^9.0.0",
+    "eslint": "^10.0.1",
     "eslint-config-prettier": "^10.0.1",
     "eslint-plugin-prettier": "^5.0.0",
-    "globals": "^16.0.0",
+    "globals": "^17.0.0",
     "mocha": "^8.4.0",
     "nyc": "^15.0.0",
     "prettier": "^3.0.0",

package/node_modules/ws/wrapper.mjs

@@ -1,8 +1,21 @@
 import createWebSocketStream from './lib/stream.js';
+import extension from './lib/extension.js';
+import PerMessageDeflate from './lib/permessage-deflate.js';
 import Receiver from './lib/receiver.js';
 import Sender from './lib/sender.js';
+import subprotocol from './lib/subprotocol.js';
 import WebSocket from './lib/websocket.js';
 import WebSocketServer from './lib/websocket-server.js';
 
-export { createWebSocketStream, Receiver, Sender, WebSocket, WebSocketServer };
+export {
+  createWebSocketStream,
+  extension,
+  PerMessageDeflate,
+  Receiver,
+  Sender,
+  subprotocol,
+  WebSocket,
+  WebSocketServer
+};
+
 export default WebSocket;

package/package.json

@@ -1 +1 @@
-{"name":"llonebot-dist","version":"7.11.0","type":"module","description":"","main":"llbot.js","author":"linyuchen","repository":{"type":"git","url":"https://github.com/LLOneBot/LuckyLilliaBot"}}
+{"name":"llonebot-dist","version":"7.11.2","type":"module","description":"","main":"llbot.js","author":"linyuchen","repository":{"type":"git","url":"https://github.com/LLOneBot/LuckyLilliaBot"}}