music-metadata 11.2.3 → 11.4.0

package/lib/ParserFactory.js

@@ -71,7 +71,7 @@ export class ParserFactory {
                 // 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);
+                const guessedType = await fileTypeFromBuffer(buf, { mpegOffsetTolerance: 10 });
                 if (!guessedType || !guessedType.mime) {
                     throw new CouldNotDetermineFileTypeError('Failed to determine audio format');
                 }
@@ -108,7 +108,7 @@ export class ParserFactory {
         try {
             mime = parseHttpContentType(httpContentType);
         }
-        catch (err) {
+        catch (_err) {
             debug(`Invalid HTTP Content-Type header value: ${httpContentType}`);
             return;
         }

package/lib/apev2/APEv2Parser.d.ts

@@ -18,8 +18,8 @@ declare const ApeContentError_base: {
 };
 export declare class ApeContentError extends ApeContentError_base {
 }
+export declare function tryParseApeHeader(metadata: INativeMetadataCollector, tokenizer: strtok3.ITokenizer, options: IOptions): Promise<void>;
 export declare class APEv2Parser extends BasicParser {
-    static tryParseApeHeader(metadata: INativeMetadataCollector, tokenizer: strtok3.ITokenizer, options: IOptions): Promise<void>;
     /**
      * Calculate the media file duration
      * @param ah ApeHeader

package/lib/apev2/APEv2Parser.js

@@ -11,15 +11,15 @@ const tagFormat = 'APEv2';
 const preamble = 'APETAGEX';
 export class ApeContentError extends makeUnexpectedFileContentError('APEv2') {
 }
+export function tryParseApeHeader(metadata, tokenizer, options) {
+    const apeParser = new APEv2Parser(metadata, tokenizer, options);
+    return apeParser.tryParseApeHeader();
+}
 export class APEv2Parser extends BasicParser {
     constructor() {
         super(...arguments);
         this.ape = {};
     }
-    static tryParseApeHeader(metadata, tokenizer, options) {
-        const apeParser = new APEv2Parser(metadata, tokenizer, options);
-        return apeParser.tryParseApeHeader();
-    }
     /**
      * Calculate the media file duration
      * @param ah ApeHeader

package/lib/asf/AsfObject.d.ts

@@ -82,7 +82,7 @@ export declare abstract class State<T> implements IGetToken<T> {
     protected postProcessTag(tags: ITag[], name: string, valueType: number, data: AnyTagValue): void;
 }
 export declare class IgnoreObjectState extends State<unknown> {
-    get(buf: Uint8Array, off: number): null;
+    get(_buf: Uint8Array, _off: number): null;
 }
 /**
  * Interface for: 3.2: File Properties Object (mandatory, one only)

package/lib/asf/AsfObject.js

@@ -83,7 +83,7 @@ export class State {
 }
 // ToDo: use ignore type
 export class IgnoreObjectState extends State {
-    get(buf, off) {
+    get(_buf, _off) {
         return null;
     }
 }

package/lib/common/GenericTagMapper.d.ts

@@ -47,5 +47,5 @@ export declare class CommonTagMapper implements IGenericTagMapper {
      * @param tag Tag e.g. {"©alb", "Buena Vista Social Club")
      * @param warnings Used to register warnings
      */
-    protected postMap(tag: ITag, warnings: IWarningCollector): void;
+    protected postMap(_tag: ITag, _warnings: IWarningCollector): void;
 }

package/lib/common/GenericTagMapper.js

@@ -44,7 +44,7 @@ export class CommonTagMapper {
      * @param tag Tag e.g. {"©alb", "Buena Vista Social Club")
      * @param warnings Used to register warnings
      */
-    postMap(tag, warnings) {
+    postMap(_tag, _warnings) {
         return;
     }
 }

package/lib/core.d.ts

@@ -63,12 +63,12 @@ export declare function scanAppendingHeaders(tokenizer: IRandomAccessTokenizer,
  * Implementation only available when loaded as Node.js
  * This method will throw an Error, always.
  */
-export declare function parseFile(filePath: string, options?: IOptions): Promise<IAudioMetadata>;
+export declare function parseFile(_filePath: string, _options?: IOptions): Promise<IAudioMetadata>;
 /**
  * Implementation only available when loaded as Node.js
  * This method will throw an Error, always.
  */
-export declare function parseStream(stream: Readable, fileInfo?: IFileInfo | string, options?: IOptions): Promise<IAudioMetadata>;
+export declare function parseStream(_stream: Readable, _fileInfo?: IFileInfo | string, _options?: IOptions): Promise<IAudioMetadata>;
 /**
  * Return a list of supported mime-types
  */

package/lib/core.js

@@ -109,14 +109,14 @@ export async function scanAppendingHeaders(tokenizer, options = {}) {
  * Implementation only available when loaded as Node.js
  * This method will throw an Error, always.
  */
-export async function parseFile(filePath, options = {}) {
+export async function parseFile(_filePath, _options = {}) {
     throw new Error('This function require a Node engine. To load Web API File objects use parseBlob instead.');
 }
 /**
  * Implementation only available when loaded as Node.js
  * This method will throw an Error, always.
  */
-export async function parseStream(stream, fileInfo, options = {}) {
+export async function parseStream(_stream, _fileInfo, _options = {}) {
     throw new Error('This function require a Node engine.');
 }
 /**

package/lib/ebml/EbmlIterator.js

@@ -194,7 +194,7 @@ function readUIntBeAsBigInt(buf, len) {
         normalizedNumber.set(cleanNumber, 8 - len);
         return Token.UINT64_BE.get(normalizedNumber, 0);
     }
-    catch (error) {
+    catch (_error) {
         return BigInt(-1);
     }
 }

package/lib/lrc/LyricsParser.js

@@ -7,16 +7,25 @@ import { LyricsContentType, TimestampFormat } from '../type.js';
 export function parseLrc(lrcString) {
     const lines = lrcString.split('\n');
     const syncText = [];
-    // Regular expression to match LRC timestamps (e.g., [00:45.52])
-    const timestampRegex = /\[(\d{2}):(\d{2})\.(\d{2})\]/;
+    // Regular expression to match LRC timestamps (e.g., [00:45.52] or [00:45.520])
+    const timestampRegex = /\[(\d{2}):(\d{2})\.(\d{2,3})\]/;
     for (const line of lines) {
         const match = line.match(timestampRegex);
         if (match) {
             const minutes = Number.parseInt(match[1], 10);
             const seconds = Number.parseInt(match[2], 10);
-            const hundredths = Number.parseInt(match[3], 10);
+            const millisecondsStr = match[3];
+            let milliseconds;
+            if (millisecondsStr.length === 3) {
+                //  (e.g., .521 = 521 millseconds)
+                milliseconds = Number.parseInt(millisecondsStr, 10);
+            }
+            else {
+                //  (e.g., .52 = 520 millseconds)
+                milliseconds = Number.parseInt(millisecondsStr, 10) * 10;
+            }
             // Convert the timestamp to milliseconds, as per TimestampFormat.milliseconds
-            const timestamp = (minutes * 60 + seconds) * 1000 + hundredths * 10;
+            const timestamp = (minutes * 60 + seconds) * 1000 + milliseconds;
             // Get the text portion of the line (e.g., "あの蝶は自由になれたかな")
             const text = line.replace(timestampRegex, '').trim();
             syncText.push({ timestamp, text });

package/lib/mp4/Atom.js

@@ -50,6 +50,7 @@ export class Atom {
             case '<id>':
             case 'ilst':
             case 'tref':
+            case 'moof':
                 return this.readAtoms(tokenizer, dataHandler, this.getPayloadLength(remaining));
             case 'meta': { // Metadata Atom, ref: https://developer.apple.com/library/content/documentation/QuickTime/QTFF/Metadata/Metadata.html#//apple_ref/doc/uid/TP40000939-CH1-SW8
                 // meta has 4 bytes of padding, ignore

package/lib/mp4/AtomToken.d.ts

@@ -402,4 +402,64 @@ export declare class ChapterText implements IGetToken<string> {
     constructor(len: number);
     get(buf: Uint8Array, off: number): string;
 }
+interface ITrackFragmentHeaderBoxFlags {
+    baseDataOffsetPresent: boolean;
+    sampleDescriptionIndexPresent: boolean;
+    defaultSampleDurationPresent: boolean;
+    defaultSampleSizePresent: boolean;
+    defaultSampleFlagsPresent: boolean;
+    defaultDurationIsEmpty: boolean;
+    defaultBaseIsMoof: boolean;
+}
+export interface ITrackFragmentHeaderBox {
+    version: number;
+    flags: ITrackFragmentHeaderBoxFlags;
+    trackId: number;
+    baseDataOffset?: bigint;
+    sampleDescriptionIndex?: number;
+    defaultSampleDuration?: number;
+    defaultSampleSize?: number;
+    defaultSampleFlags?: number;
+}
+/**
+ * Sample-size ('tfhd') TrackFragmentHeaderBox
+ */
+export declare class TrackFragmentHeaderBox implements IGetToken<ITrackFragmentHeaderBox> {
+    len: number;
+    constructor(len: number);
+    get(buf: Uint8Array, off: number): ITrackFragmentHeaderBox;
+}
+interface ITrackRunBoxFlags {
+    dataOffsetPresent: boolean;
+    firstSampleFlagsPresent: boolean;
+    sampleDurationPresent: boolean;
+    sampleSizePresent: boolean;
+    sampleFlagsPresent: boolean;
+    sampleCompositionTimeOffsetsPresent: boolean;
+}
+/**
+ * trun atom
+ */
+export interface ITrackRunBox {
+    version: number;
+    flags: ITrackRunBoxFlags;
+    samples: ITrackRunBoxSample[];
+    sampleCount: number;
+    dataOffset?: number;
+    firstSampleFlags?: number;
+}
+interface ITrackRunBoxSample {
+    sampleDuration?: number;
+    sampleSize?: number;
+    sampleFlags?: number;
+    sampleCompositionTimeOffset?: number;
+}
+/**
+ * Sample-size ('trun') TrackRunBox
+ */
+export declare class TrackRunBox implements IGetToken<ITrackRunBox> {
+    len: number;
+    constructor(len: number);
+    get(buf: Uint8Array, off: number): ITrackRunBox;
+}
 export {};

package/lib/mp4/AtomToken.js

@@ -2,6 +2,7 @@ import * as Token from 'token-types';
 import initDebug from 'debug';
 import { FourCcToken } from '../common/FourCC.js';
 import { makeUnexpectedFileContentError } from '../ParseError.js';
+import * as util from '../common/Util.js';
 const debug = initDebug('music-metadata:parser:MP4:atom');
 export class Mp4ContentError extends makeUnexpectedFileContentError('MP4') {
 }
@@ -390,4 +391,107 @@ function readTokenTable(buf, token, off, remainingLen, numberOfEntries) {
     }
     return entries;
 }
+/**
+ * Sample-size ('tfhd') TrackFragmentHeaderBox
+ */
+export class TrackFragmentHeaderBox {
+    constructor(len) {
+        this.len = len;
+    }
+    get(buf, off) {
+        const flagOffset = off + 1;
+        const header = {
+            version: Token.INT8.get(buf, off),
+            flags: {
+                baseDataOffsetPresent: util.getBit(buf, flagOffset + 2, 0),
+                sampleDescriptionIndexPresent: util.getBit(buf, flagOffset + 2, 1),
+                defaultSampleDurationPresent: util.getBit(buf, flagOffset + 2, 3),
+                defaultSampleSizePresent: util.getBit(buf, flagOffset + 2, 4),
+                defaultSampleFlagsPresent: util.getBit(buf, flagOffset + 2, 5),
+                defaultDurationIsEmpty: util.getBit(buf, flagOffset, 0),
+                defaultBaseIsMoof: util.getBit(buf, flagOffset, 1)
+            },
+            trackId: Token.UINT32_BE.get(buf, 4)
+        };
+        let dynOffset = 8;
+        if (header.flags.baseDataOffsetPresent) {
+            header.baseDataOffset = Token.UINT64_BE.get(buf, dynOffset);
+            dynOffset += 8;
+        }
+        if (header.flags.sampleDescriptionIndexPresent) {
+            header.sampleDescriptionIndex = Token.UINT32_BE.get(buf, dynOffset);
+            dynOffset += 4;
+        }
+        if (header.flags.defaultSampleDurationPresent) {
+            header.defaultSampleDuration = Token.UINT32_BE.get(buf, dynOffset);
+            dynOffset += 4;
+        }
+        if (header.flags.defaultSampleSizePresent) {
+            header.defaultSampleSize = Token.UINT32_BE.get(buf, dynOffset);
+            dynOffset += 4;
+        }
+        if (header.flags.defaultSampleFlagsPresent) {
+            header.defaultSampleFlags = Token.UINT32_BE.get(buf, dynOffset);
+        }
+        return header;
+    }
+}
+/**
+ * Sample-size ('trun') TrackRunBox
+ */
+export class TrackRunBox {
+    constructor(len) {
+        this.len = len;
+    }
+    get(buf, off) {
+        const flagOffset = off + 1;
+        const trun = {
+            version: Token.INT8.get(buf, off),
+            flags: {
+                dataOffsetPresent: util.getBit(buf, flagOffset + 2, 0),
+                firstSampleFlagsPresent: util.getBit(buf, flagOffset + 2, 2),
+                sampleDurationPresent: util.getBit(buf, flagOffset + 1, 0),
+                sampleSizePresent: util.getBit(buf, flagOffset + 1, 1),
+                sampleFlagsPresent: util.getBit(buf, flagOffset + 1, 2),
+                sampleCompositionTimeOffsetsPresent: util.getBit(buf, flagOffset + 1, 3)
+            },
+            sampleCount: Token.UINT32_BE.get(buf, off + 4),
+            samples: []
+        };
+        let dynOffset = off + 8;
+        if (trun.flags.dataOffsetPresent) {
+            trun.dataOffset = Token.UINT32_BE.get(buf, dynOffset);
+            dynOffset += 4;
+        }
+        if (trun.flags.firstSampleFlagsPresent) {
+            trun.firstSampleFlags = Token.UINT32_BE.get(buf, dynOffset);
+            dynOffset += 4;
+        }
+        for (let n = 0; n < trun.sampleCount; ++n) {
+            if (dynOffset >= this.len) {
+                debug("TrackRunBox size mismatch");
+                break;
+            }
+            const sample = {};
+            if (trun.flags.sampleDurationPresent) {
+                sample.sampleDuration = Token.UINT32_BE.get(buf, dynOffset);
+                dynOffset += 4;
+            }
+            if (trun.flags.sampleSizePresent) {
+                sample.sampleSize = Token.UINT32_BE.get(buf, dynOffset);
+                dynOffset += 4;
+            }
+            if (trun.flags.sampleFlagsPresent) {
+                sample.sampleFlags = Token.UINT32_BE.get(buf, dynOffset);
+                dynOffset += 4;
+            }
+            if (trun.flags.sampleCompositionTimeOffsetsPresent) {
+                sample.sampleCompositionTimeOffset = Token.UINT32_BE.get(buf, dynOffset);
+                dynOffset += 4;
+            }
+            trun.samples.push(sample);
+        }
+        return trun;
+    }
+}
 //# sourceMappingURL=AtomToken.js.map

package/lib/mp4/MP4Parser.d.ts

@@ -4,6 +4,7 @@ export declare class MP4Parser extends BasicParser {
     private static read_BE_Integer;
     private audioLengthInBytes;
     private tracks;
+    private getTrackById;
     parse(): Promise<void>;
     handleAtom(atom: Atom, remaining: number): Promise<void>;
     private getTrackDescription;
@@ -17,6 +18,7 @@ export declare class MP4Parser extends BasicParser {
      */
     private parseMetadataItemData;
     private parseValueAtom;
+    private parseTrackFragmentBox;
     private atomParsers;
     /**
      * @param sampleDescription

package/lib/mp4/MP4Parser.js

@@ -127,6 +127,7 @@ export class MP4Parser extends BasicParser {
             },
             tkhd: async (len) => {
                 const track = (await this.tokenizer.readToken(new AtomToken.TrackHeaderAtom(len)));
+                track.fragments = [];
                 this.tracks.push(track);
             },
             /**
@@ -214,6 +215,9 @@ export class MP4Parser extends BasicParser {
         }
         return Number(token.get(array, 0));
     }
+    getTrackById(trackId) {
+        return this.tracks.find(track => track.trackId === trackId);
+    }
     async parse() {
         this.tracks = [];
         let remainingFileSize = this.tokenizer.fileInfo.size || 0;
@@ -280,8 +284,26 @@ export class MP4Parser extends BasicParser {
         if (audioTracks.length >= 1) {
             const audioTrack = audioTracks[0];
             if (audioTrack.timeScale > 0) {
-                const duration = audioTrack.duration / audioTrack.timeScale; // calculate duration in seconds
-                this.metadata.setFormat('duration', duration);
+                if (audioTrack.duration > 0) {
+                    debug('Using duration defined on audio track');
+                    const duration = audioTrack.duration / audioTrack.timeScale; // calculate duration in seconds
+                    this.metadata.setFormat('duration', duration);
+                }
+                else if (audioTrack.fragments.length > 0) {
+                    debug('Calculate duration defined in track fragments');
+                    let totalTimeUnits = 0;
+                    for (const fragment of audioTrack.fragments) {
+                        const defaultDuration = fragment.header.defaultSampleDuration;
+                        for (const sample of fragment.trackRun.samples) {
+                            const dur = sample.sampleDuration ?? defaultDuration;
+                            if (dur == null) {
+                                throw new Error("Missing sampleDuration and no default_sample_duration in tfhd");
+                            }
+                            totalTimeUnits += dur;
+                        }
+                    }
+                    this.metadata.setFormat('duration', totalTimeUnits / audioTrack.timeScale);
+                }
             }
             const ssd = audioTrack.soundSampleDescription[0];
             if (ssd.description) {
@@ -309,6 +331,11 @@ export class MP4Parser extends BasicParser {
                 case 'ilst':
                 case '<id>':
                     return this.parseMetadataItemData(atom);
+                case 'moof':
+                    switch (atom.header.name) {
+                        case 'traf':
+                            return this.parseTrackFragmentBox(atom);
+                    }
             }
         }
         // const payloadLength = atom.getPayloadLength(remaining);
@@ -432,6 +459,35 @@ export class MP4Parser extends BasicParser {
                 this.addWarning(`atom key=${tagKey}, has unknown well-known-type (data-type): ${dataAtom.type.type}`);
         }
     }
+    parseTrackFragmentBox(trafBox) {
+        let tfhd;
+        return trafBox.readAtoms(this.tokenizer, async (child, remaining) => {
+            const payLoadLength = child.getPayloadLength(remaining);
+            switch (child.header.name) {
+                case 'tfhd': { // TrackFragmentHeaderBox
+                    const fragmentHeaderBox = new AtomToken.TrackFragmentHeaderBox(child.getPayloadLength(remaining));
+                    tfhd = await this.tokenizer.readToken(fragmentHeaderBox);
+                    break;
+                }
+                case 'tfdt': // TrackFragmentBaseMediaDecodeTimeBo
+                    await this.tokenizer.ignore(payLoadLength);
+                    break;
+                case 'trun': { // TrackRunBox
+                    const trackRunBox = new AtomToken.TrackRunBox(payLoadLength);
+                    const trun = await this.tokenizer.readToken(trackRunBox);
+                    if (tfhd) {
+                        const track = this.getTrackById(tfhd.trackId);
+                        track?.fragments.push({ header: tfhd, trackRun: trun });
+                    }
+                    break;
+                }
+                default: {
+                    debug(`Unexpected box: ${child.header.name}`);
+                    await this.tokenizer.ignore(payLoadLength);
+                }
+            }
+        }, trafBox.getPayloadLength(0));
+    }
     /**
      * @param sampleDescription
      * Ref: https://developer.apple.com/library/archive/documentation/QuickTime/QTFF/QTFFChap3/qtff3.html#//apple_ref/doc/uid/TP40000939-CH205-128916
@@ -487,11 +543,6 @@ export class MP4Parser extends BasicParser {
         await this.tokenizer.ignore(len);
     }
     findSampleOffset(track, chapterOffset) {
-        let totalDuration = 0;
-        track.timeToSampleTable.forEach(e => {
-            totalDuration += e.count * e.duration;
-        });
-        debug(`Total duration=${totalDuration}`);
         let chunkIndex = 0;
         while (chunkIndex < track.chunkOffsetTable.length && track.chunkOffsetTable[chunkIndex] < chapterOffset) {
             ++chunkIndex;

package/lib/mp4/MP4TagMapper.d.ts

@@ -4,5 +4,5 @@ import type { INativeMetadataCollector } from "../common/MetadataCollector.js";
 export declare const tagType = "iTunes";
 export declare class MP4TagMapper extends CaseInsensitiveTagMap {
     constructor();
-    protected postMap(tag: ITag, warnings: INativeMetadataCollector): void;
+    protected postMap(tag: ITag, _warnings: INativeMetadataCollector): void;
 }

package/lib/mp4/MP4TagMapper.js

@@ -110,7 +110,7 @@ export class MP4TagMapper extends CaseInsensitiveTagMap {
     constructor() {
         super([tagType], mp4TagMap);
     }
-    postMap(tag, warnings) {
+    postMap(tag, _warnings) {
         switch (tag.id) {
             case 'rate':
                 tag.value = {

package/lib/musepack/sv7/MpcSv7Parser.js

@@ -1,6 +1,6 @@
 import initDebug from 'debug';
 import { BasicParser } from '../../common/BasicParser.js';
-import { APEv2Parser } from '../../apev2/APEv2Parser.js';
+import { tryParseApeHeader } from '../../apev2/APEv2Parser.js';
 import { BitReader } from './BitReader.js';
 import * as SV7 from './StreamVersion7.js';
 import { MusepackContentError } from '../MusepackConentError.js';
@@ -29,7 +29,7 @@ export class MpcSv7Parser extends BasicParser {
         this.metadata.setFormat('codec', (version / 100).toFixed(2));
         await this.skipAudioData(header.frameCount);
         debug(`End of audio stream, switching to APEv2, offset=${this.tokenizer.position}`);
-        return APEv2Parser.tryParseApeHeader(this.metadata, this.tokenizer, this.options);
+        return tryParseApeHeader(this.metadata, this.tokenizer, this.options);
     }
     async skipAudioData(frameCount) {
         while (frameCount-- > 0) {

package/lib/musepack/sv8/MpcSv8Parser.js

@@ -1,6 +1,6 @@
 import initDebug from 'debug';
 import { BasicParser } from '../../common/BasicParser.js';
-import { APEv2Parser } from '../../apev2/APEv2Parser.js';
+import { tryParseApeHeader } from '../../apev2/APEv2Parser.js';
 import { FourCcToken } from '../../common/FourCC.js';
 import * as SV8 from './StreamVersion8.js';
 import { MusepackContentError } from '../MusepackConentError.js';
@@ -46,7 +46,7 @@ export class MpcSv8Parser extends BasicParser {
                     if (this.metadata.format.duration) {
                         this.metadata.setFormat('bitrate', this.audioLength * 8 / this.metadata.format.duration);
                     }
-                    return APEv2Parser.tryParseApeHeader(this.metadata, this.tokenizer, this.options);
+                    return tryParseApeHeader(this.metadata, this.tokenizer, this.options);
                 default:
                     throw new MusepackContentError(`Unexpected header: ${header.key}`);
             }

package/lib/ogg/opus/OpusParser.d.ts

@@ -18,7 +18,7 @@ export declare class OpusParser extends VorbisParser {
      * @param {IPageHeader} header
      * @param {Uint8Array} pageData
      */
-    protected parseFirstPage(header: IPageHeader, pageData: Uint8Array): void;
+    protected parseFirstPage(_header: IPageHeader, pageData: Uint8Array): void;
     protected parseFullPage(pageData: Uint8Array): Promise<void>;
     calculateDuration(header: IPageHeader): void;
 }

package/lib/ogg/opus/OpusParser.js

@@ -19,7 +19,7 @@ export class OpusParser extends VorbisParser {
      * @param {IPageHeader} header
      * @param {Uint8Array} pageData
      */
-    parseFirstPage(header, pageData) {
+    parseFirstPage(_header, pageData) {
         this.metadata.setFormat('codec', 'Opus');
         // Parse Opus ID Header
         this.idHeader = new Opus.IdHeader(pageData.length).get(pageData, 0);

package/lib/ogg/speex/SpeexParser.d.ts

@@ -17,5 +17,5 @@ export declare class SpeexParser extends VorbisParser {
      * @param {IPageHeader} header
      * @param {Uint8Array} pageData
      */
-    protected parseFirstPage(header: IPageHeader, pageData: Uint8Array): void;
+    protected parseFirstPage(_header: IPageHeader, pageData: Uint8Array): void;
 }

package/lib/ogg/speex/SpeexParser.js

@@ -18,7 +18,7 @@ export class SpeexParser extends VorbisParser {
      * @param {IPageHeader} header
      * @param {Uint8Array} pageData
      */
-    parseFirstPage(header, pageData) {
+    parseFirstPage(_header, pageData) {
         debug('First Ogg/Speex page');
         const speexHeader = Speex.Header.get(pageData, 0);
         this.metadata.setFormat('codec', `Speex ${speexHeader.version}`);

package/lib/ogg/theora/TheoraParser.d.ts

@@ -9,7 +9,7 @@ import type { INativeMetadataCollector } from '../../common/MetadataCollector.js
 export declare class TheoraParser implements Ogg.IPageConsumer {
     private metadata;
     private tokenizer;
-    constructor(metadata: INativeMetadataCollector, options: IOptions, tokenizer: ITokenizer);
+    constructor(metadata: INativeMetadataCollector, _options: IOptions, tokenizer: ITokenizer);
     /**
      * Vorbis 1 parser
      * @param header Ogg Page Header
@@ -17,11 +17,9 @@ export declare class TheoraParser implements Ogg.IPageConsumer {
      */
     parsePage(header: Ogg.IPageHeader, pageData: Uint8Array): Promise<void>;
     flush(): Promise<void>;
-    calculateDuration(header: Ogg.IPageHeader): void;
+    calculateDuration(_header: Ogg.IPageHeader): void;
     /**
      * Parse first Theora Ogg page. the initial identification header packet
-     * @param {IPageHeader} header
-     * @param {Buffer} pageData
      */
-    protected parseFirstPage(header: Ogg.IPageHeader, pageData: Uint8Array): Promise<void>;
+    protected parseFirstPage(_header: Ogg.IPageHeader, pageData: Uint8Array): Promise<void>;
 }

package/lib/ogg/theora/TheoraParser.js

@@ -6,7 +6,7 @@ const debug = initDebug('music-metadata:parser:ogg:theora');
  * - https://theora.org/doc/Theora.pdf
  */
 export class TheoraParser {
-    constructor(metadata, options, tokenizer) {
+    constructor(metadata, _options, tokenizer) {
         this.metadata = metadata;
         this.tokenizer = tokenizer;
     }
@@ -23,15 +23,13 @@ export class TheoraParser {
     async flush() {
         debug('flush');
     }
-    calculateDuration(header) {
+    calculateDuration(_header) {
         debug('duration calculation not implemented');
     }
     /**
      * Parse first Theora Ogg page. the initial identification header packet
-     * @param {IPageHeader} header
-     * @param {Buffer} pageData
      */
-    async parseFirstPage(header, pageData) {
+    async parseFirstPage(_header, pageData) {
         debug('First Ogg/Theora page');
         this.metadata.setFormat('codec', 'Theora');
         const idHeader = IdentificationHeader.get(pageData, 0);

package/lib/ogg/vorbis/VorbisParser.d.ts

@@ -41,7 +41,7 @@ export declare class VorbisParser implements IPageConsumer {
      * @param header
      * @param pageData
      */
-    protected parseFirstPage(header: IPageHeader, pageData: Uint8Array): void;
+    protected parseFirstPage(_header: IPageHeader, pageData: Uint8Array): void;
     protected parseFullPage(pageData: Uint8Array): Promise<void>;
     /**
      * Ref: https://xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-840005.2

package/lib/ogg/vorbis/VorbisParser.js

@@ -90,7 +90,7 @@ export class VorbisParser {
      * @param header
      * @param pageData
      */
-    parseFirstPage(header, pageData) {
+    parseFirstPage(_header, pageData) {
         this.metadata.setFormat('codec', 'Vorbis I');
         debug('Parse first page');
         // Parse  Vorbis common header

package/lib/wavpack/WavPackParser.js

@@ -1,5 +1,5 @@
 import * as Token from 'token-types';
-import { APEv2Parser } from '../apev2/APEv2Parser.js';
+import { tryParseApeHeader } from '../apev2/APEv2Parser.js';
 import { FourCcToken } from '../common/FourCC.js';
 import { BasicParser } from '../common/BasicParser.js';
 import { BlockHeaderToken, MetadataIdToken } from './WavPackToken.js';
@@ -22,7 +22,7 @@ export class WavPackParser extends BasicParser {
         // First parse all WavPack blocks
         await this.parseWavPackBlocks();
         // try to parse APEv2 header
-        return APEv2Parser.tryParseApeHeader(this.metadata, this.tokenizer, this.options);
+        return tryParseApeHeader(this.metadata, this.tokenizer, this.options);
     }
     async parseWavPackBlocks() {
         do {