music-metadata 10.5.1 → 10.6.1

package/lib/ParserFactory.js

@@ -18,6 +18,7 @@ import { oggParserLoader } from './ogg/OggLoader.js';
 import { wavpackParserLoader } from './wavpack/WavPackLoader.js';
 import { riffParserLoader } from './wav/WaveLoader.js';
 import { amrParserLoader } from './amr/AmrLoader.js';
+import { scanAppendingHeaders } from './core.js';
 const debug = initDebug('music-metadata:parser:factory');
 export function parseHttpContentType(contentType) {
     const type = ContentType.parse(contentType);
@@ -53,6 +54,13 @@ export class ParserFactory {
         this.parsers.push(parser);
     }
     async parse(tokenizer, parserLoader, opts) {
+        if (tokenizer.supportsRandomAccess()) {
+            debug('tokenizer supports random-access, scanning for appending headers');
+            await scanAppendingHeaders(tokenizer, opts);
+        }
+        else {
+            debug('tokenizer does not support random-access, cannot scan for appending headers');
+        }
         if (!parserLoader) {
             const buf = new Uint8Array(4100);
             if (tokenizer.fileInfo.mimeType) {

package/lib/apev2/APEv2Parser.d.ts

@@ -1,8 +1,9 @@
 import * as strtok3 from 'strtok3';
-import type { IOptions, IRandomReader, IApeHeader } from '../type.js';
+import type { IOptions, IApeHeader } from '../type.js';
 import type { INativeMetadataCollector } from '../common/MetadataCollector.js';
 import { BasicParser } from '../common/BasicParser.js';
 import { type IFooter, type IHeader } from './APEv2Token.js';
+import type { IRandomAccessTokenizer } from 'strtok3';
 declare const ApeContentError_base: {
     new (message: string): {
         readonly fileType: string;
@@ -27,10 +28,10 @@ export declare class APEv2Parser extends BasicParser {
     static calculateDuration(ah: IHeader): number;
     /**
      * Calculates the APEv1 / APEv2 first field offset
-     * @param reader
+     * @param tokenizer
      * @param offset
      */
-    static findApeFooterOffset(reader: IRandomReader, offset: number): Promise<IApeHeader | undefined>;
+    static findApeFooterOffset(tokenizer: IRandomAccessTokenizer, offset: number): Promise<IApeHeader | undefined>;
     private static parseTagFooter;
     private ape;
     /**

package/lib/apev2/APEv2Parser.js

@@ -32,13 +32,15 @@ export class APEv2Parser extends BasicParser {
     }
     /**
      * Calculates the APEv1 / APEv2 first field offset
-     * @param reader
+     * @param tokenizer
      * @param offset
      */
-    static async findApeFooterOffset(reader, offset) {
+    static async findApeFooterOffset(tokenizer, offset) {
         // Search for APE footer header at the end of the file
         const apeBuf = new Uint8Array(TagFooter.len);
-        await reader.randomRead(apeBuf, 0, TagFooter.len, offset - TagFooter.len);
+        const position = tokenizer.position;
+        await tokenizer.readBuffer(apeBuf, { position: offset - TagFooter.len });
+        tokenizer.setPosition(position);
         const tagFooter = TagFooter.get(apeBuf, 0);
         if (tagFooter.ID === 'APETAGEX') {
             if (tagFooter.flags.isHeader) {

package/lib/asf/AsfObject.d.ts

@@ -10,7 +10,13 @@ declare const AsfContentParseError_base: {
         stack?: string;
     };
     captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite /**
+     * Specifies the amount of time to buffer data before starting to play the file, in millisecond units.
+     * If this value is nonzero, the Play Duration field and all of the payload Presentation Time fields have been offset
+     * by this amount. Therefore, player software must subtract the value in the preroll field from the play duration and
+     * presentation times to calculate their actual values. It follows that all payload Presentation Time fields need to
+     * be at least this value.
+     */[]) => any) | undefined;
     stackTraceLimit: number;
 };
 export declare class AsfContentParseError extends AsfContentParseError_base {

package/lib/asf/AsfObject.js

@@ -310,7 +310,6 @@ export class MetadataObjectState extends State {
 }
 MetadataObjectState.guid = GUID.MetadataObject;
 // 4.8	Metadata Library Object (optional, 0 or 1)
-// biome-ignore lint/complexity/noStaticOnlyClass: Extends a non-static class
 export class MetadataLibraryObjectState extends MetadataObjectState {
 }
 MetadataLibraryObjectState.guid = GUID.MetadataLibraryObject;

package/lib/common/MetadataCollector.js

@@ -5,6 +5,7 @@ import { CombinedTagMapper } from './CombinedTagMapper.js';
 import { CommonTagMapper } from './GenericTagMapper.js';
 import { toRatio } from './Util.js';
 import { fileTypeFromBuffer } from 'file-type';
+import { parseLrc } from '../lrc/LyricsParser.js';
 const debug = initDebug('music-metadata:collector');
 const TagPriority = ['matroska', 'APEv2', 'vorbis', 'ID3v2.4', 'ID3v2.3', 'ID3v2.2', 'exif', 'asf', 'iTunes', 'AIFF', 'ID3v1'];
 /**
@@ -180,6 +181,11 @@ export class MetadataCollector {
                     this.setGenericTag(tagType, { id: 'gapless', value: tag.value.text === '1' });
                 }
                 break;
+            case 'lyrics':
+                if (typeof tag.value === 'string') {
+                    tag.value = parseLrc(tag.value);
+                }
+                break;
             default:
             // nothing to do
         }

package/lib/core.d.ts

@@ -1,8 +1,8 @@
 /**
  * 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';
+import { type AnyWebByteStream, type IFileInfo, type ITokenizer, type IRandomAccessTokenizer } from 'strtok3';
+import type { IAudioMetadata, INativeTagDict, IOptions, IPicture, IPrivateOptions, ITag } from './type.js';
 export type { IFileInfo } from 'strtok3';
 export { type IAudioMetadata, type IOptions, type ITag, type INativeTagDict, type ICommonTagsResult, type IFormat, type IPicture, type IRatio, type IChapter, type ILyricsTag, LyricsContentType, TimestampFormat, IMetadataEventTag, IMetadataEvent } from './type.js';
 export type * from './ParseError.js';
@@ -56,5 +56,5 @@ export declare function ratingToStars(rating: number | undefined): number;
  * @return Cover image, if any, otherwise null
  */
 export declare function selectCover(pictures?: IPicture[]): IPicture | null;
-export declare function scanAppendingHeaders(randomReader: IRandomReader, options?: IPrivateOptions): Promise<void>;
+export declare function scanAppendingHeaders(tokenizer: IRandomAccessTokenizer, options?: IPrivateOptions): Promise<void>;
 export declare function loadMusicMetadata(): Promise<typeof import('music-metadata')>;

package/lib/core.js

@@ -3,7 +3,6 @@
  */
 import { fromWebStream, fromBuffer } from 'strtok3';
 import { ParserFactory } from './ParserFactory.js';
-import { RandomUint8ArrayReader } from './common/RandomUint8ArrayReader.js';
 import { APEv2Parser } from './apev2/APEv2Parser.js';
 import { hasID3v1Header } from './id3v1/ID3v1Parser.js';
 import { getLyricsHeaderLength } from './lyrics3/Lyrics3.js';
@@ -41,8 +40,6 @@ export function parseWebStream(webStream, fileInfo, options = {}) {
  * Ref: https://github.com/Borewit/strtok3/blob/e6938c81ff685074d5eb3064a11c0b03ca934c1d/src/index.ts#L15
  */
 export async function parseBuffer(uint8Array, fileInfo, options = {}) {
-    const bufferReader = new RandomUint8ArrayReader(uint8Array);
-    await scanAppendingHeaders(bufferReader, options);
     const tokenizer = fromBuffer(uint8Array, { fileInfo: typeof fileInfo === 'string' ? { mimeType: fileInfo } : fileInfo });
     return parseFromTokenizer(tokenizer, options);
 }
@@ -91,12 +88,13 @@ export function selectCover(pictures) {
         return acc;
     }) : null;
 }
-export async function scanAppendingHeaders(randomReader, options = {}) {
-    let apeOffset = randomReader.fileSize;
-    if (await hasID3v1Header(randomReader)) {
+export async function scanAppendingHeaders(tokenizer, options = {}) {
+    let apeOffset = tokenizer.fileInfo.size;
+    if (await hasID3v1Header(tokenizer)) {
         apeOffset -= 128;
-        const lyricsLen = await getLyricsHeaderLength(randomReader);
+        const lyricsLen = await getLyricsHeaderLength(tokenizer);
         apeOffset -= lyricsLen;
     }
-    options.apeHeader = await APEv2Parser.findApeFooterOffset(randomReader, apeOffset);
+    options.apeHeader = await APEv2Parser.findApeFooterOffset(tokenizer, apeOffset);
 }
+//# sourceMappingURL=core.js.map

package/lib/default.cjs

@@ -1,5 +1,5 @@
-// CommonJS core (default) entry point
-"use strict";
-module.exports = {
-  loadMusicMetadata: () => import('./core.js'),
-};
+// CommonJS core (default) entry point
+"use strict";
+module.exports = {
+  loadMusicMetadata: () => import('./core.js'),
+};

package/lib/dsdiff/DsdiffToken.d.ts

@@ -1,6 +1,6 @@
 import type { IGetToken } from 'strtok3';
 import type { IChunkHeader64 } from '../iff/index.js';
-export { type IChunkHeader64 } from '../iff/index.js';
+export type { IChunkHeader64 } from '../iff/index.js';
 /**
  * DSDIFF chunk header
  * The data-size encoding is deviating from EA-IFF 85

package/lib/id3v1/ID3v1Parser.d.ts

@@ -1,6 +1,6 @@
-import type { ITokenizer } from 'strtok3';
+import type { IRandomAccessTokenizer, ITokenizer } from 'strtok3';
 import { BasicParser } from '../common/BasicParser.js';
-import type { IPrivateOptions, IRandomReader } from '../type.js';
+import type { IPrivateOptions } from '../type.js';
 import type { INativeMetadataCollector } from '../common/MetadataCollector.js';
 /**
  * ID3v1 Genre mappings
@@ -14,4 +14,4 @@ export declare class ID3v1Parser extends BasicParser {
     parse(): Promise<void>;
     private addTag;
 }
-export declare function hasID3v1Header(reader: IRandomReader): Promise<boolean>;
+export declare function hasID3v1Header(tokenizer: IRandomAccessTokenizer): Promise<boolean>;

package/lib/id3v1/ID3v1Parser.js

@@ -124,10 +124,12 @@ export class ID3v1Parser extends BasicParser {
         await this.metadata.addTag('ID3v1', id, value);
     }
 }
-export async function hasID3v1Header(reader) {
-    if (reader.fileSize >= 128) {
+export async function hasID3v1Header(tokenizer) {
+    if (tokenizer.fileInfo.size >= 128) {
         const tag = new Uint8Array(3);
-        await reader.randomRead(tag, 0, tag.length, reader.fileSize - 128);
+        const position = tokenizer.position;
+        await tokenizer.readBuffer(tag, { position: tokenizer.fileInfo.size - 128 });
+        tokenizer.setPosition(position); // Restore tokenizer position
         return new TextDecoder('latin1').decode(tag) === 'TAG';
     }
     return false;

package/lib/id3v2/FrameParser.js

@@ -248,16 +248,17 @@ export class FrameParser {
                 fzero = util.findZero(uint8Array, offset + 1, length, encoding);
                 const mimeType = util.decodeString(uint8Array.slice(offset + 1, fzero), defaultEnc);
                 offset = fzero + 1;
-                fzero = util.findZero(uint8Array, offset, length - offset, encoding);
+                fzero = util.findZero(uint8Array, offset, length, encoding);
                 const filename = util.decodeString(uint8Array.slice(offset, fzero), defaultEnc);
                 offset = fzero + 1;
-                fzero = util.findZero(uint8Array, offset, length - offset, encoding);
+                fzero = util.findZero(uint8Array, offset, length, encoding);
                 const description = util.decodeString(uint8Array.slice(offset, fzero), defaultEnc);
+                offset = fzero + 1;
                 const geob = {
                     type: mimeType,
                     filename,
                     description,
-                    data: uint8Array.slice(offset + 1, length)
+                    data: uint8Array.slice(offset, length)
                 };
                 output = geob;
                 break;

package/lib/index.js

@@ -3,9 +3,8 @@
  */
 import { fromFile, fromStream } from 'strtok3';
 import initDebug from 'debug';
-import { parseFromTokenizer, scanAppendingHeaders } from './core.js';
+import { parseFromTokenizer, } from './core.js';
 import { ParserFactory } from './ParserFactory.js';
-import { RandomFileReader } from './common/RandomFileReader.js';
 export * from './core.js';
 const debug = initDebug('music-metadata:parser');
 /**
@@ -28,13 +27,6 @@ export async function parseStream(stream, fileInfo, options = {}) {
 export async function parseFile(filePath, options = {}) {
     debug(`parseFile: ${filePath}`);
     const fileTokenizer = await fromFile(filePath);
-    const fileReader = await RandomFileReader.init(filePath, fileTokenizer.fileInfo.size);
-    try {
-        await scanAppendingHeaders(fileReader, options);
-    }
-    finally {
-        await fileReader.close();
-    }
     const parserFactory = new ParserFactory();
     try {
         const parserLoader = parserFactory.findLoaderForExtension(filePath);

package/lib/lrc/LyricsParser.d.ts

@@ -0,0 +1,7 @@
+import { type ILyricsTag } from '../type.js';
+/**
+ * Parse LRC (Lyrics) formatted text
+ * Ref: https://en.wikipedia.org/wiki/LRC_(file_format)
+ * @param lrcString
+ */
+export declare function parseLrc(lrcString: string): ILyricsTag;

package/lib/lrc/LyricsParser.js

@@ -0,0 +1,32 @@
+import { LyricsContentType, TimestampFormat } from '../type.js';
+/**
+ * Parse LRC (Lyrics) formatted text
+ * Ref: https://en.wikipedia.org/wiki/LRC_(file_format)
+ * @param lrcString
+ */
+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})\]/;
+    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);
+            // Convert the timestamp to milliseconds, as per TimestampFormat.milliseconds
+            const timestamp = (minutes * 60 + seconds) * 1000 + hundredths * 10;
+            // Get the text portion of the line (e.g., "あの蝶は自由になれたかな")
+            const text = line.replace(timestampRegex, '').trim();
+            syncText.push({ timestamp, text });
+        }
+    }
+    // Creating the ILyricsTag object
+    return {
+        contentType: LyricsContentType.lyrics,
+        timeStampFormat: TimestampFormat.milliseconds,
+        syncText,
+    };
+}
+//# sourceMappingURL=LyricsParser.js.map

package/lib/lyrics3/Lyrics3.d.ts

@@ -1,3 +1,3 @@
-import type { IRandomReader } from '../type.js';
+import type { IRandomAccessTokenizer } from 'strtok3';
 export declare const endTag2 = "LYRICS200";
-export declare function getLyricsHeaderLength(reader: IRandomReader): Promise<number>;
+export declare function getLyricsHeaderLength(tokenizer: IRandomAccessTokenizer): Promise<number>;

package/lib/lyrics3/Lyrics3.js

@@ -1,8 +1,11 @@
 export const endTag2 = 'LYRICS200';
-export async function getLyricsHeaderLength(reader) {
-    if (reader.fileSize >= 143) {
+export async function getLyricsHeaderLength(tokenizer) {
+    const fileSize = tokenizer.fileInfo.size;
+    if (fileSize >= 143) {
         const buf = new Uint8Array(15);
-        await reader.randomRead(buf, 0, buf.length, reader.fileSize - 143);
+        const position = tokenizer.position;
+        await tokenizer.readBuffer(buf, { position: fileSize - 143 });
+        tokenizer.setPosition(position); // Restore position
         const txt = new TextDecoder('latin1').decode(buf);
         const tag = txt.slice(6);
         if (tag === endTag2) {
@@ -11,3 +14,4 @@ export async function getLyricsHeaderLength(reader) {
     }
     return 0;
 }
+//# sourceMappingURL=Lyrics3.js.map

package/lib/mpeg/MpegParser.js

@@ -296,12 +296,12 @@ export class MpegParser extends AbstractID3Parser {
                     this.metadata.setFormat('bitrate', mpegSize * 8 / format.duration);
                 }
             }
-            else if (this.tokenizer.fileInfo.size && format.codecProfile === 'CBR') {
+            if (this.tokenizer.fileInfo.size && format.codecProfile === 'CBR') {
                 const mpegSize = this.tokenizer.fileInfo.size - this.mpegOffset - (hasID3v1 ? 128 : 0);
                 if (this.frame_size !== null && this.samplesPerFrame !== null) {
                     const numberOfSamples = Math.round(mpegSize / this.frame_size) * this.samplesPerFrame;
                     this.metadata.setFormat('numberOfSamples', numberOfSamples);
-                    if (format.sampleRate) {
+                    if (format.sampleRate && !format.duration) {
                         const duration = numberOfSamples / format.sampleRate;
                         debug("Calculate CBR duration based on file size: %s", duration);
                         this.metadata.setFormat('duration', duration);

package/lib/node.cjs

@@ -1,5 +1,5 @@
-// CommonJS Node entry point
-"use strict";
-module.exports = {
-  loadMusicMetadata: () => import('./index.js'),
-};
+// CommonJS Node entry point
+"use strict";
+module.exports = {
+  loadMusicMetadata: () => import('./index.js'),
+};

package/lib/riff/RiffChunk.d.ts

@@ -1,6 +1,6 @@
 import type { IGetToken } from 'strtok3';
 import type { IChunkHeader } from '../iff/index.js';
-export { type IChunkHeader } from '../iff/index.js';
+export type { IChunkHeader } from '../iff/index.js';
 /**
  * Common RIFF chunk header
  */

package/lib/type.d.ts

@@ -595,26 +595,7 @@ export interface IMetadataEvent {
     metadata: IAudioMetadata;
 }
 export type Observer = (update: IMetadataEvent) => void;
-/**
- * Provides random data read access
- * Used read operations on file of buffers
- */
-export interface IRandomReader {
-    /**
-     * Total length of file or buffer
-     */
-    fileSize: number;
-    /**
-     * Read from a given position of an abstracted file or buffer.
-     * @param {Uint8Array} buffer the buffer that the data will be written to.
-     * @param {number} offset the offset in the buffer to start writing at.
-     * @param {number} length an integer specifying the number of bytes to read.
-     * @param {number} position an argument specifying where to begin reading from in the file.
-     * @return {Promise<number>} bytes read
-     */
-    randomRead(buffer: Uint8Array, offset: number, length: number, position: number): Promise<number>;
-}
-interface ILyricsText {
+export interface ILyricsText {
     text: string;
     timestamp?: number;
 }