file-type 18.7.0 → 19.1.0

package/core.d.ts

@@ -1,6 +1,16 @@
-import type {Readable as ReadableStream} from 'node:stream';
+/**
+Typings for primary entry point, Node.js specific typings can be found in index.d.ts
+*/
+
+import type {ReadableStream as WebReadableStream} from 'node:stream/web';
 import type {ITokenizer} from 'strtok3';
 
+/**
+Either the Node.js ReadableStream or the `lib.dom.d.ts` ReadableStream.
+Related issue: https://github.com/DefinitelyTyped/DefinitelyTyped/pull/60377
+*/
+export type AnyWebReadableStream<G> = WebReadableStream<G> | ReadableStream<G>;
+
 export type FileExtension =
 	| 'jpg'
 	| 'png'
@@ -192,7 +202,7 @@ export type MimeType =
 	| 'video/webm'
 	| 'video/quicktime'
 	| 'video/vnd.avi'
-	| 'audio/vnd.wave'
+	| 'audio/wav'
 	| 'audio/qcelp'
 	| 'audio/x-ms-asf'
 	| 'video/x-ms-asf'
@@ -318,18 +328,14 @@ export type FileTypeResult = {
 	readonly mime: MimeType;
 };
 
-export type ReadableStreamWithFileType = ReadableStream & {
-	readonly fileType?: FileTypeResult;
-};
-
 /**
-Detect the file type of a `Buffer`, `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 Buffer representing file data. It works best if the buffer contains the entire file. It may work with a smaller portion as well.
+@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.
 @returns The detected file type, or `undefined` when there is no match.
 */
 export function fileTypeFromBuffer(buffer: Uint8Array | ArrayBuffer): Promise<FileTypeResult | undefined>;
