music-metadata 10.3.1 → 10.4.0

package/README.md

@@ -1,7 +1,7 @@
 [![Node.js CI](https://github.com/Borewit/music-metadata/actions/workflows/nodejs-ci.yml/badge.svg?branch=master)](https://github.com/Borewit/music-metadata/actions?query=branch%3Amaster)
 [![Build status](https://ci.appveyor.com/api/projects/status/tgtqynlon8t99qq5/branch/master?svg=true)](https://ci.appveyor.com/project/Borewit/music-metadata/branch/master)
 [![NPM version](https://img.shields.io/npm/v/music-metadata.svg)](https://npmjs.org/package/music-metadata)
-[![npm downloads](http://img.shields.io/npm/dm/music-metadata.svg)](https://npmcharts.com/compare/music-metadata,jsmediatags,musicmetadata,node-id3,mp3-parser,id3-parser,wav-file-info?start=600)
+[![npm downloads](http://img.shields.io/npm/dm/music-metadata.svg)](https://npmcharts.com/compare/music-metadata,jsmediatags,musicmetadata,node-id3,mp3-parser,id3-parser,wav-file-info?start=600&interval=30)
 [![Coverage Status](https://coveralls.io/repos/github/Borewit/music-metadata/badge.svg?branch=master)](https://coveralls.io/github/Borewit/music-metadata?branch=master)
 [![Codacy Badge](https://api.codacy.com/project/badge/Grade/57d731b05c9e41889a2a17cb4b0384d7)](https://app.codacy.com/app/Borewit/music-metadata?utm_source=github.com&utm_medium=referral&utm_content=Borewit/music-metadata&utm_campaign=Badge_Grade_Dashboard)
 [![CodeQL](https://github.com/Borewit/music-metadata/actions/workflows/codeql-analysis.yml/badge.svg)](https://github.com/Borewit/music-metadata/actions/workflows/codeql-analysis.yml)
@@ -31,14 +31,14 @@ The distributed JavaScript codebase is compliant with the [ECMAScript 2020 (11th
 This module requires a [Node.js ≥ 16](https://nodejs.org/en/about/previous-releases) engine.
 It can also be used in a browser environment when bundled with a module bundler.
 
-## Sponsor
-If you appreciate my work and want to support the development of open-source projects like [music-metadata](https://github.com/Borewit/music-metadata), [file-type](https://github.com/sindresorhus/file-type), and [listFix()](https://github.com/Borewit/listFix), consider becoming a sponsor or making a small contribution.
-Your support helps sustain ongoing development and improvements.
-[Become a sponsor to Borewit](https://github.com/sponsors/Borewit)
+## Support the Project
+If you find this project useful and would like to support its development, consider sponsoring or contributing:
 
-or
+- [Become a sponsor to Borewit](https://github.com/sponsors/Borewit)
 
-<a href="https://www.buymeacoffee.com/borewit" target="_blank"><img src="https://cdn.buymeacoffee.com/buttons/default-orange.png" alt="Buy me A coffee" height="41" width="174"></a>
+- Buy me a coffee:
+
+  <a href="https://www.buymeacoffee.com/borewit" target="_blank"><img src="https://cdn.buymeacoffee.com/buttons/default-orange.png" alt="Buy me A coffee" height="41" width="174"></a>
 
 ## Features
 

package/lib/ParserFactory.d.ts

@@ -2,14 +2,18 @@ import { type MediaType } from 'media-typer';
 import { type INativeMetadataCollector } from './common/MetadataCollector.js';
 import type { IAudioMetadata, IOptions, ParserType } from './type.js';
 import type { ITokenizer } from 'strtok3';
-export interface ITokenParser {
+export interface IParserLoader {
+    /**
+     * Returns a list of supported file extensions
+     */
+    extensions: string[];
+    parserType: ParserType;
     /**
-     * Initialize parser with output (metadata), input (tokenizer) & parsing options (options).
-     * @param metadata - Output
-     * @param tokenizer - Input
-     * @param options - Parsing options
+     * Lazy load the parser
      */
-    init(metadata: INativeMetadataCollector, tokenizer: ITokenizer, options: IOptions): ITokenParser;
+    load(metadata: INativeMetadataCollector, tokenizer: ITokenizer, options: IOptions): Promise<ITokenParser>;
+}
+export interface ITokenParser {
     /**
      * Parse audio track.
      * Called after init(...).
@@ -23,18 +27,16 @@ interface IContentType extends MediaType {
     };
 }
 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 declare class ParserFactory {
+    parsers: IParserLoader[];
+    constructor();
+    registerParser(parser: IParserLoader): void;
+    parse(tokenizer: ITokenizer, parserLoader: IParserLoader | undefined, opts?: IOptions): Promise<IAudioMetadata>;
+    /**
+     * @param filePath - Path, filename or extension to audio file
+     * @return Parser submodule name
+     */
+    findLoaderForExtension(filePath: string | undefined): IParserLoader | undefined;
+    findLoaderForType(moduleName: ParserType | undefined): IParserLoader | undefined;
+}
 export {};

package/lib/ParserFactory.js

@@ -3,20 +3,20 @@ import ContentType from 'content-type';
 import { parse as mimeTypeParse } from 'media-typer';
 import initDebug from 'debug';
 import { MetadataCollector } from './common/MetadataCollector.js';
-import { AIFFParser } from './aiff/AiffParser.js';
-import { APEv2Parser } from './apev2/APEv2Parser.js';
-import { AsfParser } from './asf/AsfParser.js';
-import { FlacParser } from './flac/FlacParser.js';
-import { MP4Parser } from './mp4/MP4Parser.js';
-import { MpegParser } from './mpeg/MpegParser.js';
-import MusepackParser from './musepack/index.js';
-import { OggParser } from './ogg/OggParser.js';
-import { WaveParser } from './wav/WaveParser.js';
-import { WavPackParser } from './wavpack/WavPackParser.js';
-import { DsfParser } from './dsf/DsfParser.js';
-import { DsdiffParser } from './dsdiff/DsdiffParser.js';
-import { MatroskaParser } from './matroska/MatroskaParser.js';
-import { CouldNotDetermineFileTypeError, InternalParserError, UnsupportedFileTypeError } from './ParseError.js';
+import { mpegParserLoader } from './mpeg/MpegLoader.js';
+import { CouldNotDetermineFileTypeError, UnsupportedFileTypeError } from './ParseError.js';
+import { apeParserLoader } from './apev2/Apev2Loader.js';
+import { asfParserLoader } from './asf/AsfLoader.js';
+import { dsdiffParserLoader } from './dsdiff/DsdiffLoader.js';
+import { aiffParserLoader } from './aiff/AiffLoader.js';
+import { dsfParserLoader } from './dsf/DsfLoader.js';
+import { flacParserLoader } from './flac/FlacLoader.js';
+import { matroskaParserLoader } from './matroska/MatroskaLoader.js';
+import { mp4ParserLoader } from './mp4/Mp4Loader.js';
+import { musepackParserLoader } from './musepack/MusepackLoader.js';
+import { oggParserLoader } from './ogg/OggLoader.js';
+import { wavpackParserLoader } from './wavpack/WavPackLoader.js';
+import { riffParserLoader } from './wav/WaveLoader.js';
 const debug = initDebug('music-metadata:parser:factory');
 export function parseHttpContentType(contentType) {
     const type = ContentType.parse(contentType);
@@ -28,129 +28,72 @@ export function parseHttpContentType(contentType) {
         parameters: type.parameters
     };
 }
-/**
- * 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}`);
+export class ParserFactory {
+    constructor() {
+        this.parsers = [];
+        [
+            flacParserLoader,
+            mpegParserLoader,
+            apeParserLoader,
+            mp4ParserLoader,
+            matroskaParserLoader,
+            riffParserLoader,
+            oggParserLoader,
+            asfParserLoader,
+            aiffParserLoader,
+            wavpackParserLoader,
+            musepackParserLoader,
+            dsfParserLoader,
+            dsdiffParserLoader
+        ].forEach(parser => this.registerParser(parser));
     }
-    return parse(tokenizer, parserId, opts);
-}
-export async function parse(tokenizer, parserId, opts) {
-    if (!parserId) {
-        if (tokenizer.fileInfo.path) {
-            parserId = getParserIdForExtension(tokenizer.fileInfo.path);
-        }
-        if (!parserId) {
-            // Parser could not be determined on MIME-type or extension
-            debug('Guess parser on content...');
+    registerParser(parser) {
+        this.parsers.push(parser);
+    }
+    async parse(tokenizer, parserLoader, opts) {
+        if (!parserLoader) {
             const buf = new Uint8Array(4100);
-            await tokenizer.peekBuffer(buf, { mayBeLess: true });
-            const guessedType = await fileTypeFromBuffer(buf);
-            if (!guessedType) {
-                throw new CouldNotDetermineFileTypeError('Failed to determine audio format');
+            if (tokenizer.fileInfo.mimeType) {
+                parserLoader = this.findLoaderForType(getParserIdForMimeType(tokenizer.fileInfo.mimeType));
+            }
+            if (!parserLoader && tokenizer.fileInfo.path) {
+                parserLoader = this.findLoaderForExtension(tokenizer.fileInfo.path);
             }
-            debug(`Guessed file type is mime=${guessedType.mime}, extension=${guessedType.ext}`);
-            parserId = getParserIdForMimeType(guessedType.mime);
-            if (!parserId) {
-                throw new UnsupportedFileTypeError(`Guessed MIME-type not supported: ${guessedType.mime}`);
+            if (!parserLoader) {
+                // Parser could not be determined on MIME-type or extension
+                debug('Guess parser on content...');
+                await tokenizer.peekBuffer(buf, { mayBeLess: true });
+                const guessedType = await fileTypeFromBuffer(buf);
+                if (!guessedType || !guessedType.mime) {
+                    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));
+                if (!parserLoader) {
+                    throw new UnsupportedFileTypeError(`Guessed MIME-type not supported: ${guessedType.mime}`);
+                }
             }
         }
+        // Parser found, execute parser
+        debug(`Loading ${parserLoader.parserType} parser...`);
+        const metadata = new MetadataCollector(opts);
+        const parser = await parserLoader.load(metadata, tokenizer, opts ?? {});
+        debug(`Parser ${parserLoader.parserType} loaded`);
+        await parser.parse();
+        return metadata.toCommonMetadata();
     }
-    // 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';
+    /**
+     * @param filePath - Path, filename or extension to audio file
+     * @return Parser submodule name
+     */
+    findLoaderForExtension(filePath) {
+        if (!filePath)
+            return;
+        const extension = getExtension(filePath).toLocaleLowerCase() || filePath;
+        return this.parsers.find(parser => parser.extensions.indexOf(extension) !== -1);
     }
-}
-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 InternalParserError(`Unknown parser type: ${moduleName}`);
+    findLoaderForType(moduleName) {
+        return moduleName ? this.parsers.find(parser => parser.parserType === moduleName) : undefined;
     }
 }
 function getExtension(fname) {
@@ -181,7 +124,7 @@ function getParserIdForMimeType(httpContentType) {
                     return 'mpeg';
                 case 'aac':
                 case 'aacp':
-                    return 'adts';
+                    return 'mpeg'; // adts
                 case 'flac':
                     return 'flac';
                 case 'ape':

package/lib/aiff/AiffLoader.d.ts

@@ -0,0 +1,2 @@
+import type { IParserLoader } from '../ParserFactory.js';
+export declare const aiffParserLoader: IParserLoader;

package/lib/aiff/AiffLoader.js

@@ -0,0 +1,8 @@
+export const aiffParserLoader = {
+    parserType: 'aiff',
+    extensions: ['.aif', 'aiff', 'aifc'],
+    async load(metadata, tokenizer, options) {
+        return new (await import('./AiffParser.js')).AIFFParser(metadata, tokenizer, options);
+    }
+};
+//# sourceMappingURL=AiffLoader.js.map

package/lib/apev2/APEv2Parser.js

@@ -17,8 +17,7 @@ export class APEv2Parser extends BasicParser {
         this.ape = {};
     }
     static tryParseApeHeader(metadata, tokenizer, options) {
-        const apeParser = new APEv2Parser();
-        apeParser.init(metadata, tokenizer, options);
+        const apeParser = new APEv2Parser(metadata, tokenizer, options);
         return apeParser.tryParseApeHeader();
     }
     /**
@@ -57,8 +56,7 @@ export class APEv2Parser extends BasicParser {
         if (footer.ID !== preamble)
             throw new ApeContentError('Unexpected APEv2 Footer ID preamble value');
         strtok3.fromBuffer(buffer);
-        const apeParser = new APEv2Parser();
-        apeParser.init(metadata, strtok3.fromBuffer(buffer), options);
+        const apeParser = new APEv2Parser(metadata, strtok3.fromBuffer(buffer), options);
         return apeParser.parseTags(footer);
     }
     /**

package/lib/apev2/Apev2Loader.d.ts

@@ -0,0 +1,2 @@
+import type { IParserLoader } from '../ParserFactory.js';
+export declare const apeParserLoader: IParserLoader;

package/lib/apev2/Apev2Loader.js

@@ -0,0 +1,8 @@
+export const apeParserLoader = {
+    parserType: 'apev2',
+    extensions: ['.ape'],
+    async load(metadata, tokenizer, options) {
+        return new (await import('./APEv2Parser.js')).APEv2Parser(metadata, tokenizer, options);
+    }
+};
+//# sourceMappingURL=Apev2Loader.js.map

package/lib/asf/AsfLoader.d.ts

@@ -0,0 +1,2 @@
+import type { IParserLoader } from '../ParserFactory.js';
+export declare const asfParserLoader: IParserLoader;

package/lib/asf/AsfLoader.js

@@ -0,0 +1,8 @@
+export const asfParserLoader = {
+    parserType: 'asf',
+    extensions: ['.asf'],
+    async load(metadata, tokenizer, options) {
+        return new (await import('./AsfParser.js')).AsfParser(metadata, tokenizer, options);
+    }
+};
+//# sourceMappingURL=AsfLoader.js.map

package/lib/common/BasicParser.d.ts

@@ -1,17 +1,17 @@
 import type { ITokenizer } from 'strtok3';
 import type { ITokenParser } from '../ParserFactory.js';
-import type { IOptions, IPrivateOptions } from '../type.js';
+import type { IOptions } from '../type.js';
 import type { INativeMetadataCollector } from './MetadataCollector.js';
 export declare abstract class BasicParser implements ITokenParser {
-    protected metadata: INativeMetadataCollector;
-    protected tokenizer: ITokenizer;
-    protected options: IPrivateOptions;
+    protected readonly metadata: INativeMetadataCollector;
+    protected readonly tokenizer: ITokenizer;
+    protected readonly options: IOptions;
     /**
      * Initialize parser with output (metadata), input (tokenizer) & parsing options (options).
      * @param {INativeMetadataCollector} metadata Output
      * @param {ITokenizer} tokenizer Input
      * @param {IOptions} options Parsing options
      */
-    init(metadata: INativeMetadataCollector, tokenizer: ITokenizer, options: IOptions): ITokenParser;
+    constructor(metadata: INativeMetadataCollector, tokenizer: ITokenizer, options: IOptions);
     abstract parse(): Promise<void>;
 }

package/lib/common/BasicParser.js

@@ -1,20 +1,14 @@
 export class BasicParser {
-    constructor() {
-        this.metadata = undefined;
-        this.tokenizer = undefined;
-        this.options = undefined;
-    }
     /**
      * Initialize parser with output (metadata), input (tokenizer) & parsing options (options).
      * @param {INativeMetadataCollector} metadata Output
      * @param {ITokenizer} tokenizer Input
      * @param {IOptions} options Parsing options
      */
-    init(metadata, tokenizer, options) {
+    constructor(metadata, tokenizer, options) {
         this.metadata = metadata;
         this.tokenizer = tokenizer;
         this.options = options;
-        return this;
     }
 }
 //# sourceMappingURL=BasicParser.js.map

package/lib/common/ParserLoader.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/common/ParserLoader.js

@@ -0,0 +1 @@
+export {};

package/lib/core.d.ts

@@ -1,5 +1,5 @@
 /**
- * Primary entry point, Node.js specific entry point is index.ts
+ * Primary entry point, Node.js specific entry point is MusepackParser.ts
  */
 import { type AnyWebByteStream, type IFileInfo, type ITokenizer } from 'strtok3';
 import type { IAudioMetadata, INativeTagDict, IOptions, IPicture, IPrivateOptions, IRandomReader, ITag } from './type.js';

package/lib/core.js

@@ -1,8 +1,8 @@
 /**
- * Primary entry point, Node.js specific entry point is index.ts
+ * Primary entry point, Node.js specific entry point is MusepackParser.ts
  */
 import { fromWebStream, fromBuffer } from 'strtok3';
-import { parseOnContentType } from './ParserFactory.js';
+import { ParserFactory } from './ParserFactory.js';
 import { RandomUint8ArrayReader } from './common/RandomUint8ArrayReader.js';
 import { APEv2Parser } from './apev2/APEv2Parser.js';
 import { hasID3v1Header } from './id3v1/ID3v1Parser.js';
@@ -53,7 +53,8 @@ export async function parseBuffer(uint8Array, fileInfo, options = {}) {
  * @returns Metadata
  */
 export function parseFromTokenizer(tokenizer, options) {
-    return parseOnContentType(tokenizer, options);
+    const parserFactory = new ParserFactory();
+    return parserFactory.parse(tokenizer, undefined, options);
 }
 /**
  * Create a dictionary ordered by their tag id (key)

package/lib/dsdiff/DsdiffLoader.d.ts

@@ -0,0 +1,2 @@
+import type { IParserLoader } from '../ParserFactory.js';
+export declare const dsdiffParserLoader: IParserLoader;

package/lib/dsdiff/DsdiffLoader.js

@@ -0,0 +1,8 @@
+export const dsdiffParserLoader = {
+    parserType: 'dsdiff',
+    extensions: ['.dff'],
+    async load(metadata, tokenizer, options) {
+        return new (await import('./DsdiffParser.js')).DsdiffParser(metadata, tokenizer, options);
+    }
+};
+//# sourceMappingURL=DsdiffLoader.js.map

package/lib/dsf/DsfLoader.d.ts

@@ -0,0 +1,2 @@
+import type { IParserLoader } from '../ParserFactory.js';
+export declare const dsfParserLoader: IParserLoader;

package/lib/dsf/DsfLoader.js

@@ -0,0 +1,8 @@
+export const dsfParserLoader = {
+    parserType: 'dsf',
+    extensions: ['.dsf'],
+    async load(metadata, tokenizer, options) {
+        return new (await import('./DsfParser.js')).DsfParser(metadata, tokenizer, options);
+    }
+};
+//# sourceMappingURL=DsfLoader.js.map

package/lib/flac/FlacLoader.d.ts

@@ -0,0 +1,2 @@
+import type { IParserLoader } from '../ParserFactory.js';
+export declare const flacParserLoader: IParserLoader;

package/lib/flac/FlacLoader.js

@@ -0,0 +1,8 @@
+export const flacParserLoader = {
+    parserType: 'flac',
+    extensions: ['.flac'],
+    async load(metadata, tokenizer, options) {
+        return new (await import('./FlacParser.js')).FlacParser(metadata, tokenizer, options);
+    }
+};
+//# sourceMappingURL=FlacLoader.js.map

package/lib/flac/FlacParser.d.ts

@@ -1,18 +1,7 @@
-import type { ITokenizer } from 'strtok3';
 import { AbstractID3Parser } from '../id3v2/AbstractID3Parser.js';
-import type { INativeMetadataCollector } from '../common/MetadataCollector.js';
-import type { IOptions } from '../type.js';
-import type { ITokenParser } from '../ParserFactory.js';
 export declare class FlacParser extends AbstractID3Parser {
     private vorbisParser;
     private padding;
-    /**
-     * Initialize parser with output (metadata), input (tokenizer) & parsing options (options).
-     * @param {INativeMetadataCollector} metadata Output
-     * @param {ITokenizer} tokenizer Input
-     * @param {IOptions} options Parsing options
-     */
-    init(metadata: INativeMetadataCollector, tokenizer: ITokenizer, options: IOptions): ITokenParser;
     postId3v2Parse(): Promise<void>;
     private parseDataBlock;
     /**

package/lib/flac/FlacParser.js

@@ -27,19 +27,9 @@ var BlockType;
 export class FlacParser extends AbstractID3Parser {
     constructor() {
         super(...arguments);
+        this.vorbisParser = new VorbisParser(this.metadata, this.options);
         this.padding = 0;
     }
-    /**
-     * Initialize parser with output (metadata), input (tokenizer) & parsing options (options).
-     * @param {INativeMetadataCollector} metadata Output
-     * @param {ITokenizer} tokenizer Input
-     * @param {IOptions} options Parsing options
-     */
-    init(metadata, tokenizer, options) {
-        super.init(metadata, tokenizer, options);
-        this.vorbisParser = new VorbisParser(metadata, options);
-        return this;
-    }
     async postId3v2Parse() {
         const fourCC = await this.tokenizer.readToken(FourCcToken);
         if (fourCC.toString() !== 'fLaC') {

package/lib/id3v1/ID3v1Parser.d.ts

@@ -1,11 +1,15 @@
+import type { ITokenizer } from 'strtok3';
 import { BasicParser } from '../common/BasicParser.js';
-import type { IRandomReader } from '../type.js';
+import type { IPrivateOptions, IRandomReader } from '../type.js';
+import type { INativeMetadataCollector } from '../common/MetadataCollector.js';
 /**
  * ID3v1 Genre mappings
  * Ref: https://de.wikipedia.org/wiki/Liste_der_ID3v1-Genres
  */
 export declare const Genres: string[];
 export declare class ID3v1Parser extends BasicParser {
+    private apeHeader;
+    constructor(metadata: INativeMetadataCollector, tokenizer: ITokenizer, options: IPrivateOptions);
     private static getGenre;
     parse(): Promise<void>;
     private addTag;

package/lib/id3v1/ID3v1Parser.js

@@ -79,6 +79,10 @@ class Id3v1StringType {
     }
 }
 export class ID3v1Parser extends BasicParser {
+    constructor(metadata, tokenizer, options) {
+        super(metadata, tokenizer, options);
+        this.apeHeader = options.apeHeader;
+    }
     static getGenre(genreIndex) {
         if (genreIndex < Genres.length) {
             return Genres[genreIndex];
@@ -90,11 +94,10 @@ export class ID3v1Parser extends BasicParser {
             debug('Skip checking for ID3v1 because the file-size is unknown');
             return;
         }
-        if (this.options.apeHeader) {
-            this.tokenizer.ignore(this.options.apeHeader.offset - this.tokenizer.position);
-            const apeParser = new APEv2Parser();
-            apeParser.init(this.metadata, this.tokenizer, this.options);
-            await apeParser.parseTags(this.options.apeHeader.footer);
+        if (this.apeHeader) {
+            this.tokenizer.ignore(this.apeHeader.offset - this.tokenizer.position);
+            const apeParser = new APEv2Parser(this.metadata, this.tokenizer, this.options);
+            await apeParser.parseTags(this.apeHeader.footer);
         }
         const offset = this.tokenizer.fileInfo.size - Iid3v1Token.len;
         if (this.tokenizer.position > offset) {

package/lib/id3v2/AbstractID3Parser.js

@@ -40,8 +40,8 @@ export class AbstractID3Parser extends BasicParser {
             this.finalize();
         }
         else {
-            const id3v1parser = new ID3v1Parser();
-            await id3v1parser.init(this.metadata, this.tokenizer, this.options).parse();
+            const id3v1parser = new ID3v1Parser(this.metadata, this.tokenizer, this.options);
+            await id3v1parser.parse();
             this.finalize();
         }
     }

package/lib/index.js

@@ -4,7 +4,7 @@
 import { fromFile, fromStream } from 'strtok3';
 import initDebug from 'debug';
 import { parseFromTokenizer, scanAppendingHeaders } from './core.js';
-import { getParserIdForExtension, parse } from './ParserFactory.js';
+import { ParserFactory } from './ParserFactory.js';
 import { RandomFileReader } from './common/RandomFileReader.js';
 export * from './core.js';
 const debug = initDebug('music-metadata:parser');
@@ -35,11 +35,12 @@ export async function parseFile(filePath, options = {}) {
     finally {
         await fileReader.close();
     }
+    const parserFactory = new ParserFactory();
     try {
-        const parserName = getParserIdForExtension(filePath);
-        if (!parserName)
+        const parserLoader = parserFactory.findLoaderForExtension(filePath);
+        if (!parserLoader)
             debug(' Parser could not be determined by file extension');
-        return await parse(fileTokenizer, parserName, options);
+        return await parserFactory.parse(fileTokenizer, parserLoader, options);
     }
     finally {
         await fileTokenizer.close();

package/lib/matroska/MatroskaLoader.d.ts

@@ -0,0 +1,2 @@
+import type { IParserLoader } from '../ParserFactory.js';
+export declare const matroskaParserLoader: IParserLoader;

package/lib/matroska/MatroskaLoader.js

@@ -0,0 +1,8 @@
+export const matroskaParserLoader = {
+    parserType: 'matroska',
+    extensions: ['.mka', '.mkv', '.mk3d', '.mks', 'webm'],
+    async load(metadata, tokenizer, options) {
+        return new (await import('./MatroskaParser.js')).MatroskaParser(metadata, tokenizer, options);
+    }
+};
+//# sourceMappingURL=MatroskaLoader.js.map

package/lib/matroska/MatroskaParser.d.ts

@@ -1,8 +1,4 @@
-import type { ITokenizer } from 'strtok3';
-import type { INativeMetadataCollector } from '../common/MetadataCollector.js';
 import { BasicParser } from '../common/BasicParser.js';
-import type { IOptions } from '../type.js';
-import type { ITokenParser } from '../ParserFactory.js';
 /**
  * Extensible Binary Meta Language (EBML) parser
  * https://en.wikipedia.org/wiki/Extensible_Binary_Meta_Language
@@ -18,13 +14,6 @@ export declare class MatroskaParser extends BasicParser {
      * Significant performance impact
      */
     private flagUseIndexToSkipClusters;
-    /**
-     * Initialize parser with output (metadata), input (tokenizer) & parsing options (options).
-     * @param {INativeMetadataCollector} metadata Output
-     * @param {ITokenizer} tokenizer Input
-     * @param {IOptions} options Parsing options
-     */
-    init(metadata: INativeMetadataCollector, tokenizer: ITokenizer, options: IOptions): ITokenParser;
     parse(): Promise<void>;
     private addTag;
 }

package/lib/matroska/MatroskaParser.js

@@ -19,18 +19,7 @@ export class MatroskaParser extends BasicParser {
          * Use index to skip multiple segment/cluster elements at once.
          * Significant performance impact
          */
-        this.flagUseIndexToSkipClusters = false;
-    }
-    /**
-     * Initialize parser with output (metadata), input (tokenizer) & parsing options (options).
-     * @param {INativeMetadataCollector} metadata Output
-     * @param {ITokenizer} tokenizer Input
-     * @param {IOptions} options Parsing options
-     */
-    init(metadata, tokenizer, options) {
-        super.init(metadata, tokenizer, options);
-        this.flagUseIndexToSkipClusters = options.mkvUseIndex ?? false;
-        return this;
+        this.flagUseIndexToSkipClusters = this.options.mkvUseIndex ?? false;
     }
     async parse() {
         const containerSize = this.tokenizer.fileInfo.size ?? Number.MAX_SAFE_INTEGER;

package/lib/mp4/Atom.js

@@ -6,13 +6,13 @@ export class Atom {
     static async readAtom(tokenizer, dataHandler, parent, remaining) {
         // Parse atom header
         const offset = tokenizer.position;
-        // debug(`Reading next token on offset=${offset}...`); //  buf.toString('ascii')
+        debug(`Reading next token on offset=${offset}...`); //  buf.toString('ascii')
         const header = await tokenizer.readToken(AtomToken.Header);
-        const extended = header.length === BigInt(1);
+        const extended = header.length === 1n;
         if (extended) {
             header.length = await tokenizer.readToken(AtomToken.ExtendedSize);
         }
-        const atomBean = new Atom(header, header.length === BigInt(1), parent);
+        const atomBean = new Atom(header, extended, parent);
         const payloadLength = atomBean.getPayloadLength(remaining);
         debug(`parse atom name=${atomBean.atomPath}, extended=${atomBean.extended}, offset=${offset}, len=${atomBean.header.length}`); //  buf.toString('ascii')
         await atomBean.readData(tokenizer, dataHandler, payloadLength);
@@ -29,13 +29,13 @@ export class Atom {
         return this.extended ? 16 : 8;
     }
     getPayloadLength(remaining) {
-        return (this.header.length === BigInt(0) ? remaining : Number(this.header.length)) - this.getHeaderLength();
+        return (this.header.length === 0n ? remaining : Number(this.header.length)) - this.getHeaderLength();
     }
     async readAtoms(tokenizer, dataHandler, size) {
         while (size > 0) {
             const atomBean = await Atom.readAtom(tokenizer, dataHandler, this, size);
             this.children.push(atomBean);
-            size -= atomBean.header.length === BigInt(0) ? size : Number(atomBean.header.length);
+            size -= atomBean.header.length === 0n ? size : Number(atomBean.header.length);
         }
     }
     async readData(tokenizer, dataHandler, remaining) {

package/lib/mp4/Mp4Loader.d.ts

@@ -0,0 +1,2 @@
+import type { IParserLoader } from '../ParserFactory.js';
+export declare const mp4ParserLoader: IParserLoader;

package/lib/mp4/Mp4Loader.js

@@ -0,0 +1,8 @@
+export const mp4ParserLoader = {
+    parserType: 'mp4',
+    extensions: ['.mp4', '.m4a', '.m4b', '.m4pa', 'm4v', 'm4r', '3gp'],
+    async load(metadata, tokenizer, options) {
+        return new (await import('./MP4Parser.js')).MP4Parser(metadata, tokenizer, options);
+    }
+};
+//# sourceMappingURL=Mp4Loader.js.map

package/lib/mpeg/MpegLoader.d.ts

@@ -0,0 +1,2 @@
+import type { IParserLoader } from '../ParserFactory.js';
+export declare const mpegParserLoader: IParserLoader;

package/lib/mpeg/MpegLoader.js

@@ -0,0 +1,8 @@
+export const mpegParserLoader = {
+    parserType: 'mpeg',
+    extensions: ['.mp2', '.mp3', '.m2a', '.aac', 'aacp'],
+    async load(metadata, tokenizer, options) {
+        return new (await import('./MpegParser.js')).MpegParser(metadata, tokenizer, options);
+    }
+};
+//# sourceMappingURL=MpegLoader.js.map

package/lib/musepack/MusepackLoader.d.ts

@@ -0,0 +1,2 @@
+import type { IParserLoader } from '../ParserFactory.js';
+export declare const musepackParserLoader: IParserLoader;

package/lib/musepack/MusepackLoader.js

@@ -0,0 +1,8 @@
+export const musepackParserLoader = {
+    parserType: 'musepack',
+    extensions: ['.mpc'],
+    async load(metadata, tokenizer, options) {
+        return new (await import('./MusepackParser.js')).MusepackParser(metadata, tokenizer, options);
+    }
+};
+//# sourceMappingURL=MusepackLoader.js.map

package/lib/musepack/{index.d.ts → MusepackParser.d.ts}

@@ -1,5 +1,4 @@
 import { AbstractID3Parser } from '../id3v2/AbstractID3Parser.js';
-declare class MusepackParser extends AbstractID3Parser {
+export declare class MusepackParser extends AbstractID3Parser {
     postId3v2Parse(): Promise<void>;
 }
-export default MusepackParser;

package/lib/musepack/{index.js → MusepackParser.js}

@@ -5,28 +5,26 @@ import { MpcSv8Parser } from './sv8/MpcSv8Parser.js';
 import { MpcSv7Parser } from './sv7/MpcSv7Parser.js';
 import { MusepackContentError } from './MusepackConentError.js';
 const debug = initDebug('music-metadata:parser:musepack');
-class MusepackParser extends AbstractID3Parser {
+export class MusepackParser extends AbstractID3Parser {
     async postId3v2Parse() {
         const signature = await this.tokenizer.peekToken(new Token.StringType(3, 'latin1'));
         let mpcParser;
         switch (signature) {
             case 'MP+': {
                 debug('Stream-version 7');
-                mpcParser = new MpcSv7Parser();
+                mpcParser = new MpcSv7Parser(this.metadata, this.tokenizer, this.options);
                 break;
             }
             case 'MPC': {
                 debug('Stream-version 8');
-                mpcParser = new MpcSv8Parser();
+                mpcParser = new MpcSv8Parser(this.metadata, this.tokenizer, this.options);
                 break;
             }
             default: {
                 throw new MusepackContentError('Invalid signature prefix');
             }
         }
-        mpcParser.init(this.metadata, this.tokenizer, this.options);
         return mpcParser.parse();
     }
 }
-export default MusepackParser;
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=MusepackParser.js.map

package/lib/ogg/OggLoader.d.ts

@@ -0,0 +1,2 @@
+import type { IParserLoader } from '../ParserFactory.js';
+export declare const oggParserLoader: IParserLoader;

package/lib/ogg/OggLoader.js

@@ -0,0 +1,8 @@
+export const oggParserLoader = {
+    parserType: 'ogg',
+    extensions: ['.ogg', '.ogv', '.oga', '.ogm', '.ogx', '.opus', '.spx'],
+    async load(metadata, tokenizer, options) {
+        return new (await import('./OggParser.js')).OggParser(metadata, tokenizer, options);
+    }
+};
+//# sourceMappingURL=OggLoader.js.map

package/lib/wav/WaveLoader.d.ts

@@ -0,0 +1,2 @@
+import type { IParserLoader } from '../ParserFactory.js';
+export declare const riffParserLoader: IParserLoader;

package/lib/wav/WaveLoader.js

@@ -0,0 +1,8 @@
+export const riffParserLoader = {
+    parserType: 'riff',
+    extensions: ['.wav', 'wave', '.bwf'],
+    async load(metadata, tokenizer, options) {
+        return new (await import('./WaveParser.js')).WaveParser(metadata, tokenizer, options);
+    }
+};
+//# sourceMappingURL=WaveLoader.js.map

package/lib/wavpack/WavPackLoader.d.ts

@@ -0,0 +1,2 @@
+import type { IParserLoader } from '../ParserFactory.js';
+export declare const wavpackParserLoader: IParserLoader;

package/lib/wavpack/WavPackLoader.js

@@ -0,0 +1,8 @@
+export const wavpackParserLoader = {
+    parserType: 'wavpack',
+    extensions: ['.wv', '.wvp'],
+    async load(metadata, tokenizer, options) {
+        return new (await import('./WavPackParser.js')).WavPackParser(metadata, tokenizer, options);
+    }
+};
+//# sourceMappingURL=WavPackLoader.js.map

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": "10.3.1",
+  "version": "10.4.0",
   "author": {
     "name": "Borewit",
     "url": "https://github.com/Borewit"
@@ -108,7 +108,7 @@
     "debug": "^4.3.4",
     "file-type": "^19.4.1",
     "media-typer": "^1.1.0",
-    "strtok3": "^8.1.0",
+    "strtok3": "^9.0.0",
     "token-types": "^6.0.0",
     "uint8array-extras": "^1.4.0"
   },
@@ -120,7 +120,7 @@
     "@types/debug": "^4.1.12",
     "@types/media-typer": "^1.1.3",
     "@types/mocha": "^10.0.7",
-    "@types/node": "^22.5.1",
+    "@types/node": "^22.5.4",
     "c8": "^10.1.2",
     "chai": "^5.1.1",
     "chai-as-promised": "^8.0.0",