mime-bytes 0.0.2

package/index.d.ts

@@ -0,0 +1,6 @@
+export { FileTypeDetector, FileTypeDetectorOptions, defaultDetector, detectFromStream, detectFromBuffer, detectFromExtension } from './file-type-detector';
+export { FileTypeDefinition, DetectionResult, ContentTypeMapping, FILE_TYPES, CONTENT_TYPE_MAPPINGS, getFileTypeByMagicBytes, getFileTypeByExtension, getFileTypesByCategory, getContentTypeByExtension, detectCharset } from './file-types-registry';
+export { peek, BufferPeekStream, PeekStreamOptions, PeekCallback, PeekPromise } from './peak';
+export * from './utils/magic-bytes';
+export * from './utils/mime-types';
+export * from './utils/extensions';

package/index.js

@@ -0,0 +1,42 @@
+"use strict";
+// Main export file for mime-bytes package
+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 });
+exports.BufferPeekStream = exports.peek = exports.detectCharset = exports.getContentTypeByExtension = exports.getFileTypesByCategory = exports.getFileTypeByExtension = exports.getFileTypeByMagicBytes = exports.CONTENT_TYPE_MAPPINGS = exports.FILE_TYPES = exports.detectFromExtension = exports.detectFromBuffer = exports.detectFromStream = exports.defaultDetector = exports.FileTypeDetector = void 0;
+// Export the main detector class and convenience functions
+var file_type_detector_1 = require("./file-type-detector");
+Object.defineProperty(exports, "FileTypeDetector", { enumerable: true, get: function () { return file_type_detector_1.FileTypeDetector; } });
+Object.defineProperty(exports, "defaultDetector", { enumerable: true, get: function () { return file_type_detector_1.defaultDetector; } });
+Object.defineProperty(exports, "detectFromStream", { enumerable: true, get: function () { return file_type_detector_1.detectFromStream; } });
+Object.defineProperty(exports, "detectFromBuffer", { enumerable: true, get: function () { return file_type_detector_1.detectFromBuffer; } });
+Object.defineProperty(exports, "detectFromExtension", { enumerable: true, get: function () { return file_type_detector_1.detectFromExtension; } });
+// Export registry types and functions
+var file_types_registry_1 = require("./file-types-registry");
+Object.defineProperty(exports, "FILE_TYPES", { enumerable: true, get: function () { return file_types_registry_1.FILE_TYPES; } });
+Object.defineProperty(exports, "CONTENT_TYPE_MAPPINGS", { enumerable: true, get: function () { return file_types_registry_1.CONTENT_TYPE_MAPPINGS; } });
+Object.defineProperty(exports, "getFileTypeByMagicBytes", { enumerable: true, get: function () { return file_types_registry_1.getFileTypeByMagicBytes; } });
+Object.defineProperty(exports, "getFileTypeByExtension", { enumerable: true, get: function () { return file_types_registry_1.getFileTypeByExtension; } });
+Object.defineProperty(exports, "getFileTypesByCategory", { enumerable: true, get: function () { return file_types_registry_1.getFileTypesByCategory; } });
+Object.defineProperty(exports, "getContentTypeByExtension", { enumerable: true, get: function () { return file_types_registry_1.getContentTypeByExtension; } });
+Object.defineProperty(exports, "detectCharset", { enumerable: true, get: function () { return file_types_registry_1.detectCharset; } });
+// Export peek stream functionality
+var peak_1 = require("./peak");
+Object.defineProperty(exports, "peek", { enumerable: true, get: function () { return peak_1.peek; } });
+Object.defineProperty(exports, "BufferPeekStream", { enumerable: true, get: function () { return peak_1.BufferPeekStream; } });
+// Export utility functions
+__exportStar(require("./utils/magic-bytes"), exports);
+__exportStar(require("./utils/mime-types"), exports);
+__exportStar(require("./utils/extensions"), exports);

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "mime-bytes",
+  "version": "0.0.2",
+  "author": "Dan Lynch <pyramation@gmail.com>",
+  "description": "mime-bytes",
+  "main": "index.js",
+  "module": "esm/index.js",
+  "types": "index.d.ts",
+  "homepage": "https://github.com/launchql/launchql",
+  "license": "SEE LICENSE IN LICENSE",
+  "publishConfig": {
+    "access": "public",
+    "directory": "dist"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/launchql/launchql"
+  },
+  "bugs": {
+    "url": "https://github.com/launchql/launchql/issues"
+  },
+  "scripts": {
+    "copy": "copyfiles -f ../../LICENSE README.md package.json dist",
+    "clean": "rimraf dist/**",
+    "prepare": "npm run build",
+    "build": "npm run clean; tsc; tsc -p tsconfig.esm.json; npm run copy",
+    "build:dev": "npm run clean; tsc --declarationMap; tsc -p tsconfig.esm.json; npm run copy",
+    "lint": "eslint . --fix",
+    "test": "jest",
+    "test:watch": "jest --watch"
+  },
+  "keywords": [],
+  "devDependencies": {
+    "@types/glob": "^8.1.0",
+    "glob": "^11.0.2"
+  },
+  "gitHead": "52bbc49baf1ed0e4a1b1f349bf1817b3f71f72b0"
+}

