file-type 20.5.0 → 21.1.0

package/core.d.ts

@@ -24,16 +24,17 @@ export type FileTypeResult = {
 };
 
 /**
-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.
 
 If file access is available, it is recommended to use `.fromFile()` instead.
 
 @param buffer - An Uint8Array or ArrayBuffer representing file data. It works best if the buffer contains the entire file. It may work with a smaller portion as well.
+@param options - Options to override default behavior.
 @returns The detected file type, or `undefined` when there is no match.
 */
-export function fileTypeFromBuffer(buffer: Uint8Array | ArrayBuffer): Promise<FileTypeResult | undefined>;
+export function fileTypeFromBuffer(buffer: Uint8Array | ArrayBuffer, options?: FileTypeOptions): Promise<FileTypeResult | undefined>;
 
 /**
 Detect the file type of a [web `ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream).
@@ -41,9 +42,10 @@ Detect the file type of a [web `ReadableStream`](https://developer.mozilla.org/e
 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.
 
 @param stream - A [web `ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream) streaming a file to examine.
+@param options - Options to override default behavior.
 @returns A `Promise` for an object with the detected file type, or `undefined` when there is no match.
 */
-export function fileTypeFromStream(stream: AnyWebByteStream): Promise<FileTypeResult | undefined>;
+export function fileTypeFromStream(stream: AnyWebByteStream, options?: FileTypeOptions): Promise<FileTypeResult | undefined>;
 
 /**
 Detect the file type from an [`ITokenizer`](https://github.com/Borewit/strtok3#tokenizer) source.
@@ -53,6 +55,7 @@ This method is used internally, but can also be used for a special "tokenizer" r
 A tokenizer propagates the internal read functions, allowing alternative transport mechanisms, to access files, to be implemented and used.
 
 @param tokenizer - File source implementing the tokenizer interface.
+@param options - Options to override default behavior.
 @returns The detected file type, or `undefined` when there is no match.
 
 An example is [`@tokenizer/http`](https://github.com/Borewit/tokenizer-http), which requests data using [HTTP-range-requests](https://developer.mozilla.org/en-US/docs/Web/HTTP/Range_requests). A difference with a conventional stream and the [*tokenizer*](https://github.com/Borewit/strtok3#tokenizer), is that it is able to *ignore* (seek, fast-forward) in the stream. For example, you may only need and read the first 6 bytes, and the last 128 bytes, which may be an advantage in case reading the entire file would take longer.
@@ -71,7 +74,7 @@ console.log(fileType);
 //=> {ext: 'mp3', mime: 'audio/mpeg'}
 ```
 */
-export function fileTypeFromTokenizer(tokenizer: ITokenizer): Promise<FileTypeResult | undefined>;
+export function fileTypeFromTokenizer(tokenizer: ITokenizer, options?: FileTypeOptions): Promise<FileTypeResult | undefined>;
 
 /**
 Supported file extensions.
@@ -96,6 +99,7 @@ export type StreamOptions = {
 Detect the file type of a [`Blob`](https://nodejs.org/api/buffer.html#class-blob) or [`File`](https://developer.mozilla.org/en-US/docs/Web/API/File).
 
 @param blob - The [`Blob`](https://nodejs.org/api/buffer.html#class-blob) used for file detection.
+@param options - Options to override default behavior.
 @returns The detected file type, or `undefined` when there is no match.
 
 @example
@@ -111,7 +115,7 @@ console.log(await fileTypeFromBlob(blob));
 //=> {ext: 'txt', mime: 'text/plain'}
 ```
 */
