music-metadata 7.12.5 → 8.0.1

package/README.md

@@ -77,8 +77,9 @@ Support for encoding / format details:
 
 ## Compatibility
 
-The JavaScript in runtime is compliant with [ECMAScript 2017 (ES8)](https://en.wikipedia.org/wiki/ECMAScript#8th_Edition_-_ECMAScript_2017).
-Requires [Node.js®](https://nodejs.org/) version 6 or higher.
+Module: version 8 migrated from [CommonJS](https://en.wikipedia.org/wiki/CommonJS) to [pure ECMAScript Module (ESM)](https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c).
+JavaScript is compliant with [ECMAScript 2019 (ES10)](https://en.wikipedia.org/wiki/ECMAScript#10th_Edition_%E2%80%93_ECMAScript_2019).
+Requires Node.js ≥ 12.20 engine.
 
 ### Browser Support
 
@@ -114,15 +115,11 @@ yarn add music-metadata
 
 ### Import music-metadata
 
-Import music-metadata in JavaScript:
+Import music-metadata:
 ```JavaScript
-const mm = require('music-metadata');
-```
-
-This is how it's done in TypeScript:
-```ts
-import * as mm from 'music-metadata';
+import { parseFile } from 'music-metadata';
 ```
+Import the methods you need, like `parseFile` in this example.
 
 ### Module Functions
 
@@ -136,19 +133,19 @@ Direct file access tends to be a little faster, because it can 'jump' to various
 
 Parses the specified file (`filePath`) and returns a promise with the metadata result (`IAudioMetadata`).
 
-```
+```ts
 parseFile(filePath: string, opts: IOptions = {}): Promise<IAudioMetadata>`
 ```
 
 Example:
 ```js
-const mm = require('music-metadata');
-const util = require('util');
+import { parseFile } from 'music-metadata';
+import { inspect } from 'util';
 
 (async () => {
   try {
-    const metadata = await mm.parseFile('../music-metadata/test/samples/MusicBrainz - Beth Hart - Sinner\'s Prayer [id3v2.3].V2.mp3');
-    console.log(util.inspect(metadata, { showHidden: false, depth: null }));
+    const metadata = await parseFile('../music-metadata/test/samples/MusicBrainz - Beth Hart - Sinner\'s Prayer [id3v2.3].V2.mp3');
+    console.log(inspect(metadata, { showHidden: false, depth: null }));
   } catch (error) {
     console.error(error.message);
   }
@@ -168,11 +165,11 @@ parseStream(stream: Stream.Readable, fileInfo?: IFileInfo | string, opts?: IOpti
 
 Example:
 ```js
-const mm = require('music-metadata');
+import { parseStream } from 'music-metadata';
 
 (async () => {
   try {
-    const metadata = await mm.parseStream(someReadStream, {mimeType: 'audio/mpeg', size: 26838});
+    const metadata = await parseStream(someReadStream, {mimeType: 'audio/mpeg', size: 26838});
     console.log(metadata);
   } catch (error) {
     console.error(error.message);
@@ -190,9 +187,11 @@ parseBuffer(buffer: Buffer, fileInfo?: IFileInfo | string, opts?: IOptions = {})
 
 Example:
 ```js
+import { parseBuffer } from 'music-metadata';
+
 (async () => {
   try {
-    const metadata = mm.parseBuffer(someBuffer, 'audio/mpeg');
+    const metadata = parseBuffer(someBuffer, 'audio/mpeg');
     console.log(metadata);
   } catch (error) {
     console.error(error.message);
@@ -215,6 +214,21 @@ Utility to Converts the native tags to a dictionary index on the tag identifier
 orderTags(nativeTags: ITag[]): [tagId: string]: any[]
 ```
 
+```js
+import { parseFile, orderTags } from 'music-metadata';
+import { inspect } from 'util';
+
+(async () => {
+  try {
+    const metadata = await parseFile('../test/samples/MusicBrainz - Beth Hart - Sinner\'s Prayer [id3v2.3].V2.mp3');
+    const orderedTags = orderTags(metadata.native['ID3v2.3']);
+    console.log(inspect(orderedTags, { showHidden: false, depth: null }));
+  } catch (error) {
+    console.error(error.message);
+  }
+})();
+```
+
 #### ratingToStars function
    
    Can be used to convert the normalized rating value to the 0..5 stars, where 0 an undefined rating, 1 the star the lowest rating and 5 the highest rating.
@@ -231,11 +245,11 @@ export function selectCover(pictures?: IPicture[]): IPicture | null
 ```
 
 ```js
-import * as mm from 'music-metadata';
+import { parseFile, selectCover } from 'music-metadata';
 
 (async () => {
-  const {common} = await mm.parseFile(filePath);
-  const cover = mm.selectCover(common.picture); // pick the cover image
+  const {common} = await parseFile(filePath);
+  const cover = selectCover(common.picture); // pick the cover image
 }
 )();
  ```
@@ -327,11 +341,15 @@ Audio format information. Defined in the TypeScript `IFormat` interface:
 
 In order to read the duration of a stream (with the exception of file streams), in some cases you should pass the size of the file in bytes.
 ```js
-mm.parseStream(someReadStream, {mimeType: 'audio/mpeg', size: 26838}, {duration: true})
-  .then( function (metadata) {
-     console.log(util.inspect(metadata, {showHidden: false, depth: null}));
-     someReadStream.close();
-   });
+import { parseStream } from 'music-metadata';
+import { inspect } from 'util';
+
+(async () => {
+    const metadata = await parseStream(someReadStream, {mimeType: 'audio/mpeg', size: 26838}, {duration: true});
+    console.log(inspect(metadata, {showHidden: false, depth: null}));
+    someReadStream.close();
+  }
+)();
 ```
 
 ### Access cover art
@@ -379,20 +397,18 @@ img.src = `data:${picture.format};base64,${picture.data.toString('base64')}`;
     1.  Using recursion
 
         ```js
-        const mm = require('music-metadata')
+        import { parseFile } from 'music-metadata';
         
         function parseFiles(audioFiles) {
           
           const audioFile = audioFiles.shift();
           
           if (audioFile) {
-            return mm.parseFile(audioFile).then(metadata => {
+            return parseFile(audioFile).then(metadata => {
               // Do great things with the metadata
               return parseFiles(audioFiles); // process rest of the files AFTER we are finished
             })
           }
-          
-          return Promise.resolve();
         }
         
         ```
@@ -402,7 +418,7 @@ img.src = `data:${picture.format};base64,${picture.data.toString('base64')}`;
         Use [async/await](https://javascript.info/async-await)
         
         ```js
-        const mm = require('music-metadata');
+        import { parseFile } from 'music-metadata';
         
         // it is required to declare the function 'async' to allow the use of await
         async function parseFiles(audioFiles) {
@@ -410,7 +426,7 @@ img.src = `data:${picture.format};base64,${picture.data.toString('base64')}`;
             for (const audioFile of audioFiles) {
             
                 // await will ensure the metadata parsing is completed before we move on to the next file
-                const metadata = await mm.parseFile(audioFile);
+                const metadata = await parseFile(audioFile);
                 // Do great things with the metadata
             }
         }

package/lib/ParserFactory.d.ts

@@ -1,6 +1,6 @@
-import { IOptions, IAudioMetadata, ParserType } from './type';
-import { ITokenizer } from 'strtok3/lib/core';
-import { INativeMetadataCollector } from './common/MetadataCollector';
+import { INativeMetadataCollector } from './common/MetadataCollector.js';
+import { IOptions, IAudioMetadata, ParserType } from './type.js';
+import { ITokenizer } from 'strtok3/core';
 export interface ITokenParser {
     /**
      * Initialize parser with output (metadata), input (tokenizer) & parsing options (options).

package/lib/ParserFactory.js

@@ -1,26 +1,24 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ParserFactory = exports.parseHttpContentType = void 0;
-const FileType = require("file-type/core");
-const ContentType = require("content-type");
-const MimeType = require("media-typer");
-const debug_1 = require("debug");
-const MetadataCollector_1 = require("./common/MetadataCollector");
-const AiffParser_1 = require("./aiff/AiffParser");
-const APEv2Parser_1 = require("./apev2/APEv2Parser");
-const AsfParser_1 = require("./asf/AsfParser");
-const FlacParser_1 = require("./flac/FlacParser");
-const MP4Parser_1 = require("./mp4/MP4Parser");
-const MpegParser_1 = require("./mpeg/MpegParser");
-const musepack_1 = require("./musepack");
-const OggParser_1 = require("./ogg/OggParser");
-const WaveParser_1 = require("./wav/WaveParser");
-const WavPackParser_1 = require("./wavpack/WavPackParser");
-const DsfParser_1 = require("./dsf/DsfParser");
-const DsdiffParser_1 = require("./dsdiff/DsdiffParser");
-const MatroskaParser_1 = require("./matroska/MatroskaParser");
-const debug = (0, debug_1.default)('music-metadata:parser:factory');
-function parseHttpContentType(contentType) {
+import { fileTypeFromBuffer } from 'file-type';
+import ContentType from 'content-type';
+import MimeType from 'media-typer';
+import initDebug from 'debug';
+import { Buffer } from 'node:buffer';
+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';
+const debug = initDebug('music-metadata:parser:factory');
+export function parseHttpContentType(contentType) {
     const type = ContentType.parse(contentType);
     const mime = MimeType.parse(type.type);
     return {
@@ -30,15 +28,14 @@ function parseHttpContentType(contentType) {
         parameters: type.parameters
     };
 }
-exports.parseHttpContentType = parseHttpContentType;
 async function parse(tokenizer, parserId, opts = {}) {
     // Parser found, execute parser
     const parser = await ParserFactory.loadParser(parserId);
-    const metadata = new MetadataCollector_1.MetadataCollector(opts);
+    const metadata = new MetadataCollector(opts);
     await parser.init(metadata, tokenizer, opts).parse();
     return metadata.toCommonMetadata();
 }
-class ParserFactory {
+export class ParserFactory {
     /**
      * Parse metadata from tokenizer
      * @param tokenizer - Tokenizer
@@ -64,7 +61,7 @@ class ParserFactory {
                 parserId = this.getParserIdForExtension(tokenizer.fileInfo.path);
             }
             if (!parserId) {
-                const guessedType = await FileType.fromBuffer(buf);
+                const guessedType = await fileTypeFromBuffer(buf);
                 if (!guessedType) {
                     throw new Error('Failed to determine audio format');
                 }
@@ -142,21 +139,21 @@ class ParserFactory {
     }
     static async loadParser(moduleName) {
         switch (moduleName) {
-            case 'aiff': return new AiffParser_1.AIFFParser();
+            case 'aiff': return new AIFFParser();
             case 'adts':
             case 'mpeg':
-                return new MpegParser_1.MpegParser();
-            case 'apev2': return new APEv2Parser_1.APEv2Parser();
-            case 'asf': return new AsfParser_1.AsfParser();
-            case 'dsf': return new DsfParser_1.DsfParser();
-            case 'dsdiff': return new DsdiffParser_1.DsdiffParser();
-            case 'flac': return new FlacParser_1.FlacParser();
-            case 'mp4': return new MP4Parser_1.MP4Parser();
-            case 'musepack': return new musepack_1.default();
-            case 'ogg': return new OggParser_1.OggParser();
-            case 'riff': return new WaveParser_1.WaveParser();
-            case 'wavpack': return new WavPackParser_1.WavPackParser();
-            case 'matroska': return new MatroskaParser_1.MatroskaParser();
+                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}`);
         }
@@ -249,4 +246,3 @@ class ParserFactory {
         }
     }
 }
-exports.ParserFactory = ParserFactory;

package/lib/aiff/AiffParser.d.ts

@@ -1,5 +1,5 @@
-import { BasicParser } from '../common/BasicParser';
-import * as iff from '../iff';
+import { BasicParser } from '../common/BasicParser.js';
+import * as iff from '../iff/index.js';
 /**
  * AIFF - Audio Interchange File Format
  *

package/lib/aiff/AiffParser.js

@@ -1,15 +1,23 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AIFFParser = void 0;
-const Token = require("token-types");
-const debug_1 = require("debug");
-const strtok3 = require("strtok3/lib/core");
-const ID3v2Parser_1 = require("../id3v2/ID3v2Parser");
-const FourCC_1 = require("../common/FourCC");
-const BasicParser_1 = require("../common/BasicParser");
-const AiffToken = require("./AiffToken");
-const iff = require("../iff");
-const debug = (0, debug_1.default)('music-metadata:parser:aiff');
+import * as Token from 'token-types';
+import initDebug from 'debug';
+import * as strtok3 from 'strtok3/core';
+import { ID3v2Parser } from '../id3v2/ID3v2Parser.js';
+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';
+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
  *
@@ -17,12 +25,12 @@ const debug = (0, debug_1.default)('music-metadata:parser:aiff');
  * - http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/AIFF/AIFF.html
  * - http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/AIFF/Docs/AIFF-1.3.pdf
  */
-class AIFFParser extends BasicParser_1.BasicParser {
+export class AIFFParser extends BasicParser {
     async parse() {
         const header = await this.tokenizer.readToken(iff.Header);
         if (header.chunkID !== 'FORM')
             throw new Error('Invalid Chunk-ID, expected \'FORM\''); // Not AIFF format
-        const type = await this.tokenizer.readToken(FourCC_1.FourCcToken);
+        const type = await this.tokenizer.readToken(FourCcToken);
         switch (type) {
             case 'AIFF':
                 this.metadata.setFormat('container', type);
@@ -56,6 +64,7 @@ class AIFFParser extends BasicParser_1.BasicParser {
         }
     }
     async readData(header) {
+        var _a;
         switch (header.chunkID) {
             case 'COMM': // The Common Chunk
                 const common = await this.tokenizer.readToken(new AiffToken.Common(header, this.isCompressed));
@@ -64,12 +73,12 @@ class AIFFParser extends BasicParser_1.BasicParser {
                 this.metadata.setFormat('numberOfChannels', common.numChannels);
                 this.metadata.setFormat('numberOfSamples', common.numSampleFrames);
                 this.metadata.setFormat('duration', common.numSampleFrames / common.sampleRate);
-                this.metadata.setFormat('codec', common.compressionName);
+                this.metadata.setFormat('codec', (_a = common.compressionName) !== null && _a !== void 0 ? _a : compressionTypes[common.compressionType]);
                 return header.chunkSize;
             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_1.ID3v2Parser().parse(this.metadata, rst, this.options);
+                await new ID3v2Parser().parse(this.metadata, rst, this.options);
                 return header.chunkSize;
             case 'SSND': // Sound Data Chunk
                 if (this.metadata.format.duration) {
@@ -81,4 +90,3 @@ class AIFFParser extends BasicParser_1.BasicParser {
         }
     }
 }
-exports.AIFFParser = AIFFParser;

package/lib/aiff/AiffToken.d.ts

@@ -1,6 +1,7 @@
-/// <reference types="node" />
+/// <reference types="node" resolution-mode="require"/>
+import { Buffer } from 'node:buffer';
+import * as iff from '../iff/index.js';
 import { IGetToken } from 'strtok3';
-import * as iff from '../iff';
 /**
  * The Common Chunk.
  * Describes fundamental parameters of the waveform data such as sample rate, bit resolution, and how many channels of

package/lib/aiff/AiffToken.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Common = void 0;
-const Token = require("token-types");
-const FourCC_1 = require("../common/FourCC");
-class Common {
+import * as Token from 'token-types';
+import { FourCcToken } from '../common/FourCC.js';
+export class Common {
     constructor(header, isAifc) {
         this.isAifc = isAifc;
         const minimumChunkSize = isAifc ? 22 : 18;
@@ -22,15 +19,20 @@ class Common {
             sampleRate: shift < 0 ? baseSampleRate >> Math.abs(shift) : baseSampleRate << shift
         };
         if (this.isAifc) {
-            res.compressionType = FourCC_1.FourCcToken.get(buf, off + 18);
+            res.compressionType = FourCcToken.get(buf, off + 18);
             if (this.len > 22) {
                 const strLen = buf.readInt8(off + 22);
-                const padding = (strLen + 1) % 2;
-                if (23 + strLen + padding === this.len) {
-                    res.compressionName = new Token.StringType(strLen, 'binary').get(buf, off + 23);
+                if (strLen > 0) {
+                    const padding = (strLen + 1) % 2;
+                    if (23 + strLen + padding === this.len) {
+                        res.compressionName = new Token.StringType(strLen, 'binary').get(buf, off + 23);
+                    }
+                    else {
+                        throw new Error('Illegal pstring length');
+                    }
                 }
                 else {
-                    throw new Error('Illegal pstring length');
+                    res.compressionName = undefined;
                 }
             }
         }
@@ -40,4 +42,3 @@ class Common {
         return res;
     }
 }
-exports.Common = Common;

package/lib/apev2/APEv2Parser.d.ts

@@ -1,8 +1,8 @@
-import * as strtok3 from 'strtok3/lib/core';
-import { IOptions, IRandomReader, IApeHeader } from '../type';
-import { INativeMetadataCollector } from '../common/MetadataCollector';
-import { BasicParser } from '../common/BasicParser';
-import { IFooter, IHeader } from './APEv2Token';
+import * as strtok3 from 'strtok3/core';
+import { IOptions, IRandomReader, IApeHeader } from '../type.js';
+import { INativeMetadataCollector } from '../common/MetadataCollector.js';
+import { BasicParser } from '../common/BasicParser.js';
+import { IFooter, IHeader } from './APEv2Token.js';
 export declare class APEv2Parser extends BasicParser {
     static tryParseApeHeader(metadata: INativeMetadataCollector, tokenizer: strtok3.ITokenizer, options: IOptions): Promise<void>;
     /**

package/lib/apev2/APEv2Parser.js

@@ -1,16 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.APEv2Parser = void 0;
-const debug_1 = require("debug");
-const strtok3 = require("strtok3/lib/core");
-const token_types_1 = require("token-types");
-const util = require("../common/Util");
-const BasicParser_1 = require("../common/BasicParser");
-const APEv2Token_1 = require("./APEv2Token");
-const debug = (0, debug_1.default)('music-metadata:parser:APEv2');
+import initDebug from 'debug';
+import * as strtok3 from 'strtok3/core';
+import { StringType } from 'token-types';
+import { Buffer } from 'node:buffer';
+import * as util from '../common/Util.js';
+import { BasicParser } from '../common/BasicParser.js';
+import { DataType, DescriptorParser, Header, TagFooter, TagItemHeader } from './APEv2Token.js';
+const debug = initDebug('music-metadata:parser:APEv2');
 const tagFormat = 'APEv2';
 const preamble = 'APETAGEX';
-class APEv2Parser extends BasicParser_1.BasicParser {
+export class APEv2Parser extends BasicParser {
     constructor() {
         super(...arguments);
         this.ape = {};
@@ -37,16 +35,16 @@ class APEv2Parser extends BasicParser_1.BasicParser {
      */
     static async findApeFooterOffset(reader, offset) {
         // Search for APE footer header at the end of the file
-        const apeBuf = Buffer.alloc(APEv2Token_1.TagFooter.len);
-        await reader.randomRead(apeBuf, 0, APEv2Token_1.TagFooter.len, offset - APEv2Token_1.TagFooter.len);
-        const tagFooter = APEv2Token_1.TagFooter.get(apeBuf, 0);
+        const apeBuf = Buffer.alloc(TagFooter.len);
+        await reader.randomRead(apeBuf, 0, TagFooter.len, offset - TagFooter.len);
+        const tagFooter = TagFooter.get(apeBuf, 0);
         if (tagFooter.ID === 'APETAGEX') {
             debug(`APE footer header at offset=${offset}`);
             return { footer: tagFooter, offset: offset - tagFooter.size };
         }
     }
     static parseTagFooter(metadata, buffer, options) {
-        const footer = APEv2Token_1.TagFooter.get(buffer, buffer.length - APEv2Token_1.TagFooter.len);
+        const footer = TagFooter.get(buffer, buffer.length - TagFooter.len);
         if (footer.ID !== preamble)
             throw new Error('Unexpected APEv2 Footer ID preamble value.');
         strtok3.fromBuffer(buffer);
@@ -58,13 +56,13 @@ class APEv2Parser extends BasicParser_1.BasicParser {
      * Parse APEv1 / APEv2 header if header signature found
      */
     async tryParseApeHeader() {
-        if (this.tokenizer.fileInfo.size && this.tokenizer.fileInfo.size - this.tokenizer.position < APEv2Token_1.TagFooter.len) {
+        if (this.tokenizer.fileInfo.size && this.tokenizer.fileInfo.size - this.tokenizer.position < TagFooter.len) {
             debug(`No APEv2 header found, end-of-file reached`);
             return;
         }
-        const footer = await this.tokenizer.peekToken(APEv2Token_1.TagFooter);
+        const footer = await this.tokenizer.peekToken(TagFooter);
         if (footer.ID === preamble) {
-            await this.tokenizer.ignore(APEv2Token_1.TagFooter.len);
+            await this.tokenizer.ignore(TagFooter.len);
             return this.parseTags(footer);
         }
         else {
@@ -79,42 +77,42 @@ class APEv2Parser extends BasicParser_1.BasicParser {
         }
     }
     async parse() {
-        const descriptor = await this.tokenizer.readToken(APEv2Token_1.DescriptorParser);
+        const descriptor = await this.tokenizer.readToken(DescriptorParser);
         if (descriptor.ID !== 'MAC ')
             throw new Error('Unexpected descriptor ID');
         this.ape.descriptor = descriptor;
-        const lenExp = descriptor.descriptorBytes - APEv2Token_1.DescriptorParser.len;
+        const lenExp = descriptor.descriptorBytes - DescriptorParser.len;
         const header = await (lenExp > 0 ? this.parseDescriptorExpansion(lenExp) : this.parseHeader());
         await this.tokenizer.ignore(header.forwardBytes);
         return this.tryParseApeHeader();
     }
     async parseTags(footer) {
         const keyBuffer = Buffer.alloc(256); // maximum tag key length
-        let bytesRemaining = footer.size - APEv2Token_1.TagFooter.len;
+        let bytesRemaining = footer.size - TagFooter.len;
         debug(`Parse APE tags at offset=${this.tokenizer.position}, size=${bytesRemaining}`);
         for (let i = 0; i < footer.fields; i++) {
-            if (bytesRemaining < APEv2Token_1.TagItemHeader.len) {
+            if (bytesRemaining < TagItemHeader.len) {
                 this.metadata.addWarning(`APEv2 Tag-header: ${footer.fields - i} items remaining, but no more tag data to read.`);
                 break;
             }
             // Only APEv2 tag has tag item headers
-            const tagItemHeader = await this.tokenizer.readToken(APEv2Token_1.TagItemHeader);
-            bytesRemaining -= APEv2Token_1.TagItemHeader.len + tagItemHeader.size;
+            const tagItemHeader = await this.tokenizer.readToken(TagItemHeader);
+            bytesRemaining -= TagItemHeader.len + tagItemHeader.size;
             await this.tokenizer.peekBuffer(keyBuffer, { length: Math.min(keyBuffer.length, bytesRemaining) });
             let zero = util.findZero(keyBuffer, 0, keyBuffer.length);
-            const key = await this.tokenizer.readToken(new token_types_1.StringType(zero, 'ascii'));
+            const key = await this.tokenizer.readToken(new StringType(zero, 'ascii'));
             await this.tokenizer.ignore(1);
             bytesRemaining -= key.length + 1;
             switch (tagItemHeader.flags.dataType) {
-                case APEv2Token_1.DataType.text_utf8: { // utf-8 text-string
-                    const value = await this.tokenizer.readToken(new token_types_1.StringType(tagItemHeader.size, 'utf8'));
+                case DataType.text_utf8: { // utf-8 text-string
+                    const value = await this.tokenizer.readToken(new StringType(tagItemHeader.size, 'utf8'));
                     const values = value.split(/\x00/g);
                     for (const val of values) {
                         this.metadata.addTag(tagFormat, key, val);
                     }
                     break;
                 }
-                case APEv2Token_1.DataType.binary: // binary (probably artwork)
+                case DataType.binary: // binary (probably artwork)
                     if (this.options.skipCovers) {
                         await this.tokenizer.ignore(tagItemHeader.size);
                     }
@@ -130,11 +128,11 @@ class APEv2Parser extends BasicParser_1.BasicParser {
                         });
                     }
                     break;
-                case APEv2Token_1.DataType.external_info:
+                case DataType.external_info:
                     debug(`Ignore external info ${key}`);
                     await this.tokenizer.ignore(tagItemHeader.size);
                     break;
-                case APEv2Token_1.DataType.reserved:
+                case DataType.reserved:
                     debug(`Ignore external info ${key}`);
                     this.metadata.addWarning(`APEv2 header declares a reserved datatype for "${key}"`);
                     await this.tokenizer.ignore(tagItemHeader.size);
@@ -147,7 +145,7 @@ class APEv2Parser extends BasicParser_1.BasicParser {
         return this.parseHeader();
     }
     async parseHeader() {
-        const header = await this.tokenizer.readToken(APEv2Token_1.Header);
+        const header = await this.tokenizer.readToken(Header);
         // ToDo before
         this.metadata.setFormat('lossless', true);
         this.metadata.setFormat('container', 'Monkey\'s Audio');
@@ -161,4 +159,3 @@ class APEv2Parser extends BasicParser_1.BasicParser {
         };
     }
 }
-exports.APEv2Parser = APEv2Parser;

package/lib/apev2/APEv2TagMapper.d.ts

@@ -1,4 +1,4 @@
-import { CaseInsensitiveTagMap } from '../common/CaseInsensitiveTagMap';
+import { CaseInsensitiveTagMap } from '../common/CaseInsensitiveTagMap.js';
 export declare class APEv2TagMapper extends CaseInsensitiveTagMap {
     constructor();
 }

package/lib/apev2/APEv2TagMapper.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.APEv2TagMapper = void 0;
-const CaseInsensitiveTagMap_1 = require("../common/CaseInsensitiveTagMap");
+import { CaseInsensitiveTagMap } from '../common/CaseInsensitiveTagMap.js';
 /**
  * ID3v2.2 tag mappings
  */
@@ -78,10 +75,9 @@ const apev2TagMap = {
     MP3GAIN_MINMAX: 'replaygain_track_minmax',
     MP3GAIN_UNDO: 'replaygain_undo'
 };
-class APEv2TagMapper extends CaseInsensitiveTagMap_1.CaseInsensitiveTagMap {
+export class APEv2TagMapper extends CaseInsensitiveTagMap {
     constructor() {
         super(['APEv2'], apev2TagMap);
     }
 }
-exports.APEv2TagMapper = APEv2TagMapper;
 //# sourceMappingURL=APEv2TagMapper.js.map

package/lib/apev2/APEv2Token.d.ts

@@ -1,5 +1,5 @@
 import * as Token from 'token-types';
-import { IGetToken } from 'strtok3/lib/core';
+import { IGetToken } from 'strtok3/core';
 /**
  * APETag versionIndex history / supported formats
  *