sigcheck 1.0.1

package/dist/core/interfaces/dto/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./detected-file-info"), exports);

package/dist/core/interfaces/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./dto";
+export * from "./options";

package/dist/core/interfaces/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./dto"), exports);
+__exportStar(require("./options"), exports);

package/dist/core/interfaces/options/detect-file-options.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Options used to pass to detect file function.
+ */
+export interface DetectFileOptions {
+    chunkSize?: number;
+}

package/dist/core/interfaces/options/detect-file-options.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/interfaces/options/file-validator-options.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Options used to pass to validators functions.
+ */
+export interface FileValidatorOptions {
+    excludeSimilarTypes?: boolean;
+}

package/dist/core/interfaces/options/file-validator-options.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/interfaces/options/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./detect-file-options";
+export * from "./validate-file-type-options";
+export * from "./file-validator-options";
+export * from "./zip-validator-options";

package/dist/core/interfaces/options/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./detect-file-options"), exports);
+__exportStar(require("./validate-file-type-options"), exports);
+__exportStar(require("./file-validator-options"), exports);
+__exportStar(require("./zip-validator-options"), exports);

package/dist/core/interfaces/options/validate-file-type-options.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Options used to pass to validate file type function.
+ */
+export interface ValidateFileTypeOptions {
+    chunkSize?: number;
+    excludeSimilarTypes?: boolean;
+}

package/dist/core/interfaces/options/validate-file-type-options.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/interfaces/options/zip-validator-options.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Options used to pass to izZip function.
+ */
+export interface ZipValidatorOptions {
+    chunkSize?: number;
+}

package/dist/core/interfaces/options/zip-validator-options.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/types/file-info.d.ts

@@ -0,0 +1,10 @@
+import { FileSignature } from "./file-signature";
+/**
+ * Information about a file
+ */
+export type FileInfo = {
+    extension: string;
+    mimeType: string;
+    description: string;
+    signatures: Array<FileSignature>;
+};

package/dist/core/types/file-info.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/types/file-signature.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Information about a unique file signature
+ */
+export type FileSignature = {
+    sequence: Array<number | string>;
+    offset?: number;
+    skippedBytes?: Array<number>;
+    description?: string;
+    compatibleExtensions?: Array<string>;
+};

package/dist/core/types/file-signature.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./file-info";
+export * from "./file-signature";

package/dist/core/types/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./file-info"), exports);
+__exportStar(require("./file-signature"), exports);

package/dist/detection/index.d.ts

@@ -0,0 +1,10 @@
+import { DetectedFileInfo, DetectFileOptions } from "../core";
+/**
+ * Detect a file by searching for a valid file signature inside the file content
+ *
+ * @param file File content represents in Array<number> / ArrayBuffer / Uint8Array
+ * @param options Optional parameters for additional actions
+ *
+ * @returns {DetectedFileInfo | undefined} DetectedFileInfo if detected a valid signature inside the file contentof, otherwise undefined
+ */
+export declare function detectFile(file: Array<number> | ArrayBuffer | Uint8Array, options?: DetectFileOptions): DetectedFileInfo | undefined;