@@ -339,10 +345,10 @@ Detect the file type of a Node.js [readable stream](https://nodejs.org/api/strea
 
 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 readable stream representing file data.
+@param stream - A Node.js Readable stream or Web API Readable Stream representing file data. The Web Readable stream **must be a byte stream**.
 @returns The detected file type, or `undefined` when there is no match.
 */
-export function fileTypeFromStream(stream: ReadableStream): Promise<FileTypeResult | undefined>;
+export function fileTypeFromStream(stream: AnyWebReadableStream<Uint8Array>): Promise<FileTypeResult | undefined>;
 
 /**
 Detect the file type from an [`ITokenizer`](https://github.com/Borewit/strtok3#tokenizer) source.
@@ -391,37 +397,6 @@ export type StreamOptions = {
 	readonly sampleSize?: number;
 };
 
-/**
-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.
-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:** This method is only available when using Node.js.
-**Note:** Requires Node.js 14 or later.
-
-@param readableStream - A [readable stream](https://nodejs.org/api/stream.html#stream_class_stream_readable) containing a file to examine.
-@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()`.
-
-@example
-```
-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});
-
-if (stream2.fileType?.mime === 'image/jpeg') {
-	// stream2 can be used to stream the JPEG image (from the very beginning of the stream)
-}
-```
-*/
-export function fileTypeStream(readableStream: ReadableStream, options?: StreamOptions): Promise<ReadableStreamWithFileType>;
-
 /**
 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).
 
@@ -508,11 +483,6 @@ export declare class FileTypeParser {
 	*/
 	fromBuffer(buffer: Uint8Array | ArrayBuffer): Promise<FileTypeResult | undefined>;
 
-	/**
-	Works the same way as {@link fileTypeFromStream}, additionally taking into account custom detectors (if any were provided to the constructor).
-	*/
-	fromStream(stream: ReadableStream): Promise<FileTypeResult | undefined>;
-
 	/**
 	Works the same way as {@link fileTypeFromTokenizer}, additionally taking into account custom detectors (if any were provided to the constructor).
 	*/
@@ -522,9 +492,4 @@ export declare class FileTypeParser {
 	Works the same way as {@link fileTypeFromBlob}, additionally taking into account custom detectors (if any were provided to the constructor).
 	*/
 	fromBlob(blob: Blob): Promise<FileTypeResult | undefined>;
-
-	/**
-	Works the same way as {@link fileTypeStream}, additionally taking into account custom detectors (if any were provided to the constructor).
-	*/
-	toDetectionStream(readableStream: ReadableStream, options?: StreamOptions): Promise<FileTypeResult | undefined>;
 }

package/core.js

@@ -1,6 +1,10 @@
-import {Buffer} from 'node:buffer';
+/**
+Primary entry point, Node.js specific entry point is index.js
+*/
+
 import * as Token from 'token-types';
-import * as strtok3 from 'strtok3/core'; // eslint-disable-line n/file-extension-in-import
+import * as strtok3 from 'strtok3/core';
+import {includes, indexOf, getUintBE} from 'uint8array-extras';
 import {
 	stringToBytes,
 	tarHeaderChecksumMatches,
@@ -8,7 +12,7 @@ import {
 } from './util.js';
 import {extensions, mimeTypes} from './supported.js';
 
-const minimumBytes = 4100; // A fair amount of file-types are detectable within this range.
+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);
@@ -75,7 +79,7 @@ export class FileTypeParser {
 
 	async fromBuffer(input) {
 		if (!(input instanceof Uint8Array || input instanceof ArrayBuffer)) {
-			throw new TypeError(`Expected the \`input\` argument to be of type \`Uint8Array\` or \`Buffer\` or \`ArrayBuffer\`, got \`${typeof input}\``);
+			throw new TypeError(`Expected the \`input\` argument to be of type \`Uint8Array\` or \`ArrayBuffer\`, got \`${typeof input}\``);
 		}
 
 		const buffer = input instanceof Uint8Array ? input : new Uint8Array(input);
@@ -88,12 +92,11 @@ export class FileTypeParser {
 	}
 
 	async fromBlob(blob) {
-		const buffer = await blob.arrayBuffer();
-		return this.fromBuffer(new Uint8Array(buffer));
+		return this.fromStream(blob.stream());
 	}
 
 	async fromStream(stream) {
-		const tokenizer = await strtok3.fromStream(stream);
+		const tokenizer = await strtok3.fromWebStream(stream);
 		try {
 			return await this.fromTokenizer(tokenizer);
 		} finally {
@@ -101,41 +104,6 @@ export class FileTypeParser {
 		}
 	}
 
-	async toDetectionStream(readableStream, options = {}) {
-		const {default: stream} = await import('node:stream');
-		const {sampleSize = minimumBytes} = options;
-
-		return new Promise((resolve, reject) => {
-			readableStream.on('error', reject);
-
-			readableStream.once('readable', () => {
-				(async () => {
-					try {
-						// Set up output stream
-						const pass = new stream.PassThrough();
-						const outputStream = stream.pipeline ? stream.pipeline(readableStream, pass, () => {}) : readableStream.pipe(pass);
-
-						// Read the input stream and detect the filetype
-						const chunk = readableStream.read(sampleSize) ?? readableStream.read() ?? Buffer.alloc(0);
-						try {
-							pass.fileType = await this.fromBuffer(chunk);
-						} catch (error) {
-							if (error instanceof strtok3.EndOfStreamError) {
-								pass.fileType = undefined;
-							} else {
-								reject(error);
-							}
-						}
-
-						resolve(outputStream);
-					} catch (error) {
-						reject(error);
-					}
-				})();
-			});
-		});
-	}
-
 	check(header, options) {
 		return _check(this.buffer, header, options);
 	}
@@ -145,7 +113,7 @@ export class FileTypeParser {
 	}
 
 	async parse(tokenizer) {
-		this.buffer = Buffer.alloc(minimumBytes);
+		this.buffer = new Uint8Array(reasonableDetectionSizeInBytes);
 
 		// Keep reading until EOF if the file size is unknown.
 		if (tokenizer.fileInfo.size === undefined) {
@@ -372,12 +340,14 @@ export class FileTypeParser {
 				while (tokenizer.position + 30 < tokenizer.fileInfo.size) {
 					await tokenizer.readBuffer(this.buffer, {length: 30});
 
+					const view = new DataView(this.buffer.buffer);
+
 					// https://en.wikipedia.org/wiki/Zip_(file_format)#File_headers
 					const zipHeader = {
-						compressedSize: this.buffer.readUInt32LE(18),
-						uncompressedSize: this.buffer.readUInt32LE(22),
-						filenameLength: this.buffer.readUInt16LE(26),
-						extraFieldLength: this.buffer.readUInt16LE(28),
+						compressedSize: view.getUint32(18, true),
+						uncompressedSize: view.getUint32(22, true),
+						filenameLength: view.getUint16(26, true),
+						extraFieldLength: view.getUint16(28, true),
 					};
 
 					zipHeader.filename = await tokenizer.readToken(new Token.StringType(zipHeader.filenameLength, 'utf-8'));
@@ -472,7 +442,8 @@ export class FileTypeParser {
 						while (nextHeaderIndex < 0 && (tokenizer.position < tokenizer.fileInfo.size)) {
 							await tokenizer.peekBuffer(this.buffer, {mayBeLess: true});
 
-							nextHeaderIndex = this.buffer.indexOf('504B0304', 0, 'hex');
+							nextHeaderIndex = indexOf(this.buffer, new Uint8Array([0x50, 0x4B, 0x03, 0x04]));
+
 							// Move position to the next header if found, skip the whole buffer otherwise
 							await tokenizer.ignore(nextHeaderIndex >= 0 ? nextHeaderIndex : this.buffer.length);
 						}
@@ -495,7 +466,7 @@ export class FileTypeParser {
 		if (this.checkString('OggS')) {
 			// This is an OGG container
 			await tokenizer.ignore(28);
-			const type = Buffer.alloc(8);
+			const type = new Uint8Array(8);
 			await tokenizer.readBuffer(type);
 
 			// Needs to be before `ogg` check
@@ -576,7 +547,7 @@ export class FileTypeParser {
 		) {
 			// They all can have MIME `video/mp4` except `application/mp4` special-case which is hard to detect.
 			// For some cases, we're specific, everything else falls to `video/mp4` with `mp4` extension.
-			const brandMajor = this.buffer.toString('binary', 8, 12).replace('\0', ' ').trim();
+			const brandMajor = new Token.StringType(4, 'latin1').get(this.buffer, 8).replace('\0', ' ').trim();
 			switch (brandMajor) {
 				case 'avif':
 				case 'avis':
@@ -706,11 +677,11 @@ export class FileTypeParser {
 			try {
 				await tokenizer.ignore(1350);
 				const maxBufferSize = 10 * 1024 * 1024;
-				const buffer = Buffer.alloc(Math.min(maxBufferSize, tokenizer.fileInfo.size));
+				const buffer = new Uint8Array(Math.min(maxBufferSize, tokenizer.fileInfo.size));
 				await tokenizer.readBuffer(buffer, {mayBeLess: true});
 
 				// Check if this is an Adobe Illustrator file
-				if (buffer.includes(Buffer.from('AIPrivateData'))) {
+				if (includes(buffer, new TextEncoder().encode('AIPrivateData'))) {
 					return {
 						ext: 'ai',
 						mime: 'application/postscript',
@@ -765,27 +736,31 @@ export class FileTypeParser {
 			async function readField() {
 				const msb = await tokenizer.peekNumber(Token.UINT8);
 				let mask = 0x80;
-				let ic = 0; // 0 = A, 1 = B, 2 = C, 3
-				// = D
+				let ic = 0; // 0 = A, 1 = B, 2 = C, 3 = D
 
 				while ((msb & mask) === 0 && mask !== 0) {
 					++ic;
 					mask >>= 1;
 				}
 
-				const id = Buffer.alloc(ic + 1);
+				const id = new Uint8Array(ic + 1);
 				await tokenizer.readBuffer(id);
 				return id;
 			}
 
 			async function readElement() {
-				const id = await readField();
+				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: id.readUIntBE(0, id.length),
-					len: lengthField.readUIntBE(lengthField.length - nrLength, nrLength),
+					id: getUintBE(idView),
+					len: getUintBE(lengthView),
 				};
 			}
 
@@ -793,8 +768,8 @@ export class FileTypeParser {
 				while (children > 0) {
 					const element = await readElement();
 					if (element.id === 0x42_82) {
-						const rawValue = await tokenizer.readToken(new Token.StringType(element.len, 'utf-8'));
-						return rawValue.replace(/\00.*$/g, ''); // Return DocType
+						const rawValue = await tokenizer.readToken(new Token.StringType(element.len));
+						return rawValue.replaceAll(/\00.*$/g, ''); // Return DocType
 					}
 
 					await tokenizer.ignore(element.len); // ignore payload
@@ -835,7 +810,7 @@ export class FileTypeParser {
 			if (this.check([0x57, 0x41, 0x56, 0x45], {offset: 8})) {
 				return {
 					ext: 'wav',
-					mime: 'audio/vnd.wave',
+					mime: 'audio/wav',
 				};
 			}
 
@@ -1059,7 +1034,7 @@ export class FileTypeParser {
 		}
 
 		if (this.checkString('AC')) {
-			const version = this.buffer.toString('binary', 2, 6);
+			const version = new Token.StringType(4, 'latin1').get(this.buffer, 2);
 			if (version.match('^d*') && version >= 1000 && version <= 1050) {
 				return {
 					ext: 'dwg',
@@ -1126,7 +1101,7 @@ export class FileTypeParser {
 			async function readChunkHeader() {
 				return {
 					length: await tokenizer.readToken(Token.INT32_BE),
-					type: await tokenizer.readToken(new Token.StringType(4, 'binary')),
+					type: await tokenizer.readToken(new Token.StringType(4, 'latin1')),
 				};
 			}
 
@@ -1213,7 +1188,7 @@ export class FileTypeParser {
 		// ASF_Header_Object first 80 bytes
 		if (this.check([0x30, 0x26, 0xB2, 0x75, 0x8E, 0x66, 0xCF, 0x11, 0xA6, 0xD9])) {
 			async function readHeader() {
-				const guid = Buffer.alloc(16);
+				const guid = new Uint8Array(16);
 				await tokenizer.readBuffer(guid);
 				return {
 					id: guid,
@@ -1228,7 +1203,7 @@ export class FileTypeParser {
 				let payload = header.size - 24;
 				if (_check(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 = Buffer.alloc(16);
+					const typeId = new Uint8Array(16);
 					payload -= await tokenizer.readBuffer(typeId);
 
 					if (_check(typeId, [0x40, 0x9E, 0x69, 0xF8, 0x4D, 0x5B, 0xCF, 0x11, 0xA8, 0xFD, 0x00, 0x80, 0x5F, 0x5C, 0x44, 0x2B])) {
@@ -1432,10 +1407,11 @@ export class FileTypeParser {
 		}
 
 		if (this.check([0x04, 0x00, 0x00, 0x00]) && this.buffer.length >= 16) { // Rough & quick check Pickle/ASAR
-			const jsonSize = this.buffer.readUInt32LE(12);
+			const jsonSize = new DataView(this.buffer.buffer).getUint32(12, true);
+
 			if (jsonSize > 12 && this.buffer.length >= jsonSize + 16) {
 				try {
-					const header = this.buffer.slice(16, jsonSize + 16).toString();
+					const header = new TextDecoder().decode(this.buffer.slice(16, jsonSize + 16));
 					const json = JSON.parse(header);
 					// Check if Pickle is ASAR
 					if (json.files) { // Final check, assuring Pickle/ASAR format
@@ -1682,9 +1658,5 @@ export class FileTypeParser {
 	}
 }
 
-export async function fileTypeStream(readableStream, options = {}) {
-	return new FileTypeParser().toDetectionStream(readableStream, options);
-}
-
 export const supportedExtensions = new Set(extensions);
 export const supportedMimeTypes = new Set(mimeTypes);

package/index.d.ts

@@ -1,13 +1,69 @@
-import type {FileTypeResult} from './core.js';
+/**
+Typings for Node.js specific entry point.
+*/
+
+import type {Readable as NodeReadableStream} from 'node:stream';
+import type {FileTypeResult, StreamOptions, AnyWebReadableStream} from './core.js';
+import {FileTypeParser} from './core.js';
+
+export type ReadableStreamWithFileType = NodeReadableStream & {
+	readonly fileType?: FileTypeResult;
+};
+
+export declare class NodeFileTypeParser extends FileTypeParser {
+	/**
+	@param stream - Node.js `stream.Readable` or Web API `ReadableStream`.
+	*/
+	fromStream(stream: AnyWebReadableStream<Uint8Array> | NodeReadableStream): Promise<FileTypeResult | undefined>;
+
+	/**
+	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>;
+}
 
 /**
 Detect the file type of a file path.
 
 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 path - The file path to parse.
+@param path
 @returns The detected file type and MIME type or `undefined` when there is no match.
 */
 export function fileTypeFromFile(path: string): Promise<FileTypeResult | undefined>;
 
+export function fileTypeFromStream(stream: AnyWebReadableStream<Uint8Array> | NodeReadableStream): 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()`.
+
+This method can be handy to put in between a stream, 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:** This method is only available when using Node.js.
+**Note:** Requires Node.js 14 or later.
+
+@param readableStream - A [readable stream](https://nodejs.org/api/stream.html#stream_class_stream_readable) containing a file to examine.
+@param options - Maybe used to override the default sample-size.
+@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()`.
+
+@example
+```
+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});
+
+if (stream2.fileType?.mime === 'image/jpeg') {
+	// stream2 can be used to stream the JPEG image (from the very beginning of the stream)
+}
+```
+ */
+export function fileTypeStream(readableStream: NodeReadableStream, options?: StreamOptions): Promise<ReadableStreamWithFileType>;
+
 export * from './core.js';

package/index.js

@@ -1,5 +1,56 @@
+/**
+Node.js specific entry point.
+*/
+
+import {ReadableStream as WebReadableStream} from 'node:stream/web';
 import * as strtok3 from 'strtok3';
-import {FileTypeParser} from './core.js';
+import {FileTypeParser, reasonableDetectionSizeInBytes} from './core.js';
+
+export class NodeFileTypeParser extends FileTypeParser {
+	async fromStream(stream) {
+		const tokenizer = await (stream instanceof WebReadableStream ? strtok3.fromWebStream(stream) : strtok3.fromStream(stream));
+		try {
+			return super.fromTokenizer(tokenizer);
+		} finally {
+			await tokenizer.close();
+		}
+	}
+
+	async toDetectionStream(readableStream, options = {}) {
+		const {default: stream} = await import('node:stream');
+		const {sampleSize = reasonableDetectionSizeInBytes} = options;
+
+		return new Promise((resolve, reject) => {
+			readableStream.on('error', reject);
+
+			readableStream.once('readable', () => {
+				(async () => {
+					try {
+						// Set up output stream
+						const pass = new stream.PassThrough();
+						const outputStream = stream.pipeline ? stream.pipeline(readableStream, pass, () => {}) : readableStream.pipe(pass);
+
+						// Read the input stream and detect the filetype
+						const chunk = readableStream.read(sampleSize) ?? readableStream.read() ?? new Uint8Array(0);
+						try {
+							pass.fileType = await this.fromBuffer(chunk);
+						} catch (error) {
+							if (error instanceof strtok3.EndOfStreamError) {
+								pass.fileType = undefined;
+							} else {
+								reject(error);
+							}
+						}
+
+						resolve(outputStream);
+					} catch (error) {
+						reject(error);
+					}
+				})();
+			});
+		});
+	}
+}
 
 export async function fileTypeFromFile(path, fileTypeOptions) {
 	const tokenizer = await strtok3.fromFile(path);
@@ -11,4 +62,12 @@ export async function fileTypeFromFile(path, fileTypeOptions) {
 	}
 }
 
-export * from './core.js';
+export async function fileTypeFromStream(stream, fileTypeOptions) {
+	return (new NodeFileTypeParser(fileTypeOptions)).fromStream(stream);
+}
+
+export async function fileTypeStream(readableStream, options = {}) {
+	return new NodeFileTypeParser().toDetectionStream(readableStream, options);
+}
+
+export {fileTypeFromBuffer, fileTypeFromBlob, FileTypeParser, supportedMimeTypes, supportedExtensions} from './core.js';

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "file-type",
-	"version": "18.7.0",
-	"description": "Detect the file type of a Buffer/Uint8Array/ArrayBuffer",
+	"version": "19.1.0",
+	"description": "Detect the file type of a Uint8Array/ArrayBuffer",
 	"license": "MIT",
 	"repository": "sindresorhus/file-type",
 	"funding": "https://github.com/sindresorhus/file-type?sponsor=1",
@@ -14,13 +14,13 @@
 	"exports": {
 		".": {
 			"node": "./index.js",
-			"default": "./browser.js"
+			"default": "./core.js"
 		},
 		"./core": "./core.js"
 	},
 	"sideEffects": false,
 	"engines": {
-		"node": ">=14.16"
+		"node": ">=18"
 	},
 	"scripts": {
 		"test": "xo && ava && tsd"
@@ -28,8 +28,6 @@
 	"files": [
 		"index.js",
 		"index.d.ts",
-		"browser.js",
-		"browser.d.ts",
 		"core.js",
 		"core.d.ts",
 		"supported.js",
@@ -210,24 +208,27 @@
 		"fbx"
 	],
 	"dependencies": {
-		"readable-web-to-node-stream": "^3.0.2",
-		"strtok3": "^7.0.0",
-		"token-types": "^5.0.1"
+		"strtok3": "^7.1.0",
+		"token-types": "^6.0.0",
+		"uint8array-extras": "^1.3.0"
 	},
 	"devDependencies": {
 		"@tokenizer/token": "^0.3.0",
-		"@types/node": "^20.1.2",
-		"ava": "^5.2.0",
+		"@types/node": "^20.10.7",
+		"ava": "^6.0.1",
 		"commonmark": "^0.30.0",
 		"noop-stream": "^1.0.0",
-		"tsd": "^0.28.1",
-		"xo": "^0.54.2"
+		"tsd": "^0.30.3",
+		"xo": "^0.56.0"
 	},
 	"xo": {
 		"envs": [
 			"node",
 			"browser"
 		],
+		"ignores": [
+			"fixture"
+		],
 		"rules": {
 			"no-inner-declarations": "warn",
 			"no-await-in-loop": "warn",

package/readme.md

@@ -1,6 +1,6 @@
 # file-type
 
-> Detect the file type of a Buffer/Uint8Array/ArrayBuffer
+> Detect the file type of a Uint8Array/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.
 
@@ -31,7 +31,7 @@ console.log(await fileTypeFromFile('Unicorn.png'));
 //=> {ext: 'png', mime: 'image/png'}
 ```
 
-Determine file type from a Buffer, which may be a portion of the beginning of a file:
+Determine file type from a Uint8Array/ArrayBuffer, which may be a portion of the beginning of a file:
 
 ```js
 import {fileTypeFromBuffer} from 'file-type';
@@ -107,7 +107,7 @@ console.log(fileType);
 
 ### fileTypeFromBuffer(buffer)
 
-Detect the file type of a `Buffer`, `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.
 
@@ -122,7 +122,7 @@ Or `undefined` when there is no match.
 
 #### buffer
 
-Type: `Buffer | Uint8Array | ArrayBuffer`
+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.
 
@@ -147,7 +147,7 @@ The file path to parse.
 
 ### fileTypeFromStream(stream)
 
-Detect the file type of a Node.js [readable stream](https://nodejs.org/api/stream.html#stream_class_stream_readable).
+Detect the file type of a [Node.js readable stream](https://nodejs.org/api/stream.html#stream_class_stream_readable) or a [Web API ReadableStream](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream).
 
 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.
 
@@ -168,6 +168,8 @@ A readable stream representing file data.
 
 Detect the file type of a [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob).
 
+It will **stream** the underlying Blob, and required a [ReadableStreamBYOBReader](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStreamBYOBReader) which **require Node.js ≥ 20**.
+
 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:
@@ -335,7 +337,7 @@ const customDetectors = [
 	async tokenizer => {
 		const unicornHeader = [85, 78, 73, 67, 79, 82, 78]; // 'UNICORN' as decimal string
 
-		const buffer = Buffer.alloc(7);
+		const buffer = new Uint8Array(7);
 		await tokenizer.peekBuffer(buffer, {length: unicornHeader.length, mayBeLess: true});
 
 		if (unicornHeader.every((value, index) => value === buffer[index])) {
@@ -346,7 +348,7 @@ const customDetectors = [
 	},
 ];
 
-const buffer = Buffer.from('UNICORN');
+const buffer = new Uint8Array(new TextEncoder().encode('UNICORN'));
 const parser = new FileTypeParser({customDetectors});
 const fileType = await parser.fromBuffer(buffer);
 console.log(fileType);

package/supported.js

@@ -189,7 +189,7 @@ export const mimeTypes = [
 	'video/webm',
 	'video/quicktime',
 	'video/vnd.avi',
-	'audio/vnd.wave',
+	'audio/wav',
 	'audio/qcelp',
 	'audio/x-ms-asf',
 	'video/x-ms-asf',

package/util.js

@@ -1,3 +1,5 @@
+import {StringType} from 'token-types';
+
 export function stringToBytes(string) {
 	return [...string].map(character => character.charCodeAt(0)); // eslint-disable-line unicorn/prefer-code-point
 }
@@ -5,12 +7,12 @@ export function stringToBytes(string) {
 /**
 Checks whether the TAR checksum is valid.
 
-@param {Buffer} buffer - The TAR header `[offset ... offset + 512]`.
+@param {Uint8Array} arrayBuffer - The TAR header `[offset ... offset + 512]`.
 @param {number} offset - TAR header offset.
 @returns {boolean} `true` if the TAR checksum is valid, otherwise `false`.
 */
-export function tarHeaderChecksumMatches(buffer, offset = 0) {
-	const readSum = Number.parseInt(buffer.toString('utf8', 148, 154).replace(/\0.*$/, '').trim(), 8); // Read sum in header
+export function tarHeaderChecksumMatches(arrayBuffer, offset = 0) {
+	const readSum = Number.parseInt(new StringType(6).get(arrayBuffer, 148).replace(/\0.*$/, '').trim(), 8); // Read sum in header
 	if (Number.isNaN(readSum)) {
 		return false;
 	}
@@ -18,11 +20,11 @@ export function tarHeaderChecksumMatches(buffer, offset = 0) {
 	let sum = 8 * 0x20; // Initialize signed bit sum
 
 	for (let index = offset; index < offset + 148; index++) {
-		sum += buffer[index];
+		sum += arrayBuffer[index];
 	}
 
 	for (let index = offset + 156; index < offset + 512; index++) {
-		sum += buffer[index];
+		sum += arrayBuffer[index];
 	}
 
 	return readSum === sum;

package/browser.d.ts

@@ -1,29 +0,0 @@
-import type {FileTypeResult} from './core.js';
-
-/**
-Detect the file type of a [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream).
-
-@example
-```
-import {fileTypeFromStream} from 'file-type';
-
-const url = 'https://upload.wikimedia.org/wikipedia/en/a/a9/Example.jpg';
-
-const response = await fetch(url);
-const fileType = await fileTypeFromStream(response.body);
-
-console.log(fileType);
-//=> {ext: 'jpg', mime: 'image/jpeg'}
-```
-*/
-export declare function fileTypeFromStream(stream: ReadableStream): Promise<FileTypeResult | undefined>;
-
-export {
-	fileTypeFromBuffer,
-	fileTypeFromBlob,
-	supportedExtensions,
-	supportedMimeTypes,
-	type FileTypeResult,
-	type FileExtension,
-	type MimeType,
-} from './core.js';

package/browser.js

@@ -1,15 +0,0 @@
-import {ReadableWebToNodeStream} from 'readable-web-to-node-stream';
-import {fileTypeFromStream as coreFileTypeFromStream} from './core.js';
-
-export async function fileTypeFromStream(stream) {
-	const readableWebToNodeStream = new ReadableWebToNodeStream(stream);
-	const fileType = await coreFileTypeFromStream(readableWebToNodeStream);
-	await readableWebToNodeStream.close();
-	return fileType;
-}
-
-export {
-	fileTypeFromTokenizer,
-	fileTypeFromBuffer,
-	fileTypeStream,
-} from './core.js';