llonebot-dist 7.11.0 → 7.11.2

package/node_modules/file-type/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "file-type",
-	"version": "21.3.2",
+	"version": "22.0.0",
 	"description": "Detect the file type of a file, stream, or data",
 	"license": "MIT",
 	"repository": "sindresorhus/file-type",
@@ -12,41 +12,18 @@
 	},
 	"type": "module",
 	"exports": {
-		".": {
-			"node": {
-				"types": "./index.d.ts",
-				"import": "./index.js",
-				"module-sync": "./index.js"
-			},
-			"default": {
-				"types": "./core.d.ts",
-				"import": "./core.js",
-				"module-sync": "./core.js"
-			}
-		},
-		"./core": {
-			"types": "./core.d.ts",
-			"default": "./core.js"
-		},
-		"./node": {
-			"types": "./index.d.ts",
-			"default": "./index.js"
-		}
+		"types": "./source/index.d.ts",
+		"default": "./source/index.js"
 	},
 	"sideEffects": false,
 	"engines": {
-		"node": ">=20"
+		"node": ">=22"
 	},
 	"scripts": {
-		"test": "xo && ava && tsd"
+		"test": "xo && ava && tsd --typings source/index.d.ts --files source/index.test-d.ts"
 	},
 	"files": [
-		"index.js",
-		"index.d.ts",
-		"core.js",
-		"core.d.ts",
-		"supported.js",
-		"util.js"
+		"source"
 	],
 	"keywords": [
 		"mime",
@@ -248,42 +225,48 @@
 		"ppsx",
 		"tar.gz",
 		"reg",
-		"dat"
+		"dat",
+		"key",
+		"numbers",
+		"pages"
 	],
 	"dependencies": {
 		"@tokenizer/inflate": "^0.4.1",
-		"strtok3": "^10.3.4",
-		"token-types": "^6.1.1",
-		"uint8array-extras": "^1.4.0"
+		"strtok3": "^10.3.5",
+		"token-types": "^6.1.2",
+		"uint8array-extras": "^1.5.0"
 	},
 	"devDependencies": {
 		"@tokenizer/token": "^0.3.0",
-		"@types/node": "^25.3.3",
+		"@types/node": "^25.5.0",
 		"ava": "^7.0.0",
 		"commonmark": "^0.31.2",
 		"get-stream": "^9.0.1",
-		"noop-stream": "^1.0.0",
 		"tsd": "^0.33.0",
-		"xo": "^0.60.0"
+		"xo": "^2.0.2"
 	},