package/dist/detection/index.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectFile = void 0;
+const core_1 = require("../core");
+const utils_1 = require("../utils");
+/**
+ * Detect a file by searching for a valid file signature inside the file content
+ *
+ * @param file File content represents in Array<number> / ArrayBuffer / Uint8Array
+ * @param options Optional parameters for additional actions
+ *
+ * @returns {DetectedFileInfo | undefined} DetectedFileInfo if detected a valid signature inside the file contentof, otherwise undefined
+ */
+function detectFile(file, options) {
+    var _a;
+    if (options &&
+        Object.prototype.hasOwnProperty.call(options, "chunkSize") &&
+        ((_a = options === null || options === void 0 ? void 0 : options.chunkSize) !== null && _a !== void 0 ? _a : 0) <= 0)
+        throw new RangeError("chunkSize must be bigger than zero");
+    const fileChunk = (0, utils_1.getFileChunk)(file, (options === null || options === void 0 ? void 0 : options.chunkSize) || 64); // Take chunk from the beginning of the file
+    if (fileChunk.length === 0)
+        return undefined;
+    const detectedFiles = [];
+    const filesRequiredAdditionalCheck = [];
+    for (const type in core_1.FileTypes) {
+        if (Object.prototype.hasOwnProperty.call(core_1.FileTypes, type)) {
+            const signatures = core_1.FileTypes.getSignaturesByName(type);
+            const matchedSignature = core_1.FileTypes.detectbBySignatures(fileChunk, signatures);
+            if (matchedSignature) {
+                const fileType = core_1.FileTypes.getInfoByName(type);
+                if (core_1.FILE_TYPES_REQUIRED_ADDITIONAL_CHECK.includes(fileType.extension)) {
+                    filesRequiredAdditionalCheck.push(fileType.extension);
+                }
+                const fileInfo = {
+                    extension: fileType.extension,
+                    mimeType: fileType.mimeType,
+                    description: fileType.description,
+                    signature: Object.assign(Object.assign({}, matchedSignature), { sequence: matchedSignature.sequence.map((num) => num.toString(16)) }),
+                };
+                detectedFiles.push(fileInfo);
+            }
+        }
+    }
+    if (detectedFiles.length === 0)
+        return undefined;
+    if (detectedFiles.length === 1 && filesRequiredAdditionalCheck.length === 0)
+        return detectedFiles[0];
+    // Some files share the same signature. Additional check required
+    const detectedType = core_1.FileTypes.detectTypeByAdditionalCheck(fileChunk, detectedFiles);
+    if (!detectedType)
+        return undefined;
+    return detectedFiles.find((df) => df.extension === detectedType);
+}
+exports.detectFile = detectFile;

package/dist/index.d.ts

