file-type 10.9.0 → 11.1.0

package/index.d.ts

@@ -1,139 +1,205 @@
 /// <reference types="node"/>
 import {Readable as ReadableStream} from 'stream';
 
-export type FileType =
-	| 'jpg'
-	| 'png'
-	| 'gif'
-	| 'webp'
-	| 'flif'
-	| 'cr2'
-	| 'tif'
-	| 'bmp'
-	| 'jxr'
-	| 'psd'
-	| 'zip'
-	| 'tar'
-	| 'rar'
-	| 'gz'
-	| 'bz2'
-	| '7z'
-	| 'dmg'
-	| 'mp4'
-	| 'm4v'
-	| 'mid'
-	| 'mkv'
-	| 'webm'
-	| 'mov'
-	| 'avi'
-	| 'wmv'
-	| 'mpg'
-	| 'mp2'
-	| 'mp3'
-	| 'm4a'
-	| 'ogg'
-	| 'opus'
-	| 'flac'
-	| 'wav'
-	| 'qcp'
-	| 'amr'
-	| 'pdf'
-	| 'epub'
-	| 'mobi'
-	| 'exe'
-	| 'swf'
-	| 'rtf'
-	| 'woff'
-	| 'woff2'
-	| 'eot'
-	| 'ttf'
-	| 'otf'
-	| 'ico'
-	| 'flv'
-	| 'ps'
-	| 'xz'
-	| 'sqlite'
-	| 'nes'
-	| 'crx'
-	| 'xpi'
-	| 'cab'
-	| 'deb'
-	| 'ar'
-	| 'rpm'
-	| 'Z'
-	| 'lz'
-	| 'msi'
-	| 'mxf'
-	| 'mts'
-	| 'wasm'
-	| 'blend'
-	| 'bpg'
-	| 'docx'
-	| 'pptx'
-	| 'xlsx'
-	| '3gp'
-	| 'jp2'
-	| 'jpm'
-	| 'jpx'
-	| 'mj2'
-	| 'aif'
-	| 'odt'
-	| 'ods'
-	| 'odp'
-	| 'xml'
-	| 'heic'
-	| 'cur'
-	| 'ktx'
-	| 'ape'
-	| 'wv'
-	| 'asf'
-	| 'wma'
-	| 'wmv'
-	| 'dcm'
-	| 'mpc'
-	| 'ics'
-	| 'glb'
-	| 'pcap';
-
-export interface FileTypeResult {
-	/**
-	 * One of the supported [file types](https://github.com/sindresorhus/file-type#supported-file-types).
-	 */
-	ext: FileType;
+declare namespace fileType {
+	type FileType =
+		| 'jpg'
+		| 'png'
+		| 'gif'
+		| 'webp'
+		| 'flif'
+		| 'cr2'
+		| 'orf'
+		| 'arw'
+		| 'dng'
+		| 'nef'
+		| 'tif'
+		| 'bmp'
+		| 'jxr'
+		| 'psd'
+		| 'zip'
+		| 'tar'
+		| 'rar'
+		| 'gz'
+		| 'bz2'
+		| '7z'
+		| 'dmg'
+		| 'mp4'
+		| 'mid'
+		| 'mkv'
+		| 'webm'
+		| 'mov'
+		| 'avi'
+		| 'wmv'
+		| 'mpg'
+		| 'mp2'
+		| 'mp3'
+		| 'm4a'
+		| 'ogg'
+		| 'opus'
+		| 'flac'
+		| 'wav'
+		| 'qcp'
+		| 'amr'
+		| 'pdf'
+		| 'epub'
+		| 'mobi'
+		| 'exe'
+		| 'swf'
+		| 'rtf'
+		| 'woff'
+		| 'woff2'
+		| 'eot'
+		| 'ttf'
+		| 'otf'
+		| 'ico'
+		| 'flv'
+		| 'ps'
+		| 'xz'
+		| 'sqlite'
+		| 'nes'
+		| 'crx'
+		| 'xpi'
+		| 'cab'
+		| 'deb'
+		| 'ar'
+		| 'rpm'
+		| 'Z'
+		| 'lz'
+		| 'msi'
+		| 'mxf'
+		| 'mts'
+		| 'wasm'
+		| 'blend'
+		| 'bpg'
+		| 'docx'
+		| 'pptx'
+		| 'xlsx'
+		| '3gp'
+		| '3g2'
+		| 'jp2'
+		| 'jpm'
+		| 'jpx'
+		| 'mj2'
+		| 'aif'
+		| 'odt'
+		| 'ods'
+		| 'odp'
+		| 'xml'
+		| 'heic'
+		| 'cur'
+		| 'ktx'
+		| 'ape'
+		| 'wv'
+		| 'asf'
+		| 'wma'
+		| 'wmv'
+		| 'dcm'
+		| 'mpc'
+		| 'ics'
+		| 'glb'
+		| 'pcap'
+		| 'dsf'
+		| 'lnk'
+		| 'alias'
+		| 'voc'
+		| 'ac3'
+		| 'm4a'
+		| 'm4b'
+		| 'm4p'
+		| 'm4v'
+		| 'f4a'
+		| 'f4b'
+		| 'f4p'
+		| 'f4v';
 
-	/**
-	 * The detected [MIME type](https://en.wikipedia.org/wiki/Internet_media_type).
-	 */
-	mime: string;
+	interface FileTypeResult {
+		/**
+		One of the supported [file types](https://github.com/sindresorhus/file-type#supported-file-types).
+		*/
+		ext: FileType;
+
+		/**
+		The detected [MIME type](https://en.wikipedia.org/wiki/Internet_media_type).
+		*/
+		mime: string;
+	}
+
+	type ReadableStreamWithFileType = ReadableStream & {
+		readonly fileType?: FileTypeResult;
+	};
 }
 
-export type ReadableStreamWithFileType = ReadableStream & {
-	readonly fileType: FileTypeResult | null;
-};
+declare const fileType: {
+	/**
+	Detect the file type of a `Buffer`/`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.
+
+	@param buffer - It only needs the first `.minimumBytes` bytes. The exception is detection of `docx`, `pptx`, and `xlsx` which potentially requires reading the whole file.
+	@returns The detected file type and MIME type or `undefined` when there was no match.
+
+	@example
+	```
+	import readChunk = require('read-chunk');
+	import fileType = require('file-type');
+
+	const buffer = readChunk.sync('unicorn.png', 0, fileType.minimumBytes);
+
+	fileType(buffer);
+	//=> {ext: 'png', mime: 'image/png'}
+
 
-export interface FileTypeModule {
-	(buffer: Buffer | Uint8Array): FileTypeResult | null;
+	// Or from a remote location:
+
+	import * as http from 'http';
+
+	const url = 'https://assets-cdn.github.com/images/spinners/octocat-spinner-32.gif';
+
+	http.get(url, response => {
+		response.on('readable', () => {
+			const chunk = response.read(fileType.minimumBytes);
+			response.destroy();
+			console.log(fileType(chunk));
+			//=> {ext: 'gif', mime: 'image/gif'}
+		});
+	});
+	```
+	*/
+	(buffer: Buffer | Uint8Array | ArrayBuffer): fileType.FileTypeResult | undefined;
 
 	/**
-	 * The minimum amount of bytes needed to detect a file type. Currently, it's 4100 bytes, but it can change, so don't hard-code it.
-	 */
+	The minimum amount of bytes needed to detect a file type. Currently, it's 4100 bytes, but it can change, so don't hard-code it.
+	*/
 	readonly minimumBytes: number;
 
 	/**
-	 * Detect the file type of a readable stream.
-	 *
-	 * @param readableStream - A readable stream containing a file to examine, see: [`stream.Readable`](https://nodejs.org/api/stream.html#stream_class_stream_readable).
-	 * @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()`.
-	 */
-	readonly stream: (readableStream: ReadableStream) => Promise<ReadableStreamWithFileType>;
-}
+	Detect the file type of a readable stream.
+
+	@param readableStream - A readable stream containing a file to examine, see: [`stream.Readable`](https://nodejs.org/api/stream.html#stream_class_stream_readable).
+	@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()`.
 
-/**
- * Detect the file type of a `Buffer`/`Uint8Array`. 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 buffer - It only needs the first `.minimumBytes` bytes. The exception is detection of `docx`, `pptx`, and `xlsx` which potentially requires reading the whole file.
- * @returns An object with the detected file type and MIME type or `null` when there was no match.
- */
-declare const fileType: FileTypeModule;
+	@example
+	```
+	import * as fs from 'fs';
+	import * as crypto from 'crypto';
+	import fileType = require('file-type');
+
+	(async () => {
+		const read = fs.createReadStream('encrypted.enc');
+		const decipher = crypto.createDecipheriv(alg, key, iv);
+
+		const stream = await fileType.stream(read.pipe(decipher));
+
+		console.log(stream.fileType);
+		//=> {ext: 'mov', mime: 'video/quicktime'}
+
+		const write = fs.createWriteStream(`decrypted.${stream.fileType.ext}`);
+		stream.pipe(write);
+	})();
+	```
+	*/
+	readonly stream: (
+		readableStream: ReadableStream
+	) => Promise<fileType.ReadableStreamWithFileType>;
+};
 
-export default fileType;
+export = fileType;

package/index.js

@@ -1,30 +1,19 @@
 'use strict';
-const toBytes = s => [...s].map(c => c.charCodeAt(0));
-const xpiZipFilename = toBytes('META-INF/mozilla.rsa');
-const oxmlContentTypes = toBytes('[Content_Types].xml');
-const oxmlRels = toBytes('_rels/.rels');
+const {stringToBytes, readUInt64LE, tarHeaderChecksumMatches, uint8ArrayUtf8ByteString} = require('./util');
 
-function readUInt64LE(buf, offset = 0) {
-	let n = buf[offset];
-	let mul = 1;
-	let i = 0;
-	while (++i < 8) {
-		mul *= 0x100;
-		n += buf[offset + i] * mul;
-	}
-
-	return n;
-}
+const xpiZipFilename = stringToBytes('META-INF/mozilla.rsa');
+const oxmlContentTypes = stringToBytes('[Content_Types].xml');
+const oxmlRels = stringToBytes('_rels/.rels');
 
 const fileType = input => {
-	if (!(input instanceof Uint8Array || Buffer.isBuffer(input))) {
-		throw new TypeError(`Expected the \`input\` argument to be of type \`Uint8Array\` or \`Buffer\`, got \`${typeof input}\``);
+	if (!(input instanceof Uint8Array || input instanceof ArrayBuffer || Buffer.isBuffer(input))) {
+		throw new TypeError(`Expected the \`input\` argument to be of type \`Uint8Array\` or \`Buffer\` or \`ArrayBuffer\`, got \`${typeof input}\``);
 	}
 
-	const buf = input instanceof Uint8Array ? input : new Uint8Array(input);
+	const buffer = input instanceof Uint8Array ? input : new Uint8Array(input);
 
-	if (!(buf && buf.length > 1)) {
-		return null;
+	if (!(buffer && buffer.length > 1)) {
+		return;
 	}
 
 	const check = (header, options) => {
@@ -36,10 +25,10 @@ const fileType = input => {
 			// If a bitmask is set
 			if (options.mask) {
 				// If header doesn't equal `buf` with bits masked off
-				if (header[i] !== (options.mask[i] & buf[i + options.offset])) {
+				if (header[i] !== (options.mask[i] & buffer[i + options.offset])) {
 					return false;
 				}
-			} else if (header[i] !== buf[i + options.offset]) {
+			} else if (header[i] !== buffer[i + options.offset]) {
 				return false;
 			}
 		}
@@ -47,7 +36,7 @@ const fileType = input => {
 		return true;
 	};
 
-	const checkString = (header, options) => check(toBytes(header), options);
+	const checkString = (header, options) => check(stringToBytes(header), options);
 
 	if (check([0xFF, 0xD8, 0xFF])) {
 		return {
@@ -84,7 +73,7 @@ const fileType = input => {
 		};
 	}
 
-	// Needs to be before `tif` check
+	// `cr2`, `orf`, and `arw` need to be before `tif` check
 	if (
 		(check([0x49, 0x49, 0x2A, 0x0]) || check([0x4D, 0x4D, 0x0, 0x2A])) &&
 		check([0x43, 0x52], {offset: 8})
@@ -95,6 +84,34 @@ const fileType = input => {
 		};
 	}
 
+	if (check([0x49, 0x49, 0x52, 0x4F, 0x08, 0x00, 0x00, 0x00, 0x18])) {
+		return {
+			ext: 'orf',
+			mime: 'image/x-olympus-orf'
+		};
+	}
+
+	if (check([0x49, 0x49, 0x2A, 0x00, 0x10, 0xFB, 0x86, 0x01])) {
+		return {
+			ext: 'arw',
+			mime: 'image/x-sony-arw'
+		};
+	}
+
+	if (check([0x49, 0x49, 0x2A, 0x00, 0x08, 0x00, 0x00, 0x00, 0x2D])) {
+		return {
+			ext: 'dng',
+			mime: 'image/x-adobe-dng'
+		};
+	}
+
+	if (check([0x49, 0x49, 0x2A, 0x00, 0x30, 0x3D, 0x72, 0x01, 0x1C])) {
+		return {
+			ext: 'nef',
+			mime: 'image/x-nikon-nef'
+		};
+	}
+
 	if (
 		check([0x49, 0x49, 0x2A, 0x0]) ||
 		check([0x4D, 0x4D, 0x0, 0x2A])
@@ -177,7 +194,7 @@ const fileType = input => {
 
 		let zipHeaderIndex = 0; // The first zip header was already found at index 0
 		let oxmlFound = false;
-		let type = null;
+		let type;
 
 		do {
 			const offset = zipHeaderIndex + 30;
@@ -209,7 +226,7 @@ const fileType = input => {
 				return type;
 			}
 
-			zipHeaderIndex = findNextZipHeaderIndex(buf, offset);
+			zipHeaderIndex = findNextZipHeaderIndex(buffer, offset);
 		} while (zipHeaderIndex >= 0);
 
 		// No more zip parts available in the buffer, but maybe we are almost certain about the type?
@@ -220,8 +237,8 @@ const fileType = input => {
 
 	if (
 		check([0x50, 0x4B]) &&
-		(buf[2] === 0x3 || buf[2] === 0x5 || buf[2] === 0x7) &&
-		(buf[3] === 0x4 || buf[3] === 0x6 || buf[3] === 0x8)
+		(buffer[2] === 0x3 || buffer[2] === 0x5 || buffer[2] === 0x7) &&
+		(buffer[3] === 0x4 || buffer[3] === 0x6 || buffer[3] === 0x8)
 	) {
 		return {
 			ext: 'zip',
@@ -229,7 +246,10 @@ const fileType = input => {
 		};
 	}
 
-	if (check([0x75, 0x73, 0x74, 0x61, 0x72], {offset: 257})) {
+	if (
+		check([0x30, 0x30, 0x30, 0x30, 0x30, 0x30], {offset: 148, mask: [0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8]}) && // Valid tar checksum
+		tarHeaderChecksumMatches(buffer)
+	) {
 		return {
 			ext: 'tar',
 			mime: 'application/x-tar'
@@ -238,7 +258,7 @@ const fileType = input => {
 
 	if (
 		check([0x52, 0x61, 0x72, 0x21, 0x1A, 0x7]) &&
-		(buf[6] === 0x0 || buf[6] === 0x1)
+		(buffer[6] === 0x0 || buffer[6] === 0x1)
 	) {
 		return {
 			ext: 'rar',
@@ -274,25 +294,70 @@ const fileType = input => {
 		};
 	}
 
-	if (check([0x33, 0x67, 0x70, 0x35]) || // 3gp5
-		(
-			check([0x0, 0x0, 0x0]) && check([0x66, 0x74, 0x79, 0x70], {offset: 4}) &&
-				(
-					check([0x6D, 0x70, 0x34, 0x31], {offset: 8}) || // MP41
-					check([0x6D, 0x70, 0x34, 0x32], {offset: 8}) || // MP42
-					check([0x69, 0x73, 0x6F, 0x6D], {offset: 8}) || // ISOM
-					check([0x69, 0x73, 0x6F, 0x32], {offset: 8}) || // ISO2
-					check([0x6D, 0x6D, 0x70, 0x34], {offset: 8}) || // MMP4
-					check([0x4D, 0x34, 0x56], {offset: 8}) || // M4V
-					check([0x64, 0x61, 0x73, 0x68], {offset: 8}) // DASH
-				)
-		)) {
+	// `mov` format variants
+	if (
+		check([0x66, 0x72, 0x65, 0x65], {offset: 4}) || // `free`
+		check([0x6D, 0x64, 0x61, 0x74], {offset: 4}) || // `mdat` MJPEG
+		check([0x6D, 0x6F, 0x6F, 0x76], {offset: 4}) || // `moov`
+		check([0x77, 0x69, 0x64, 0x65], {offset: 4}) // `wide`
+	) {
 		return {
-			ext: 'mp4',
-			mime: 'video/mp4'
+			ext: 'mov',
+			mime: 'video/quicktime'
 		};
 	}
 
+	// File Type Box (https://en.wikipedia.org/wiki/ISO_base_media_file_format)
+	// It's not required to be first, but it's recommended to be. Almost all ISO base media files start with `ftyp` box.
+	// `ftyp` box must contain a brand major identifier, which must consist of ISO 8859-1 printable characters.
+	// Here we check for 8859-1 printable characters (for simplicity, it's a mask which also catches one non-printable character).
+	if (
+		check([0x66, 0x74, 0x79, 0x70], {offset: 4}) && // `ftyp`
+		(buffer[8] & 0x60) !== 0x00 && (buffer[9] & 0x60) !== 0x00 && (buffer[10] & 0x60) !== 0x00 && (buffer[11] & 0x60) !== 0x00 // Brand major
+	) {
+		// 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 = uint8ArrayUtf8ByteString(buffer, 8, 12);
+		switch (brandMajor) {
+			case 'mif1':
+				return {ext: 'heic', mime: 'image/heif'};
+			case 'msf1':
+				return {ext: 'heic', mime: 'image/heif-sequence'};
+			case 'heic': case 'heix':
+				return {ext: 'heic', mime: 'image/heic'};
+			case 'hevc': case 'hevx':
+				return {ext: 'heic', mime: 'image/heic-sequence'};
+			case 'qt  ':
+				return {ext: 'mov', mime: 'video/quicktime'};
+			case 'M4V ': case 'M4VH': case 'M4VP':
+				return {ext: 'm4v', mime: 'video/x-m4v'};
+			case 'M4P ':
+				return {ext: 'm4p', mime: 'video/mp4'};
+			case 'M4B ':
+				return {ext: 'm4b', mime: 'audio/mp4'};
+			case 'M4A ':
+				return {ext: 'm4a', mime: 'audio/x-m4a'};
+			case 'F4V ':
+				return {ext: 'f4v', mime: 'video/mp4'};
+			case 'F4P ':
+				return {ext: 'f4p', mime: 'video/mp4'};
+			case 'F4A ':
+				return {ext: 'f4a', mime: 'audio/mp4'};
+			case 'F4B ':
+				return {ext: 'f4b', mime: 'audio/mp4'};
+			default:
+				if (brandMajor.startsWith('3g')) {
+					if (brandMajor.startsWith('3g2')) {
+						return {ext: '3g2', mime: 'video/3gpp2'};
+					}
+
+					return {ext: '3gp', mime: 'video/3gpp'};
+				}
+
+				return {ext: 'mp4', mime: 'video/mp4'};
+		}
+	}
+
 	if (check([0x4D, 0x54, 0x68, 0x64])) {
 		return {
 			ext: 'mid',
@@ -302,7 +367,7 @@ const fileType = input => {
 
 	// https://github.com/threatstack/libmagic/blob/master/magic/Magdir/matroska
 	if (check([0x1A, 0x45, 0xDF, 0xA3])) {
-		const sliced = buf.subarray(4, 4 + 4096);
+		const sliced = buffer.subarray(4, 4 + 4096);
 		const idPos = sliced.findIndex((el, i, arr) => arr[i] === 0x42 && arr[i + 1] === 0x82);
 
 		if (idPos !== -1) {
@@ -325,18 +390,6 @@ const fileType = input => {
 		}
 	}
 
-	if (check([0x0, 0x0, 0x0, 0x14, 0x66, 0x74, 0x79, 0x70, 0x71, 0x74, 0x20, 0x20]) ||
-		check([0x66, 0x72, 0x65, 0x65], {offset: 4}) || // Type: `free`
-		check([0x66, 0x74, 0x79, 0x70, 0x71, 0x74, 0x20, 0x20], {offset: 4}) ||
-		check([0x6D, 0x64, 0x61, 0x74], {offset: 4}) || // MJPEG
-		check([0x6D, 0x6F, 0x6F, 0x76], {offset: 4}) || // Type: `moov`
-		check([0x77, 0x69, 0x64, 0x65], {offset: 4})) {
-		return {
-			ext: 'mov',
-			mime: 'video/quicktime'
-		};
-	}
-
 	// RIFF file format which might be AVI, WAV, QCP, etc
 	if (check([0x52, 0x49, 0x46, 0x46])) {
 		if (check([0x41, 0x56, 0x49], {offset: 8})) {
@@ -368,7 +421,7 @@ const fileType = input => {
 
 		let offset = 30;
 		do {
-			const objectSize = readUInt64LE(buf, offset + 16);
+			const objectSize = readUInt64LE(buffer, offset + 16);
 			if (check([0x91, 0x07, 0xDC, 0xB7, 0xB7, 0xA9, 0xCF, 0x11, 0x8E, 0xE6, 0x00, 0xC0, 0x0C, 0x20, 0x53, 0x65], {offset})) {
 				// Sync on Stream-Properties-Object (B7DC0791-A9B7-11CF-8EE6-00C00C205365)
 				if (check([0x40, 0x9E, 0x69, 0xF8, 0x4D, 0x5B, 0xCF, 0x11, 0xA8, 0xFD, 0x00, 0x80, 0x5F, 0x5C, 0x44, 0x2B], {offset: offset + 24})) {
@@ -391,7 +444,7 @@ const fileType = input => {
 			}
 
 			offset += objectSize;
-		} while (offset + 24 <= buf.length);
+		} while (offset + 24 <= buffer.length);
 
 		// Default to ASF generic extension
 		return {
@@ -410,18 +463,11 @@ const fileType = input => {
 		};
 	}
 
-	if (check([0x66, 0x74, 0x79, 0x70, 0x33, 0x67], {offset: 4})) {
-		return {
-			ext: '3gp',
-			mime: 'video/3gpp'
-		};
-	}
-
 	// Check for MPEG header at different starting offsets
-	for (let start = 0; start < 2 && start < (buf.length - 16); start++) {
+	for (let start = 0; start < 2 && start < (buffer.length - 16); start++) {
 		if (
 			check([0x49, 0x44, 0x33], {offset: start}) || // ID3 header
-			check([0xFF, 0xE2], {offset: start, mask: [0xFF, 0xE2]}) // MPEG 1 or 2 Layer 3 header
+			check([0xFF, 0xE2], {offset: start, mask: [0xFF, 0xE6]}) // MPEG 1 or 2 Layer 3 header
 		) {
 			return {
 				ext: 'mp3',
@@ -430,7 +476,7 @@ const fileType = input => {
 		}
 
 		if (
-			check([0xFF, 0xE4], {offset: start, mask: [0xFF, 0xE4]}) // MPEG 1 or 2 Layer 2 header
+			check([0xFF, 0xE4], {offset: start, mask: [0xFF, 0xE6]}) // MPEG 1 or 2 Layer 2 header
 		) {
 			return {
 				ext: 'mp2',
@@ -457,15 +503,6 @@ const fileType = input => {
 		}
 	}
 
-	if (
-		check([0x66, 0x74, 0x79, 0x70, 0x4D, 0x34, 0x41], {offset: 4})
-	) {
-		return { // MPEG-4 layer 3 (audio)
-			ext: 'm4a',
-			mime: 'audio/mp4' // RFC 4337
-		};
-	}
-
 	// Needs to be before `ogg` check
 	if (check([0x4F, 0x70, 0x75, 0x73, 0x48, 0x65, 0x61, 0x64], {offset: 28})) {
 		return {
@@ -568,7 +605,7 @@ const fileType = input => {
 	}
 
 	if (
-		(buf[0] === 0x43 || buf[0] === 0x46) &&
+		(buffer[0] === 0x43 || buffer[0] === 0x46) &&
 		check([0x57, 0x53], {offset: 1})
 	) {
 		return {
@@ -838,37 +875,6 @@ const fileType = input => {
 		};
 	}
 
-	// File Type Box (https://en.wikipedia.org/wiki/ISO_base_media_file_format)
-	if (check([0x66, 0x74, 0x79, 0x70], {offset: 4})) {
-		if (check([0x6D, 0x69, 0x66, 0x31], {offset: 8})) {
-			return {
-				ext: 'heic',
-				mime: 'image/heif'
-			};
-		}
-
-		if (check([0x6D, 0x73, 0x66, 0x31], {offset: 8})) {
-			return {
-				ext: 'heic',
-				mime: 'image/heif-sequence'
-			};
-		}
-
-		if (check([0x68, 0x65, 0x69, 0x63], {offset: 8}) || check([0x68, 0x65, 0x69, 0x78], {offset: 8})) {
-			return {
-				ext: 'heic',
-				mime: 'image/heic'
-			};
-		}
-
-		if (check([0x68, 0x65, 0x76, 0x63], {offset: 8}) || check([0x68, 0x65, 0x76, 0x78], {offset: 8})) {
-			return {
-				ext: 'heic',
-				mime: 'image/heic-sequence'
-			};
-		}
-	}
-
 	if (check([0xAB, 0x4B, 0x54, 0x58, 0x20, 0x31, 0x31, 0xBB, 0x0D, 0x0A, 0x1A, 0x0A])) {
 		return {
 			ext: 'ktx',
@@ -920,26 +926,64 @@ const fileType = input => {
 		};
 	}
 
-	return null;
+	// Sony DSD Stream File (DSF)
+	if (check([0x44, 0x53, 0x44, 0x20])) {
+		return {
+			ext: 'dsf',
+			mime: 'audio/x-dsf' // Non-standard
+		};
+	}
+
+	if (check([0x4C, 0x00, 0x00, 0x00, 0x01, 0x14, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46])) {
+		return {
+			ext: 'lnk',
+			mime: 'application/x.ms.shortcut' // Invented by us
+		};
+	}
+
+	if (check([0x62, 0x6F, 0x6F, 0x6B, 0x00, 0x00, 0x00, 0x00, 0x6D, 0x61, 0x72, 0x6B, 0x00, 0x00, 0x00, 0x00])) {
+		return {
+			ext: 'alias',
+			mime: 'application/x.apple.alias' // Invented by us
+		};
+	}
+
+	if (checkString('Creative Voice File')) {
+		return {
+			ext: 'voc',
+			mime: 'audio/x-voc'
+		};
+	}
+
+	if (check([0x0B, 0x77])) {
+		return {
+			ext: 'ac3',
+			mime: 'audio/vnd.dolby.dd-raw'
+		};
+	}
 };
 
 module.exports = fileType;
-module.exports.default = fileType;
 
 Object.defineProperty(fileType, 'minimumBytes', {value: 4100});
 
-module.exports.stream = readableStream => new Promise(resolve => {
+fileType.stream = readableStream => new Promise((resolve, reject) => {
 	// Using `eval` to work around issues when bundling with Webpack
 	const stream = eval('require')('stream'); // eslint-disable-line no-eval
 
 	readableStream.once('readable', () => {
 		const pass = new stream.PassThrough();
 		const chunk = readableStream.read(module.exports.minimumBytes) || readableStream.read();
-		pass.fileType = fileType(chunk);
+		try {
+			pass.fileType = fileType(chunk);
+		} catch (error) {
+			reject(error);
+		}
+
 		readableStream.unshift(chunk);
 
 		if (stream.pipeline) {
-			resolve(stream.pipeline(readableStream, pass));
+			resolve(stream.pipeline(readableStream, pass, () => {}));
 		} else {
 			resolve(readableStream.pipe(pass));
 		}

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "file-type",
-	"version": "10.9.0",
-	"description": "Detect the file type of a Buffer/Uint8Array",
+	"version": "11.1.0",
+	"description": "Detect the file type of a Buffer/Uint8Array/ArrayBuffer",
 	"license": "MIT",
 	"repository": "sindresorhus/file-type",
 	"author": {
@@ -13,11 +13,12 @@
 		"node": ">=6"
 	},
 	"scripts": {
-		"test": "xo && ava && tsd-check"
+		"test": "xo && ava && tsd"
 	},
 	"files": [
 		"index.js",
-		"index.d.ts"
+		"index.d.ts",
+		"util.js"
 	],
 	"keywords": [
 		"mime",
@@ -45,6 +46,10 @@
 		"webp",
 		"flif",
 		"cr2",
+		"orf",
+		"arw",
+		"dng",
+		"nef",
 		"tif",
 		"bmp",
 		"jxr",
@@ -57,7 +62,6 @@
 		"7z",
 		"dmg",
 		"mp4",
-		"m4v",
 		"mid",
 		"mkv",
 		"webm",
@@ -118,14 +122,28 @@
 		"wma",
 		"ics",
 		"glb",
-		"pcap"
+		"pcap",
+		"dsf",
+		"lnk",
+		"alias",
+		"voc",
+		"ac3",
+		"3g2",
+		"m4a",
+		"m4b",
+		"m4p",
+		"m4v",
+		"f4a",
+		"f4b",
+		"f4p",
+		"f4v"
 	],
 	"devDependencies": {
-		"@types/node": "^11.10.4",
-		"ava": "^1.2.1",
+		"@types/node": "^11.12.2",
+		"ava": "^1.4.1",
 		"pify": "^4.0.1",
-		"read-chunk": "^3.0.0",
-		"tsd-check": "^0.3.0",
+		"read-chunk": "^3.2.0",
+		"tsd": "^0.7.1",
 		"xo": "^0.24.0"
 	}
 }

package/readme.md

@@ -1,6 +1,6 @@
 # file-type [![Build Status](https://travis-ci.org/sindresorhus/file-type.svg?branch=master)](https://travis-ci.org/sindresorhus/file-type)
 
-> Detect the file type of a Buffer/Uint8Array
+> Detect the file type of a Buffer/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.
 
@@ -95,11 +95,11 @@ Returns an `Object` with:
 - `ext` - One of the [supported file types](#supported-file-types)
 - `mime` - The [MIME type](https://en.wikipedia.org/wiki/Internet_media_type)
 
-Or `null` when there is no match.
+Or `undefined` when there is no match.
 
 #### input
 
-Type: `Buffer` `Uint8Array`
+Type: `Buffer | Uint8Array | ArrayBuffer`
 
 It only needs the first `.minimumBytes` bytes. The exception is detection of `docx`, `pptx`, and `xlsx` which potentially requires reading the whole file.
 
@@ -129,7 +129,11 @@ Type: [`stream.Readable`](https://nodejs.org/api/stream.html#stream_class_stream
 - [`gif`](https://en.wikipedia.org/wiki/GIF)
 - [`webp`](https://en.wikipedia.org/wiki/WebP)
 - [`flif`](https://en.wikipedia.org/wiki/Free_Lossless_Image_Format)
-- [`cr2`](https://fileinfo.com/extension/cr2)
+- [`cr2`](https://fileinfo.com/extension/cr2) - Canon Raw image file (v2)
+- [`orf`](https://en.wikipedia.org/wiki/ORF_format) - Olympus Raw image file
+- [`arw`](https://en.wikipedia.org/wiki/Raw_image_format#ARW) - Sony Alpha Raw image file
+- [`dng`](https://en.wikipedia.org/wiki/Digital_Negative) - Adobe Digital Negative image file
+- [`nef`](https://www.nikonusa.com/en/learn-and-explore/a/products-and-innovation/nikon-electronic-format-nef.html) - Nikon Electronic Format image file
 - [`tif`](https://en.wikipedia.org/wiki/Tagged_Image_File_Format)
 - [`bmp`](https://en.wikipedia.org/wiki/BMP_file_format)
 - [`jxr`](https://en.wikipedia.org/wiki/JPEG_XR)
@@ -142,7 +146,6 @@ Type: [`stream.Readable`](https://nodejs.org/api/stream.html#stream_class_stream
 - [`7z`](https://en.wikipedia.org/wiki/7z)
 - [`dmg`](https://en.wikipedia.org/wiki/Apple_Disk_Image)
 - [`mp4`](https://en.wikipedia.org/wiki/MPEG-4_Part_14#Filename_extensions)
-- [`m4v`](https://en.wikipedia.org/wiki/M4V)
 - [`mid`](https://en.wikipedia.org/wiki/MIDI)
 - [`mkv`](https://en.wikipedia.org/wiki/Matroska)
 - [`webm`](https://en.wikipedia.org/wiki/WebM)
@@ -193,7 +196,6 @@ Type: [`stream.Readable`](https://nodejs.org/api/stream.html#stream_class_stream
 - [`docx`](https://en.wikipedia.org/wiki/Office_Open_XML)
 - [`pptx`](https://en.wikipedia.org/wiki/Office_Open_XML)
 - [`xlsx`](https://en.wikipedia.org/wiki/Office_Open_XML)
-- [`3gp`](https://en.wikipedia.org/wiki/3GP_and_3G2)
 - [`jp2`](https://en.wikipedia.org/wiki/JPEG_2000) - JPEG 2000
 - [`jpm`](https://en.wikipedia.org/wiki/JPEG_2000) - JPEG 2000
 - [`jpx`](https://en.wikipedia.org/wiki/JPEG_2000) - JPEG 2000
@@ -216,10 +218,25 @@ Type: [`stream.Readable`](https://nodejs.org/api/stream.html#stream_class_stream
 - [`ics`](https://en.wikipedia.org/wiki/ICalendar#Data_format) - iCalendar
 - [`glb`](https://github.com/KhronosGroup/glTF) - GL Transmission Format
 - [`pcap`](https://wiki.wireshark.org/Development/LibpcapFileFormat) - Libpcap File Format
+- [`dsf`](https://dsd-guide.com/sites/default/files/white-papers/DSFFileFormatSpec_E.pdf) - Sony DSD Stream File (DSF)
+- [`lnk`](https://en.wikipedia.org/wiki/Shortcut_%28computing%29#Microsoft_Windows) - Microsoft Windows file shortcut
+- [`alias`](https://en.wikipedia.org/wiki/Alias_%28Mac_OS%29) - macOS Alias file
+- [`voc`](https://wiki.multimedia.cx/index.php/Creative_Voice) - Creative Voice File
+- [`ac3`](https://www.atsc.org/standard/a522012-digital-audio-compression-ac-3-e-ac-3-standard-12172012/) - ATSC A/52 Audio File
+- [`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
+- [`3g2`](https://en.wikipedia.org/wiki/3GP_and_3G2#3G2) - Multimedia container format defined by the 3GPP2 for 3G CDMA2000 multimedia services
+- [`m4v`](https://en.wikipedia.org/wiki/M4V) -  MPEG-4 Visual bitstreams
+- [`m4p`](https://en.wikipedia.org/wiki/MPEG-4_Part_14#Filename_extensions) - MPEG-4 files with audio streams encrypted by FairPlay Digital Rights Management as were sold through the iTunes Store
+- [`m4a`](https://en.wikipedia.org/wiki/M4A) - Audio-only MPEG-4 files
+- [`m4b`](https://en.wikipedia.org/wiki/M4B) - Audiobook and podcast MPEG-4 files, which also contain metadata including chapter markers, images, and hyperlinks
+- [`f4v`](https://en.wikipedia.org/wiki/Flash_Video) - ISO base media file format used by Adobe Flash Player
+- [`f4p`](https://en.wikipedia.org/wiki/Flash_Video) - ISO base media file format protected by Adobe Access DRM used by Adobe Flash Player
+- [`f4a`](https://en.wikipedia.org/wiki/Flash_Video) - Audio-only ISO base media file format used by Adobe Flash Player
+- [`f4b`](https://en.wikipedia.org/wiki/Flash_Video) - Audiobook and podcast ISO base media file format used by Adobe Flash Player
 
 *SVG isn't included as it requires the whole file to be read, but you can get it [here](https://github.com/sindresorhus/is-svg).*
 
-*Pull request welcome for additional commonly used file types.*
+*Pull requests are welcome for additional commonly used file types.*
 
 
 ## Related

package/util.js

@@ -0,0 +1,58 @@
+'use strict';
+
+exports.stringToBytes = string => [...string].map(character => character.charCodeAt(0));
+
+const uint8ArrayUtf8ByteString = (array, start, end) => {
+	return String.fromCharCode(...array.slice(start, end));
+};
+
+exports.readUInt64LE = (buffer, offset = 0) => {
+	let n = buffer[offset];
+	let mul = 1;
+	let i = 0;
+
+	while (++i < 8) {
+		mul *= 0x100;
+		n += buffer[offset + i] * mul;
+	}
+
+	return n;
+};
+
+exports.tarHeaderChecksumMatches = buffer => { // Does not check if checksum field characters are valid
+	if (buffer.length < 512) { // `tar` header size, cannot compute checksum without it
+		return false;
+	}
+
+	const MASK_8TH_BIT = 0x80;
+
+	let sum = 256; // Intitalize sum, with 256 as sum of 8 spaces in checksum field
+	let signedBitSum = 0; // Initialize signed bit sum
+
+	for (let i = 0; i < 148; i++) {
+		const byte = buffer[i];
+		sum += byte;
+		signedBitSum += byte & MASK_8TH_BIT; // Add signed bit to signed bit sum
+	}
+
+	// Skip checksum field
+
+	for (let i = 156; i < 512; i++) {
+		const byte = buffer[i];
+		sum += byte;
+		signedBitSum += byte & MASK_8TH_BIT; // Add signed bit to signed bit sum
+	}
+
+	const readSum = parseInt(uint8ArrayUtf8ByteString(buffer, 148, 154), 8); // Read sum in header
+
+	// Some implementations compute checksum incorrectly using signed bytes
+	return (
+		// Checksum in header equals the sum we calculated
+		readSum === sum ||
+
+		// Checksum in header equals sum we calculated plus signed-to-unsigned delta
+		readSum === (sum - (signedBitSum << 1))
+	);
+};
+
+exports.uint8ArrayUtf8ByteString = uint8ArrayUtf8ByteString;