package/peak.d.ts

@@ -0,0 +1,20 @@
+import { Transform, TransformOptions, Readable } from 'stream';
+export interface PeekStreamOptions extends TransformOptions {
+    peekBytes: number;
+}
+export declare class BufferPeekStream extends Transform {
+    private peekBytes;
+    private buffer;
+    private bufferLength;
+    private peeked;
+    constructor(options: PeekStreamOptions);
+    _transform(chunk: any, encoding: BufferEncoding, callback: Function): void;
+    _flush(callback: Function): void;
+}
+export declare function peek(source: Readable, bytes: number, callback?: (err: Error | null, buffer: Buffer, dest: BufferPeekStream) => void): BufferPeekStream;
+export declare function peek(source: Readable, callback: (err: Error | null, buffer: Buffer, dest: BufferPeekStream) => void): BufferPeekStream;
+export declare namespace peek {
+    var promise: (source: Readable, bytes?: number) => Promise<[Buffer, BufferPeekStream]>;
+}
+export type PeekCallback = (err: Error | null, buffer: Buffer, dest: BufferPeekStream) => void;
+export type PeekPromise = (source: Readable, bytes?: number) => Promise<[Buffer, BufferPeekStream]>;

package/peak.js

@@ -0,0 +1,95 @@
+"use strict";
+// TypeScript implementation of peek stream for efficient file type detection
+// Based on reference-packages/buffer-peak/peak.js
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BufferPeekStream = void 0;
+exports.peek = peek;
+const stream_1 = require("stream");
+class BufferPeekStream extends stream_1.Transform {
+    peekBytes;
+    buffer;
+    bufferLength;
+    peeked;
+    constructor(options) {
+        super(options);
+        this.peekBytes = options.peekBytes || 16;
+        this.buffer = Buffer.alloc(0);
+        this.bufferLength = 0;
+        this.peeked = false;
+    }
+    _transform(chunk, encoding, callback) {
+        if (this.peeked) {
+            // After peeking, just pass through
+            this.push(chunk);
+            callback();
+            return;
+        }
+        // Accumulate data until we have enough to peek
+        const chunkBuffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, encoding);
+        this.buffer = Buffer.concat([this.buffer, chunkBuffer]);
+        this.bufferLength += chunkBuffer.length;
+        if (this.bufferLength >= this.peekBytes) {
+            // We have enough data to peek
+            this.peeked = true;
+            // Emit the peek event with the requested bytes
+            const peekBuffer = this.buffer.slice(0, this.peekBytes);
+            this.emit('peek', peekBuffer);
+            // Push all accumulated data
+            this.push(this.buffer);
+            this.buffer = Buffer.alloc(0);
+            this.bufferLength = 0;
+            callback();
+        }
+        else {
+            // Need more data
+            callback();
+        }
+    }
+    _flush(callback) {
+        if (!this.peeked && this.bufferLength > 0) {
+            // Not enough data was received, emit what we have
+            this.peeked = true;
+            this.emit('peek', this.buffer);
+            this.push(this.buffer);
+        }
+        callback();
+    }
+}
+exports.BufferPeekStream = BufferPeekStream;
+function peek(source, bytesOrCallback, callback) {
+    let bytes;
+    let cb;
+    if (typeof bytesOrCallback === 'function') {
+        bytes = 16; // Default peek bytes
+        cb = bytesOrCallback;
+    }
+    else {
+        bytes = bytesOrCallback;
+        cb = callback;
+    }
+    const dest = new BufferPeekStream({ peekBytes: bytes });
+    if (cb) {
+        dest.once('peek', (buffer) => {
+            cb(null, buffer, dest);
+        });
+        dest.once('error', (err) => {
+            cb(err, Buffer.alloc(0), dest);
+        });
+    }
+    return source.pipe(dest);
+}
+// Promise-based version
+peek.promise = function (source, bytes = 16) {
+    return new Promise((resolve, reject) => {
+        const dest = peek(source, bytes, (err, buffer, stream) => {
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve([buffer, stream]);
+            }
+        });
+        // Handle source errors
+        source.once('error', reject);
+    });
+};