@@ -0,0 +1,55 @@
+declare const fileTypeChecker: {
+    validateFileType(file: number[] | ArrayBuffer | Uint8Array, types: string[], options?: import("./core").ValidateFileTypeOptions | undefined): boolean;
+    isAAC(file: number[] | ArrayBuffer | Uint8Array, options?: import("./core").FileValidatorOptions | undefined): boolean;
+    isAMR(file: number[] | ArrayBuffer | Uint8Array): boolean;
+    isFLAC(file: number[] | ArrayBuffer | Uint8Array): boolean;
+    isM4A(file: number[] | ArrayBuffer | Uint8Array): boolean;
+    isMP3(file: number[] | ArrayBuffer | Uint8Array): boolean;
+    isWAV(file: number[] | ArrayBuffer | Uint8Array): boolean;
+    is7Z(file: number[] | ArrayBuffer | Uint8Array): boolean;
+    isLZH(file: number[] | ArrayBuffer | Uint8Array): boolean;
+    isRAR(file: number[] | ArrayBuffer | Uint8Array): boolean;
+    isZIP(file: number[] | ArrayBuffer | Uint8Array, options?: import("./core").ZipValidatorOptions | undefined): boolean;
+    isAVIF(file: number[] | ArrayBuffer | Uint8Array): boolean;
+    isBMP(file: number[] | ArrayBuffer | Uint8Array): boolean;
+    isBPG(file: number[] | ArrayBuffer | Uint8Array): boolean;
+    isCR2(file: number[] | ArrayBuffer | Uint8Array): boolean;
+    isEXR(file: number[] | ArrayBuffer | Uint8Array): boolean;
+    isGIF(file: number[] | ArrayBuffer | Uint8Array): boolean;
+    isHEIC(file: number[] | ArrayBuffer | Uint8Array): boolean;
+    isICO(file: number[] | ArrayBuffer | Uint8Array): boolean;
+    isJPEG(file: number[] | ArrayBuffer | Uint8Array): boolean;
+    isPBM(file: number[] | ArrayBuffer | Uint8Array): boolean;
+    isPGM(file: number[] | ArrayBuffer | Uint8Array): boolean;
+    isPNG(file: number[] | ArrayBuffer | Uint8Array): boolean;
+    isPPM(file: number[] | ArrayBuffer | Uint8Array): boolean;
+    isPSD(file: number[] | ArrayBuffer | Uint8Array): boolean;
+    isTIFF(file: number[] | ArrayBuffer | Uint8Array): boolean;
+    isWEBP(file: number[] | ArrayBuffer | Uint8Array): boolean;
+    isBLEND(file: number[] | ArrayBuffer | Uint8Array): boolean;
+    isELF(file: number[] | ArrayBuffer | Uint8Array): boolean;
+    isEXE(file: number[] | ArrayBuffer | Uint8Array): boolean;
+    isMACHO(file: number[] | ArrayBuffer | Uint8Array): boolean;
+    isINDD(file: number[] | ArrayBuffer | Uint8Array): boolean;
+    isORC(file: number[] | ArrayBuffer | Uint8Array): boolean;
+    isPARQUET(file: number[] | ArrayBuffer | Uint8Array): boolean;
+    isPDF(file: number[] | ArrayBuffer | Uint8Array): boolean;
+    isPS(file: number[] | ArrayBuffer | Uint8Array): boolean;
+    isRTF(file: number[] | ArrayBuffer | Uint8Array): boolean;
+    isSQLITE(file: number[] | ArrayBuffer | Uint8Array): boolean;
+    isSTL(file: number[] | ArrayBuffer | Uint8Array): boolean;
+    isTTF(file: number[] | ArrayBuffer | Uint8Array): boolean;
+    isDOC(file: number[] | ArrayBuffer | Uint8Array): boolean;
+    isPCAP(file: number[] | ArrayBuffer | Uint8Array): boolean;
+    isAVI(file: number[] | ArrayBuffer | Uint8Array): boolean;
+    isFLV(file: number[] | ArrayBuffer | Uint8Array): boolean;
+    isM4V(file: number[] | ArrayBuffer | Uint8Array): boolean;
+    isMKV(file: number[] | ArrayBuffer | Uint8Array): boolean;
+    isMOV(file: number[] | ArrayBuffer | Uint8Array): boolean;
+    isMP4(file: number[] | ArrayBuffer | Uint8Array, options?: import("./core").FileValidatorOptions | undefined): boolean;
+    isOGG(file: number[] | ArrayBuffer | Uint8Array): boolean;
+    isSWF(file: number[] | ArrayBuffer | Uint8Array): boolean;
+    isWEBM(file: number[] | ArrayBuffer | Uint8Array): boolean;
+    detectFile(file: number[] | ArrayBuffer | Uint8Array, options?: import("./core").DetectFileOptions | undefined): import("./core").DetectedFileInfo | undefined;
+};
+export = fileTypeChecker;

package/dist/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+const detectionFunctions = __importStar(require("./detection"));
+const validationFunctions = __importStar(require("./validation"));
+const fileTypeChecker = Object.assign(Object.assign({}, detectionFunctions), validationFunctions);
+module.exports = fileTypeChecker;

package/dist/utils/index.d.ts

