@rezwanul7/storage 0.0.0-stage → 0.1.0

package/dist/index.cjs

@@ -0,0 +1,475 @@
+'use strict';
+
+// src/shared/fileSize.ts
+var SIZE_UNITS = {
+  b: 1,
+  kb: 1024,
+  mb: 1024 ** 2,
+  gb: 1024 ** 3,
+  tb: 1024 ** 4
+};
+function parseFileSize(input) {
+  if (input == null) return void 0;
+  if (typeof input === "number" && Number.isFinite(input)) return input;
+  if (typeof input !== "string") return void 0;
+  const match = input.trim().toLowerCase().match(/^(\d+(?:\.\d+)?)\s*(b|kb|mb|gb|tb)?$/);
+  if (!match) return void 0;
+  return parseFloat(match[1]) * (SIZE_UNITS[match[2] || "b"] ?? 1);
+}
+function formatFileSize(bytes) {
+  if (bytes === 0) return "0 B";
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  const index = Math.floor(Math.log(bytes) / Math.log(1024));
+  return `${(bytes / Math.pow(1024, index)).toFixed(1)} ${units[index]}`;
+}
+
+// src/shared/mimeTypes.ts
+var DANGEROUS_EXTENSIONS = /* @__PURE__ */ new Set([
+  "sh",
+  "bash",
+  "zsh",
+  "exe",
+  "dll",
+  "com",
+  "scr",
+  "bat",
+  "cmd",
+  "ps1",
+  "jar",
+  "class"
+]);
+var DANGEROUS_MIME = /* @__PURE__ */ new Set([
+  "application/x-sh",
+  "application/x-shellscript",
+  "text/x-shellscript",
+  "text/x-sh",
+  "application/x-dosexec",
+  "application/java-archive"
+]);
+var MIME_BY_EXT = {
+  // Image
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  bmp: "image/bmp",
+  webp: "image/webp",
+  tiff: "image/tiff",
+  tif: "image/tiff",
+  svg: "image/svg+xml",
+  ico: "image/vnd.microsoft.icon",
+  avif: "image/avif",
+  heic: "image/heic",
+  // Audio
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  ogg: "audio/ogg",
+  flac: "audio/x-flac",
+  m4a: "audio/mp4",
+  // Video
+  mp4: "video/mp4",
+  mkv: "video/x-matroska",
+  mov: "video/quicktime",
+  avi: "video/x-msvideo",
+  webm: "video/webm",
+  // Documents
+  pdf: "application/pdf",
+  xls: "application/vnd.ms-excel",
+  xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  ods: "application/vnd.oasis.opendocument.spreadsheet",
+  ppt: "application/vnd.ms-powerpoint",
+  pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  odp: "application/vnd.oasis.opendocument.presentation",
+  doc: "application/msword",
+  docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  odt: "application/vnd.oasis.opendocument.text",
+  rtf: "application/rtf",
+  // Datasets (JSON Lines has no registered MIME, so it is served as JSON)
+  csv: "text/csv",
+  tsv: "text/tab-separated-values",
+  json: "application/json",
+  jsonl: "application/json",
+  ndjson: "application/json",
+  // Archives
+  zip: "application/zip",
+  rar: "application/x-rar-compressed",
+  "7z": "application/x-7z-compressed",
+  tar: "application/x-tar",
+  gz: "application/gzip",
+  // Code
+  js: "text/javascript",
+  jsx: "text/jsx",
+  ts: "text/typescript",
+  tsx: "text/tsx",
+  py: "text/x-python",
+  rb: "text/x-ruby",
+  php: "application/x-httpd-php",
+  java: "text/x-java-source",
+  kt: "text/x-kotlin",
+  c: "text/x-c",
+  cpp: "text/x-c",
+  h: "text/x-c",
+  hpp: "text/x-c",
+  cs: "text/x-csharp",
+  go: "text/x-go",
+  rs: "text/x-rust",
+  html: "text/html",
+  htm: "text/html",
+  css: "text/css",
+  scss: "text/x-scss",
+  yaml: "text/yaml",
+  yml: "text/yaml",
+  sql: "application/sql",
+  xml: "application/xml",
+  // Text
+  txt: "text/plain",
+  md: "text/markdown",
+  markdown: "text/markdown",
+  log: "text/plain",
+  ini: "text/plain",
+  cfg: "text/plain",
+  conf: "text/plain",
+  env: "text/plain",
+  // Executables (blocked by DANGEROUS_EXTENSIONS, mapped so they report a real MIME)
+  sh: "application/x-sh",
+  bash: "application/x-sh",
+  zsh: "application/x-sh",
+  exe: "application/x-msdos-program",
+  dll: "application/x-msdownload",
+  com: "application/x-msdownload",
+  bat: "application/x-msdownload",
+  jar: "application/java-archive",
+  class: "application/java-vm"
+};
+var EXT_BY_MIME = {};
+for (const [ext, mime] of Object.entries(MIME_BY_EXT)) {
+  EXT_BY_MIME[mime] ??= ext;
+}
+function mimeFromExtension(ext) {
+  if (!ext) return void 0;
+  return MIME_BY_EXT[ext.toLowerCase()];
+}
+function extensionFromMime(mime) {
+  if (!mime) return void 0;
+  return EXT_BY_MIME[mime.toLowerCase()];
+}
+
+// src/shared/fileExtension.ts
+function getFileExtension(name) {
+  const dot = name.lastIndexOf(".");
+  if (dot === -1) return void 0;
+  return name.slice(dot + 1).toLowerCase() || void 0;
+}
+
+// src/shared/detectFileTypeFromName.ts
+function detectFileTypeFromName(input) {
+  const name = input.name;
+  const declaredMime = input.type || void 0;
+  const declaredExt = getFileExtension(name);
+  const finalExt = declaredExt;
+  const finalMime = resolveMime(declaredExt, declaredMime);
+  if (declaredExt && DANGEROUS_EXTENSIONS.has(declaredExt)) {
+    return {
+      ok: false,
+      reason: `Extension .${declaredExt} is blocked.`,
+      mime: finalMime,
+      ext: finalExt
+    };
+  }
+  if (declaredMime && DANGEROUS_MIME.has(declaredMime)) {
+    return {
+      ok: false,
+      reason: `MIME type ${declaredMime} is unsafe.`,
+      mime: finalMime,
+      ext: finalExt
+    };
+  }
+  if (declaredExt) {
+    return {
+      ok: true,
+      mime: finalMime,
+      ext: declaredExt
+    };
+  }
+  if (declaredMime) {
+    return {
+      ok: true,
+      mime: declaredMime,
+      ext: extensionFromMime(declaredMime)
+    };
+  }
+  return {
+    ok: false,
+    reason: "Unable to determine file type.",
+    mime: finalMime,
+    ext: void 0
+  };
+}
+function resolveMime(ext, declaredMime) {
+  const lookup = mimeFromExtension(ext);
+  if (lookup) {
+    return lookup;
+  }
+  if (declaredMime) {
+    return declaredMime;
+  }
+  return "application/octet-stream";
+}
+
+// src/shared/fileCategories/fileCategories.detect.ts
+var FILE_CATEGORY_DETECTORS = [
+  // ---- IMAGE ---------------------------------------------------------------
+  {
+    id: "Image",
+    parent: "Image",
+    detect: {
+      mimeStartsWith: ["image/"],
+      extensions: ["png", "jpg", "jpeg", "gif", "bmp", "webp", "tiff", "svg"]
+    }
+  },
+  // ---- AUDIO ---------------------------------------------------------------
+  {
+    id: "Audio",
+    parent: "Audio",
+    detect: {
+      mimeStartsWith: ["audio/"],
+      extensions: ["mp3", "wav", "ogg", "flac", "m4a"]
+    }
+  },
+  // ---- VIDEO ---------------------------------------------------------------
+  {
+    id: "Video",
+    parent: "Video",
+    detect: {
+      mimeStartsWith: ["video/"],
+      extensions: ["mp4", "mkv", "mov", "avi", "webm"]
+    }
+  },
+  // ---- PDF -----------------------------------------------------------------
+  {
+    id: "Pdf",
+    parent: "Document",
+    detect: {
+      mimeEquals: ["application/pdf"],
+      extensions: ["pdf"]
+    }
+  },
+  // ---- SPREADSHEET ---------------------------------------------------------
+  {
+    id: "Spreadsheet",
+    parent: "Document",
+    detect: {
+      mimeEquals: [
+        "application/vnd.ms-excel",
+        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        "application/vnd.oasis.opendocument.spreadsheet"
+      ],
+      extensions: ["xls", "xlsx", "ods"]
+    }
+  },
+  // ---- PRESENTATION --------------------------------------------------------
+  {
+    id: "Presentation",
+    parent: "Document",
+    detect: {
+      mimeEquals: [
+        "application/vnd.ms-powerpoint",
+        "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+        "application/vnd.oasis.opendocument.presentation"
+      ],
+      extensions: ["ppt", "pptx", "odp"]
+    }
+  },
+  // ---- DOCUMENT (WORD / RICH DOCS) ----------------------------------------
+  {
+    id: "Document",
+    parent: "Document",
+    detect: {
+      mimeEquals: [
+        "application/msword",
+        "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+        "application/vnd.oasis.opendocument.text"
+      ],
+      extensions: ["doc", "docx", "odt", "rtf"]
+    }
+  },
+  // ---- DATASET (CSV, JSONL, NDJSON, TSV) -----------------------------------
+  {
+    id: "Dataset",
+    parent: "Document",
+    detect: {
+      mimeEquals: ["text/csv", "application/json", "text/tab-separated-values"],
+      extensions: ["csv", "tsv", "jsonl", "ndjson"]
+    }
+  },
+  // ---- ARCHIVE -------------------------------------------------------------
+  {
+    id: "Archive",
+    parent: "Binary",
+    detect: {
+      mimeEquals: [
+        "application/zip",
+        "application/x-7z-compressed",
+        "application/x-rar-compressed",
+        "application/x-tar",
+        "application/gzip"
+      ],
+      extensions: ["zip", "rar", "7z", "tar", "gz"]
+    }
+  },
+  // ---- CODE ----------------------------------------------------------------
+  {
+    id: "Code",
+    parent: "Text",
+    detect: {
+      // Exact MIMEs (from MIME_BY_EXT) so source files match Code before Text's "text/" prefix
+      mimeEquals: [
+        "text/javascript",
+        "text/jsx",
+        "text/typescript",
+        "text/tsx",
+        "text/x-python",
+        "text/x-ruby",
+        "text/x-java-source",
+        "text/x-kotlin",
+        "text/x-c",
+        "text/x-csharp",
+        "text/x-go",
+        "text/x-rust",
+        "text/html",
+        "text/css",
+        "text/x-scss",
+        "text/yaml"
+      ],
+      extensions: [
+        "js",
+        "ts",
+        "tsx",
+        "jsx",
+        "py",
+        "rb",
+        "php",
+        "java",
+        "kt",
+        "c",
+        "cpp",
+        "h",
+        "hpp",
+        "cs",
+        "go",
+        "rs",
+        "sh",
+        "bash",
+        "zsh",
+        "html",
+        "css",
+        "scss",
+        "json",
+        "yml",
+        "yaml",
+        "sql"
+      ]
+    }
+  },
+  // ---- TEXT (PLAIN, MARKDOWN, LOGS, ETC.) ----------------------------------
+  {
+    id: "Text",
+    parent: "Text",
+    detect: {
+      mimeStartsWith: ["text/"],
+      extensions: ["txt", "md", "markdown", "log", "ini", "cfg", "conf", "env"]
+    }
+  },
+  // ---- BINARY (FALLBACK FOR NON-TEXT, NON-ARCHIVE) -------------------------
+  {
+    id: "Binary",
+    parent: "Binary",
+    detect: {
+      mimeEquals: ["application/octet-stream"]
+    }
+  },
+  // ---- UNKNOWN -------------------------------------------------------------
+  {
+    id: "Unknown",
+    parent: "Unknown"
+  }
+];
+
+// src/shared/fileCategories/getFileCategory.ts
+function getFileCategory(input) {
+  const mime = normalize(input.mime);
+  const ext = normalize(input.ext);
+  if (mime) {
+    for (const def of FILE_CATEGORY_DETECTORS) {
+      const eq = def.detect?.mimeEquals;
+      if (eq && eq.includes(mime)) {
+        return def.id;
+      }
+    }
+  }
+  if (mime) {
+    for (const def of FILE_CATEGORY_DETECTORS) {
+      const prefixes = def.detect?.mimeStartsWith;
+      if (prefixes && prefixes.some((p) => mime.startsWith(p))) {
+        return def.id;
+      }
+    }
+  }
+  if (ext) {
+    for (const def of FILE_CATEGORY_DETECTORS) {
+      const exts = def.detect?.extensions;
+      if (exts && exts.includes(ext)) {
+        return def.id;
+      }
+    }
+  }
+  return "Unknown";
+}
+function normalize(value) {
+  if (!value) return void 0;
+  const trimmed = value.trim().toLowerCase();
+  return trimmed || void 0;
+}
+
+// src/shared/fileCategories/getExtensionsByCategory.ts
+function getExtensionsByCategory(category) {
+  const extensions = FILE_CATEGORY_DETECTORS.find((c) => c.id === category)?.detect?.extensions;
+  if (!extensions?.length) {
+    throw new Error(
+      `File category '${category}' does not define extensions. Please add the configuration in fileCategories.detect.ts.`
+    );
+  }
+  return [...extensions];
+}
+function getExtensionsByCategories(categories) {
+  return Array.from(
+    new Set(
+      categories.flatMap((category) => getExtensionsByCategory(category))
+    )
+  );
+}
+
+// src/shared/fileCategories/getMimeTypesByCategory.ts
+function getMimeTypesByCategory(category) {
+  const mimeEquals = FILE_CATEGORY_DETECTORS.find((c) => c.id === category)?.detect?.mimeEquals;
+  if (!mimeEquals?.length) {
+    throw new Error(
+      `File category '${category}' does not define 'mimeEquals'. Please add the configuration in fileCategories.detect.ts.`
+    );
+  }
+  return [...mimeEquals];
+}
+function getMimeTypesByCategories(categories) {
+  return Array.from(new Set(categories.flatMap(getMimeTypesByCategory)));
+}
+
+exports.FILE_CATEGORY_DETECTORS = FILE_CATEGORY_DETECTORS;
+exports.detectFileTypeFromName = detectFileTypeFromName;
+exports.formatFileSize = formatFileSize;
+exports.getExtensionsByCategories = getExtensionsByCategories;
+exports.getExtensionsByCategory = getExtensionsByCategory;
+exports.getFileCategory = getFileCategory;
+exports.getFileExtension = getFileExtension;
+exports.getMimeTypesByCategories = getMimeTypesByCategories;
+exports.getMimeTypesByCategory = getMimeTypesByCategory;
+exports.parseFileSize = parseFileSize;

