music-metadata 11.0.4 → 11.1.0

package/README.md

@@ -584,6 +584,10 @@ import { parseFile, selectCover } from 'music-metadata';
 )();
  ```
 
+#### `getSupportedMimeTypes` function
+
+Returns a list of supported MIME-types. This may include some MIME-types which are not formally recognized.
+
 ### `IOptions` Interface
 - `duration`: `boolean` (default: `false`)
 

package/lib/ParserFactory.d.ts

@@ -7,6 +7,7 @@ export interface IParserLoader {
      * Returns a list of supported file extensions
      */
     extensions: string[];
+    mimeTypes: string[];
     parserType: ParserType;
     /**
      * Lazy load the parser implementation class.
@@ -37,6 +38,7 @@ export declare class ParserFactory {
      * @return Parser submodule name
      */
     findLoaderForExtension(filePath: string | undefined): IParserLoader | undefined;
-    findLoaderForType(moduleName: ParserType | undefined): IParserLoader | undefined;
+    findLoaderForContentType(httpContentType: string): IParserLoader | undefined;
+    getSupportedMimeTypes(): string[];
 }
 export {};

package/lib/ParserFactory.js

@@ -62,7 +62,7 @@ export class ParserFactory {
         if (!parserLoader) {
             const buf = new Uint8Array(4100);
             if (tokenizer.fileInfo.mimeType) {
-                parserLoader = this.findLoaderForType(getParserIdForMimeType(tokenizer.fileInfo.mimeType));
+                parserLoader = this.findLoaderForContentType(tokenizer.fileInfo.mimeType);
             }
             if (!parserLoader && tokenizer.fileInfo.path) {
                 parserLoader = this.findLoaderForExtension(tokenizer.fileInfo.path);
@@ -76,7 +76,7 @@ export class ParserFactory {
                     throw new CouldNotDetermineFileTypeError('Failed to determine audio format');
                 }
                 debug(`Guessed file type is mime=${guessedType.mime}, extension=${guessedType.ext}`);
-                parserLoader = this.findLoaderForType(getParserIdForMimeType(guessedType.mime));
+                parserLoader = this.findLoaderForContentType(guessedType.mime);
                 if (!parserLoader) {
                     throw new UnsupportedFileTypeError(`Guessed MIME-type not supported: ${guessedType.mime}`);
                 }
@@ -101,99 +101,33 @@ export class ParserFactory {
         const extension = getExtension(filePath).toLocaleLowerCase() || filePath;
         return this.parsers.find(parser => parser.extensions.indexOf(extension) !== -1);
     }
-    findLoaderForType(moduleName) {
-        return moduleName ? this.parsers.find(parser => parser.parserType === moduleName) : undefined;
+    findLoaderForContentType(httpContentType) {
+        let mime;
+        if (!httpContentType)
+            return;
+        try {
+            mime = parseHttpContentType(httpContentType);
+        }
+        catch (err) {
+            debug(`Invalid HTTP Content-Type header value: ${httpContentType}`);
+            return;
+        }
+        const subType = mime.subtype.indexOf('x-') === 0 ? mime.subtype.substring(2) : mime.subtype;
+        return this.parsers.find(parser => parser.mimeTypes.find(loader => loader.indexOf(`${mime.type}/${subType}`) !== -1));
+    }
+    getSupportedMimeTypes() {
+        const mimeTypeSet = new Set();
+        this.parsers.forEach(loader => {
+            loader.mimeTypes.forEach(mimeType => {
+                mimeTypeSet.add(mimeType);
+                mimeTypeSet.add(mimeType.replace('/', '/x-'));
+            });
+        });
+        return Array.from(mimeTypeSet);
     }
 }
 function getExtension(fname) {
     const i = fname.lastIndexOf('.');
     return i === -1 ? '' : fname.slice(i);
 }
-/**
- * @param httpContentType - HTTP Content-Type, extension, path or filename
- * @returns Parser submodule name
- */
-function getParserIdForMimeType(httpContentType) {
-    let mime;
-    if (!httpContentType)
-        return;
-    try {
-        mime = parseHttpContentType(httpContentType);
-    }
-    catch (err) {
-        debug(`Invalid HTTP Content-Type header value: ${httpContentType}`);
-        return;
-    }
-    const subType = mime.subtype.indexOf('x-') === 0 ? mime.subtype.substring(2) : mime.subtype;
-    switch (mime.type) {
-        case 'audio':
-            switch (subType) {
-                case 'mp3': // Incorrect MIME-type, Chrome, in Web API File object
-                case 'mpeg':
-                    return 'mpeg';
-                case 'aac':
-                case 'aacp':
-                    return 'mpeg'; // adts
-                case 'flac':
-                    return 'flac';
-                case 'ape':
-                case 'monkeys-audio':
-                    return 'apev2';
-                case 'mp4':
-                case 'm4a':
-                    return 'mp4';
-                case 'ogg': // RFC 7845
-                case 'opus': // RFC 6716
-                case 'speex': // RFC 5574
-                    return 'ogg';
-                case 'ms-wma':
-                case 'ms-wmv':
-                case 'ms-asf':
-                    return 'asf';
-                case 'aiff':
-                case 'aif':
-                case 'aifc':
-                    return 'aiff';
-                case 'vnd.wave':
-                case 'wav':
-                case 'wave':
-                    return 'riff';
-                case 'wavpack':
-                    return 'wavpack';
-                case 'musepack':
-                    return 'musepack';
-                case 'matroska':
-                case 'webm':
-                    return 'matroska';
-                case 'dsf':
-                    return 'dsf';
-                case 'amr':
-                    return 'amr';
-            }
-            break;
-        case 'video':
-            switch (subType) {
-                case 'ms-asf':
-                case 'ms-wmv':
-                    return 'asf';
-                case 'm4v':
-                case 'mp4':
-                    return 'mp4';
-                case 'ogg':
-                    return 'ogg';
-                case 'matroska':
-                case 'webm':
-                    return 'matroska';
-            }
-            break;
-        case 'application':
-            switch (subType) {
-                case 'vnd.ms-asf':
-                    return 'asf';
-                case 'ogg':
-                    return 'ogg';
-            }
-            break;
-    }
-}
 //# sourceMappingURL=ParserFactory.js.map

package/lib/aiff/AiffLoader.js

@@ -1,6 +1,7 @@
 export const aiffParserLoader = {
     parserType: 'aiff',
     extensions: ['.aif', 'aiff', 'aifc'],
+    mimeTypes: ['audio/aiff', 'audio/aif', 'audio/aifc', 'application/aiff'],
     async load() {
         return (await import('./AiffParser.js')).AIFFParser;
     }

package/lib/apev2/Apev2Loader.js

@@ -1,6 +1,7 @@
 export const apeParserLoader = {
     parserType: 'apev2',
     extensions: ['.ape'],
+    mimeTypes: ['audio/ape', 'audio/monkeys-audio'],
     async load() {
         return (await import('./APEv2Parser.js')).APEv2Parser;
     }

package/lib/asf/AsfLoader.js

@@ -1,6 +1,7 @@
 export const asfParserLoader = {
     parserType: 'asf',
     extensions: ['.asf'],
+    mimeTypes: ['audio/ms-wma', 'video/ms-wmv', 'audio/ms-asf', 'video/ms-asf', 'application/vnd.ms-asf'],
     async load() {
         return (await import('./AsfParser.js')).AsfParser;
     }

package/lib/core.d.ts

@@ -63,3 +63,7 @@ export declare function scanAppendingHeaders(tokenizer: IRandomAccessTokenizer,
  * This method will throw an Error, always.
  */
 export declare function parseFile(filePath: string, options?: IOptions): Promise<IAudioMetadata>;
+/**
+ * Return a list of supported mime-types
+ */
+export declare function getSupportedMimeTypes(): string[];

package/lib/core.js

@@ -111,4 +111,10 @@ export async function scanAppendingHeaders(tokenizer, options = {}) {
 export async function parseFile(filePath, options = {}) {
     throw new Error('To load Web API File objects use parseBlob instead. For loading files, you need to import with the "node" condition is set.');
 }
+/**
+ * Return a list of supported mime-types
+ */
+export function getSupportedMimeTypes() {
+    return new ParserFactory().getSupportedMimeTypes();
+}
 //# sourceMappingURL=core.js.map

package/lib/dsdiff/DsdiffLoader.js

@@ -1,6 +1,7 @@
 export const dsdiffParserLoader = {
     parserType: 'dsdiff',
     extensions: ['.dff'],
+    mimeTypes: ['audio/dsf', 'audio/dsd'],
     async load() {
         return (await import('./DsdiffParser.js')).DsdiffParser;
     }

package/lib/dsf/DsfLoader.js

@@ -1,6 +1,7 @@
 export const dsfParserLoader = {
     parserType: 'dsf',
     extensions: ['.dsf'],
+    mimeTypes: ['audio/dsf'],
     async load() {
         return (await import('./DsfParser.js')).DsfParser;
     }

package/lib/flac/FlacLoader.js

@@ -1,6 +1,7 @@
 export const flacParserLoader = {
     parserType: 'flac',
     extensions: ['.flac'],
+    mimeTypes: ['audio/flac'],
     async load() {
         return (await import('./FlacParser.js')).FlacParser;
     }

package/lib/matroska/MatroskaLoader.js

@@ -1,6 +1,7 @@
 export const matroskaParserLoader = {
     parserType: 'matroska',
     extensions: ['.mka', '.mkv', '.mk3d', '.mks', 'webm'],
+    mimeTypes: ['audio/matroska', 'audio/webm', 'video/webm'],
     async load() {
         return (await import('./MatroskaParser.js')).MatroskaParser;
     }

package/lib/mp4/Mp4Loader.js

@@ -1,6 +1,7 @@
 export const mp4ParserLoader = {
     parserType: 'mp4',
     extensions: ['.mp4', '.m4a', '.m4b', '.m4pa', 'm4v', 'm4r', '3gp'],
+    mimeTypes: ['audio/mp4', 'audio/m4a', 'video/m4v', 'video/mp4'],
     async load() {
         return (await import('./MP4Parser.js')).MP4Parser;
     }

package/lib/mpeg/MpegLoader.js

@@ -1,6 +1,7 @@
 export const mpegParserLoader = {
     parserType: 'mpeg',
     extensions: ['.mp2', '.mp3', '.m2a', '.aac', 'aacp'],
+    mimeTypes: ['audio/mpeg', 'audio/mp3', 'audio/aacs', 'audio/aacp'],
     async load() {
         return (await import('./MpegParser.js')).MpegParser;
     }

package/lib/musepack/MusepackLoader.js

@@ -1,6 +1,7 @@
 export const musepackParserLoader = {
     parserType: 'musepack',
     extensions: ['.mpc'],
+    mimeTypes: ['audio/musepack'],
     async load() {
         return (await import('./MusepackParser.js')).MusepackParser;
     }

package/lib/ogg/OggLoader.js

@@ -1,6 +1,7 @@
 export const oggParserLoader = {
     parserType: 'ogg',
     extensions: ['.ogg', '.ogv', '.oga', '.ogm', '.ogx', '.opus', '.spx'],
+    mimeTypes: ['audio/ogg', 'audio/opus', 'audio/speex', 'video/ogg'], // RFC 7845, RFC 6716, RFC 5574
     async load() {
         return (await import('./OggParser.js')).OggParser;
     }

package/lib/type.d.ts

@@ -521,7 +521,7 @@ export interface IAudioMetadata extends INativeAudioMetadata {
 /**
  * Corresponds with parser module name
  */
-export type ParserType = 'mpeg' | 'apev2' | 'mp4' | 'asf' | 'flac' | 'ogg' | 'aiff' | 'wavpack' | 'riff' | 'musepack' | 'dsf' | 'dsdiff' | 'adts' | 'matroska' | 'amr';
+export type ParserType = 'mpeg' | 'apev2' | 'mp4' | 'asf' | 'flac' | 'ogg' | 'aiff' | 'wavpack' | 'riff' | 'musepack' | 'dsf' | 'dsdiff' | 'adts' | 'matroska';
 export interface IOptions {
     /**
      * default: `false`, if set to `true`, it will parse the whole media file if required to determine the duration.

package/lib/wav/WaveLoader.js

@@ -1,6 +1,7 @@
 export const riffParserLoader = {
     parserType: 'riff',
     extensions: ['.wav', 'wave', '.bwf'],
+    mimeTypes: ['audio/vnd.wave', 'audio/wav', 'audio/wave'],
     async load() {
         return (await import('./WaveParser.js')).WaveParser;
     }

package/lib/wavpack/WavPackLoader.js

@@ -1,6 +1,7 @@
 export const wavpackParserLoader = {
     parserType: 'wavpack',
     extensions: ['.wv', '.wvp'],
+    mimeTypes: ['audio/wavpack'],
     async load() {
         return (await import('./WavPackParser.js')).WavPackParser;
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "music-metadata",
   "description": "Music metadata parser for Node.js, supporting virtual any audio and tag format.",
-  "version": "11.0.4",
+  "version": "11.1.0",
   "author": {
     "name": "Borewit",
     "url": "https://github.com/Borewit"
@@ -122,12 +122,12 @@
     "@types/debug": "^4.1.12",
     "@types/media-typer": "^1.1.3",
     "@types/mocha": "^10.0.10",
-    "@types/node": "^22.13.13",
+    "@types/node": "^22.14.0",
     "c8": "^10.1.3",
     "chai": "^5.2.0",
     "chai-as-promised": "^8.0.1",
     "del-cli": "^6.0.0",
-    "mime": "^4.0.6",
+    "mime": "^4.0.7",
     "mocha": "^11.1.0",
     "node-readable-to-web-readable-stream": "^0.4.2",
     "remark-cli": "^12.0.1",
@@ -139,7 +139,7 @@
     "node": ">=18"
   },
   "repository": {
-    "type": "https://github.com/borewit/music-metadata.git"
+    "type": "github:Borewit/music-metadata"
   },
   "license": "MIT",
   "bugs": {