@@ -0,0 +1,67 @@
+import { FileInfo } from "../core";
+/**
+ * Takes a file content in different types, convert it into array of numbers and returns a chunk of the required size
+ *
+ * @param file - File content represents in Array<number> / ArrayBuffer / Uint8Array
+ * @param fileChunkLength - Required file chunk length
+ *
+ * @returns {Array<number>} File chunk of the required size represents in Array<number>
+ */
+export declare function getFileChunk(file: Array<number> | ArrayBuffer | Uint8Array, fileChunkLength?: number): Array<number>;
+/**
+ * Fetch a property of a object by its name
+ *
+ * @param obj The required object
+ * @param prop The property name
+ *
+ * @returns {FileInfo} A property of the rquired object
+ */
+export declare function fetchFromObject(obj: any, prop: string): FileInfo;
+/**
+ * Identify whether a valid 'mkv'/'web' file is 'mkv' or 'webm'.
+ * By checking for the presence of the "DocType" element in the 'webm' header.
+ * Or by checking the presence of the "Segment" element in the 'mkv' header.
+ *
+ * @param fileChunk - A chunk from the beginning of a file content, represents in array of numbers
+ *
+ * @returns {string | undefined} 'webm' if found webm string A property of the rquired object
+ */
+export declare function findMatroskaDocTypeElements(fileChunk: Array<number>): string | undefined;
+/**
+ * Determine if array of numbers contains the "fytp" string.
+ * M4V files typically have a "ftyp" box in the first few bytes, which can be checked by searching for the string "ftyp" in the buffer.
+ *
+ * @param fileChunk A chunk from the beginning of a file content, represents in array of numbers
+ *
+ * @returns {boolean} True if found the "ftyp" string in the fileChunk, otherwise false
+ */
+export declare function isftypStringIncluded(fileChunk: Array<number>): boolean;
+/**
+ * Determine if array of numbers contains the "FLV" string.
+ * FLV files typically have a "FLV" string in the first few bytes of the file, which can be checked using TextDecoder or similar.
+ *
+ * @param fileChunk A chunk from the beginning of a file content, represents in array of numbers
+ *
+ * @returns {boolean} True if found the "FLV" string in the fileChunk, otherwise false
+ */
+export declare function isFlvStringIncluded(fileChunk: Array<number>): boolean;
+export declare function isFileContaineJfiforExifHeader(file: number[]): boolean;
+/**
+ * Determine if array of numbers contains the "ftypavif" string.
+ * AVIF files typically have a "ftypavif" string at bytes 5-12 of the file, which can be checked using TextDecoder or similar.
+ *
+ * @param fileChunk A chunk from the beginning of a file content, represents in array of numbers
+ *
+ * @returns {boolean} True if found the "AVIF" string in the fileChunk, otherwise false
+ */
+export declare function isAvifStringIncluded(fileChunk: Array<number>): boolean;
+/**
+ * Determine if a file chunk contains a HEIC file box.
+ * HEIC files typically have an 'ftyp' box with specific major brand signatures
+ * such as 'heic', 'hevc', 'mif1', and 'msf1' which can be checked by searching
+ * for these strings in the file chunk.
+ *
+ * @param fileChunk A chunk from the beginning of a file content, represented as an array of numbers.
+ * @returns {boolean} True if found a HEIC signature in the fileChunk, otherwise false.
+ */
+export declare function isHeicSignatureIncluded(fileChunk: Array<number>): boolean;