package/dist/index.d.cts

@@ -0,0 +1,116 @@
+export { S as SharedFileRules } from './fileRules.types-CGXBnwzd.cjs';
+
+/** Bytes for a size like "5MB", "200kb", "1.5GB", "500" or a number, or undefined if it can't be read. */
+declare function parseFileSize(input?: string | number): number | undefined;
+/** A byte count for people: "512.0 B", "1.2 KB", "8.5 MB". */
+declare function formatFileSize(bytes: number): string;
+
+/** A file's type as read from its name and declared MIME type, and whether that type is safe. */
+interface FileTypeFromName {
+    /** False when the type is dangerous (an executable or script) or can't be determined. */
+    ok: boolean;
+    /** Why the file isn't `ok`. */
+    reason?: string;
+    /** The MIME type for the extension, else the declared one. */
+    mime: string | undefined;
+    /** The extension, lower case and without the dot. */
+    ext: string | undefined;
+}
+/**
+ * A file's type from its name and declared MIME type, without reading its bytes. Use it for early feedback in the
+ * browser; the server checks every upload again from its bytes.
+ *
+ * @param file - The file to inspect.
+ * @returns Its type and whether it is safe.
+ */
+declare function detectFileTypeFromName(file: File): FileTypeFromName;
+/**
+ * A file's type from a name and a declared MIME type (`File.type`), without reading any bytes.
+ *
+ * @param info - The file name and the declared MIME type, which may be empty.
+ * @returns Its type and whether it is safe.
+ */
+declare function detectFileTypeFromName(info: {
+    name: string;
+    type?: string;
+}): FileTypeFromName;
+
+/**
+ * The lower-cased extension of a file name, without the dot.
+ *
+ * Undefined when the name has no dot ("Makefile") or nothing after it ("file."). A dotfile keeps its name as the
+ * extension (".env" → "env"), which the Text category relies on.
+ */
+declare function getFileExtension(name: string): string | undefined;
+
+/** The File categories the package knows. */
+type FileCategory = "Image" | "Audio" | "Video" | "Pdf" | "Document" | "Spreadsheet" | "Presentation" | "Dataset" | "Archive" | "Code" | "Text" | "Binary" | "Unknown";
+/** A broader group a File category belongs to, such as Document for Pdf and Spreadsheet. */
+type FileCategoryParent = "Image" | "Audio" | "Video" | "Document" | "Text" | "Binary" | "Unknown";
+/** One row of {@link FILE_CATEGORY_DETECTORS}: a File category and how to recognise it. */
+interface FileCategoryDetect {
+    /** The File category. */
+    id: FileCategory;
+    /** The broader group it belongs to. */
+    parent?: FileCategoryParent;
+    /** What identifies it. */
+    detect?: {
+        /** Exact MIME types. */
+        mimeEquals?: string[];
+        /** MIME type prefixes, such as `"image/"`. */
+        mimeStartsWith?: string[];
+        /** Extensions, lower case and without the dot. */
+        extensions?: string[];
+    };
+}
+
+/** Every File category and how to recognise it, in the order {@link getFileCategory} tries them. */
+declare const FILE_CATEGORY_DETECTORS: FileCategoryDetect[];
+
+/**
+ * A file's File category from its MIME type and extension: an exact MIME match wins, then a MIME prefix, then the
+ * extension.
+ *
+ * @param input - The MIME type and extension, either of which may be missing.
+ * @returns The File category, or `"Unknown"`.
+ */
+declare function getFileCategory(input: {
+    mime?: string | null;
+    ext?: string | null;
+}): FileCategory;
+
+/**
+ * The extensions of a File category, to put in `allowedExtensions`.
+ *
+ * @param category - The File category.
+ * @returns Its extensions, lower case and without the dot.
+ * @throws Error when the category defines no extensions, such as `"Unknown"`.
+ */
+declare function getExtensionsByCategory(category: FileCategory): string[];
+/**
+ * The extensions of several File categories, without duplicates.
+ *
+ * @param categories - The File categories.
+ * @returns Their extensions, lower case and without the dot.
+ * @throws Error when a category defines no extensions.
+ */
+declare function getExtensionsByCategories(categories: FileCategory[]): string[];
+
+/**
+ * The exact MIME types of a File category, to put in `allowedMimeTypes`.
+ *
+ * @param category - The File category.
+ * @returns Its MIME types.
+ * @throws Error when the category matches by MIME prefix only, such as `"Image"`, or defines none.
+ */
+declare function getMimeTypesByCategory(category: FileCategory): string[];
+/**
+ * The exact MIME types of several File categories, without duplicates.
+ *
+ * @param categories - The File categories.
+ * @returns Their MIME types.
+ * @throws Error when a category defines no exact MIME types.
+ */
+declare function getMimeTypesByCategories(categories: FileCategory[]): string[];
+
+export { FILE_CATEGORY_DETECTORS, type FileCategory, type FileCategoryDetect, type FileCategoryParent, type FileTypeFromName, detectFileTypeFromName, formatFileSize, getExtensionsByCategories, getExtensionsByCategory, getFileCategory, getFileExtension, getMimeTypesByCategories, getMimeTypesByCategory, parseFileSize };