package/utils/extensions.d.ts

@@ -0,0 +1,9 @@
+export declare function normalizeExtension(extension: string): string;
+export declare function getExtension(filename: string): string;
+export declare function isCompressedExtension(extension: string): boolean;
+export declare function isDocumentExtension(extension: string): boolean;
+export declare function isMediaExtension(extension: string): boolean;
+export declare function isImageExtension(extension: string): boolean;
+export declare function isExecutableExtension(extension: string): boolean;
+export declare function getCategoryFromExtension(extension: string): string;
+export declare function getDoubleExtension(filename: string): string | null;

package/utils/extensions.js

@@ -0,0 +1,125 @@
+"use strict";
+// Extension utility functions
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeExtension = normalizeExtension;
+exports.getExtension = getExtension;
+exports.isCompressedExtension = isCompressedExtension;
+exports.isDocumentExtension = isDocumentExtension;
+exports.isMediaExtension = isMediaExtension;
+exports.isImageExtension = isImageExtension;
+exports.isExecutableExtension = isExecutableExtension;
+exports.getCategoryFromExtension = getCategoryFromExtension;
+exports.getDoubleExtension = getDoubleExtension;
+// Normalize file extension
+function normalizeExtension(extension) {
+    return extension.toLowerCase().replace(/^\./, '');
+}
+// Extract extension from filename
+function getExtension(filename) {
+    const lastDot = filename.lastIndexOf('.');
+    if (lastDot === -1 || lastDot === filename.length - 1) {
+        return '';
+    }
+    return normalizeExtension(filename.substring(lastDot + 1));
+}
+// Check if extension is commonly associated with compressed files
+function isCompressedExtension(extension) {
+    const compressed = [
+        'zip', 'rar', '7z', 'tar', 'gz', 'bz2', 'xz', 'lz', 'lzma', 'z',
+        'tgz', 'tbz', 'tbz2', 'txz', 'tlz', 'arc', 'arj', 'cab', 'dmg',
+        'iso', 'lha', 'lzh', 'pkg', 'deb', 'rpm', 'msi', 'jar', 'war',
+        'ear', 'sar', 'aar', 'apk', 'ipa', 'xpi', 'egg', 'whl', 'gem'
+    ];
+    return compressed.includes(normalizeExtension(extension));
+}
+// Check if extension is commonly associated with document files
+function isDocumentExtension(extension) {
+    const documents = [
+        'pdf', 'doc', 'docx', 'odt', 'rtf', 'tex', 'wpd', 'txt', 'md',
+        'xls', 'xlsx', 'ods', 'csv', 'ppt', 'pptx', 'odp', 'epub', 'mobi',
+        'azw', 'azw3', 'fb2', 'lit', 'pdb', 'ps', 'eps', 'indd', 'xps'
+    ];
+    return documents.includes(normalizeExtension(extension));
+}
+// Check if extension is commonly associated with media files
+function isMediaExtension(extension) {
+    const media = [
+        // Video
+        'mp4', 'avi', 'mkv', 'mov', 'wmv', 'flv', 'webm', 'vob', 'ogv',
+        'ogg', 'm4v', '3gp', '3g2', 'mpg', 'mpeg', 'mp2', 'mpe', 'mpv',
+        'm2v', 'svi', 'mxf', 'roq', 'nsv', 'f4v', 'f4p', 'f4a', 'f4b',
+        // Audio
+        'mp3', 'wav', 'flac', 'aac', 'ogg', 'oga', 'wma', 'm4a', 'opus',
+        'ape', 'wv', 'amr', 'ac3', 'dts', 'spx', 'mid', 'midi', 'kar',
+        'aiff', 'aif', 'aifc', 'au', 'snd', 'voc', 'ra', 'rm', 'ram'
+    ];
+    return media.includes(normalizeExtension(extension));
+}
+// Check if extension is commonly associated with image files
+function isImageExtension(extension) {
+    const images = [
+        'jpg', 'jpeg', 'png', 'gif', 'bmp', 'svg', 'webp', 'ico', 'tif',
+        'tiff', 'psd', 'raw', 'heif', 'heic', 'indd', 'ai', 'eps', 'ps',
+        'xcf', 'cdr', 'cmx', 'dib', 'jxr', 'hdp', 'wdp', 'cur', 'icns',
+        'pbm', 'pgm', 'ppm', 'pnm', 'pcx', 'dcx', 'dds', 'dng', 'cr2',
+        'cr3', 'crw', 'nef', 'nrw', 'orf', 'raf', 'rw2', 'rwl', 'srw',
+        'arw', 'srf', 'sr2', 'bay', 'cap', 'iiq', 'eip', 'dcs', 'dcr',
+        'drf', 'k25', 'kdc', 'mdc', 'mef', 'mos', 'mrw', 'pef', 'ptx',
+        'pxn', 'r3d', 'x3f', 'qoi'
+    ];
+    return images.includes(normalizeExtension(extension));
+}
+// Check if extension is commonly associated with executable files
+function isExecutableExtension(extension) {
+    const executables = [
+        'exe', 'dll', 'so', 'dylib', 'app', 'deb', 'rpm', 'dmg', 'pkg',
+        'msi', 'bat', 'cmd', 'sh', 'ps1', 'vbs', 'js', 'jar', 'class',
+        'pyc', 'pyo', 'elf', 'o', 'out', 'bin', 'run', 'com', 'scr',
+        'cpl', 'ocx', 'sys', 'drv', 'efi', 'mui', 'ax', 'ime', 'rs',
+        'tsp', 'fon', 'wasm', 'ko', 'mod', 'prx', 'puff', 'axf', 'dex'
+    ];
+    return executables.includes(normalizeExtension(extension));
+}
+// Get category from extension
+function getCategoryFromExtension(extension) {
+    const ext = normalizeExtension(extension);
+    if (isImageExtension(ext))
+        return 'image';
+    if (isMediaExtension(ext))
+        return 'media';
+    if (isDocumentExtension(ext))
+        return 'document';
+    if (isCompressedExtension(ext))
+        return 'archive';
+    if (isExecutableExtension(ext))
+        return 'executable';
+    // Check for specific categories
+    const categories = {
+        font: ['ttf', 'otf', 'woff', 'woff2', 'eot', 'fon', 'fnt'],
+        database: ['db', 'db3', 'sqlite', 'sqlite3', 'mdb', 'accdb', 'dbf'],
+        code: ['js', 'ts', 'jsx', 'tsx', 'py', 'java', 'c', 'cpp', 'h', 'hpp', 'cs', 'php', 'rb', 'go', 'rs', 'swift', 'kt', 'scala', 'r', 'lua', 'pl', 'sh', 'bash', 'zsh', 'fish', 'ps1', 'psm1', 'psd1', 'bat', 'cmd'],
+        config: ['json', 'xml', 'yaml', 'yml', 'toml', 'ini', 'cfg', 'conf', 'properties', 'env'],
+        text: ['txt', 'md', 'markdown', 'rst', 'asciidoc', 'adoc', 'org', 'tex', 'log']
+    };
+    for (const [category, extensions] of Object.entries(categories)) {
+        if (extensions.includes(ext)) {
+            return category;
+        }
+    }
+    return 'other';
+}
+// Common double extensions (e.g., .tar.gz)
+const DOUBLE_EXTENSIONS = [
+    'tar.gz', 'tar.bz2', 'tar.xz', 'tar.lz', 'tar.lzma', 'tar.Z',
+    'tar.br', 'tar.zst', 'user.js', 'min.js', 'min.css', 'd.ts'
+];
+// Get double extension if applicable
+function getDoubleExtension(filename) {
+    const lower = filename.toLowerCase();
+    for (const doubleExt of DOUBLE_EXTENSIONS) {
+        if (lower.endsWith('.' + doubleExt)) {
+            return doubleExt;
+        }
+    }
+    return null;
+}

