file-type 16.5.0 → 17.0.0

package/index.d.ts

@@ -1,11 +1,5 @@
-/// <reference types="node"/>
-import {Readable as ReadableStream} from 'stream';
-import * as core from './core';
-
-export type ReadableStreamWithFileType = core.ReadableStreamWithFileType;
-export type FileTypeResult = core.FileTypeResult;
-export type FileExtension = core.FileExtension;
-export type MimeType = core.MimeType;
+import {Readable as ReadableStream} from 'node:stream';
+import {FileTypeResult} from './core.js';
 
 /**
 Detect the file type of a file path.
@@ -15,13 +9,6 @@ The file type is detected by checking the [magic number](https://en.wikipedia.or
 @param path - The file path to parse.
 @returns The detected file type and MIME type or `undefined` when there is no match.
 */
-export function fromFile(path: string): Promise<core.FileTypeResult | undefined>;
+export function fileTypeFromFile(path: string): Promise<FileTypeResult | undefined>;
 
-export {
-	fromBuffer,
-	fromStream,
-	fromTokenizer,
-	extensions,
-	mimeTypes,
-	stream
-} from './core';
+export * from './core.js';

package/index.js

@@ -1,32 +1,13 @@
-'use strict';
-const strtok3 = require('strtok3');
-const core = require('./core');
+import * as strtok3 from 'strtok3';
+import {fileTypeFromTokenizer} from './core.js';
 
-async function fromFile(path) {
+export async function fileTypeFromFile(path) {
 	const tokenizer = await strtok3.fromFile(path);
 	try {
-		return await core.fromTokenizer(tokenizer);
+		return await fileTypeFromTokenizer(tokenizer);
 	} finally {
 		await tokenizer.close();
 	}
 }
 
-const fileType = {
-	fromFile
-};
-
-Object.assign(fileType, core);
-
-Object.defineProperty(fileType, 'extensions', {
-	get() {
-		return core.extensions;
-	}
-});
-
-Object.defineProperty(fileType, 'mimeTypes', {
-	get() {
-		return core.mimeTypes;
-	}
-});
-
-module.exports = fileType;
+export * from './core.js';

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "file-type",
-	"version": "16.5.0",
+	"version": "17.0.0",
 	"description": "Detect the file type of a Buffer/Uint8Array/ArrayBuffer",
 	"license": "MIT",
 	"repository": "sindresorhus/file-type",
@@ -10,11 +10,18 @@
 		"email": "sindresorhus@gmail.com",
 		"url": "https://sindresorhus.com"
 	},
+	"type": "module",
+	"exports": {
+		".": {
+			"node": "./index.js",
+			"default": "./browser.js"
+		},
+		"./core": "./core.js"
+	},
 	"engines": {
-		"node": ">=8"
+		"node": "^12.20.0 || ^14.13.1 || >=16.0.0"
 	},
 	"scripts": {
-		"ava": "ava --serial --verbose",
 		"test": "xo && ava && tsd"
 	},
 	"files": [
@@ -187,18 +194,19 @@
 		"jxl",
 		"vcf"
 	],
-	"devDependencies": {
-		"@types/node": "^13.1.4",
-		"ava": "^2.3.0",
-		"noop-stream": "^0.1.0",
-		"read-chunk": "^3.2.0",
-		"tsd": "^0.11.0",
-		"xo": "^0.25.3"
-	},
 	"dependencies": {
-		"readable-web-to-node-stream": "^3.0.0",
-		"strtok3": "^6.0.3",
-		"token-types": "^2.0.0"
+		"readable-web-to-node-stream": "^3.0.2",
+		"strtok3": "7.0.0-alpha.4",
+		"token-types": "^4.1.1"
+	},
+	"devDependencies": {
+		"@tokenizer/token": "^0.3.0",
+		"@types/node": "^16.11.10",
+		"ava": "^3.15.0",
+		"noop-stream": "^1.0.0",
+		"tsd": "^0.19.0",
+		"typescript": "^4.5.2",
+		"xo": "^0.46.4"
 	},
 	"xo": {
 		"envs": [
@@ -208,8 +216,12 @@
 		"rules": {
 			"no-inner-declarations": "warn",
 			"no-await-in-loop": "warn",
-			"promise/prefer-await-to-then": "warn",
-			"prefer-named-capture-group": "off"
+			"no-bitwise": "off",
+			"@typescript-eslint/no-unsafe-assignment": "off"
 		}
+	},
+	"ava": {
+		"serial": true,
+		"verbose": true
 	}
 }