-	"xo": {
-		"envs": [
-			"node",
-			"browser"
-		],
-		"ignores": [
-			"fixture"
-		],
-		"rules": {
-			"no-inner-declarations": "warn",
-			"no-await-in-loop": "warn",
-			"no-bitwise": "off",
-			"@typescript-eslint/no-unsafe-assignment": "off",
-			"unicorn/text-encoding-identifier-case": "off",
-			"unicorn/switch-case-braces": "off",
-			"unicorn/prefer-top-level-await": "off"
+	"xo": [
+		{
+			"ignores": [
+				"fixture/**"
+			]
+		},
+		{
+			"rules": {
+				"no-inner-declarations": "warn",
+				"no-await-in-loop": "warn",
+				"no-bitwise": "off",
+				"@typescript-eslint/no-unsafe-assignment": "off",
+				"unicorn/text-encoding-identifier-case": "off",
+				"unicorn/switch-case-braces": "off",
+				"unicorn/prefer-top-level-await": "off",
+				"n/prefer-global/buffer": "off",
+				"@stylistic/curly-newline": "off",
+				"ava/no-useless-t-pass": "off",
+				"ava/no-conditional-assertion": "off"
+			}
 		}
-	},
+	],
 	"ava": {
 		"serial": true
 	}

package/node_modules/file-type/readme.md

@@ -50,52 +50,6 @@ console.log(await fileTypeFromBuffer(buffer));
 
 Determine file type from a stream:
 
-```js
-import fs from 'node:fs';
-import {fileTypeFromStream} from 'file-type';
-
-const stream = fs.createReadStream('Unicorn.mp4');
-
-console.log(await fileTypeFromStream(stream));
-//=> {ext: 'mp4', mime: 'video/mp4'}
-```
-
-The stream method can also be used to read from a remote location:
-
-```js
-import got from 'got';
-import {fileTypeFromStream} from 'file-type';
-
-const url = 'https://upload.wikimedia.org/wikipedia/en/a/a9/Example.jpg';
-
-const stream = got.stream(url);
-
-console.log(await fileTypeFromStream(stream));
-//=> {ext: 'jpg', mime: 'image/jpeg'}
-```
-
-Another stream example:
-
-```js
-import stream from 'node:stream';
-import fs from 'node:fs';
-import crypto from 'node:crypto';
-import {fileTypeStream} from 'file-type';
-
-const read = fs.createReadStream('encrypted.enc');
-const decipher = crypto.createDecipheriv(alg, key, iv);
-
-const streamWithFileType = await fileTypeStream(stream.pipeline(read, decipher));
-
-console.log(streamWithFileType.fileType);
-//=> {ext: 'mov', mime: 'video/quicktime'}
-
-const write = fs.createWriteStream(`decrypted.${streamWithFileType.fileType.ext}`);
-streamWithFileType.pipe(write);
-```
-
-### Browser
-
 ```js
 import {fileTypeFromStream} from 'file-type';
 
@@ -112,7 +66,7 @@ console.log(fileType);
 
 ### fileTypeFromBuffer(buffer, options)
 
-Detect the file type of a `Uint8Array`, or `ArrayBuffer`.
+Detect the file type of a `Uint8Array` or `ArrayBuffer`.
 
 The file type is detected by checking the [magic number](https://en.wikipedia.org/wiki/Magic_number_(programming)#Magic_numbers_in_files) of the buffer.
 
@@ -135,11 +89,9 @@ A buffer representing file data. It works best if the buffer contains the entire
 
 Detect the file type of a file path.
 
-This is for Node.js only.
+Only available in environments where `node:fs` is available, such as Node.js. To read from a [`File`](https://developer.mozilla.org/docs/Web/API/File), see [`fileTypeFromBlob()`](#filetypefromblobblob-options).
 
-To read from a [`File`](https://developer.mozilla.org/docs/Web/API/File), see [`fileTypeFromBlob()`](#filetypefromblobblob-options).
-
-The file type is detected by checking the [magic number](https://en.wikipedia.org/wiki/Magic_number_(programming)#Magic_numbers_in_files) of the buffer.
+The file type is detected by checking the [magic number](https://en.wikipedia.org/wiki/Magic_number_(programming)#Magic_numbers_in_files) of the file.
 
 Returns a `Promise` for an object with the detected file type:
 
@@ -154,14 +106,10 @@ Type: `string`
 
 The file path to parse.
 
-### fileTypeFromStream(stream)
+### fileTypeFromStream(stream, options)
 
 Detect the file type of a [web `ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream).
 