package/utils/magic-bytes.d.ts

@@ -0,0 +1,9 @@
+export declare function hexToBuffer(hexArray: string[]): Buffer;
+export declare function bufferToHex(buffer: Buffer): string;
+export declare function compareBytes(buffer: Buffer, pattern: string[], offset?: number): boolean;
+export declare function findMagicBytes(buffer: Buffer, patterns: Array<{
+    pattern: string[];
+    offset?: number;
+}>): number;
+export declare function extractBytes(buffer: Buffer, offset: number, length: number): Buffer;
+export declare function isTextLike(buffer: Buffer): boolean;

package/utils/magic-bytes.js

@@ -0,0 +1,69 @@
+"use strict";
+// Magic bytes utility functions
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hexToBuffer = hexToBuffer;
+exports.bufferToHex = bufferToHex;
+exports.compareBytes = compareBytes;
+exports.findMagicBytes = findMagicBytes;
+exports.extractBytes = extractBytes;
+exports.isTextLike = isTextLike;
+function hexToBuffer(hexArray) {
+    const bytes = hexArray.map(hex => {
+        if (hex === '?')
+            return 0; // Wildcard placeholder
+        return parseInt(hex.replace(/0x/i, ''), 16);
+    });
+    return Buffer.from(bytes);
+}
+function bufferToHex(buffer) {
+    return buffer.toString('hex');
+}
+function compareBytes(buffer, pattern, offset = 0) {
+    // Empty patterns should not match
+    if (!pattern || pattern.length === 0) {
+        return false;
+    }
+    if (offset + pattern.length > buffer.length) {
+        return false;
+    }
+    for (let i = 0; i < pattern.length; i++) {
+        if (pattern[i] === '?')
+            continue; // Skip wildcards
+        const expectedByte = parseInt(pattern[i].replace(/0x/i, ''), 16);
+        const actualByte = buffer[offset + i];
+        if (expectedByte !== actualByte) {
+            return false;
+        }
+    }
+    return true;
+}
+function findMagicBytes(buffer, patterns) {
+    for (let i = 0; i < patterns.length; i++) {
+        const { pattern, offset = 0 } = patterns[i];
+        if (compareBytes(buffer, pattern, offset)) {
+            return i;
+        }
+    }
+    return -1;
+}
+// Extract a specific number of bytes from buffer at offset
+function extractBytes(buffer, offset, length) {
+    if (offset + length > buffer.length) {
+        return buffer.slice(offset);
+    }
+    return buffer.slice(offset, offset + length);
+}
+// Check if buffer contains text-like content
+function isTextLike(buffer) {
+    const sampleSize = Math.min(buffer.length, 512);
+    let printableCount = 0;
+    for (let i = 0; i < sampleSize; i++) {
+        const byte = buffer[i];
+        // Check for printable ASCII characters, tabs, newlines, carriage returns
+        if ((byte >= 32 && byte <= 126) || byte === 9 || byte === 10 || byte === 13) {
+            printableCount++;
+        }
+    }
+    // If more than 85% are printable characters, likely text
+    return (printableCount / sampleSize) > 0.85;
+}