package/readme.md

@@ -6,10 +6,40 @@ The file type is detected by checking the [magic number](https://en.wikipedia.or
 
 This package is for detecting binary-based file formats, not text-based formats like `.txt`, `.csv`, `.svg`, etc.
 
+<br>
+
+---
+
+<div align="center">
+	<p>
+		<p>
+			<sup>
+				<a href="https://github.com/sponsors/sindresorhus">My open source work is supported by the community</a>
+			</sup>
+		</p>
+		<sup>Special thanks to:</sup>
+		<br>
+		<br>
+		<a href="https://bit.io/?utm_campaign=github_repo&utm_medium=referral&utm_content=file-type&utm_source=github">
+			<div>
+				<img src="https://sindresorhus.com/assets/thanks/bitio-logo.svg" width="190" alt="bit.io">
+			</div>
+			<b>Instant, shareable cloud PostgreSQL database</b>
+			<div>
+				<sup>Import any dataset in seconds, share with anyone with a click, try without signing up</sup>
+			</div>
+		</a>
+	</p>
+</div>
+
+---
+
+<br>
+
 ## Install
 
-```
-$ npm install file-type
+```sh
+npm install file-type
 ```
 
 ## Usage
@@ -19,114 +49,99 @@ $ npm install file-type
 Determine file type from a file:
 
 ```js
-const FileType = require('file-type');
+import {fileTypeFromFile} from 'file-type';
 
-(async () => {
-	console.log(await FileType.fromFile('Unicorn.png'));
-	//=> {ext: 'png', mime: 'image/png'}
-})();
+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:
 
 ```js
-const FileType = require('file-type');
-const readChunk = require('read-chunk');
+import {fileTypeFromBuffer} from 'file-type';
+import {readChunk} from 'read-chunk';
 
-(async () => {
-	const buffer = readChunk.sync('Unicorn.png', 0, 4100);
+const buffer = await readChunk('Unicorn.png', {length: 4100});
 
-	console.log(await FileType.fromBuffer(buffer));
-	//=> {ext: 'png', mime: 'image/png'}
-})();
+console.log(await fileTypeFromBuffer(buffer));
+//=> {ext: 'png', mime: 'image/png'}
 ```
 
 Determine file type from a stream:
 
 ```js
-const fs = require('fs');
-const FileType = require('file-type');
+import fs from 'node:fs';
+import {fileTypeFromStream} from 'file-type';
 
-(async () => {
-	const stream = fs.createReadStream('Unicorn.mp4');
+const stream = fs.createReadStream('Unicorn.mp4');
 
-	console.log(await FileType.fromStream(stream));
-	//=> {ext: 'mp4', mime: 'video/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
-const got = require('got');
-const FileType = require('file-type');
+import got from 'got';
+import {fileTypeFromStream} from 'file-type';
 
 const url = 'https://upload.wikimedia.org/wikipedia/en/a/a9/Example.jpg';
 
-(async () => {
-	const stream = got.stream(url);
+const stream = got.stream(url);
 
-	console.log(await FileType.fromStream(stream));
-	//=> {ext: 'jpg', mime: 'image/jpeg'}
-})();
+console.log(await fileTypeFromStream(stream));
+//=> {ext: 'jpg', mime: 'image/jpeg'}
 ```
 
 Another stream example:
 
 ```js
-const stream = require('stream');
-const fs = require('fs');
-const crypto = require('crypto');
-const FileType = require('file-type');
+import stream from 'node:stream';
+import fs from 'node:fs';
+import crypto from 'node:crypto';
+import {fileTypeStream} from 'file-type';
 
-(async () => {
-	const read = fs.createReadStream('encrypted.enc');
-	const decipher = crypto.createDecipheriv(alg, key, iv);
+const read = fs.createReadStream('encrypted.enc');
+const decipher = crypto.createDecipheriv(alg, key, iv);
 
-	const fileTypeStream = await FileType.stream(stream.pipeline(read, decipher));
+const streamWithFileType = await fileTypeStream(stream.pipeline(read, decipher));
 
-	console.log(fileTypeStream.fileType);
-	//=> {ext: 'mov', mime: 'video/quicktime'}
+console.log(streamWithFileType.fileType);
+//=> {ext: 'mov', mime: 'video/quicktime'}
 
-	const write = fs.createWriteStream(`decrypted.${fileTypeStream.fileType.ext}`);
-	fileTypeStream.pipe(write);
-})();
+const write = fs.createWriteStream(`decrypted.${streamWithFileType.fileType.ext}`);
+streamWithFileType.pipe(write);
 ```
 
 #### Browser
 
 ```js
-const FileType = require('file-type/browser');
+import {fileTypeFromStream} from 'file-type';
 
 const url = 'https://upload.wikimedia.org/wikipedia/en/a/a9/Example.jpg';
 
-(async () => {
-	const response = await fetch(url);
-	const fileType = await FileType.fromStream(response.body);
+const response = await fetch(url);
+const fileType = await fileTypeFromStream(response.body);
 
-	console.log(fileType);
-	//=> {ext: 'jpg', mime: 'image/jpeg'}
-})();
+console.log(fileType);
+//=> {ext: 'jpg', mime: 'image/jpeg'}
 ```
 
 ```js
-const FileType = require('file-type/browser');
+import {fileTypeFromBlob} from 'file-type';
 
-(async () => {
-	const blob = new Blob(['<?xml version="1.0" encoding="ISO-8859-1" ?>'], {
-		type: 'plain/text',
-		endings: 'native'
-	});
+const blob = new Blob(['<?xml version="1.0" encoding="ISO-8859-1" ?>'], {
+	type: 'plain/text',
+	endings: 'native'
+});
 
-	console.log(await FileType.fromBlob(blob));
-	//=> {ext: 'txt', mime: 'plain/text'}
-})();
+console.log(await fileTypeFromBlob(blob));
+//=> {ext: 'txt', mime: 'plain/text'}
 ```
 
 ## API
 
-### FileType.fromBuffer(buffer)
+### fileTypeFromBuffer(buffer)
 
 Detect the file type of a `Buffer`, `Uint8Array`, or `ArrayBuffer`.
 
@@ -147,7 +162,7 @@ Type: `Buffer | 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.
 
-### FileType.fromFile(filePath)
+### fileTypeFromFile(filePath)
 
 Detect the file type of a file path.
 
@@ -166,7 +181,7 @@ Type: `string`
 
 The file path to parse.
 
-### FileType.fromStream(stream)
+### fileTypeFromStream(stream)
 
 Detect the file type of a Node.js [readable stream](https://nodejs.org/api/stream.html#stream_class_stream_readable).
 
@@ -185,7 +200,7 @@ Type: [`stream.Readable`](https://nodejs.org/api/stream.html#stream_class_stream
 
 A readable stream representing file data.
 
-### FileType.fromTokenizer(tokenizer)
+### fileTypeFromTokenizer(tokenizer)
 
 Detect the file type from an `ITokenizer` source.
 
@@ -203,41 +218,37 @@ 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 can *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.
 
 ```js
-const {makeTokenizer} = require('@tokenizer/http');
-const FileType = require('file-type');
+import {makeTokenizer} from '@tokenizer/http';
+import {fileTypeFromTokenizer} from 'file-type';
 
 const audioTrackUrl = 'https://test-audio.netlify.com/Various%20Artists%20-%202009%20-%20netBloc%20Vol%2024_%20tiuqottigeloot%20%5BMP3-V2%5D/01%20-%20Diablo%20Swing%20Orchestra%20-%20Heroines.mp3';
 
-(async () => {
-	const httpTokenizer = await makeTokenizer(audioTrackUrl);
-	const fileType = await FileType.fromTokenizer(httpTokenizer);
+const httpTokenizer = await makeTokenizer(audioTrackUrl);
+const fileType = await fileTypeFromTokenizer(httpTokenizer);
 
-	console.log(fileType);
-	//=> {ext: 'mp3', mime: 'audio/mpeg'}
-})();
+console.log(fileType);
+//=> {ext: 'mp3', mime: 'audio/mpeg'}
 ```
 
 Or use [`@tokenizer/s3`](https://github.com/Borewit/tokenizer-s3) to determine the file type of a file stored on [Amazon S3](https://aws.amazon.com/s3):
 
 ```js
-const FileType = require('file-type');
-const S3 = require('aws-sdk/clients/s3');
-const {makeTokenizer} = require('@tokenizer/s3');
-
-(async () => {
-	// Initialize the S3 client
-	const s3 = new S3();
-
-	// Initialize the S3 tokenizer.
-	const s3Tokenizer = await makeTokenizer(s3, {
-		Bucket: 'affectlab',
-		Key: '1min_35sec.mp4'
-	});
-
-	// Figure out what kind of file it is.
-	const fileType = await FileType.fromTokenizer(s3Tokenizer);
-	console.log(fileType);
-})();
+import S3 from 'aws-sdk/clients/s3';
+import {makeTokenizer} from '@tokenizer/s3';
+import {fileTypeFromTokenizer} from 'file-type';
+
+// Initialize the S3 client
+const s3 = new S3();
+
+// Initialize the S3 tokenizer.
+const s3Tokenizer = await makeTokenizer(s3, {
+	Bucket: 'affectlab',
+	Key: '1min_35sec.mp4'
+});
+
+// Figure out what kind of file it is.
+const fileType = await fileTypeFromTokenizer(s3Tokenizer);
+console.log(fileType);
 ```
 
 Note that only the minimum amount of data required to determine the file type is read (okay, just a bit extra to prevent too many fragmented reads).
@@ -248,13 +259,48 @@ Type: [`ITokenizer`](https://github.com/Borewit/strtok3#tokenizer)
 
 A file source implementing the [tokenizer interface](https://github.com/Borewit/strtok3#tokenizer).
 
-### FileType.stream(readableStream)
-
-Detect the file type of a readable stream.
+### fileTypeStream(readableStream, options?)
 
 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 `FileType.fromFile()`.
 
-*Note:* This method is only available using Node.js.
+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.
+
+#### readableStream
+
+Type: [`stream.Readable`](https://nodejs.org/api/stream.html#stream_class_stream_readable)
+
+#### options
+
+Type: `object`
+
+##### sampleSize
+
+Type: `number`\
+Default: `4100`
+
+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});
+
+if (stream2.fileType && stream2.fileType.mime === 'image/jpeg') {
+	// stream2 can be used to stream the JPEG image (from the very beginning of the stream)
+}
+```
 
 #### readableStream
 
@@ -262,13 +308,13 @@ Type: [`stream.Readable`](https://nodejs.org/api/stream.html#stream_class_stream
 
 The input stream.
 
-### FileType.extensions
+### supportedExtensions
 
-Returns a set of supported file extensions.
+Returns a `Set<string>` of supported file extensions.
 
-### FileType.mimeTypes
+### supportedMimeTypes
 
-Returns a set of supported MIME types.
+Returns a `Set<string>` of supported MIME types.
 
 ## Supported file types
 
@@ -349,7 +395,7 @@ Returns a set of supported MIME types.
 - [`lz`](https://en.wikipedia.org/wiki/Lzip) - Arhive file
 - [`cfb`](https://en.wikipedia.org/wiki/Compound_File_Binary_Format) - Compount File Binary Format
 - [`mxf`](https://en.wikipedia.org/wiki/Material_Exchange_Format) - Material Exchange Format
-- [`mts`](https://en.wikipedia.org/wiki/.m2ts) - Blu-ray Disc Audio-Video MPEG-2 Transport Stream
+- [`mts`](https://en.wikipedia.org/wiki/.m2ts) - MPEG-2 Transport Stream, both raw and Blu-ray Disc Audio-Video (BDAV) versions
 - [`wasm`](https://en.wikipedia.org/wiki/WebAssembly) - WebAssembly intermediate compiled format
 - [`blend`](https://wiki.blender.org/index.php/Dev:Source/Architecture/File_Format) - Blender project
 - [`bpg`](https://bellard.org/bpg/) - Better Portable Graphics file