music-metadata 10.0.1 → 10.2.0

package/lib/ParserFactory.d.ts

@@ -1,5 +1,6 @@
-import { INativeMetadataCollector } from './common/MetadataCollector.js';
-import { IOptions, IAudioMetadata, ParserType } from './type.js';
+import { type MediaType } from 'media-typer';
+import { type INativeMetadataCollector } from './common/MetadataCollector.js';
+import type { IOptions, IAudioMetadata, ParserType } from './type.js';
 import type { ITokenizer } from 'strtok3';
 export interface ITokenParser {
     /**
@@ -16,33 +17,24 @@ export interface ITokenParser {
      */
     parse(): Promise<void>;
 }
-export declare function parseHttpContentType(contentType: string): {
-    type: string;
-    subtype: string;
-    suffix?: string;
+interface IContentType extends MediaType {
     parameters: {
         [id: string]: string;
     };
-};
-export declare class ParserFactory {
-    /**
-     * Parse metadata from tokenizer
-     * @param tokenizer - Tokenizer
-     * @param opts - Options
-     * @returns Native metadata
-     */
-    static parseOnContentType(tokenizer: ITokenizer, opts: IOptions): Promise<IAudioMetadata>;
-    static parse(tokenizer: ITokenizer, parserId: ParserType, opts: IOptions): Promise<IAudioMetadata>;
-    /**
-     * @param filePath - Path, filename or extension to audio file
-     * @return Parser sub-module name
-     */
-    static getParserIdForExtension(filePath: string): ParserType;
-    static loadParser(moduleName: ParserType): Promise<ITokenParser>;
-    private static getExtension;
-    /**
-     * @param httpContentType - HTTP Content-Type, extension, path or filename
-     * @returns Parser sub-module name
-     */
-    private static getParserIdForMimeType;
 }
+export declare function parseHttpContentType(contentType: string): IContentType;
+/**
+ * Parse metadata from tokenizer
+ * @param tokenizer - Tokenizer
+ * @param opts - Options
+ * @returns Native metadata
+ */
+export declare function parseOnContentType(tokenizer: ITokenizer, opts?: IOptions): Promise<IAudioMetadata>;
+export declare function parse(tokenizer: ITokenizer, parserId?: ParserType, opts?: IOptions): Promise<IAudioMetadata>;
+/**
+ * @param filePath - Path, filename or extension to audio file
+ * @return Parser submodule name
+ */
+export declare function getParserIdForExtension(filePath: string | undefined): ParserType | undefined;
+export declare function loadParser(moduleName: ParserType): Promise<ITokenParser>;
+export {};

package/lib/ParserFactory.js

@@ -1,6 +1,6 @@
 import { fileTypeFromBuffer } from 'file-type';
 import ContentType from 'content-type';
-import MimeType from 'media-typer';
+import { parse as mimeTypeParse } from 'media-typer';
 import initDebug from 'debug';
 import { MetadataCollector } from './common/MetadataCollector.js';
 import { AIFFParser } from './aiff/AiffParser.js';
@@ -19,7 +19,7 @@ import { MatroskaParser } from './matroska/MatroskaParser.js';
 const debug = initDebug('music-metadata:parser:factory');
 export function parseHttpContentType(contentType) {
     const type = ContentType.parse(contentType);
-    const mime = MimeType.parse(type.type);
+    const mime = mimeTypeParse(type.type);
     return {
         type: mime.type,
         subtype: mime.subtype,
@@ -27,221 +27,218 @@ export function parseHttpContentType(contentType) {
         parameters: type.parameters
     };
 }
-async function parse(tokenizer, parserId, opts = {}) {
-    // Parser found, execute parser
-    const parser = await ParserFactory.loadParser(parserId);
-    const metadata = new MetadataCollector(opts);
-    await parser.init(metadata, tokenizer, opts).parse();
-    return metadata.toCommonMetadata();
+/**
+ * Parse metadata from tokenizer
+ * @param tokenizer - Tokenizer
+ * @param opts - Options
+ * @returns Native metadata
+ */
+export async function parseOnContentType(tokenizer, opts) {
+    const { mimeType, path, url } = tokenizer.fileInfo;
+    // Resolve parser based on MIME-type or file extension
+    const parserId = getParserIdForMimeType(mimeType) || getParserIdForExtension(path) || getParserIdForExtension(url);
+    if (!parserId) {
+        debug(`No parser found for MIME-type / extension: ${mimeType}`);
+    }
+    return parse(tokenizer, parserId, opts);
 }
-export class ParserFactory {
-    /**
-     * Parse metadata from tokenizer
-     * @param tokenizer - Tokenizer
-     * @param opts - Options
-     * @returns Native metadata
-     */
-    static async parseOnContentType(tokenizer, opts) {
-        const { mimeType, path, url } = await tokenizer.fileInfo;
-        // Resolve parser based on MIME-type or file extension
-        const parserId = ParserFactory.getParserIdForMimeType(mimeType) || ParserFactory.getParserIdForExtension(path) || ParserFactory.getParserIdForExtension(url);
-        if (!parserId) {
-            debug('No parser found for MIME-type / extension: ' + mimeType);
+export async function parse(tokenizer, parserId, opts) {
+    if (!parserId) {
+        // Parser could not be determined on MIME-type or extension
+        debug('Guess parser on content...');
+        const buf = new Uint8Array(4100);
+        await tokenizer.peekBuffer(buf, { mayBeLess: true });
+        if (tokenizer.fileInfo.path) {
+            parserId = getParserIdForExtension(tokenizer.fileInfo.path);
         }
-        return this.parse(tokenizer, parserId, opts);
-    }
-    static async parse(tokenizer, parserId, opts) {
         if (!parserId) {
-            // Parser could not be determined on MIME-type or extension
-            debug('Guess parser on content...');
-            const buf = new Uint8Array(4100);
-            await tokenizer.peekBuffer(buf, { mayBeLess: true });
-            if (tokenizer.fileInfo.path) {
-                parserId = this.getParserIdForExtension(tokenizer.fileInfo.path);
+            const guessedType = await fileTypeFromBuffer(buf);
+            if (!guessedType) {
+                throw new Error('Failed to determine audio format');
             }
+            debug(`Guessed file type is mime=${guessedType.mime}, extension=${guessedType.ext}`);
+            parserId = getParserIdForMimeType(guessedType.mime);
             if (!parserId) {
-                const guessedType = await fileTypeFromBuffer(buf);
-                if (!guessedType) {
-                    throw new Error('Failed to determine audio format');
-                }
-                debug(`Guessed file type is mime=${guessedType.mime}, extension=${guessedType.ext}`);
-                parserId = ParserFactory.getParserIdForMimeType(guessedType.mime);
-                if (!parserId) {
-                    throw new Error('Guessed MIME-type not supported: ' + guessedType.mime);
-                }
+                throw new Error(`Guessed MIME-type not supported: ${guessedType.mime}`);
             }
         }
-        // Parser found, execute parser
-        return parse(tokenizer, parserId, opts);
     }
-    /**
-     * @param filePath - Path, filename or extension to audio file
-     * @return Parser sub-module name
-     */
-    static getParserIdForExtension(filePath) {
-        if (!filePath)
-            return;
-        const extension = this.getExtension(filePath).toLocaleLowerCase() || filePath;
-        switch (extension) {
-            case '.mp2':
-            case '.mp3':
-            case '.m2a':
-            case '.aac': // Assume it is ADTS-container
-                return 'mpeg';
-            case '.ape':
-                return 'apev2';
-            case '.mp4':
-            case '.m4a':
-            case '.m4b':
-            case '.m4pa':
-            case '.m4v':
-            case '.m4r':
-            case '.3gp':
-                return 'mp4';
-            case '.wma':
-            case '.wmv':
-            case '.asf':
-                return 'asf';
-            case '.flac':
-                return 'flac';
-            case '.ogg':
-            case '.ogv':
-            case '.oga':
-            case '.ogm':
-            case '.ogx':
-            case '.opus': // recommended filename extension for Ogg Opus
-            case '.spx': // recommended filename extension for Ogg Speex
-                return 'ogg';
-            case '.aif':
-            case '.aiff':
-            case '.aifc':
-                return 'aiff';
-            case '.wav':
-            case '.bwf': // Broadcast Wave Format
-                return 'riff';
-            case '.wv':
-            case '.wvp':
-                return 'wavpack';
-            case '.mpc':
-                return 'musepack';
-            case '.dsf':
-                return 'dsf';
-            case '.dff':
-                return 'dsdiff';
-            case '.mka':
-            case '.mkv':
-            case '.mk3d':
-            case '.mks':
-            case '.webm':
-                return 'matroska';
-        }
+    // Parser found, execute parser
+    const parser = await loadParser(parserId);
+    const metadata = new MetadataCollector(opts);
+    await parser.init(metadata, tokenizer, opts ?? {}).parse();
+    return metadata.toCommonMetadata();
+}
+/**
+ * @param filePath - Path, filename or extension to audio file
+ * @return Parser submodule name
+ */
+export function getParserIdForExtension(filePath) {
+    if (!filePath)
+        return;
+    const extension = getExtension(filePath).toLocaleLowerCase() || filePath;
+    switch (extension) {
+        case '.mp2':
+        case '.mp3':
+        case '.m2a':
+        case '.aac': // Assume it is ADTS-container
+            return 'mpeg';
+        case '.ape':
+            return 'apev2';
+        case '.mp4':
+        case '.m4a':
+        case '.m4b':
+        case '.m4pa':
+        case '.m4v':
+        case '.m4r':
+        case '.3gp':
+            return 'mp4';
+        case '.wma':
+        case '.wmv':
+        case '.asf':
+            return 'asf';
+        case '.flac':
+            return 'flac';
+        case '.ogg':
+        case '.ogv':
+        case '.oga':
+        case '.ogm':
+        case '.ogx':
+        case '.opus': // recommended filename extension for Ogg Opus
+        case '.spx': // recommended filename extension for Ogg Speex
+            return 'ogg';
+        case '.aif':
+        case '.aiff':
+        case '.aifc':
+            return 'aiff';
+        case '.wav':
+        case '.bwf': // Broadcast Wave Format
+            return 'riff';
+        case '.wv':
+        case '.wvp':
+            return 'wavpack';
+        case '.mpc':
+            return 'musepack';
+        case '.dsf':
+            return 'dsf';
+        case '.dff':
+            return 'dsdiff';
+        case '.mka':
+        case '.mkv':
+        case '.mk3d':
+        case '.mks':
+        case '.webm':
+            return 'matroska';
     }
-    static async loadParser(moduleName) {
-        switch (moduleName) {
-            case 'aiff': return new AIFFParser();
-            case 'adts':
-            case 'mpeg':
-                return new MpegParser();
-            case 'apev2': return new APEv2Parser();
-            case 'asf': return new AsfParser();
-            case 'dsf': return new DsfParser();
-            case 'dsdiff': return new DsdiffParser();
-            case 'flac': return new FlacParser();
-            case 'mp4': return new MP4Parser();
-            case 'musepack': return new MusepackParser();
-            case 'ogg': return new OggParser();
-            case 'riff': return new WaveParser();
-            case 'wavpack': return new WavPackParser();
-            case 'matroska': return new MatroskaParser();
-            default:
-                throw new Error(`Unknown parser type: ${moduleName}`);
-        }
+}
+export async function loadParser(moduleName) {
+    switch (moduleName) {
+        case 'aiff': return new AIFFParser();
+        case 'adts':
+        case 'mpeg':
+            return new MpegParser();
+        case 'apev2': return new APEv2Parser();
+        case 'asf': return new AsfParser();
+        case 'dsf': return new DsfParser();
+        case 'dsdiff': return new DsdiffParser();
+        case 'flac': return new FlacParser();
+        case 'mp4': return new MP4Parser();
+        case 'musepack': return new MusepackParser();
+        case 'ogg': return new OggParser();
+        case 'riff': return new WaveParser();
+        case 'wavpack': return new WavPackParser();
+        case 'matroska': return new MatroskaParser();
+        default:
+            throw new Error(`Unknown parser type: ${moduleName}`);
     }
-    static getExtension(fname) {
-        const i = fname.lastIndexOf('.');
-        return i === -1 ? '' : fname.slice(i);
+}
+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);
     }
-    /**
-     * @param httpContentType - HTTP Content-Type, extension, path or filename
-     * @returns Parser sub-module name
-     */
-    static getParserIdForMimeType(httpContentType) {
-        let mime;
-        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 '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';
-                }
-                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;
-        }
+    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 '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';
+            }
+            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/AiffParser.js

@@ -6,18 +6,8 @@ import { FourCcToken } from '../common/FourCC.js';
 import { BasicParser } from '../common/BasicParser.js';
 import * as AiffToken from './AiffToken.js';
 import * as iff from '../iff/index.js';
+import { compressionTypes } from './AiffToken.js';
 const debug = initDebug('music-metadata:parser:aiff');
-const compressionTypes = {
-    NONE: 'not compressed	PCM	Apple Computer',
-    sowt: 'PCM (byte swapped)',
-    fl32: '32-bit floating point IEEE 32-bit float',
-    fl64: '64-bit floating point IEEE 64-bit float	Apple Computer',
-    alaw: 'ALaw 2:1	8-bit ITU-T G.711 A-law',
-    ulaw: 'µLaw 2:1	8-bit ITU-T G.711 µ-law	Apple Computer',
-    ULAW: 'CCITT G.711 u-law 8-bit ITU-T G.711 µ-law',
-    ALAW: 'CCITT G.711 A-law 8-bit ITU-T G.711 A-law',
-    FL32: 'Float 32	IEEE 32-bit float '
-};
 /**
  * AIFF - Audio Interchange File Format
  *
@@ -26,6 +16,10 @@ const compressionTypes = {
  * - http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/AIFF/Docs/AIFF-1.3.pdf
  */
 export class AIFFParser extends BasicParser {
+    constructor() {
+        super(...arguments);
+        this.isCompressed = null;
+    }
     async parse() {
         const header = await this.tokenizer.readToken(iff.Header);
         if (header.chunkID !== 'FORM')
@@ -41,12 +35,12 @@ export class AIFFParser extends BasicParser {
                 this.isCompressed = true;
                 break;
             default:
-                throw Error('Unsupported AIFF type: ' + type);
+                throw new Error(`Unsupported AIFF type: ${type}`);
         }
         this.metadata.setFormat('lossless', !this.isCompressed);
         try {
             while (!this.tokenizer.fileInfo.size || this.tokenizer.fileInfo.size - this.tokenizer.position >= iff.Header.len) {
-                debug('Reading AIFF chunk at offset=' + this.tokenizer.position);
+                debug(`Reading AIFF chunk at offset=${this.tokenizer.position}`);
                 const chunkHeader = await this.tokenizer.readToken(iff.Header);
                 const nextChunk = 2 * Math.round(chunkHeader.chunkSize / 2);
                 const bytesRead = await this.readData(chunkHeader);
@@ -55,7 +49,7 @@ export class AIFFParser extends BasicParser {
         }
         catch (err) {
             if (err instanceof strtok3.EndOfStreamError) {
-                debug(`End-of-stream`);
+                debug("End-of-stream");
             }
             else {
                 throw err;
@@ -63,22 +57,28 @@ export class AIFFParser extends BasicParser {
         }
     }
     async readData(header) {
-        var _a;
         switch (header.chunkID) {
-            case 'COMM': // The Common Chunk
+            case 'COMM': { // The Common Chunk
+                if (this.isCompressed === null) {
+                    throw new Error('Failed to parse AIFF.COMM chunk when compression type is unknown');
+                }
                 const common = await this.tokenizer.readToken(new AiffToken.Common(header, this.isCompressed));
                 this.metadata.setFormat('bitsPerSample', common.sampleSize);
                 this.metadata.setFormat('sampleRate', common.sampleRate);
                 this.metadata.setFormat('numberOfChannels', common.numChannels);
                 this.metadata.setFormat('numberOfSamples', common.numSampleFrames);
                 this.metadata.setFormat('duration', common.numSampleFrames / common.sampleRate);
-                this.metadata.setFormat('codec', (_a = common.compressionName) !== null && _a !== void 0 ? _a : compressionTypes[common.compressionType]);
+                if (common.compressionName || common.compressionType) {
+                    this.metadata.setFormat('codec', common.compressionName ?? compressionTypes[common.compressionType]);
+                }
                 return header.chunkSize;
-            case 'ID3 ': // ID3-meta-data
+            }
+            case 'ID3 ': { // ID3-meta-data
                 const id3_data = await this.tokenizer.readToken(new Token.Uint8ArrayType(header.chunkSize));
                 const rst = strtok3.fromBuffer(id3_data);
                 await new ID3v2Parser().parse(this.metadata, rst, this.options);
                 return header.chunkSize;
+            }
             case 'SSND': // Sound Data Chunk
                 if (this.metadata.format.duration) {
                     this.metadata.setFormat('bitrate', 8 * header.chunkSize / this.metadata.format.duration);
@@ -96,8 +96,9 @@ export class AIFFParser extends BasicParser {
     }
     async readTextChunk(header) {
         const value = await this.tokenizer.readToken(new Token.StringType(header.chunkSize, 'ascii'));
-        const values = value.split('\0').map(v => v.trim()).filter(v => v && v.length);
+        const values = value.split('\0').map(v => v.trim()).filter(v => v?.length);
         await Promise.all(values.map(v => this.metadata.addTag('AIFF', header.chunkID, v)));
         return header.chunkSize;
     }
 }
+//# sourceMappingURL=AiffParser.js.map

package/lib/aiff/AiffToken.d.ts

@@ -1,5 +1,17 @@
-import * as iff from '../iff/index.js';
+import type * as iff from '../iff/index.js';
 import type { IGetToken } from 'strtok3';
+export declare const compressionTypes: {
+    NONE: string;
+    sowt: string;
+    fl32: string;
+    fl64: string;
+    alaw: string;
+    ulaw: string;
+    ULAW: string;
+    ALAW: string;
+    FL32: string;
+};
+export type CompressionTypeCode = keyof typeof compressionTypes;
 /**
  * The Common Chunk.
  * Describes fundamental parameters of the waveform data such as sample rate, bit resolution, and how many channels of
@@ -10,7 +22,7 @@ export interface ICommon {
     numSampleFrames: number;
     sampleSize: number;
     sampleRate: number;
-    compressionType?: string;
+    compressionType?: CompressionTypeCode;
     compressionName?: string;
 }
 export declare class Common implements IGetToken<ICommon> {

package/lib/aiff/AiffToken.js

@@ -1,5 +1,16 @@
 import * as Token from 'token-types';
 import { FourCcToken } from '../common/FourCC.js';
+export const compressionTypes = {
+    NONE: 'not compressed	PCM	Apple Computer',
+    sowt: 'PCM (byte swapped)',
+    fl32: '32-bit floating point IEEE 32-bit float',
+    fl64: '64-bit floating point IEEE 64-bit float	Apple Computer',
+    alaw: 'ALaw 2:1	8-bit ITU-T G.711 A-law',
+    ulaw: 'µLaw 2:1	8-bit ITU-T G.711 µ-law	Apple Computer',
+    ULAW: 'CCITT G.711 u-law 8-bit ITU-T G.711 µ-law',
+    ALAW: 'CCITT G.711 A-law 8-bit ITU-T G.711 A-law',
+    FL32: 'Float 32	IEEE 32-bit float '
+};
 export class Common {
     constructor(header, isAifc) {
         this.isAifc = isAifc;
@@ -42,3 +53,4 @@ export class Common {
         return res;
     }
 }
+//# sourceMappingURL=AiffToken.js.map