package/dist/index.d.ts

@@ -0,0 +1,116 @@
+export { S as SharedFileRules } from './fileRules.types-CGXBnwzd.js';
+
+/** Bytes for a size like "5MB", "200kb", "1.5GB", "500" or a number, or undefined if it can't be read. */
+declare function parseFileSize(input?: string | number): number | undefined;
+/** A byte count for people: "512.0 B", "1.2 KB", "8.5 MB". */
+declare function formatFileSize(bytes: number): string;
+
+/** A file's type as read from its name and declared MIME type, and whether that type is safe. */
+interface FileTypeFromName {
+    /** False when the type is dangerous (an executable or script) or can't be determined. */
+    ok: boolean;
+    /** Why the file isn't `ok`. */
+    reason?: string;
+    /** The MIME type for the extension, else the declared one. */
+    mime: string | undefined;
+    /** The extension, lower case and without the dot. */
+    ext: string | undefined;
+}
+/**
+ * A file's type from its name and declared MIME type, without reading its bytes. Use it for early feedback in the
+ * browser; the server checks every upload again from its bytes.
+ *
+ * @param file - The file to inspect.
+ * @returns Its type and whether it is safe.
+ */
+declare function detectFileTypeFromName(file: File): FileTypeFromName;
+/**
+ * A file's type from a name and a declared MIME type (`File.type`), without reading any bytes.
+ *
+ * @param info - The file name and the declared MIME type, which may be empty.
+ * @returns Its type and whether it is safe.
+ */
+declare function detectFileTypeFromName(info: {
+    name: string;
+    type?: string;
+}): FileTypeFromName;
+
+/**
+ * The lower-cased extension of a file name, without the dot.
+ *
+ * Undefined when the name has no dot ("Makefile") or nothing after it ("file."). A dotfile keeps its name as the
+ * extension (".env" → "env"), which the Text category relies on.
+ */
+declare function getFileExtension(name: string): string | undefined;
+
+/** The File categories the package knows. */
+type FileCategory = "Image" | "Audio" | "Video" | "Pdf" | "Document" | "Spreadsheet" | "Presentation" | "Dataset" | "Archive" | "Code" | "Text" | "Binary" | "Unknown";
+/** A broader group a File category belongs to, such as Document for Pdf and Spreadsheet. */
+type FileCategoryParent = "Image" | "Audio" | "Video" | "Document" | "Text" | "Binary" | "Unknown";
+/** One row of {@link FILE_CATEGORY_DETECTORS}: a File category and how to recognise it. */
+interface FileCategoryDetect {
+    /** The File category. */
+    id: FileCategory;
+    /** The broader group it belongs to. */
+    parent?: FileCategoryParent;
+    /** What identifies it. */
+    detect?: {
+        /** Exact MIME types. */
+        mimeEquals?: string[];
+        /** MIME type prefixes, such as `"image/"`. */
+        mimeStartsWith?: string[];
+        /** Extensions, lower case and without the dot. */
+        extensions?: string[];
+    };
+}
+
+/** Every File category and how to recognise it, in the order {@link getFileCategory} tries them. */
+declare const FILE_CATEGORY_DETECTORS: FileCategoryDetect[];
+
+/**
+ * A file's File category from its MIME type and extension: an exact MIME match wins, then a MIME prefix, then the
+ * extension.
+ *
+ * @param input - The MIME type and extension, either of which may be missing.
+ * @returns The File category, or `"Unknown"`.
+ */
+declare function getFileCategory(input: {
+    mime?: string | null;
+    ext?: string | null;
+}): FileCategory;
+
+/**
+ * The extensions of a File category, to put in `allowedExtensions`.
+ *
+ * @param category - The File category.
+ * @returns Its extensions, lower case and without the dot.
+ * @throws Error when the category defines no extensions, such as `"Unknown"`.
+ */
+declare function getExtensionsByCategory(category: FileCategory): string[];
+/**
+ * The extensions of several File categories, without duplicates.
+ *
+ * @param categories - The File categories.
+ * @returns Their extensions, lower case and without the dot.
+ * @throws Error when a category defines no extensions.
+ */
+declare function getExtensionsByCategories(categories: FileCategory[]): string[];
+
+/**
+ * The exact MIME types of a File category, to put in `allowedMimeTypes`.
+ *
+ * @param category - The File category.
+ * @returns Its MIME types.
+ * @throws Error when the category matches by MIME prefix only, such as `"Image"`, or defines none.
+ */
+declare function getMimeTypesByCategory(category: FileCategory): string[];
+/**
+ * The exact MIME types of several File categories, without duplicates.
+ *
+ * @param categories - The File categories.
+ * @returns Their MIME types.
+ * @throws Error when a category defines no exact MIME types.
+ */
+declare function getMimeTypesByCategories(categories: FileCategory[]): string[];
+
+export { FILE_CATEGORY_DETECTORS, type FileCategory, type FileCategoryDetect, type FileCategoryParent, type FileTypeFromName, detectFileTypeFromName, formatFileSize, getExtensionsByCategories, getExtensionsByCategory, getFileCategory, getFileExtension, getMimeTypesByCategories, getMimeTypesByCategory, parseFileSize };