-export declare function fileTypeFromBlob(blob: Blob): Promise<FileTypeResult | undefined>;
+export declare function fileTypeFromBlob(blob: Blob, options?: FileTypeOptions): Promise<FileTypeResult | undefined>;
 
 /**
 A custom file type detector.
@@ -184,6 +188,17 @@ export type Detector = {
 
 export type FileTypeOptions = {
 	customDetectors?: Iterable<Detector>;
+
+	/**
+	Specifies the byte tolerance for locating the first MPEG audio frame (e.g. `.mp1`, `.mp2`, `.mp3`, `.aac`).
+
+	Allows detection to handle slight sync offsets between the expected and actual frame start. Common in malformed or incorrectly muxed files, which, while technically invalid, do occur in the wild.
+
+	A tolerance of 10 bytes covers most cases.
+
+ 	@default 0
+	*/
+	mpegOffsetTolerance?: number;
 };
 
 export declare class TokenizerPositionError extends Error {

package/core.js

@@ -4,8 +4,8 @@ Primary entry point, Node.js specific entry point is index.js
 
 import * as Token from 'token-types';
 import * as strtok3 from 'strtok3/core';
-import {ZipHandler} from '@tokenizer/inflate';
-import {includes, getUintBE} from 'uint8array-extras';
+import {ZipHandler, GzipHandler} from '@tokenizer/inflate';
+import {getUintBE} from 'uint8array-extras';
 import {
 	stringToBytes,
 	tarHeaderChecksumMatches,
@@ -15,74 +15,75 @@ import {extensions, mimeTypes} from './supported.js';
 
 export const reasonableDetectionSizeInBytes = 4100; // A fair amount of file-types are detectable within this range.
 
-export async function fileTypeFromStream(stream) {
-	return new FileTypeParser().fromStream(stream);
+export async function fileTypeFromStream(stream, options) {
+	return new FileTypeParser(options).fromStream(stream);
 }
 
-export async function fileTypeFromBuffer(input) {
-	return new FileTypeParser().fromBuffer(input);
+export async function fileTypeFromBuffer(input, options) {
+	return new FileTypeParser(options).fromBuffer(input);
 }
 
-export async function fileTypeFromBlob(blob) {
-	return new FileTypeParser().fromBlob(blob);
+export async function fileTypeFromBlob(blob, options) {
+	return new FileTypeParser(options).fromBlob(blob);
 }
 
 function getFileTypeFromMimeType(mimeType) {
-	switch (mimeType.toLowerCase()) {
+	mimeType = mimeType.toLowerCase();
+	switch (mimeType) {
 		case 'application/epub+zip':
 			return {
 				ext: 'epub',
-				mime: 'application/epub+zip',
+				mime: mimeType,
 			};
 		case 'application/vnd.oasis.opendocument.text':
 			return {
 				ext: 'odt',
-				mime: 'application/vnd.oasis.opendocument.text',
+				mime: mimeType,
 			};
 		case 'application/vnd.oasis.opendocument.text-template':
 			return {
 				ext: 'ott',
-				mime: 'application/vnd.oasis.opendocument.text-template',
+				mime: mimeType,
 			};
 		case 'application/vnd.oasis.opendocument.spreadsheet':
 			return {
 				ext: 'ods',
-				mime: 'application/vnd.oasis.opendocument.spreadsheet',
+				mime: mimeType,
 			};
 		case 'application/vnd.oasis.opendocument.spreadsheet-template':
 			return {
 				ext: 'ots',
-				mime: 'application/vnd.oasis.opendocument.spreadsheet-template',
+				mime: mimeType,
 			};
 		case 'application/vnd.oasis.opendocument.presentation':
 			return {
 				ext: 'odp',
-				mime: 'application/vnd.oasis.opendocument.presentation',
+				mime: mimeType,
 			};
 		case 'application/vnd.oasis.opendocument.presentation-template':
 			return {
 				ext: 'otp',
-				mime: 'application/vnd.oasis.opendocument.presentation-template',
+				mime: mimeType,
 			};
 		case 'application/vnd.oasis.opendocument.graphics':
 			return {
 				ext: 'odg',
-				mime: 'application/vnd.oasis.opendocument.graphics',
+				mime: mimeType,
 			};
 		case 'application/vnd.oasis.opendocument.graphics-template':
 			return {
 				ext: 'otg',
-				mime: 'application/vnd.oasis.opendocument.graphics-template',
+				mime: mimeType,
 			};
 		case 'application/vnd.openxmlformats-officedocument.presentationml.slideshow':
 			return {
 				ext: 'ppsx',
-				mime: 'application/vnd.openxmlformats-officedocument.presentationml.slideshow',
+				mime: mimeType,
 			};
 		case 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet':
 			return {
 				ext: 'xlsx',
-				mime: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+				mime: mimeType,
 			};
 		case 'application/vnd.ms-excel.sheet.macroenabled':
 			return {
@@ -92,7 +93,7 @@ function getFileTypeFromMimeType(mimeType) {
 		case 'application/vnd.openxmlformats-officedocument.spreadsheetml.template':
 			return {
 				ext: 'xltx',
-				mime: 'application/vnd.openxmlformats-officedocument.spreadsheetml.template',
+				mime: mimeType,
 			};
 		case 'application/vnd.ms-excel.template.macroenabled':
 			return {
@@ -107,7 +108,7 @@ function getFileTypeFromMimeType(mimeType) {
 		case 'application/vnd.openxmlformats-officedocument.wordprocessingml.document':
 			return {
 				ext: 'docx',
-				mime: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+				mime: mimeType,
 			};
 		case 'application/vnd.ms-word.document.macroenabled':
 			return {
@@ -117,7 +118,7 @@ function getFileTypeFromMimeType(mimeType) {
 		case 'application/vnd.openxmlformats-officedocument.wordprocessingml.template':
 			return {
 				ext: 'dotx',
-				mime: 'application/vnd.openxmlformats-officedocument.wordprocessingml.template',
+				mime: mimeType,
 			};
 		case 'application/vnd.ms-word.template.macroenabledtemplate':
 			return {
@@ -127,7 +128,7 @@ function getFileTypeFromMimeType(mimeType) {
 		case 'application/vnd.openxmlformats-officedocument.presentationml.template':
 			return {
 				ext: 'potx',
-				mime: 'application/vnd.openxmlformats-officedocument.presentationml.template',
+				mime: mimeType,
 			};
 		case 'application/vnd.ms-powerpoint.template.macroenabled':
 			return {
@@ -137,7 +138,7 @@ function getFileTypeFromMimeType(mimeType) {
 		case 'application/vnd.openxmlformats-officedocument.presentationml.presentation':
 			return {
 				ext: 'pptx',
-				mime: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+				mime: mimeType,
 			};
 		case 'application/vnd.ms-powerpoint.presentation.macroenabled':
 			return {
@@ -179,8 +180,8 @@ function _check(buffer, headers, options) {
 	return true;
 }
 
-export async function fileTypeFromTokenizer(tokenizer) {
-	return new FileTypeParser().fromTokenizer(tokenizer);
+export async function fileTypeFromTokenizer(tokenizer, options) {
+	return new FileTypeParser(options).fromTokenizer(tokenizer);
 }
 
 export async function fileTypeStream(webStream, options) {
@@ -189,6 +190,11 @@ export async function fileTypeStream(webStream, options) {
 
 export class FileTypeParser {
 	constructor(options) {
+		this.options = {
+			mpegOffsetTolerance: 0,
+			...options,
+		};
+
 		this.detectors = [...(options?.customDetectors ?? []),
 			{id: 'core', detect: this.detectConfident},
 			{id: 'core.imprecise', detect: this.detectImprecise}];
@@ -228,11 +234,16 @@ export class FileTypeParser {
 	}
 
 	async fromBlob(blob) {
-		return this.fromStream(blob.stream());
+		const tokenizer = strtok3.fromBlob(blob, this.tokenizerOptions);
+		try {
+			return await this.fromTokenizer(tokenizer);
+		} finally {
+			await tokenizer.close();
+		}
 	}
 
 	async fromStream(stream) {
-		const tokenizer = await strtok3.fromWebStream(stream, this.tokenizerOptions);
+		const tokenizer = strtok3.fromWebStream(stream, this.tokenizerOptions);
 		try {
 			return await this.fromTokenizer(tokenizer);
 		} finally {
@@ -253,7 +264,7 @@ export class FileTypeParser {
 			if (!done && chunk) {
 				try {
 					// Attempt to detect the file type from the chunk
-					detectedFileType = await this.fromBuffer(chunk.slice(0, sampleSize));
+					detectedFileType = await this.fromBuffer(chunk.subarray(0, sampleSize));
 				} catch (error) {
 					if (!(error instanceof strtok3.EndOfStreamError)) {
 						throw error; // Re-throw non-EndOfStreamError
@@ -290,7 +301,7 @@ export class FileTypeParser {
 	}
 
 	checkString(header, options) {
-		return this.check(stringToBytes(header), options);
+		return this.check(stringToBytes(header, options?.encoding), options);
 	}
 
 	// Detections with a high degree of certainty in identifying the correct file type
@@ -304,7 +315,7 @@ export class FileTypeParser {
 
 		this.tokenizer = tokenizer;
 
-		await tokenizer.peekBuffer(this.buffer, {length: 12, mayBeLess: true});
+		await tokenizer.peekBuffer(this.buffer, {length: 32, mayBeLess: true});
 
 		// -- 2-byte signatures --
 
@@ -402,6 +413,21 @@ export class FileTypeParser {
 		}
 
 		if (this.check([0x1F, 0x8B, 0x8])) {
+			const gzipHandler = new GzipHandler(tokenizer);
+
+			const stream = gzipHandler.inflate();
+			try {
+				const compressedFileType = await this.fromStream(stream);
+				if (compressedFileType && compressedFileType.ext === 'tar') {
+					return {
+						ext: 'tar.gz',
+						mime: 'application/gzip',
+					};
+				}
+			} finally {
+				await stream.cancel();
+			}
+
 			return {
 				ext: 'gz',
 				mime: 'application/gzip',
@@ -571,6 +597,10 @@ export class FileTypeParser {
 
 						return {};
 				}
+			}).catch(error => {
+				if (!(error instanceof strtok3.EndOfStreamError)) {
+					throw error; // Re-throw non-EndOfStreamError
+				}
 			});
 
 			return fileType ?? {
@@ -709,7 +739,7 @@ export class FileTypeParser {
 		if (this.checkString('fLaC')) {
 			return {
 				ext: 'flac',
-				mime: 'audio/x-flac',
+				mime: 'audio/flac',
 			};
 		}
 
@@ -728,28 +758,6 @@ export class FileTypeParser {
 		}
 
 		if (this.checkString('%PDF')) {
-			try {
-				const skipBytes = 1350;
-				if (skipBytes === await tokenizer.ignore(skipBytes)) {
-					const maxBufferSize = 10 * 1024 * 1024;
-					const buffer = new Uint8Array(Math.min(maxBufferSize, tokenizer.fileInfo.size - skipBytes));
-					await tokenizer.readBuffer(buffer, {mayBeLess: true});
-
-					// Check if this is an Adobe Illustrator file
-					if (includes(buffer, new TextEncoder().encode('AIPrivateData'))) {
-						return {
-							ext: 'ai',
-							mime: 'application/postscript',
-						};
-					}
-				}
-			} catch (error) {
-				// Swallow end of stream error if file is too small for the Adobe AI check
-				if (!(error instanceof strtok3.EndOfStreamError)) {
-					throw error;
-				}
-			}
-
 			// Assume this is just a normal PDF
 			return {
 				ext: 'pdf',
@@ -846,7 +854,7 @@ export class FileTypeParser {
 				case 'matroska':
 					return {
 						ext: 'mkv',
-						mime: 'video/x-matroska',
+						mime: 'video/matroska',
 					};
 
 				default:
@@ -920,10 +928,10 @@ export class FileTypeParser {
 			};
 		}
 
-		if (this.checkString('PAR1')) {
+		if (this.checkString('PAR1') || this.checkString('PARE')) {
 			return {
 				ext: 'parquet',
-				mime: 'application/x-parquet',
+				mime: 'application/vnd.apache.parquet',
 			};
 		}
 
@@ -948,6 +956,13 @@ export class FileTypeParser {
 			};
 		}
 
+		if (this.checkString('regf')) {
+			return {
+				ext: 'dat',
+				mime: 'application/x-ft-windows-registry-hive',
+			};
+		}
+
 		// -- 5-byte signatures --
 
 		if (this.check([0x4F, 0x54, 0x54, 0x4F, 0x00])) {
@@ -1199,7 +1214,7 @@ export class FileTypeParser {
 		if (this.check([0x41, 0x52, 0x52, 0x4F, 0x57, 0x31, 0x00, 0x00])) {
 			return {
 				ext: 'arrow',
-				mime: 'application/x-apache-arrow',
+				mime: 'application/vnd.apache.arrow.file',
 			};
 		}
 
@@ -1299,6 +1314,15 @@ export class FileTypeParser {
 			}
 		}
 
+		// -- 10-byte signatures --
+
+		if (this.checkString('REGEDIT4\r\n')) {
+			return {
+				ext: 'reg',
+				mime: 'application/x-ms-regedit',
+			};
+		}
+
 		// -- 12-byte signatures --
 
 		// RIFF file format which might be AVI, WAV, QCP, etc
@@ -1459,8 +1483,8 @@ export class FileTypeParser {
 			};
 		}
 
-		if (this.check([0xFE, 0xFF])) { // UTF-16-BOM-LE
-			if (this.check([0, 60, 0, 63, 0, 120, 0, 109, 0, 108], {offset: 2})) {
+		if (this.check([0xFE, 0xFF])) { // UTF-16-BOM-BE
+			if (this.checkString('<?xml ', {offset: 2, encoding: 'utf-16be'})) {
 				return {
 					ext: 'xml',
 					mime: 'application/xml',
@@ -1478,7 +1502,7 @@ export class FileTypeParser {
 			};
 		}
 
-		// Increase sample size from 12 to 256.
+		// Increase sample size from 32 to 256.
 		await tokenizer.peekBuffer(this.buffer, {length: Math.min(256, tokenizer.fileInfo.size), mayBeLess: true});
 
 		if (this.check([0x61, 0x63, 0x73, 0x70], {offset: 36})) {
@@ -1541,7 +1565,7 @@ export class FileTypeParser {
 
 			if (jsonSize > 12 && this.buffer.length >= jsonSize + 16) {
 				try {
-					const header = new TextDecoder().decode(this.buffer.slice(16, jsonSize + 16));
+					const header = new TextDecoder().decode(this.buffer.subarray(16, jsonSize + 16));
 					const json = JSON.parse(header);
 					// Check if Pickle is ASAR
 					if (json.files) { // Final check, assuring Pickle/ASAR format
@@ -1644,28 +1668,37 @@ export class FileTypeParser {
 		await tokenizer.peekBuffer(this.buffer, {length: Math.min(512, tokenizer.fileInfo.size), mayBeLess: true});
 
 		// Requires a buffer size of 512 bytes
-		if (tarHeaderChecksumMatches(this.buffer)) {
+		if ((this.checkString('ustar', {offset: 257}) && (this.checkString('\0', {offset: 262}) || this.checkString(' ', {offset: 262})))
+			|| (this.check([0, 0, 0, 0, 0, 0], {offset: 257}) && tarHeaderChecksumMatches(this.buffer))) {
 			return {
 				ext: 'tar',
 				mime: 'application/x-tar',
 			};
 		}
 
-		if (this.check([0xFF, 0xFE])) { // UTF-16-BOM-BE
-			if (this.check([60, 0, 63, 0, 120, 0, 109, 0, 108, 0], {offset: 2})) {
+		if (this.check([0xFF, 0xFE])) { // UTF-16-BOM-LE
+			const encoding = 'utf-16le';
+			if (this.checkString('<?xml ', {offset: 2, encoding})) {
 				return {
 					ext: 'xml',
 					mime: 'application/xml',
 				};
 			}
 
-			if (this.check([0xFF, 0x0E, 0x53, 0x00, 0x6B, 0x00, 0x65, 0x00, 0x74, 0x00, 0x63, 0x00, 0x68, 0x00, 0x55, 0x00, 0x70, 0x00, 0x20, 0x00, 0x4D, 0x00, 0x6F, 0x00, 0x64, 0x00, 0x65, 0x00, 0x6C, 0x00], {offset: 2})) {
+			if (this.check([0xFF, 0x0E], {offset: 2}) && this.checkString('SketchUp Model', {offset: 4, encoding})) {
 				return {
 					ext: 'skp',
 					mime: 'application/vnd.sketchup.skp',
 				};
 			}
 
+			if (this.checkString('Windows Registry Editor Version 5.00\r\n', {offset: 2, encoding})) {
+				return {
+					ext: 'reg',
+					mime: 'application/x-ms-regedit',
+				};
+			}
+
 			return undefined; // Some text based format
 		}
 
@@ -1714,47 +1747,16 @@ export class FileTypeParser {
 			};
 		}
 
+		// Adjust buffer to `mpegOffsetTolerance`
+		await tokenizer.peekBuffer(this.buffer, {length: Math.min(2 + this.options.mpegOffsetTolerance, tokenizer.fileInfo.size), mayBeLess: true});
+
 		// Check MPEG 1 or 2 Layer 3 header, or 'layer 0' for ADTS (MPEG sync-word 0xFFE)
-		if (this.buffer.length >= 2 && this.check([0xFF, 0xE0], {offset: 0, mask: [0xFF, 0xE0]})) {
-			if (this.check([0x10], {offset: 1, mask: [0x16]})) {
-				// Check for (ADTS) MPEG-2
-				if (this.check([0x08], {offset: 1, mask: [0x08]})) {
-					return {
-						ext: 'aac',
-						mime: 'audio/aac',
-					};
+		if (this.buffer.length >= (2 + this.options.mpegOffsetTolerance)) {
+			for (let depth = 0; depth <= this.options.mpegOffsetTolerance; ++depth) {
+				const type = this.scanMpeg(depth);
+				if (type) {
+					return type;
 				}
-
-				// Must be (ADTS) MPEG-4
-				return {
-					ext: 'aac',
-					mime: 'audio/aac',
-				};
-			}
-
-			// MPEG 1 or 2 Layer 3 header
-			// Check for MPEG layer 3
-			if (this.check([0x02], {offset: 1, mask: [0x06]})) {
-				return {
-					ext: 'mp3',
-					mime: 'audio/mpeg',
-				};
-			}
-
-			// Check for MPEG layer 2
-			if (this.check([0x04], {offset: 1, mask: [0x06]})) {
-				return {
-					ext: 'mp2',
-					mime: 'audio/mpeg',
-				};
-			}
-
-			// Check for MPEG layer 1
-			if (this.check([0x06], {offset: 1, mask: [0x06]})) {
-				return {
-					ext: 'mp1',
-					mime: 'audio/mpeg',
-				};
 			}
 		}
 	};
@@ -1831,6 +1833,57 @@ export class FileTypeParser {
 			};
 		}
 	}
+
+	/**
+	Scan check MPEG 1 or 2 Layer 3 header, or 'layer 0' for ADTS (MPEG sync-word 0xFFE).
+
+	@param offset - Offset to scan for sync-preamble.
+	@returns {{ext: string, mime: string}}
+	*/
+	scanMpeg(offset) {
+		if (this.check([0xFF, 0xE0], {offset, mask: [0xFF, 0xE0]})) {
+			if (this.check([0x10], {offset: offset + 1, mask: [0x16]})) {
+				// Check for (ADTS) MPEG-2
+				if (this.check([0x08], {offset: offset + 1, mask: [0x08]})) {
+					return {
+						ext: 'aac',
+						mime: 'audio/aac',
+					};
+				}
+
+				// Must be (ADTS) MPEG-4
+				return {
+					ext: 'aac',
+					mime: 'audio/aac',
+				};
+			}
+
+			// MPEG 1 or 2 Layer 3 header
+			// Check for MPEG layer 3
+			if (this.check([0x02], {offset: offset + 1, mask: [0x06]})) {
+				return {
+					ext: 'mp3',
+					mime: 'audio/mpeg',
+				};
+			}
+
+			// Check for MPEG layer 2
+			if (this.check([0x04], {offset: offset + 1, mask: [0x06]})) {
+				return {
+					ext: 'mp2',
+					mime: 'audio/mpeg',
+				};
+			}
+
+			// Check for MPEG layer 1
+			if (this.check([0x06], {offset: offset + 1, mask: [0x06]})) {
+				return {
+					ext: 'mp1',
+					mime: 'audio/mpeg',
+				};
+			}
+		}
+	}
 }
 
 export const supportedExtensions = new Set(extensions);

package/index.d.ts

@@ -8,8 +8,8 @@ import {
 	type FileTypeResult,
 	type StreamOptions,
 	type AnyWebReadableStream,
-	type Detector,
 	type AnyWebReadableByteStreamWithFileType,
+	type FileTypeOptions,
 	FileTypeParser as DefaultFileTypeParser,
 } from './core.js';
 
@@ -31,8 +31,8 @@ export declare class FileTypeParser extends DefaultFileTypeParser {
 	/**
 	Works the same way as {@link fileTypeStream}, additionally taking into account custom detectors (if any were provided to the constructor).
 	*/
-	toDetectionStream(readableStream: NodeReadableStream, options?: StreamOptions): Promise<ReadableStreamWithFileType>;
-	toDetectionStream(webStream: AnyWebReadableStream<Uint8Array>, options?: StreamOptions): Promise<AnyWebReadableByteStreamWithFileType>;
+	toDetectionStream(readableStream: NodeReadableStream, options?: FileTypeOptions & StreamOptions): Promise<ReadableStreamWithFileType>;
+	toDetectionStream(webStream: AnyWebReadableStream<Uint8Array>, options?: FileTypeOptions & StreamOptions): Promise<AnyWebReadableByteStreamWithFileType>;
 }
 
 /**
@@ -48,7 +48,7 @@ The file type is detected by checking the [magic number](https://en.wikipedia.or
 
 @returns The detected file type and MIME type or `undefined` when there is no match.
 */
-export function fileTypeFromFile(filePath: string, options?: {customDetectors?: Iterable<Detector>}): Promise<FileTypeResult | undefined>;
+export function fileTypeFromFile(filePath: string, options?: FileTypeOptions): Promise<FileTypeResult | undefined>;
 
 /**
 Detect the file type of a [web `ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream).
@@ -60,9 +60,10 @@ Direct support for Node.js streams will be dropped in the future, when Node.js s
 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.
 
 @param stream - A [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) streaming a file to examine.
-@returns A `Promise` for an object with the detected file type, or `undefined` when there is no match.
+@param options - Options to override default behaviour.
+ @returns A `Promise` for an object with the detected file type, or `undefined` when there is no match.
 */
-export function fileTypeFromStream(stream: AnyWebReadableStream<Uint8Array> | NodeReadableStream): Promise<FileTypeResult | undefined>;
+export function fileTypeFromStream(stream: AnyWebReadableStream<Uint8Array> | NodeReadableStream, options?: FileTypeOptions): Promise<FileTypeResult | undefined>;
 
 /**
 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()`.
@@ -91,7 +92,7 @@ if (stream2.fileType?.mime === 'image/jpeg') {
 }
 ```
 */
-export function fileTypeStream(readableStream: NodeReadableStream, options?: StreamOptions): Promise<ReadableStreamWithFileType>;
-export function fileTypeStream(webStream: AnyWebByteStream, options?: StreamOptions): Promise<AnyWebReadableByteStreamWithFileType>;
+export function fileTypeStream(readableStream: NodeReadableStream, options?: FileTypeOptions & StreamOptions): Promise<ReadableStreamWithFileType>;
+export function fileTypeStream(webStream: AnyWebByteStream, options?: FileTypeOptions & StreamOptions): Promise<AnyWebReadableByteStreamWithFileType>;
 
 export * from './core.js';

package/index.js

@@ -65,12 +65,12 @@ export class FileTypeParser extends DefaultFileTypeParser {
 	}
 }
 
-export async function fileTypeFromFile(path, fileTypeOptions) {
-	return (new FileTypeParser(fileTypeOptions)).fromFile(path, fileTypeOptions);
+export async function fileTypeFromFile(path, options) {
+	return (new FileTypeParser(options)).fromFile(path, options);
 }
 
-export async function fileTypeFromStream(stream, fileTypeOptions) {
-	return (new FileTypeParser(fileTypeOptions)).fromStream(stream);
+export async function fileTypeFromStream(stream, options) {
+	return (new FileTypeParser(options)).fromStream(stream);
 }
 
 export async function fileTypeStream(readableStream, options = {}) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "file-type",
-	"version": "20.5.0",
+	"version": "21.1.0",
 	"description": "Detect the file type of a file, stream, or data",
 	"license": "MIT",
 	"repository": "sindresorhus/file-type",
@@ -35,7 +35,7 @@
 	},
 	"sideEffects": false,
 	"engines": {
-		"node": ">=18"
+		"node": ">=20"
 	},
 	"scripts": {
 		"test": "xo && ava && tsd"
@@ -198,7 +198,6 @@
 		"it",
 		"s3m",
 		"xm",
-		"ai",
 		"skp",
 		"avif",
 		"eps",
@@ -244,22 +243,25 @@
 		"jar",
 		"rm",
 		"ppsm",
-		"ppsx"
+		"ppsx",
+		"tar.gz",
+		"reg",
+		"dat"
 	],
 	"dependencies": {
-		"@tokenizer/inflate": "^0.2.6",
-		"strtok3": "^10.2.0",
+		"@tokenizer/inflate": "^0.3.1",
+		"strtok3": "^10.3.1",
 		"token-types": "^6.0.0",
 		"uint8array-extras": "^1.4.0"
 	},
 	"devDependencies": {
 		"@tokenizer/token": "^0.3.0",
-		"@types/node": "^22.10.5",
-		"ava": "^6.0.1",
+		"@types/node": "^22.15.21",
+		"ava": "^6.3.0",
 		"commonmark": "^0.31.2",
 		"get-stream": "^9.0.1",
 		"noop-stream": "^1.0.0",
-		"tsd": "^0.31.2",
+		"tsd": "^0.32.0",
 		"xo": "^0.60.0"
 	},
 	"xo": {

package/readme.md

@@ -109,7 +109,7 @@ console.log(fileType);
 
 ## API
 
-### fileTypeFromBuffer(buffer)
+### fileTypeFromBuffer(buffer, options)
 
 Detect the file type of a `Uint8Array`, or `ArrayBuffer`.
 
@@ -130,13 +130,13 @@ Type: `Uint8Array | ArrayBuffer`
 
 A buffer representing file data. It works best if the buffer contains the entire file. It may work with a smaller portion as well.
 
-### fileTypeFromFile(filePath)
+### fileTypeFromFile(filePath, options)
 
 Detect the file type of a file path.
 
 This is for Node.js only.
 
-To read from a [`File`](https://developer.mozilla.org/docs/Web/API/File), see [`fileTypeFromBlob()`](#filetypefromblobblob).
+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.
 
@@ -176,7 +176,7 @@ Type: [Web `ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/Re
 
 A readable stream representing file data.
 
-### fileTypeFromBlob(blob)
+### fileTypeFromBlob(blob, options)
 
 Detect the file type of a [`Blob`](https://developer.mozilla.org/docs/Web/API/Blob),
 
@@ -225,7 +225,7 @@ async function readFromBlobWithoutStreaming(blob) {
 
 Type: [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob)
 
-### fileTypeFromTokenizer(tokenizer)
+### fileTypeFromTokenizer(tokenizer, options)
 
 Detect the file type from an `ITokenizer` source.
 
@@ -304,6 +304,8 @@ Type: [`stream.Readable`](https://nodejs.org/api/stream.html#stream_class_stream
 
 Type: `object`
 
+Supports the following options in addition to the [general options](#options):
+
 ##### sampleSize
 
 Type: `number`\
@@ -341,6 +343,32 @@ Returns a `Set<string>` of supported file extensions.
 
 Returns a `Set<string>` of supported MIME types.
 
+### Options
+
+#### customDetectors
+
+Array of custom file type detectors to run before default detectors.
+
+For example:
+
+```js
+import {fileTypeFromFile} from 'file-type';
+import {detectXml} from '@file-type/xml';
+
+const fileType = await fileTypeFromFile('sample.kml', {customDetectors: [detectXml]});
+console.log(fileType);
+```
+
+#### mpegOffsetTolerance
+
+Default: `0`
+
+Specifies the byte tolerance for locating the first MPEG audio frame (e.g. `.mp1`, `.mp2`, `.mp3`, `.aac`).
+
+Allows detection to handle slight sync offsets between the expected and actual frame start. Common in malformed or incorrectly muxed files, which, while technically invalid, do occur in the wild.
+
+A tolerance of 10 bytes covers most cases.
+
 ## Custom detectors
 
 Custom file type detectors are plugins designed to extend the default detection capabilities.
@@ -353,6 +381,8 @@ Detectors can be added via the constructor options or by directly modifying `Fil
 
 ### Example adding a detector
 
+For example:
+
 ```js
 import {FileTypeParser} from 'file-type';
 import {detectXml} from '@file-type/xml';
@@ -364,6 +394,7 @@ console.log(fileType);
 
 ### Available third-party file-type detectors
 
+- [@file-type/av](https://github.com/Borewit/file-type-av): Improves detection of audio and video file formats, with accurate differentiation between the two
 - [@file-type/xml](https://github.com/Borewit/file-type-xml): Detects common XML file types, such as GLM, KML, MusicXML, RSS, SVG, and XHTML
 
 ### Detector execution flow
@@ -436,7 +467,6 @@ abortController.abort(); // Abort file-type reading from the Blob stream.
 - [`aac`](https://en.wikipedia.org/wiki/Advanced_Audio_Coding) - Advanced Audio Coding
 - [`ac3`](https://www.atsc.org/standard/a522012-digital-audio-compression-ac-3-e-ac-3-standard-12172012/) - ATSC A/52 Audio File
 - [`ace`](https://en.wikipedia.org/wiki/ACE_(compressed_file_format)) - ACE archive
-- [`ai`](https://en.wikipedia.org/wiki/Adobe_Illustrator_Artwork) - Adobe Illustrator Artwork
 - [`aif`](https://en.wikipedia.org/wiki/Audio_Interchange_File_Format) - Audio Interchange file
 - [`alias`](https://en.wikipedia.org/wiki/Alias_%28Mac_OS%29) - macOS Alias file
 - [`amr`](https://en.wikipedia.org/wiki/Adaptive_Multi-Rate_audio_codec) - Adaptive Multi-Rate audio codec
@@ -465,6 +495,7 @@ abortController.abort(); // Abort file-type reading from the Blob stream.
 - [`cr3`](https://fileinfo.com/extension/cr3) - Canon Raw image file (v3)
 - [`crx`](https://developer.chrome.com/extensions/crx) - Google Chrome extension
 - [`cur`](https://en.wikipedia.org/wiki/ICO_(file_format)) - Icon file
+- [`dat`](https://en.wikipedia.org/wiki/Windows_Registry) - Windows registry hive file
 - [`dcm`](https://en.wikipedia.org/wiki/DICOM#Data_format) - DICOM Image File
 - [`deb`](https://en.wikipedia.org/wiki/Deb_(file_format)) - Debian package
 - [`dmg`](https://en.wikipedia.org/wiki/Apple_Disk_Image) - Apple Disk Image
@@ -567,6 +598,7 @@ abortController.abort(); // Abort file-type reading from the Blob stream.
 - [`qcp`](https://en.wikipedia.org/wiki/QCP) - Tagged and chunked data
 - [`raf`](https://en.wikipedia.org/wiki/Raw_image_format) - Fujifilm RAW image file
 - [`rar`](https://en.wikipedia.org/wiki/RAR_(file_format)) - Archive file
+- [`reg`](https://en.wikipedia.org/wiki/Windows_Registry) - Windows registry (entries) file format
 - [`rm`](https://en.wikipedia.org/wiki/RealMedia) - RealMedia
 - [`rpm`](https://fileinfo.com/extension/rpm) - Red Hat Package Manager file
 - [`rtf`](https://en.wikipedia.org/wiki/Rich_Text_Format) - Rich Text Format
@@ -578,7 +610,8 @@ abortController.abort(); // Abort file-type reading from the Blob stream.
 - [`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)
 - [`swf`](https://en.wikipedia.org/wiki/SWF) - Adobe Flash Player file
-- [`tar`](https://en.wikipedia.org/wiki/Tar_(computing)#File_format) - Tarball archive 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)
 - [`tif`](https://en.wikipedia.org/wiki/Tagged_Image_File_Format) - Tagged Image file
 - [`ttc`](https://en.wikipedia.org/wiki/TrueType#TrueType_Collection) - TrueType Collection font
 - [`ttf`](https://en.wikipedia.org/wiki/TrueType) - TrueType font

package/supported.js

@@ -128,7 +128,6 @@ export const extensions = [
 	'it',
 	's3m',
 	'xm',
-	'ai',
 	'skp',
 	'avif',
 	'eps',
@@ -175,6 +174,9 @@ export const extensions = [
 	'rm',
 	'ppsm',
 	'ppsx',
+	'tar.gz',
+	'reg',
+	'dat',
 ];
 
 export const mimeTypes = [
@@ -208,10 +210,10 @@ export const mimeTypes = [
 	'application/x-bzip2',
 	'application/x-7z-compressed',
 	'application/x-apple-diskimage',
-	'application/x-apache-arrow',
+	'application/vnd.apache.arrow.file',
 	'video/mp4',
 	'audio/midi',
-	'video/x-matroska',
+	'video/matroska',
 	'video/webm',
 	'video/quicktime',
 	'video/vnd.avi',
@@ -228,7 +230,7 @@ export const mimeTypes = [
 	'audio/ogg',
 	'audio/ogg; codecs=opus',
 	'application/ogg',
-	'audio/x-flac',
+	'audio/flac',
 	'audio/ape',
 	'audio/wavpack',
 	'audio/amr',
@@ -321,7 +323,7 @@ export const mimeTypes = [
 	'image/jls',
 	'application/vnd.ms-outlook',
 	'image/vnd.dwg',
-	'application/x-parquet',
+	'application/vnd.apache.parquet',
 	'application/java-vm',
 	'application/x-arj',
 	'application/x-cpio',
@@ -349,4 +351,6 @@ export const mimeTypes = [
 	'application/vnd.ms-powerpoint.presentation.macroenabled.12',
 	'application/java-archive',
 	'application/vnd.rn-realmedia',
+	'application/x-ms-regedit',
+	'application/x-ft-windows-registry-hive',
 ];

package/util.js

@@ -1,6 +1,26 @@
 import {StringType} from 'token-types';
 
-export function stringToBytes(string) {
+export function stringToBytes(string, encoding) {
+	if (encoding === 'utf-16le') {
+		const bytes = [];
+		for (let index = 0; index < string.length; index++) {
+			const code = string.charCodeAt(index); // eslint-disable-line unicorn/prefer-code-point
+			bytes.push(code & 0xFF, (code >> 8) & 0xFF); // High byte
+		}
+
+		return bytes;
+	}
+
+	if (encoding === 'utf-16be') {
+		const bytes = [];
+		for (let index = 0; index < string.length; index++) {
+			const code = string.charCodeAt(index); // eslint-disable-line unicorn/prefer-code-point
+			bytes.push((code >> 8) & 0xFF, code & 0xFF); // Low byte
+		}
+
+		return bytes;
+	}
+
 	return [...string].map(character => character.charCodeAt(0)); // eslint-disable-line unicorn/prefer-code-point
 }