music-metadata 10.6.0 → 10.6.2

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/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/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/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);
@@ -46,3 +38,4 @@ export async function parseFile(filePath, options = {}) {
         await fileTokenizer.close();
     }
 }
+//# sourceMappingURL=index.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

@@ -354,7 +354,7 @@ export class MpegParser extends AbstractID3Parser {
         if (this.frameCount === 0) {
             this.mpegOffset = this.tokenizer.position - 1;
         }
-        await this.tokenizer.peekBuffer(this.buf_frame_header, { offset: 1, length: 3 });
+        await this.tokenizer.peekBuffer(this.buf_frame_header.subarray(1), { length: 3 });
         let header;
         try {
             header = FrameHeader.get(this.buf_frame_header, 0);

package/lib/type.d.ts

@@ -595,25 +595,6 @@ 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>;
-}
 export interface ILyricsText {
     text: string;
     timestamp?: number;

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.6.0",
+  "version": "10.6.2",
   "author": {
     "name": "Borewit",
     "url": "https://github.com/Borewit"
@@ -109,8 +109,9 @@
     "content-type": "^1.0.5",
     "debug": "^4.3.7",
     "file-type": "^19.6.0",
+    "link": "^2.1.1",
     "media-typer": "^1.1.0",
-    "strtok3": "^9.0.1",
+    "strtok3": "^10.0.0",
     "token-types": "^6.0.0",
     "uint8array-extras": "^1.4.0"
   },
@@ -121,19 +122,18 @@
     "@types/content-type": "^1.1.8",
     "@types/debug": "^4.1.12",
     "@types/media-typer": "^1.1.3",
-    "@types/mocha": "^10.0.9",
-    "@types/node": "^22.9.0",
+    "@types/mocha": "^10.0.10",
+    "@types/node": "^22.10.1",
     "c8": "^10.1.2",
     "chai": "^5.1.2",
-    "chai-as-promised": "^8.0.0",
+    "chai-as-promised": "^8.0.1",
     "del-cli": "^6.0.0",
     "mime": "^4.0.4",
     "mocha": "^10.8.2",
-    "prettier": "^3.3.3",
     "remark-cli": "^12.0.1",
     "remark-preset-lint-consistent": "^6.0.0",
     "ts-node": "^10.9.2",
-    "typescript": "^5.6.3"
+    "typescript": "^5.7.2"
   },
   "engines": {
     "node": ">=16.0.0"

package/lib/common/RandomFileReader.d.ts

@@ -1,21 +0,0 @@
-import type { IRandomReader } from '../type.js';
-/**
- * Provides abstract file access via the IRandomRead interface
- */
-export declare class RandomFileReader implements IRandomReader {
-    private readonly fileHandle;
-    filePath: string;
-    fileSize: number;
-    private constructor();
-    /**
-     * Read from a given position of an abstracted file or buffer.
-     * @param buffer {Uint8Array} is the buffer that the data will be written to.
-     * @param offset {number} is the offset in the buffer to start writing at.
-     * @param length {number}is an integer specifying the number of bytes to read.
-     * @param position {number} is 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>;
-    close(): Promise<void>;
-    static init(filePath: string, fileSize: number): Promise<RandomFileReader>;
-}

package/lib/common/RandomFileReader.js

@@ -1,30 +0,0 @@
-import * as fs from 'node:fs';
-/**
- * Provides abstract file access via the IRandomRead interface
- */
-export class RandomFileReader {
-    constructor(fileHandle, filePath, fileSize) {
-        this.fileHandle = fileHandle;
-        this.filePath = filePath;
-        this.fileSize = fileSize;
-    }
-    /**
-     * Read from a given position of an abstracted file or buffer.
-     * @param buffer {Uint8Array} is the buffer that the data will be written to.
-     * @param offset {number} is the offset in the buffer to start writing at.
-     * @param length {number}is an integer specifying the number of bytes to read.
-     * @param position {number} is an argument specifying where to begin reading from in the file.
-     * @return {Promise<number>} bytes read
-     */
-    async randomRead(buffer, offset, length, position) {
-        const result = await this.fileHandle.read(buffer, offset, length, position);
-        return result.bytesRead;
-    }
-    async close() {
-        return this.fileHandle.close();
-    }
-    static async init(filePath, fileSize) {
-        const fileHandle = await fs.promises.open(filePath, 'r');
-        return new RandomFileReader(fileHandle, filePath, fileSize);
-    }
-}

package/lib/common/RandomUint8ArrayReader.d.ts

@@ -1,18 +0,0 @@
-import type { IRandomReader } from '../type.js';
-/**
- * Provides abstract Uint8Array access via the IRandomRead interface
- */
-export declare class RandomUint8ArrayReader implements IRandomReader {
-    private readonly uint8Array;
-    readonly fileSize: number;
-    constructor(uint8Array: Uint8Array);
-    /**
-     * Read from a given position of an abstracted file or buffer.
-     * @param uint8Array - Uint8Array that the data will be written to.
-     * @param offset - Offset in the buffer to start writing at.
-     * @param length - Integer specifying the number of bytes to read.
-     * @param position - Specifies where to begin reading from in the file.
-     * @return Promise providing bytes read
-     */
-    randomRead(uint8Array: Uint8Array, offset: number, length: number, position: number): Promise<number>;
-}

package/lib/common/RandomUint8ArrayReader.js

@@ -1,21 +0,0 @@
-/**
- * Provides abstract Uint8Array access via the IRandomRead interface
- */
-export class RandomUint8ArrayReader {
-    constructor(uint8Array) {
-        this.uint8Array = uint8Array;
-        this.fileSize = uint8Array.length;
-    }
-    /**
-     * Read from a given position of an abstracted file or buffer.
-     * @param uint8Array - Uint8Array that the data will be written to.
-     * @param offset - Offset in the buffer to start writing at.
-     * @param length - Integer specifying the number of bytes to read.
-     * @param position - Specifies where to begin reading from in the file.
-     * @return Promise providing bytes read
-     */
-    async randomRead(uint8Array, offset, length, position) {
-        uint8Array.set(this.uint8Array.subarray(position, position + length), offset);
-        return length;
-    }
-}