package/dist/utils/index.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isHeicSignatureIncluded = exports.isAvifStringIncluded = exports.isFileContaineJfiforExifHeader = exports.isFlvStringIncluded = exports.isftypStringIncluded = exports.findMatroskaDocTypeElements = exports.fetchFromObject = exports.getFileChunk = void 0;
+/**
+ * Takes a file content in different types, convert it into array of numbers and returns a chunk of the required size
+ *
+ * @param file - File content represents in Array<number> / ArrayBuffer / Uint8Array
+ * @param fileChunkLength - Required file chunk length
+ *
+ * @returns {Array<number>} File chunk of the required size represents in Array<number>
+ */
+function getFileChunk(file, fileChunkLength = 32 // default length - 32 bytes
+) {
+    const fileToCheck = file instanceof ArrayBuffer ? new Uint8Array(file) : file;
+    let chunk = [];
+    if ((Array.isArray(file) && isArrayofNumbers(file)) ||
+        file instanceof ArrayBuffer ||
+        file instanceof Uint8Array) {
+        chunk = Array.from(fileToCheck.slice(0, fileChunkLength));
+    }
+    else {
+        throw new TypeError(`Expected the \`file\` argument to be of type \`Array<number>\`, \`Uint8Array\`, or \`ArrayBuffer\`, got \`${typeof file}\``);
+    }
+    if (!isLegalChunk(chunk))
+        throw new TypeError(`File content contains illegal values`);
+    return chunk;
+}
+exports.getFileChunk = getFileChunk;
+/**
+ * Determine if array of numbers is a legal file chunk
+ *
+ * @param fileChunk File content represents in Array<number>
+ *
+ * @returns {boolean} True if the file content is verified, otherwise false
+ */
+function isLegalChunk(fileChunk) {
+    return fileChunk.every((num) => typeof num === "number" && !isNaN(num));
+}
+/**
+ * Fetch a property of a object by its name
+ *
+ * @param obj The required object
+ * @param prop The property name
+ *
+ * @returns {FileInfo} A property of the rquired object
+ */
+// eslint-disable-next-line
+function fetchFromObject(obj, prop) {
+    const _index = prop.indexOf(".");
+    if (_index > -1) {
+        return fetchFromObject(obj[prop.slice(0, _index)], prop.slice(_index + 1));
+    }
+    return obj[prop];
+}
+exports.fetchFromObject = fetchFromObject;
+/**
+ * Identify whether a valid 'mkv'/'web' file is 'mkv' or 'webm'.
+ * By checking for the presence of the "DocType" element in the 'webm' header.
+ * Or by checking the presence of the "Segment" element in the 'mkv' header.
+ *
+ * @param fileChunk - A chunk from the beginning of a file content, represents in array of numbers
+ *
+ * @returns {string | undefined} 'webm' if found webm string A property of the rquired object
+ */
+function findMatroskaDocTypeElements(fileChunk) {
+    const webmString = "webm";
+    const mkvString = "matroska";
+    const byteString = fileChunk.map((num) => String.fromCharCode(num)).join("");
+    if (byteString.includes(webmString)) {
+        return "webm";
+    }
+    if (byteString.includes(mkvString)) {
+        return "mkv";
+    }
+    return undefined; // File type not identified
+}
+exports.findMatroskaDocTypeElements = findMatroskaDocTypeElements;
+/**
+ * Determine if array of numbers contains the "fytp" string.
+ * M4V files typically have a "ftyp" box in the first few bytes, which can be checked by searching for the string "ftyp" in the buffer.
+ *
+ * @param fileChunk A chunk from the beginning of a file content, represents in array of numbers
+ *
+ * @returns {boolean} True if found the "ftyp" string in the fileChunk, otherwise false
+ */
+function isftypStringIncluded(fileChunk) {
+    const ftypSignature = [0x66, 0x74, 0x79, 0x70]; // "ftyp" signature
+    // Check the first few bytes for the "ftyp" signature
+    for (let i = 0; i < fileChunk.length - ftypSignature.length; i++) {
+        let found = true;
+        for (let j = 0; j < ftypSignature.length; j++) {
+            if (fileChunk[i + j] !== ftypSignature[j]) {
+                found = false;
+                break;
+            }
+        }
+        if (found) {
+            return true;
+        }
+    }
+    return false;
+}
+exports.isftypStringIncluded = isftypStringIncluded;
+/**
+ * Determine if array of numbers contains the "FLV" string.
+ * FLV files typically have a "FLV" string in the first few bytes of the file, which can be checked using TextDecoder or similar.
+ *
+ * @param fileChunk A chunk from the beginning of a file content, represents in array of numbers
+ *
+ * @returns {boolean} True if found the "FLV" string in the fileChunk, otherwise false
+ */
+function isFlvStringIncluded(fileChunk) {
+    const signature = fileChunk.slice(0, 3);
+    const signatureString = new TextDecoder().decode(new Uint8Array(signature));
+    return signatureString.includes("FLV");
+}
+exports.isFlvStringIncluded = isFlvStringIncluded;
+function isFileContaineJfiforExifHeader(file) {
+    // Check if the fourth byte is one of the known JFIF or EXIF header markers
+    const headerMarker = file[3];
+    if (headerMarker === 0xe0 || // JFIF
+        headerMarker === 0xe1 // EXIF
+    ) {
+        return true; // It's a JPEG file
+    }
+    return false;
+}
+exports.isFileContaineJfiforExifHeader = isFileContaineJfiforExifHeader;
+/**
+ * Determine if array of numbers contains the "ftypavif" string.
+ * AVIF files typically have a "ftypavif" string at bytes 5-12 of the file, which can be checked using TextDecoder or similar.
+ *
+ * @param fileChunk A chunk from the beginning of a file content, represents in array of numbers
+ *
+ * @returns {boolean} True if found the "AVIF" string in the fileChunk, otherwise false
+ */
+function isAvifStringIncluded(fileChunk) {
+    // Convert the relevant slice of the file chunk from hexadecimal to characters
+    const signature = fileChunk
+        .slice(4, 12)
+        .map((hex) => String.fromCharCode(hex))
+        .join("");
+    return signature === "ftypavif";
+}
+exports.isAvifStringIncluded = isAvifStringIncluded;
+// eslint-disable-next-line
+function isArrayofNumbers(arr) {
+    return arr.every((element) => typeof element === "number");
+}
+/**
+ * Determine if a file chunk contains a HEIC file box.
+ * HEIC files typically have an 'ftyp' box with specific major brand signatures
+ * such as 'heic', 'hevc', 'mif1', and 'msf1' which can be checked by searching
+ * for these strings in the file chunk.
+ *
+ * @param fileChunk A chunk from the beginning of a file content, represented as an array of numbers.
+ * @returns {boolean} True if found a HEIC signature in the fileChunk, otherwise false.
+ */
+function isHeicSignatureIncluded(fileChunk) {
+    // Convert the first part of the file chunk to a string to check for signatures
+    const byteString = fileChunk.map((num) => String.fromCharCode(num)).join("");
+    // List of possible HEIC 'ftyp' signatures
+    const heicSignatures = ["ftypheic", "ftyphevc", "ftypmif1", "ftypmsf1"];
+    // Check if any of the HEIC signatures are included in the byte string
+    return heicSignatures.some((signature) => byteString.includes(signature));
+}
+exports.isHeicSignatureIncluded = isHeicSignatureIncluded;