-If the engine is Node.js, this may also be a [Node.js `stream.Readable`](https://nodejs.org/api/stream.html#stream_class_stream_readable).
-
-Direct support for Node.js streams will be dropped in the future, when Node.js streams can be converted to Web streams (see [`toWeb()`](https://nodejs.org/api/stream.html#streamreadabletowebstreamreadable-options)).
-
 The file type is detected by checking the [magic number](https://en.wikipedia.org/wiki/Magic_number_(programming)#Magic_numbers_in_files) of the buffer.
 
 Returns a `Promise` for an object with the detected file type:
@@ -173,13 +121,16 @@ Or `undefined` when there is no match.
 
 #### stream
 
-Type: [Web `ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream) or [Node.js `stream.Readable`](https://nodejs.org/api/stream.html#stream_class_stream_readable)
+Type: [Web `ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream)
 
 A readable stream representing file data.
 
+> [!TIP]
+> If you have a Node.js `stream.Readable`, convert it with [`Readable.toWeb()`](https://nodejs.org/api/stream.html#streamreadabletowebstreamreadable-options).
+
 ### fileTypeFromBlob(blob, options)
 
-Detect the file type of a [`Blob`](https://developer.mozilla.org/docs/Web/API/Blob),
+Detect the file type of a [`Blob`](https://developer.mozilla.org/docs/Web/API/Blob).
 
 > [!TIP]
 > A [`File` object](https://developer.mozilla.org/docs/Web/API/File) is a `Blob` and can be passed in here.
@@ -248,7 +199,6 @@ import {S3Client} from '@aws-sdk/client-s3';
 import {makeChunkedTokenizerFromS3} from '@tokenizer/s3';
 import {fileTypeFromTokenizer} from 'file-type';
 
-// Initialize the S3 client
 // Initialize S3 client
 const s3 = new S3Client();
 
@@ -275,16 +225,16 @@ A file source implementing the [tokenizer interface](https://github.com/Borewit/
 
 Returns a `Promise` which resolves to the original readable stream argument, but with an added `fileType` property, which is an object like the one returned from `fileTypeFromFile()`.
 
-This method can be handy to put in between a stream, but it comes with a price.
+This method can be handy to put in a stream pipeline, but it comes with a price.
 Internally `stream()` builds up a buffer of `sampleSize` bytes, used as a sample, to determine the file type.
 The sample size impacts the file detection resolution.
 A smaller sample size will result in lower probability of the best file type detection.
 
-**Note:** When using Node.js, a `stream.Readable` may be provided as well.
+#### webStream
 
-#### readableStream
+Type: [Web `ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream)
 
-Type: [`stream.Readable`](https://nodejs.org/api/stream.html#stream_class_stream_readable)
+The input stream.
 
 #### options
 
@@ -302,25 +252,18 @@ The sample size in bytes.
 #### Example
 
 ```js
-import got from 'got';
 import {fileTypeStream} from 'file-type';
 
 const url = 'https://upload.wikimedia.org/wikipedia/en/a/a9/Example.jpg';
 
-const stream1 = got.stream(url);
-const stream2 = await fileTypeStream(stream1, {sampleSize: 1024});
+const response = await fetch(url);
+const stream = await fileTypeStream(response.body, {sampleSize: 1024});
 
-if (stream2.fileType?.mime === 'image/jpeg') {
-	// stream2 can be used to stream the JPEG image (from the very beginning of the stream)
+if (stream.fileType?.mime === 'image/jpeg') {
+	// stream can be used to stream the JPEG image (from the very beginning of the stream)
 }
 ```
 
-#### readableStream
-
-Type: [`stream.Readable`](https://nodejs.org/api/stream.html#stream_class_stream_readable)
-
-The input stream.
-
 ### supportedExtensions
 
 Returns a `Set<string>` of supported file extensions.
@@ -360,15 +303,11 @@ A tolerance of 10 bytes covers most cases.
 Custom file type detectors are plugins designed to extend the default detection capabilities.
 They allow support for uncommon file types, non-binary formats, or customized detection behavior.
 
-Detectors can be added via the constructor options or by modifying `FileTypeParser#detectors` directly.
-Detectors provided through the constructor are executed before the default ones.
-
 Detectors can be added via the constructor options or by directly modifying `FileTypeParser#detectors`.
+Detectors provided through the constructor are executed before the default ones.
 
 ### Example adding a detector
 
-For example:
-
 ```js
 import {FileTypeParser} from 'file-type';
 import {detectXml} from '@file-type/xml';
@@ -394,14 +333,14 @@ If a detector returns `undefined`, the following rules apply:
 
 ### Writing your own custom detector
 
-Below is an example of a custom detector array. This can be passed to the `FileTypeParser` via the `fileTypeOptions` argument.
+Below is an example of a custom detector. This can be passed to the `FileTypeParser` via the `customDetectors` option.
 
 ```js
 import {FileTypeParser} from 'file-type';
 
 const unicornDetector = {
 	id: 'unicorn', // May be used to recognize the detector in the detector list
-  	async detect(tokenizer) {
+	async detect(tokenizer) {
 		const unicornHeader = [85, 78, 73, 67, 79, 82, 78]; // "UNICORN" in ASCII decimal
 
 		const buffer = new Uint8Array(unicornHeader.length);
@@ -426,7 +365,10 @@ console.log(fileType); // {ext: 'unicorn', mime: 'application/unicorn'}
 @param fileType - The file type detected by standard or previous custom detectors, or `undefined` if no match is found.
 @returns The detected file type, or `undefined` if no match is found.
 */
-export type Detector = (tokenizer: ITokenizer, fileType?: FileTypeResult) => Promise<FileTypeResult | undefined>;
+export type Detector = {
+	id: string;
+	detect: (tokenizer: ITokenizer, fileType?: FileTypeResult) => Promise<FileTypeResult | undefined>;
+};
 ```
 
 ## Abort signal
@@ -436,9 +378,9 @@ Some async operations can be aborted by passing an [`AbortSignal`](https://devel
 ```js
 import {FileTypeParser} from 'file-type';
 
-const abortController = new AbortController()
+const abortController = new AbortController();
 
-const parser = new FileTypeParser({abortSignal: abortController.signal});
+const parser = new FileTypeParser({signal: abortController.signal});
 
 const promise = parser.fromStream(blob.stream());
 
@@ -447,6 +389,8 @@ abortController.abort(); // Abort file-type reading from the Blob stream.
 
 ## Supported file types
 
+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.
+
 - [`3g2`](https://en.wikipedia.org/wiki/3GP_and_3G2#3G2) - Multimedia container format defined by the 3GPP2 for 3G CDMA2000 multimedia services
 - [`3gp`](https://en.wikipedia.org/wiki/3GP_and_3G2#3GP) - Multimedia container format defined by the Third Generation Partnership Project (3GPP) for 3G UMTS multimedia services
 - [`3mf`](https://en.wikipedia.org/wiki/3D_Manufacturing_Format) - 3D Manufacturing Format
@@ -528,6 +472,7 @@ abortController.abort(); // Abort file-type reading from the Blob stream.
 - [`jpx`](https://en.wikipedia.org/wiki/JPEG_2000) - JPEG 2000
 - [`jxl`](https://en.wikipedia.org/wiki/JPEG_XL) - JPEG XL image format
 - [`jxr`](https://en.wikipedia.org/wiki/JPEG_XR) - Joint Photographic Experts Group extended range
+- [`key`](https://en.wikipedia.org/wiki/Keynote_(presentation_software)) - Apple Keynote presentation
 - [`ktx`](https://www.khronos.org/opengles/sdk/tools/KTX/file_format_spec/) - OpenGL and OpenGL ES textures
 - [`lnk`](https://en.wikipedia.org/wiki/Shortcut_%28computing%29#Microsoft_Windows) - Microsoft Windows file shortcut
 - [`lz`](https://en.wikipedia.org/wiki/Lzip) - Archive file
@@ -554,6 +499,7 @@ abortController.abort(); // Abort file-type reading from the Blob stream.
 - [`mxf`](https://en.wikipedia.org/wiki/Material_Exchange_Format) - Material Exchange Format
 - [`nef`](https://www.nikonusa.com/en/learn-and-explore/a/products-and-innovation/nikon-electronic-format-nef.html) - Nikon Electronic Format image file
 - [`nes`](https://fileinfo.com/extension/nes) - Nintendo NES ROM
+- [`numbers`](https://en.wikipedia.org/wiki/Numbers_(spreadsheet)) - Apple Numbers spreadsheet
 - [`odg`](https://en.wikipedia.org/wiki/OpenDocument) - OpenDocument for drawing
 - [`odp`](https://en.wikipedia.org/wiki/OpenDocument) - OpenDocument for presentations
 - [`ods`](https://en.wikipedia.org/wiki/OpenDocument) - OpenDocument for spreadsheets
@@ -570,6 +516,7 @@ abortController.abort(); // Abort file-type reading from the Blob stream.
 - [`otp`](https://en.wikipedia.org/wiki/OpenDocument_technical_specification#Templates) - OpenDocument template for presentations
 - [`ots`](https://en.wikipedia.org/wiki/OpenDocument_technical_specification#Templates) - OpenDocument template for spreadsheets
 - [`ott`](https://en.wikipedia.org/wiki/OpenDocument_technical_specification#Templates) - OpenDocument template for word processing
+- [`pages`](https://en.wikipedia.org/wiki/Pages_(word_processor)) - Apple Pages document
 - [`parquet`](https://en.wikipedia.org/wiki/Apache_Parquet) - Apache Parquet
 - [`pcap`](https://wiki.wireshark.org/Development/LibpcapFileFormat) - Libpcap File Format
 - [`pdf`](https://en.wikipedia.org/wiki/Portable_Document_Format) - Portable Document Format
@@ -581,7 +528,7 @@ abortController.abort(); // Abort file-type reading from the Blob stream.
 - [`ppsx`](https://en.wikipedia.org/wiki/List_of_Microsoft_Office_filename_extensions#PowerPoint) - Office PowerPoint 2007 slide show
 - [`pptm`](https://en.wikipedia.org/wiki/List_of_Microsoft_Office_filename_extensions) - Microsoft PowerPoint macro-enabled document
 - [`pptx`](https://en.wikipedia.org/wiki/Office_Open_XML) - Microsoft PowerPoint document
-- [`ps`](https://en.wikipedia.org/wiki/Postscript) - Postscript
+- [`ps`](https://en.wikipedia.org/wiki/Postscript) - PostScript
 - [`psd`](https://en.wikipedia.org/wiki/Adobe_Photoshop#File_format) - Adobe Photoshop document
 - [`pst`](https://en.wikipedia.org/wiki/Personal_Storage_Table) - Personal Storage Table file
 - [`qcp`](https://en.wikipedia.org/wiki/QCP) - Tagged and chunked data
@@ -598,7 +545,7 @@ abortController.abort(); // Abort file-type reading from the Blob stream.
 - [`skp`](https://en.wikipedia.org/wiki/SketchUp) - SketchUp
 - [`spx`](https://en.wikipedia.org/wiki/Ogg) - Audio file
 - [`sqlite`](https://www.sqlite.org/fileformat2.html) - SQLite file
-- [`stl`](https://en.wikipedia.org/wiki/STL_(file_format)) - Standard Tesselated Geometry File Format (ASCII only)
+- [`stl`](https://en.wikipedia.org/wiki/STL_(file_format)) - Standard Tessellated Geometry File Format (ASCII only)
 - [`swf`](https://en.wikipedia.org/wiki/SWF) - Adobe Flash Player file
 - [`tar`](https://en.wikipedia.org/wiki/Tar_(computing)#File_format) - Tape archive or tarball
 - [`tar.gz`](https://en.wikipedia.org/wiki/Gzip) - Gzipped tape archive (tarball)
@@ -630,29 +577,15 @@ abortController.abort(); // Abort file-type reading from the Blob stream.
 
 *[Pull requests](.github/pull_request_template.md) are welcome for additional commonly used file types.*
 
-The following file types will not be accepted, but most of them are supported by [third-party detector](#available-third-party-file-type-detectors)
+The following file types will not be accepted, but most of them are supported by [third-party detectors](#available-third-party-file-type-detectors).
 - [MS-CFB: Microsoft Compound File Binary File Format based formats](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-cfb/53989ce4-7b05-4f8d-829b-d08d6148375b)
 	- `.doc` - Microsoft Word 97-2003 Document
 	- `.xls` - Microsoft Excel 97-2003 Document
-	- `.ppt` - Microsoft PowerPoint97-2003 Document
+	- `.ppt` - Microsoft PowerPoint 97-2003 Document
 	- `.msi` - Microsoft Windows Installer
 - `.csv` - [Reason.](https://github.com/sindresorhus/file-type/issues/264#issuecomment-568439196)
 - `.svg`
 
-#### tokenizer
-
-Type: [`ITokenizer`](https://github.com/Borewit/strtok3#tokenizer)
-
-Usable as source of the examined file.
-
-#### fileType
-
-Type: `FileTypeResult`
-
-An object having an `ext` (extension) and `mime` (mime type) property.
-
-Detected by the standard detections or a previous custom detection. Undefined if no matching fileTypeResult could be found.
-
 ## Related
 
 - [file-type-cli](https://github.com/sindresorhus/file-type-cli) - CLI for this module

package/node_modules/file-type/source/detectors/asf.js

@@ -0,0 +1,127 @@
+import * as Token from 'token-types';
+import * as strtok3 from 'strtok3/core';
+import {
+	maximumUntrustedSkipSizeInBytes,
+	ParserHardLimitError,
+	checkBytes,
+	safeReadBuffer,
+	safeIgnore,
+	hasUnknownFileSize,
+	hasExceededUnknownSizeScanBudget,
+} from '../parser.js';
+
+const maximumAsfHeaderObjectCount = 512;
+const maximumAsfHeaderPayloadSizeInBytes = 1024 * 1024;
+
+export async function detectAsf(tokenizer) {
+	let isMalformedAsf = false;
+	try {
+		async function readHeader() {
+			const guid = new Uint8Array(16);
+			await safeReadBuffer(tokenizer, guid, undefined, {
+				maximumLength: guid.length,
+				reason: 'ASF header GUID',
+			});
+			return {
+				id: guid,
+				size: Number(await tokenizer.readToken(Token.UINT64_LE)),
+			};
+		}
+
+		await safeIgnore(tokenizer, 30, {
+			maximumLength: 30,
+			reason: 'ASF header prelude',
+		});
+		const isUnknownFileSize = hasUnknownFileSize(tokenizer);
+		const asfHeaderScanStart = tokenizer.position;
+		let asfHeaderObjectCount = 0;
+		while (tokenizer.position + 24 < tokenizer.fileInfo.size) {
+			asfHeaderObjectCount++;
+			if (asfHeaderObjectCount > maximumAsfHeaderObjectCount) {
+				break;
+			}
+
+			if (hasExceededUnknownSizeScanBudget(tokenizer, asfHeaderScanStart, maximumUntrustedSkipSizeInBytes)) {
+				break;
+			}
+
+			const previousPosition = tokenizer.position;
+			const header = await readHeader();
+			let payload = header.size - 24;
+			if (
+				!Number.isFinite(payload)
+				|| payload < 0
+			) {
+				isMalformedAsf = true;
+				break;
+			}
+
+			if (checkBytes(header.id, [0x91, 0x07, 0xDC, 0xB7, 0xB7, 0xA9, 0xCF, 0x11, 0x8E, 0xE6, 0x00, 0xC0, 0x0C, 0x20, 0x53, 0x65])) {
+				// Sync on Stream-Properties-Object (B7DC0791-A9B7-11CF-8EE6-00C00C205365)
+				const typeId = new Uint8Array(16);
+				payload -= await safeReadBuffer(tokenizer, typeId, undefined, {
+					maximumLength: typeId.length,
+					reason: 'ASF stream type GUID',
+				});
+
+				if (checkBytes(typeId, [0x40, 0x9E, 0x69, 0xF8, 0x4D, 0x5B, 0xCF, 0x11, 0xA8, 0xFD, 0x00, 0x80, 0x5F, 0x5C, 0x44, 0x2B])) {
+					// Found audio:
+					return {
+						ext: 'asf',
+						mime: 'audio/x-ms-asf',
+					};
+				}
+
+				if (checkBytes(typeId, [0xC0, 0xEF, 0x19, 0xBC, 0x4D, 0x5B, 0xCF, 0x11, 0xA8, 0xFD, 0x00, 0x80, 0x5F, 0x5C, 0x44, 0x2B])) {
+					// Found video:
+					return {
+						ext: 'asf',
+						mime: 'video/x-ms-asf',
+					};
+				}
+
+				break;
+			}
+
+			if (
+				isUnknownFileSize
+				&& payload > maximumAsfHeaderPayloadSizeInBytes
+			) {
+				isMalformedAsf = true;
+				break;
+			}
+
+			await safeIgnore(tokenizer, payload, {
+				maximumLength: isUnknownFileSize ? maximumAsfHeaderPayloadSizeInBytes : tokenizer.fileInfo.size,
+				reason: 'ASF header payload',
+			});
+
+			// Safeguard against malformed files: break if the position did not advance.
+			if (tokenizer.position <= previousPosition) {
+				isMalformedAsf = true;
+				break;
+			}
+		}
+	} catch (error) {
+		if (
+			error instanceof strtok3.EndOfStreamError
+			|| error instanceof ParserHardLimitError
+		) {
+			if (hasUnknownFileSize(tokenizer)) {
+				isMalformedAsf = true;
+			}
+		} else {
+			throw error;
+		}
+	}
+
+	if (isMalformedAsf) {
+		return;
+	}
+
+	// Default to ASF generic extension
+	return {
+		ext: 'asf',
+		mime: 'application/vnd.ms-asf',
+	};
+}

package/node_modules/file-type/source/detectors/ebml.js

@@ -0,0 +1,120 @@
+import * as Token from 'token-types';
+import {getUintBE} from 'uint8array-extras';
+import {
+	maximumUntrustedSkipSizeInBytes,
+	getSafeBound,
+	safeReadBuffer,
+	safeIgnore,
+	hasUnknownFileSize,
+	hasExceededUnknownSizeScanBudget,
+} from '../parser.js';
+
+const maximumEbmlDocumentTypeSizeInBytes = 64;
+const maximumEbmlElementPayloadSizeInBytes = 1024 * 1024;
+const maximumEbmlElementCount = 256;
+
+export async function detectEbml(tokenizer) {
+	async function readField() {
+		const msb = await tokenizer.peekNumber(Token.UINT8);
+		let mask = 0x80;
+		let ic = 0; // 0 = A, 1 = B, 2 = C, 3 = D
+
+		while ((msb & mask) === 0 && mask !== 0) {
+			++ic;
+			mask >>= 1;
+		}
+
+		const id = new Uint8Array(ic + 1);
+		await safeReadBuffer(tokenizer, id, undefined, {
+			maximumLength: id.length,
+			reason: 'EBML field',
+		});
+		return id;
+	}
+
+	async function readElement() {
+		const idField = await readField();
+		const lengthField = await readField();
+
+		lengthField[0] ^= 0x80 >> (lengthField.length - 1);
+		const nrLength = Math.min(6, lengthField.length); // JavaScript can max read 6 bytes integer
+
+		const idView = new DataView(idField.buffer);
+		const lengthView = new DataView(lengthField.buffer, lengthField.length - nrLength, nrLength);
+
+		return {
+			id: getUintBE(idView),
+			len: getUintBE(lengthView),
+		};
+	}
+
+	async function readChildren(children) {
+		let ebmlElementCount = 0;
+		while (children > 0) {
+			ebmlElementCount++;
+			if (ebmlElementCount > maximumEbmlElementCount) {
+				return;
+			}
+
+			if (hasExceededUnknownSizeScanBudget(tokenizer, ebmlScanStart, maximumUntrustedSkipSizeInBytes)) {
+				return;
+			}
+
+			const previousPosition = tokenizer.position;
+			const element = await readElement();
+
+			if (element.id === 0x42_82) {
+				// `DocType` is a short string ("webm", "matroska", ...), reject implausible lengths to avoid large allocations.
+				if (element.len > maximumEbmlDocumentTypeSizeInBytes) {
+					return;
+				}
+
+				const documentTypeLength = getSafeBound(element.len, maximumEbmlDocumentTypeSizeInBytes, 'EBML DocType');
+				const rawValue = await tokenizer.readToken(new Token.StringType(documentTypeLength));
+				return rawValue.replaceAll(/\0.*$/gv, ''); // Return DocType
+			}
+
+			if (
+				hasUnknownFileSize(tokenizer)
+				&& (
+					!Number.isFinite(element.len)
+					|| element.len < 0
+					|| element.len > maximumEbmlElementPayloadSizeInBytes
+				)
+			) {
+				return;
+			}
+
+			await safeIgnore(tokenizer, element.len, {
+				maximumLength: hasUnknownFileSize(tokenizer) ? maximumEbmlElementPayloadSizeInBytes : tokenizer.fileInfo.size,
+				reason: 'EBML payload',
+			}); // ignore payload
+			--children;
+
+			// Safeguard against malformed files: bail if the position did not advance.
+			if (tokenizer.position <= previousPosition) {
+				return;
+			}
+		}
+	}
+
+	const rootElement = await readElement();
+	const ebmlScanStart = tokenizer.position;
+	const documentType = await readChildren(rootElement.len);
+
+	switch (documentType) {
+		case 'webm':
+			return {
+				ext: 'webm',
+				mime: 'video/webm',
+			};
+
+		case 'matroska':
+			return {
+				ext: 'mkv',
+				mime: 'video/matroska',
+			};
+
+		default:
+	}
+}