package/utils/mime-types.d.ts

@@ -0,0 +1,14 @@
+export declare const MIME_CATEGORIES: {
+    readonly IMAGE: "image";
+    readonly VIDEO: "video";
+    readonly AUDIO: "audio";
+    readonly APPLICATION: "application";
+    readonly TEXT: "text";
+    readonly FONT: "font";
+};
+export type MimeCategory = typeof MIME_CATEGORIES[keyof typeof MIME_CATEGORIES];
+export declare function getMimeCategory(mimeType: string): MimeCategory | null;
+export declare function isBinaryMimeType(mimeType: string): boolean;
+export declare function normalizeMimeType(mimeType: string): string;
+export declare function getFileCategoryFromMime(mimeType: string): string;
+export declare function resolveMimeAlias(mimeType: string): string;

package/utils/mime-types.js

@@ -0,0 +1,98 @@
+"use strict";
+// MIME type utility functions
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MIME_CATEGORIES = void 0;
+exports.getMimeCategory = getMimeCategory;
+exports.isBinaryMimeType = isBinaryMimeType;
+exports.normalizeMimeType = normalizeMimeType;
+exports.getFileCategoryFromMime = getFileCategoryFromMime;
+exports.resolveMimeAlias = resolveMimeAlias;
+// Common MIME type categories
+exports.MIME_CATEGORIES = {
+    IMAGE: 'image',
+    VIDEO: 'video',
+    AUDIO: 'audio',
+    APPLICATION: 'application',
+    TEXT: 'text',
+    FONT: 'font'
+};
+// Extract category from MIME type
+function getMimeCategory(mimeType) {
+    const category = mimeType.split('/')[0];
+    if (Object.values(exports.MIME_CATEGORIES).includes(category)) {
+        return category;
+    }
+    return null;
+}
+// Check if MIME type is binary
+function isBinaryMimeType(mimeType) {
+    const textTypes = [
+        'text/',
+        'application/json',
+        'application/xml',
+        'application/javascript',
+        'application/typescript',
+        'application/x-sh',
+        'application/x-csh',
+        'application/x-python',
+        'application/x-ruby',
+        'application/x-perl'
+    ];
+    return !textTypes.some(type => mimeType.startsWith(type));
+}
+// Normalize MIME type (remove parameters)
+function normalizeMimeType(mimeType) {
+    return mimeType.split(';')[0].trim().toLowerCase();
+}
+// Get file category from MIME type
+function getFileCategoryFromMime(mimeType) {
+    const normalized = normalizeMimeType(mimeType);
+    if (normalized.startsWith('image/'))
+        return 'image';
+    if (normalized.startsWith('video/'))
+        return 'video';
+    if (normalized.startsWith('audio/'))
+        return 'audio';
+    if (normalized.startsWith('font/'))
+        return 'font';
+    if (normalized.startsWith('text/'))
+        return 'text';
+    // Special cases for application types
+    if (normalized.includes('zip') || normalized.includes('compressed') || normalized.includes('archive')) {
+        return 'archive';
+    }
+    if (normalized.includes('pdf') || normalized.includes('document') || normalized.includes('msword') || normalized.includes('officedocument')) {
+        return 'document';
+    }
+    if (normalized.includes('executable') || normalized.includes('x-msdownload') || normalized.includes('x-elf') || normalized.includes('x-mach')) {
+        return 'executable';
+    }
+    if (normalized.includes('sqlite') || normalized.includes('database')) {
+        return 'database';
+    }
+    return 'other';
+}
+// Common MIME type aliases
+const MIME_ALIASES = {
+    'application/x-javascript': 'application/javascript',
+    'text/javascript': 'application/javascript',
+    'application/x-mpegURL': 'application/vnd.apple.mpegurl',
+    'audio/mp3': 'audio/mpeg',
+    'audio/x-mp3': 'audio/mpeg',
+    'audio/x-mpeg': 'audio/mpeg',
+    'video/x-m4v': 'video/mp4',
+    'audio/x-m4a': 'audio/mp4',
+    'image/jpg': 'image/jpeg',
+    'image/x-png': 'image/png',
+    'image/x-icon': 'image/vnd.microsoft.icon',
+    'text/xml': 'application/xml',
+    'application/x-compressed': 'application/x-compress',
+    'application/x-gzip': 'application/gzip',
+    'application/x-bzip': 'application/x-bzip2',
+    'application/x-tar': 'application/tar'
+};
+// Resolve MIME type aliases
+function resolveMimeAlias(mimeType) {
+    const normalized = normalizeMimeType(mimeType);
+    return MIME_ALIASES[normalized] || normalized;
+}