package/dist/validation/audio.d.ts

@@ -0,0 +1,50 @@
+import { FileValidatorOptions } from "../core";
+/**
+ * Determine if file content contains a valid 'aac' file signature
+ *
+ * @param file File content represents in Array<number> / ArrayBuffer / Uint8Array
+ * @param options parameters for additional actions
+ *
+ * @returns {boolean} True if found a signature of type 'aac' in file content, otherwise false
+ */
+export declare function isAAC(file: Array<number> | ArrayBuffer | Uint8Array, options?: FileValidatorOptions): boolean;
+/**
+ * Determine if file content contains a valid 'amr' file signature
+ *
+ * @param file File content represents in Array<number> / ArrayBuffer / Uint8Array
+ *
+ * @returns {boolean} True if found a signature of type 'amr' in file content, otherwise false
+ */
+export declare function isAMR(file: Array<number> | ArrayBuffer | Uint8Array): boolean;
+/**
+ * Determine if file content contains a valid 'flac' file signature
+ *
+ * @param file File content represents in Array<number> / ArrayBuffer / Uint8Array
+ *
+ * @returns {boolean} True if found a signature of type 'flac' in file content, otherwise false
+ */
+export declare function isFLAC(file: Array<number> | ArrayBuffer | Uint8Array): boolean;
+/**
+ * Determine if file content contains a valid 'm4a' file signature
+ *
+ * @param file File content represents in Array<number> / ArrayBuffer / Uint8Array
+ *
+ * @returns {boolean} True if found a signature of type 'm4a' in file content, otherwise false
+ */
+export declare function isM4A(file: Array<number> | ArrayBuffer | Uint8Array): boolean;
+/**
+ * Determine if file content contains a valid 'mp3' file signature
+ *
+ * @param file File content represents in Array<number> / ArrayBuffer / Uint8Array
+ *
+ * @returns {boolean} True if found a signature of type 'mp3' in file content, otherwise false
+ */
+export declare function isMP3(file: Array<number> | ArrayBuffer | Uint8Array): boolean;
+/**
+ * Determine if file content contains a valid 'wav' file signature
+ *
+ * @param file File content represents in Array<number> / ArrayBuffer / Uint8Array
+ *
+ * @returns {boolean} True if found a signature of type 'wav' in file content, otherwise false
+ */
+export declare function isWAV(file: Array<number> | ArrayBuffer | Uint8Array): boolean;