sigcheck 1.0.1

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

@@ -0,0 +1,215 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileTypes = exports.FILE_TYPES_REQUIRED_ADDITIONAL_CHECK = void 0;
+const utils_1 = require("../../utils");
+const audio_1 = require("./audio");
+const compressed_1 = require("./compressed");
+const other_1 = require("./other");
+const image_1 = require("./image");
+const video_1 = require("./video");
+const validation_1 = require("../../validation");
+exports.FILE_TYPES_REQUIRED_ADDITIONAL_CHECK = [
+    "m4v",
+    "flv",
+    "mp4",
+    "mkv",
+    "webm",
+    "avif",
+    "heic",
+];
+/**
+ * A class hold all supported file typs with their unique signatures
+ */
+class FileTypes {
+    /**
+     * Receive information on a file type by its property name from FileTypes class
+     *
+     * @param propertyName Property name from FileTypes class
+     *
+     * @returns {FileInfo} File type information
+     */
+    static getInfoByName(propertyName) {
+        const file = (0, utils_1.fetchFromObject)(FileTypes, propertyName.toUpperCase());
+        return file;
+    }
+    /**
+     * Receive an array of file type signatures by its property name from FileTypes class
+     *
+     * @param propertyName Property name from FileTypes class
+     *
+     * @returns {Array<FileSignature>} All unique signatures with their information
+     */
+    static getSignaturesByName(propertyName) {
+        const { signatures } = (0, utils_1.fetchFromObject)(FileTypes, propertyName.toUpperCase());
+        return signatures;
+    }
+    /**
+     * Determine if a valid signature exist in a file chunk
+     *
+     * @param fileChunk A chunk from the beginning of a file content, represents in array of numbers
+     * @param acceptedSignatures Valid signatures to search for in fileChunk
+     *
+     * @returns {boolean} True if found a valid signature inside the chunk, otherwise false
+     */
+    static detectSignature(fileChunk, acceptedSignatures) {
+        for (const signature of acceptedSignatures) {
+            let found = true;
+            const offset = signature.offset || 0;
+            let skippedBytes = 0;
+            for (let i = 0; i < signature.sequence.length; i++) {
+                if (signature.skippedBytes && signature.skippedBytes.includes(i)) {
+                    skippedBytes++;
+                    continue;
+                }
+                if (fileChunk[offset + i] !== signature.sequence[i - skippedBytes]) {
+                    found = false;
+                    break;
+                }
+            }
+            if (found) {
+                return signature;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Perfomrs an additional check for detected file types by their unique structure
+     *
+     * @param fileChunk A chunk from the beginning of a file content, represents in array of numbers
+     * @param detectedFiles A list of detected files
+     * @returns {string | undefined} File type extension if found, otherwise undefined
+     */
+    static detectTypeByAdditionalCheck(fileChunk, detectedFiles) {
+        const detectedExtensions = detectedFiles.map((df) => df.extension);
+        if (detectedExtensions.some((de) => ["m4v", "flv", "mp4", "heic"].includes(de))) {
+            if (detectedExtensions.includes("heic") && (0, validation_1.isHEIC)(fileChunk))
+                return "heic";
+            const isFlv = (0, validation_1.isFLV)(fileChunk);
+            if (isFlv)
+                return "flv";
+            const isM4v = (0, validation_1.isM4V)(fileChunk) && !(0, validation_1.isHEIC)(fileChunk);
+            if (isM4v)
+                return "m4v";
+            return "mp4";
+        }
+        else if (detectedExtensions.some((de) => ["mkv", "webm"].includes(de))) {
+            const matroskaDocTypeElement = (0, utils_1.findMatroskaDocTypeElements)(fileChunk);
+            if (matroskaDocTypeElement === "mkv" && (0, validation_1.isMKV)(fileChunk))
+                return "mkv";
+            else if (matroskaDocTypeElement === "webm" && (0, validation_1.isWEBM)(fileChunk))
+                return "webm";
+            return undefined;
+        }
+        else if (detectedExtensions.some((de) => ["avif"].includes(de))) {
+            const isAvif = (0, utils_1.isAvifStringIncluded)(fileChunk);
+            if (isAvif)
+                return "avif";
+        }
+        return undefined;
+    }
+    /**
+     * Determine if a file chunk contains a valid signature and return the file signature if exist
+     *
+     * @param fileChunk A chunk from the beginning of a file content, represents in array of numbers
+     * @param acceptedSignatures Valid signatures to search for in fileChunk
+     *
+     * @returns {FileSignature | undefined } FileSignature if found a valid signature, otherwise undefined
+     */
+    static detectbBySignatures(fileChunk, acceptedSignatures) {
+        for (const signature of acceptedSignatures) {
+            let skippedBytes = 0;
+            let found = true;
+            const offset = signature.offset || 0;
+            const signatureLength = (signature === null || signature === void 0 ? void 0 : signature.skippedBytes)
+                ? signature.sequence.length + signature.skippedBytes.length
+                : signature.sequence.length;
+            for (let i = 0; i < signatureLength; i++) {
+                if (signature.skippedBytes && signature.skippedBytes.includes(i)) {
+                    skippedBytes++;
+                    continue;
+                }
+                if (fileChunk[offset + i] !== signature.sequence[i - skippedBytes]) {
+                    found = false;
+                    break;
+                }
+            }
+            if (found) {
+                return signature;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Determine if file content contains a valid signature of a required type
+     *
+     * @param fileChunk A chunk from the beginning of a file content, represents in array of numbers
+     * @param type The file type to match against
+     *
+     * @returns {boolean} True if found a signature of the type in file content, otherwise false
+     */
+    static checkByFileType(fileChunk, type) {
+        if (Object.prototype.hasOwnProperty.call(FileTypes, type.toUpperCase())) {
+            const acceptedSignatures = FileTypes.getSignaturesByName(type.toUpperCase());
+            const detectedSignature = FileTypes.detectSignature(fileChunk, acceptedSignatures);
+            if (detectedSignature)
+                return true;
+        }
+        return false;
+    }
+}
+exports.FileTypes = FileTypes;
+// audio
+FileTypes.AAC = audio_1.AudioTypes.AAC;
+FileTypes.AMR = audio_1.AudioTypes.AMR;
+FileTypes.FLAC = audio_1.AudioTypes.FLAC;
+FileTypes.M4A = audio_1.AudioTypes.M4A;
+FileTypes.MP3 = audio_1.AudioTypes.MP3;
+FileTypes.WAV = audio_1.AudioTypes.WAV;
+// image
+FileTypes.AVIF = image_1.ImageTypes.AVIF;
+FileTypes.BMP = image_1.ImageTypes.BMP;
+FileTypes.BPG = image_1.ImageTypes.BPG;
+FileTypes.CR2 = image_1.ImageTypes.CR2;
+FileTypes.EXR = image_1.ImageTypes.EXR;
+FileTypes.GIF = image_1.ImageTypes.GIF;
+FileTypes.HEIC = image_1.ImageTypes.HEIC;
+FileTypes.ICO = image_1.ImageTypes.ICO;
+FileTypes.JPEG = image_1.ImageTypes.JPEG;
+FileTypes.PBM = image_1.ImageTypes.PBM;
+FileTypes.PGM = image_1.ImageTypes.PGM;
+FileTypes.PNG = image_1.ImageTypes.PNG;
+FileTypes.PPM = image_1.ImageTypes.PPM;
+FileTypes.PSD = image_1.ImageTypes.PSD;
+FileTypes.TIFF = image_1.ImageTypes.TIFF;
+FileTypes.WEBP = image_1.ImageTypes.WEBP;
+// video
+FileTypes.AVI = video_1.VideoTypes.AVI;
+FileTypes.FLV = video_1.VideoTypes.FLV;
+FileTypes.M4V = video_1.VideoTypes.M4V;
+FileTypes.MKV = video_1.VideoTypes.MKV;
+FileTypes.MOV = video_1.VideoTypes.MOV;
+FileTypes.MP4 = video_1.VideoTypes.MP4;
+FileTypes.OGG = video_1.VideoTypes.OGG;
+FileTypes.SWF = video_1.VideoTypes.SWF;
+FileTypes.WEBM = video_1.VideoTypes.WEBM;
+// compressed
+FileTypes._7Z = compressed_1.CompressedTypes._7Z;
+FileTypes.LZH = compressed_1.CompressedTypes.LZH;
+FileTypes.RAR = compressed_1.CompressedTypes.RAR;
+FileTypes.ZIP = compressed_1.CompressedTypes.ZIP;
+// other
+FileTypes.BLEND = other_1.OtherTypes.BLEND;
+FileTypes.DOC = other_1.OtherTypes.DOC;
+FileTypes.ELF = other_1.OtherTypes.ELF;
+FileTypes.EXE = other_1.OtherTypes.EXE;
+FileTypes.INDD = other_1.OtherTypes.INDD;
+FileTypes.MACHO = other_1.OtherTypes.MACHO;
+FileTypes.ORC = other_1.OtherTypes.ORC;
+FileTypes.PARQUET = other_1.OtherTypes.PARQUET;
+FileTypes.PCAP = other_1.OtherTypes.PCAP;
+FileTypes.PDF = other_1.OtherTypes.PDF;
+FileTypes.PS = other_1.OtherTypes.PS;
+FileTypes.RTF = other_1.OtherTypes.RTF;
+FileTypes.SQLITE = other_1.OtherTypes.SQLITE;
+FileTypes.STL = other_1.OtherTypes.STL;
+FileTypes.TTF = other_1.OtherTypes.TTF;

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

@@ -0,0 +1,21 @@
+import { FileInfo } from "../types/file-info";
+/**
+ * Other files information with their unique signatures
+ */
+export declare class OtherTypes {
+    static BLEND: FileInfo;
+    static DOC: FileInfo;
+    static ELF: FileInfo;
+    static EXE: FileInfo;
+    static INDD: FileInfo;
+    static MACHO: FileInfo;
+    static PDF: FileInfo;
+    static ORC: FileInfo;
+    static PARQUET: FileInfo;
+    static PS: FileInfo;
+    static RTF: FileInfo;
+    static SQLITE: FileInfo;
+    static STL: FileInfo;
+    static TTF: FileInfo;
+    static PCAP: FileInfo;
+}

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

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OtherTypes = void 0;
+/**
+ * Other files information with their unique signatures
+ */
+class OtherTypes {
+}
+exports.OtherTypes = OtherTypes;
+OtherTypes.BLEND = {
+    extension: "blend",
+    mimeType: "application/x-blender",
+    description: "Blender File Format",
+    signatures: [
+        {
+            sequence: [0x42, 0x4c, 0x45, 0x4e, 0x44, 0x45, 0x52],
+        },
+    ],
+};
+OtherTypes.DOC = {
+    extension: "doc",
+    mimeType: "application/msword",
+    description: "Old Microsoft Word documents",
+    signatures: [
+        {
+            sequence: [0xd0, 0xcf, 0x11, 0xe0, 0xa1, 0xb1, 0x1a, 0xe1],
+            compatibleExtensions: [
+                "xls",
+                "ppt",
+                "msi",
+                "msg",
+                "dot",
+                "pps",
+                "xla",
+                "wiz",
+            ],
+            description: "An Object Linking and Embedding (OLE) Compound File (CF) (i.e., OLECF) file format, known as Compound Binary File format by Microsoft, used by Microsoft Office 97-2003 applications",
+        },
+        {
+            sequence: [0xdb, 0xa5, 0x2d, 0x00],
+            description: "Microsoft Word 2.0 file format",
+        },
+    ],
+};
+OtherTypes.ELF = {
+    extension: "elf",
+    mimeType: "application/x-executable",
+    description: "Executable and Linking Format executable file (Linux/Unix)",
+    signatures: [
+        {
+            sequence: [0x7f, 0x45, 0x4c, 0x46],
+        },
+    ],
+};
+OtherTypes.EXE = {
+    extension: "exe",
+    mimeType: "application/x-msdownload",
+    description: "Windows/DOS executable file and its descendants",
+    signatures: [
+        {
+            sequence: [0x4d, 0x5a],
+            compatibleExtensions: [
+                "acm",
+                "ax",
+                "cpl",
+                "com",
+                "dll",
+                "drv",
+                "efi",
+                "fon",
+                "iec",
+                "ime",
+                "mui",
+                "ocx",
+                "olb",
+                "pif",
+                "qts",
+                "qtx",
+                "rs",
+                "sys",
+                "scr",
+                "tsp",
+                "vbx",
+                "vxd",
+            ],
+        },
+        {
+            sequence: [0x5a, 0x4d],
+            description: "DOS ZM executable (rare)",
+        },
+    ],
+};
+OtherTypes.INDD = {
+    extension: "indd",
+    mimeType: "application/x-indesign",
+    description: "Adobe InDesign document",
+    signatures: [
+        {
+            sequence: [
+                0x06, 0x06, 0xed, 0xf5, 0xd8, 0x1d, 0x46, 0xe5, 0xbd, 0x31, 0xef,
+                0xe7, 0xfe, 0x74, 0xb7, 0x1d,
+            ],
+            compatibleExtensions: ["indt"],
+        },
+    ],
+};
+OtherTypes.MACHO = {
+    extension: "macho",
+    mimeType: "application/x-mach-binary",
+    description: "Apple OS X ABI Mach-O binary file",
+    signatures: [
+        {
+            sequence: [0xfe, 0xed, 0xfa, 0xce],
+            description: "32-bit",
+        },
+        {
+            sequence: [0xce, 0xfa, 0xed, 0xfe],
+            description: "32-bit, where target system has reverse byte ordering from host running compiler",
+        },
+        {
+            sequence: [0xfe, 0xed, 0xfa, 0xcf],
+            description: "64-bit",
+        },
+        {
+            sequence: [0xcf, 0xfa, 0xed, 0xfe],
+            description: "64-bit, where target system has reverse byte ordering from host running compiler",
+        },
+        {
+            sequence: [0xca, 0xfe, 0xba, 0xbe],
+            description: "Mach-O Fat Binary",
+        },
+    ],
+};
+OtherTypes.PDF = {
+    extension: "pdf",
+    mimeType: "application/pdf",
+    description: "Portable Document Format",
+    signatures: [
+        {
+            sequence: [0x25, 0x50, 0x44, 0x46, 0x2d],
+        },
+    ],
+};
+OtherTypes.ORC = {
+    extension: "orc",
+    mimeType: "application/x-orc",
+    description: "Apache ORC (Optimized Row Columnar) file format for columnar storage",
+    signatures: [
+        {
+            sequence: [0x4f, 0x52, 0x43],
+        },
+    ],
+};
+OtherTypes.PARQUET = {
+    extension: "parquet",
+    mimeType: "application/vnd.apache.parquet",
+    description: "Apache Parquet file format for columnar storage",
+    signatures: [
+        {
+            sequence: [0x50, 0x41, 0x52, 0x31],
+        },
+    ],
+};
+OtherTypes.PS = {
+    extension: "ps",
+    mimeType: "application/postscript",
+    description: "PostScript document",
+    signatures: [
+        {
+            sequence: [0x25, 0x21, 0x50, 0x53],
+        },
+    ],
+};
+OtherTypes.RTF = {
+    extension: "rtf",
+    mimeType: "application/rtf",
+    description: "Rich Text Format word processing file",
+    signatures: [
+        {
+            sequence: [0x7b, 0x5c, 0x72, 0x74, 0x66, 0x31],
+        },
+    ],
+};
+OtherTypes.SQLITE = {
+    extension: "sqlite",
+    mimeType: "application/x-sqlite3",
+    description: "SQLite database file",
+    signatures: [
+        {
+            sequence: [
+                0x53, 0x51, 0x4c, 0x69, 0x74, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x6d,
+                0x61, 0x74, 0x20, 0x33, 0x00,
+            ],
+        },
+    ],
+};
+OtherTypes.STL = {
+    extension: "stl",
+    mimeType: "application/sla",
+    description: "ASCII STL (STereoLithography) file for 3D printing",
+    signatures: [
+        {
+            sequence: [0x73, 0x6f, 0x6c, 0x69, 0x64],
+        },
+    ],
+};
+OtherTypes.TTF = {
+    extension: "ttf",
+    mimeType: "application/x-font-ttf",
+    description: "TrueType font file",
+    signatures: [
+        {
+            sequence: [0x74, 0x72, 0x75, 0x65, 0x00],
+        },
+        {
+            sequence: [0x00, 0x01, 0x00, 0x00, 0x00],
+            compatibleExtensions: ["tte, dfont"],
+        },
+    ],
+};
+OtherTypes.PCAP = {
+    extension: "pcap",
+    mimeType: "application/vnd.tcpdump.pcap",
+    description: "Libpcap File Format",
+    signatures: [
+        {
+            sequence: [0xd4, 0xc3, 0xb2, 0xa1],
+        },
+        {
+            sequence: [0x4d, 0x3c, 0xb2, 0xa1],
+            description: "Nanosecond resolution",
+        },
+    ],
+};

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

@@ -0,0 +1,15 @@
+import { FileInfo } from "../types/file-info";
+/**
+ * Video files information with their unique signatures
+ */
+export declare class VideoTypes {
+    static AVI: FileInfo;
+    static FLV: FileInfo;
+    static M4V: FileInfo;
+    static MKV: FileInfo;
+    static MOV: FileInfo;
+    static MP4: FileInfo;
+    static OGG: FileInfo;
+    static SWF: FileInfo;
+    static WEBM: FileInfo;
+}

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

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VideoTypes = void 0;
+/**
+ * Video files information with their unique signatures
+ */
+class VideoTypes {
+}
+exports.VideoTypes = VideoTypes;
+VideoTypes.AVI = {
+    extension: "avi",
+    mimeType: "video/x-msvideo",
+    description: "Audio Video Interleave video format",
+    signatures: [
+        {
+            sequence: [
+                0x52, 0x49, 0x46, 0x46, 0x41, 0x56, 0x49, 0x20, 0x4c, 0x49, 0x53,
+                0x54,
+            ],
+            skippedBytes: [4, 5, 6, 7],
+        },
+    ],
+};
+VideoTypes.FLV = {
+    extension: "flv",
+    mimeType: "video/x-flv",
+    description: "Flash Video file",
+    signatures: [
+        {
+            sequence: [0x46, 0x4c, 0x56, 0x01],
+        },
+        {
+            sequence: [0x66, 0x74, 0x79, 0x70, 0x4d, 0x34, 0x56, 0x20],
+            description: "ISO Media, MPEG v4 system, or iTunes AVC-LC file",
+            offset: 4,
+            compatibleExtensions: ["mp4", "m4v"],
+        },
+    ],
+};
+VideoTypes.M4V = {
+    extension: "m4v",
+    mimeType: "video/x-m4v",
+    description: "Apple's video container format, very similar to MP4",
+    signatures: [
+        {
+            sequence: [0x66, 0x74, 0x79, 0x70, 0x6d, 0x70, 0x34, 0x32],
+            description: "MPEG-4 video | QuickTime file",
+            offset: 4,
+            compatibleExtensions: ["mp4"],
+        },
+        {
+            sequence: [0x66, 0x74, 0x79, 0x70, 0x4d, 0x34, 0x56, 0x20],
+            description: "ISO Media, MPEG v4 system, or iTunes AVC-LC file",
+            offset: 4,
+            compatibleExtensions: ["mp4", "flv"],
+        },
+    ],
+};
+VideoTypes.MKV = {
+    extension: "mkv",
+    mimeType: "video/x-matroska",
+    description: "MKV (Matroska Video) is a flexible, open-source media container format that supports multiple audio, video, and subtitle streams in a single file",
+    signatures: [
+        {
+            sequence: [0x1a, 0x45, 0xdf, 0xa3],
+            description: "EBML identifier",
+            compatibleExtensions: ["webm", "mka", "mks", "mk3d"],
+        },
+    ],
+};
+VideoTypes.MOV = {
+    extension: "mov",
+    mimeType: "video/quicktime",
+    description: "QuickTime movie file",
+    signatures: [
+        {
+            sequence: [0x66, 0x74, 0x79, 0x70, 0x71, 0x74, 0x20, 0x20],
+            offset: 4,
+        },
+        {
+            sequence: [0x6d, 0x6f, 0x6f, 0x76],
+            offset: 4,
+        },
+    ],
+};
+VideoTypes.MP4 = {
+    extension: "mp4",
+    mimeType: "video/mp4",
+    description: "A multimedia container format widely used for storing audio, video, and other data, and is known for its high compression efficiency and compatibility with many devices",
+    signatures: [
+        {
+            sequence: [0x66, 0x74, 0x79, 0x70, 0x4d, 0x53, 0x4e, 0x56],
+            description: "MPEG-4 video file",
+            offset: 4,
+        },
+        {
+            sequence: [0x66, 0x74, 0x79, 0x70, 0x69, 0x73, 0x6f, 0x6d],
+            description: "ISO Base Media file (MPEG-4) v1",
+            offset: 4,
+        },
+        {
+            sequence: [0x66, 0x74, 0x79, 0x70, 0x4d, 0x34, 0x56, 0x20],
+            description: "ISO Media, MPEG v4 system, or iTunes AVC-LC file",
+            offset: 4,
+            compatibleExtensions: ["m4v", "flv"],
+        },
+    ],
+};
+VideoTypes.OGG = {
+    extension: "ogg",
+    mimeType: "video/ogg",
+    description: "Ogg Vorbis Codec compressed Multimedia file",
+    signatures: [
+        {
+            sequence: [
+                0x4f, 0x67, 0x67, 0x53, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0x00, 0x00, 0x00,
+            ],
+            compatibleExtensions: ["oga", "ogv", "ogx"],
+        },
+    ],
+};
+VideoTypes.SWF = {
+    extension: "swf",
+    mimeType: "application/x-shockwave-flash",
+    description: "SWF (Shockwave Flash) is a file format for multimedia, vector graphics, and ActionScript, used for creating and delivering animations, games, and other interactive web-based content",
+    signatures: [
+        {
+            sequence: [0x43, 0x57, 0x53],
+            description: "Macromedia Shockwave Flash player file (zlib compressed, SWF 6 and later)",
+        },
+        {
+            sequence: [0x46, 0x57, 0x53],
+            description: "Macromedia Shockwave Flash player file (uncompressed)",
+        },
+        {
+            sequence: [0x5a, 0x57, 0x53],
+            description: "Macromedia Shockwave Flash player file (uncompressed)",
+        },
+    ],
+};
+VideoTypes.WEBM = {
+    extension: "webm",
+    mimeType: "video/webm",
+    description: "WebM is a royalty-free, open-source media file format optimized for web delivery, using efficient VP8 video and Vorbis audio codecs",
+    signatures: [
+        {
+            sequence: [0x1a, 0x45, 0xdf, 0xa3],
+            description: "EBML identifier",
+            compatibleExtensions: ["mkv"],
+        },
+    ],
+};

package/dist/core/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./file-types";
+export * from "./interfaces";
+export * from "./types";

package/dist/core/index.js

@@ -0,0 +1,19 @@
+"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-types"), exports);
+__exportStar(require("./interfaces"), exports);
+__exportStar(require("./types"), exports);

package/dist/core/interfaces/dto/detected-file-info.d.ts

@@ -0,0 +1,10 @@
+import { FileSignature } from "../../types";
+/**
+ * Information about a detected file based on its signature
+ */
+export interface DetectedFileInfo {
+    extension: string;
+    mimeType: string;
+    description: string;
+    signature: FileSignature;
+}

package/dist/core/interfaces/dto/detected-file-info.js

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

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

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