music-metadata 10.0.1 → 10.2.0

package/lib/dsf/DsfParser.js

@@ -17,7 +17,7 @@ export class DsfParser extends AbstractID3Parser {
         this.metadata.setFormat('lossless', true);
         const dsdChunk = await this.tokenizer.readToken(DsdChunk);
         if (dsdChunk.metadataPointer === BigInt(0)) {
-            debug(`No ID3v2 tag present`);
+            debug("No ID3v2 tag present");
         }
         else {
             debug(`expect ID3v2 at offset=${dsdChunk.metadataPointer}`);
@@ -32,7 +32,7 @@ export class DsfParser extends AbstractID3Parser {
             const chunkHeader = await this.tokenizer.readToken(ChunkHeader);
             debug(`Parsing chunk name=${chunkHeader.id} size=${chunkHeader.size}`);
             switch (chunkHeader.id) {
-                case 'fmt ':
+                case 'fmt ': {
                     const formatChunk = await this.tokenizer.readToken(FormatChunk);
                     this.metadata.setFormat('numberOfChannels', formatChunk.channelNum);
                     this.metadata.setFormat('sampleRate', formatChunk.samplingFrequency);
@@ -42,6 +42,7 @@ export class DsfParser extends AbstractID3Parser {
                     const bitrate = formatChunk.bitsPerSample * formatChunk.samplingFrequency * formatChunk.channelNum;
                     this.metadata.setFormat('bitrate', bitrate);
                     return; // We got what we want, stop further processing of chunks
+                }
                 default:
                     this.tokenizer.ignore(Number(chunkHeader.size) - ChunkHeader.len);
                     break;
@@ -50,3 +51,4 @@ export class DsfParser extends AbstractID3Parser {
         }
     }
 }
+//# sourceMappingURL=DsfParser.js.map

package/lib/ebml/EbmlIterator.d.ts

@@ -0,0 +1,52 @@
+import { type ITokenizer } from 'strtok3';
+import { type IElementType, type ITree, type ValueType } from './types.js';
+export interface ILinkedElementType extends IElementType {
+    id: number;
+    parent: ILinkedElementType | undefined;
+    readonly container?: {
+        [id: number]: ILinkedElementType;
+    };
+}
+export declare enum ParseAction {
+    ReadNext = 0,// Continue reading the next elements
+    IgnoreElement = 2,// Ignore (do not read) this element
+    SkipSiblings = 3,// Skip all remaining elements at the same level
+    TerminateParsing = 4,// Terminate the parsing process
+    SkipElement = 5
+}
+/**
+ * @return true, to quit the parser
+ */
+export type IElementListener = {
+    startNext: (dtdElement: ILinkedElementType) => ParseAction;
+    elementValue: (dtdElement: ILinkedElementType, value: ValueType, offset: number) => Promise<void>;
+};
+/**
+ * Extensible Binary Meta Language (EBML) iterator
+ * https://en.wikipedia.org/wiki/Extensible_Binary_Meta_Language
+ * http://matroska.sourceforge.net/technical/specs/rfc/index.html
+ *
+ * WEBM VP8 AUDIO FILE
+ */
+export declare class EbmlIterator {
+    private tokenizer;
+    private padding;
+    private parserMap;
+    private ebmlMaxIDLength;
+    private ebmlMaxSizeLength;
+    /**
+     * @param {ITokenizer} tokenizer Input
+     * @param tokenizer
+     */
+    constructor(tokenizer: ITokenizer);
+    iterate(dtdElement: IElementType, posDone: number, listener: IElementListener): Promise<ITree>;
+    private parseContainer;
+    private readVintData;
+    private readElement;
+    private readFloat;
+    private readFlag;
+    private readUint;
+    private readString;
+    private readBuffer;
+}
+export declare function getElementPath(element: ILinkedElementType): string;

package/lib/ebml/EbmlIterator.js

@@ -0,0 +1,220 @@
+import { Float32_BE, Float64_BE, StringType, UINT8 } from 'token-types';
+import initDebug from 'debug';
+import { EndOfStreamError } from 'strtok3';
+import { DataType } from './types.js';
+import * as Token from 'token-types';
+const debug = initDebug('music-metadata:parser:ebml');
+export var ParseAction;
+(function (ParseAction) {
+    ParseAction[ParseAction["ReadNext"] = 0] = "ReadNext";
+    ParseAction[ParseAction["IgnoreElement"] = 2] = "IgnoreElement";
+    ParseAction[ParseAction["SkipSiblings"] = 3] = "SkipSiblings";
+    ParseAction[ParseAction["TerminateParsing"] = 4] = "TerminateParsing";
+    ParseAction[ParseAction["SkipElement"] = 5] = "SkipElement"; // Consider the element has read, assume position is at the next element
+})(ParseAction || (ParseAction = {}));
+/**
+ * Extensible Binary Meta Language (EBML) iterator
+ * https://en.wikipedia.org/wiki/Extensible_Binary_Meta_Language
+ * http://matroska.sourceforge.net/technical/specs/rfc/index.html
+ *
+ * WEBM VP8 AUDIO FILE
+ */
+export class EbmlIterator {
+    /**
+     * @param {ITokenizer} tokenizer Input
+     * @param tokenizer
+     */
+    constructor(tokenizer) {
+        this.tokenizer = tokenizer;
+        this.padding = 0;
+        this.parserMap = new Map();
+        this.ebmlMaxIDLength = 4;
+        this.ebmlMaxSizeLength = 8;
+        this.parserMap.set(DataType.uint, e => this.readUint(e));
+        this.parserMap.set(DataType.string, e => this.readString(e));
+        this.parserMap.set(DataType.binary, e => this.readBuffer(e));
+        this.parserMap.set(DataType.uid, async (e) => this.readBuffer(e));
+        this.parserMap.set(DataType.bool, e => this.readFlag(e));
+        this.parserMap.set(DataType.float, e => this.readFloat(e));
+    }
+    async iterate(dtdElement, posDone, listener) {
+        return this.parseContainer(linkParents(dtdElement), posDone, listener);
+    }
+    async parseContainer(dtdElement, posDone, listener) {
+        const tree = {};
+        while (this.tokenizer.position < posDone) {
+            let element;
+            const elementPosition = this.tokenizer.position;
+            try {
+                element = await this.readElement();
+            }
+            catch (error) {
+                if (error instanceof EndOfStreamError) {
+                    break;
+                }
+                throw error;
+            }
+            const child = dtdElement.container[element.id];
+            if (child) {
+                const action = listener.startNext(child);
+                switch (action) {
+                    case ParseAction.ReadNext:
+                        {
+                            if (element.id === 0x1F43B675) {
+                                // Hack to ignore remaining segment, when cluster element received
+                                // await this.tokenizer.ignore(posDone - this.tokenizer.position);
+                                // break;
+                            }
+                            debug(`Read element: name=${getElementPath(child)}{id=0x${element.id.toString(16)}, container=${!!child.container}} at position=${elementPosition}`);
+                            if (child.container) {
+                                const res = await this.parseContainer(child, element.len >= 0 ? this.tokenizer.position + element.len : -1, listener);
+                                if (child.multiple) {
+                                    if (!tree[child.name]) {
+                                        tree[child.name] = [];
+                                    }
+                                    tree[child.name].push(res);
+                                }
+                                else {
+                                    tree[child.name] = res;
+                                }
+                                await listener.elementValue(child, res, elementPosition);
+                            }
+                            else {
+                                const parser = this.parserMap.get(child.value);
+                                if (typeof parser === 'function') {
+                                    const value = await parser(element);
+                                    tree[child.name] = value;
+                                    await listener.elementValue(child, value, elementPosition);
+                                }
+                            }
+                        }
+                        break;
+                    case ParseAction.SkipElement:
+                        debug(`Go to next element: name=${getElementPath(child)}, element.id=0x${element.id}, container=${!!child.container} at position=${elementPosition}`);
+                        break;
+                    case ParseAction.IgnoreElement:
+                        debug(`Ignore element: name=${getElementPath(child)}, element.id=0x${element.id}, container=${!!child.container} at position=${elementPosition}`);
+                        await this.tokenizer.ignore(element.len);
+                        break;
+                    case ParseAction.SkipSiblings:
+                        debug(`Ignore remaining container, at: name=${getElementPath(child)}, element.id=0x${element.id}, container=${!!child.container} at position=${elementPosition}`);
+                        await this.tokenizer.ignore(posDone - this.tokenizer.position);
+                        break;
+                    case ParseAction.TerminateParsing:
+                        debug(`Terminate parsing at element: name=${getElementPath(child)}, element.id=0x${element.id}, container=${!!child.container} at position=${elementPosition}`);
+                        return tree;
+                }
+            }
+            else {
+                switch (element.id) {
+                    case 0xec: // void
+                        this.padding += element.len;
+                        await this.tokenizer.ignore(element.len);
+                        break;
+                    default:
+                        debug(`parseEbml: parent=${getElementPath(dtdElement)}, unknown child: id=${element.id.toString(16)} at position=${elementPosition}`);
+                        this.padding += element.len;
+                        await this.tokenizer.ignore(element.len);
+                }
+            }
+        }
+        return tree;
+    }
+    async readVintData(maxLength) {
+        const msb = await this.tokenizer.peekNumber(UINT8);
+        let mask = 0x80;
+        let oc = 1;
+        // Calculate VINT_WIDTH
+        while ((msb & mask) === 0) {
+            if (oc > maxLength) {
+                throw new Error('VINT value exceeding maximum size');
+            }
+            ++oc;
+            mask >>= 1;
+        }
+        const id = new Uint8Array(oc);
+        await this.tokenizer.readBuffer(id);
+        return id;
+    }
+    async readElement() {
+        const id = await this.readVintData(this.ebmlMaxIDLength);
+        const lenField = await this.readVintData(this.ebmlMaxSizeLength);
+        lenField[0] ^= 0x80 >> (lenField.length - 1);
+        return {
+            id: readUIntBE(id, id.length),
+            len: readUIntBE(lenField, lenField.length)
+        };
+    }
+    async readFloat(e) {
+        switch (e.len) {
+            case 0:
+                return 0.0;
+            case 4:
+                return this.tokenizer.readNumber(Float32_BE);
+            case 8:
+                return this.tokenizer.readNumber(Float64_BE);
+            case 10:
+                return this.tokenizer.readNumber(Float64_BE);
+            default:
+                throw new Error(`Invalid IEEE-754 float length: ${e.len}`);
+        }
+    }
+    async readFlag(e) {
+        return (await this.readUint(e)) === 1;
+    }
+    async readUint(e) {
+        const buf = await this.readBuffer(e);
+        return readUIntBE(buf, e.len);
+    }
+    async readString(e) {
+        const rawString = await this.tokenizer.readToken(new StringType(e.len, 'utf-8'));
+        return rawString.replace(/\x00.*$/g, '');
+    }
+    async readBuffer(e) {
+        const buf = new Uint8Array(e.len);
+        await this.tokenizer.readBuffer(buf);
+        return buf;
+    }
+}
+function readUIntBE(buf, len) {
+    return Number(readUIntBeAsBigInt(buf, len));
+}
+/**
+ * Reeds an unsigned integer from a big endian buffer of length `len`
+ * @param buf Buffer to decode from
+ * @param len Number of bytes
+ * @private
+ */
+function readUIntBeAsBigInt(buf, len) {
+    const normalizedNumber = new Uint8Array(8);
+    const cleanNumber = buf.subarray(0, len);
+    try {
+        normalizedNumber.set(cleanNumber, 8 - len);
+        return Token.UINT64_BE.get(normalizedNumber, 0);
+    }
+    catch (error) {
+        return BigInt(-1);
+    }
+}
+function linkParents(element) {
+    if (element.container) {
+        Object.keys(element.container)
+            .map(id => {
+            const child = element.container[id];
+            child.id = Number.parseInt(id);
+            return child;
+        }).forEach(child => {
+            child.parent = element;
+            linkParents(child);
+        });
+    }
+    return element;
+}
+export function getElementPath(element) {
+    let path = '';
+    if (element.parent && element.parent.name !== 'dtd') {
+        path += `${getElementPath(element.parent)}/`;
+    }
+    return path + element.name;
+}
+//# sourceMappingURL=EbmlIterator.js.map

package/lib/ebml/types.d.ts

@@ -0,0 +1,36 @@
+export interface ITree {
+    [name: string]: string | number | boolean | Uint8Array | ITree | ITree[];
+}
+export declare enum DataType {
+    'string' = 0,
+    uint = 1,
+    uid = 2,
+    bool = 3,
+    binary = 4,
+    float = 5
+}
+export type ValueType = string | number | Uint8Array | boolean | ITree | ITree[];
+export interface IHeader {
+    id: number;
+    len: number;
+}
+export interface IEbmlElements {
+    version?: number;
+    readVersion?: number;
+    maxIDWidth?: number;
+    maxSizeWidth?: number;
+    docType?: string;
+    docTypeVersion?: number;
+    docTypeReadVersion?: number;
+}
+export interface IElementType {
+    readonly name: string;
+    readonly value?: DataType;
+    readonly container?: {
+        [id: number]: IElementType;
+    };
+    readonly multiple?: boolean;
+}
+export interface IEbmlDoc {
+    ebml: IEbmlElements;
+}

package/lib/ebml/types.js

@@ -0,0 +1,10 @@
+export var DataType;
+(function (DataType) {
+    DataType[DataType["string"] = 0] = "string";
+    DataType[DataType["uint"] = 1] = "uint";
+    DataType[DataType["uid"] = 2] = "uid";
+    DataType[DataType["bool"] = 3] = "bool";
+    DataType[DataType["binary"] = 4] = "binary";
+    DataType[DataType["float"] = 5] = "float";
+})(DataType || (DataType = {}));
+//# sourceMappingURL=types.js.map

package/lib/flac/FlacParser.d.ts

@@ -1,8 +1,8 @@
 import type { ITokenizer } from 'strtok3';
 import { AbstractID3Parser } from '../id3v2/AbstractID3Parser.js';
-import { INativeMetadataCollector } from '../common/MetadataCollector.js';
-import { IOptions } from '../type.js';
-import { ITokenParser } from '../ParserFactory.js';
+import type { INativeMetadataCollector } from '../common/MetadataCollector.js';
+import type { IOptions } from '../type.js';
+import type { ITokenParser } from '../ParserFactory.js';
 export declare class FlacParser extends AbstractID3Parser {
     private vorbisParser;
     private padding;

package/lib/flac/FlacParser.js

@@ -45,7 +45,7 @@ export class FlacParser extends AbstractID3Parser {
         let blockHeader;
         do {
             // Read block header
-            blockHeader = await this.tokenizer.readToken(Metadata.BlockHeader);
+            blockHeader = await this.tokenizer.readToken(BlockHeader);
             // Parse block data
             await this.parseDataBlock(blockHeader);
         } while (!blockHeader.lastBlock);
@@ -74,7 +74,7 @@ export class FlacParser extends AbstractID3Parser {
                 await this.parsePicture(blockHeader.length);
                 return;
             default:
-                this.metadata.addWarning('Unknown block type: ' + blockHeader.type);
+                this.metadata.addWarning(`Unknown block type: ${blockHeader.type}`);
         }
         // Ignore data block
         return this.tokenizer.ignore(blockHeader.length).then();
@@ -83,9 +83,9 @@ export class FlacParser extends AbstractID3Parser {
      * Parse STREAMINFO
      */
     async parseBlockStreamInfo(dataLen) {
-        if (dataLen !== Metadata.BlockStreamInfo.len)
+        if (dataLen !== BlockStreamInfo.len)
             throw new Error('Unexpected block-stream-info length');
-        const streamInfo = await this.tokenizer.readToken(Metadata.BlockStreamInfo);
+        const streamInfo = await this.tokenizer.readToken(BlockStreamInfo);
         this.metadata.setFormat('container', 'FLAC');
         this.metadata.setFormat('codec', 'FLAC');
         this.metadata.setFormat('lossless', true);
@@ -115,15 +115,11 @@ export class FlacParser extends AbstractID3Parser {
         if (this.options.skipCovers) {
             return this.tokenizer.ignore(dataLen);
         }
-        else {
-            const picture = await this.tokenizer.readToken(new VorbisPictureToken(dataLen));
-            this.vorbisParser.addTag('METADATA_BLOCK_PICTURE', picture);
-        }
+        const picture = await this.tokenizer.readToken(new VorbisPictureToken(dataLen));
+        this.vorbisParser.addTag('METADATA_BLOCK_PICTURE', picture);
     }
 }
-class Metadata {
-}
-Metadata.BlockHeader = {
+const BlockHeader = {
     len: 4,
     get: (buf, off) => {
         return {
@@ -137,7 +133,7 @@ Metadata.BlockHeader = {
  * METADATA_BLOCK_DATA
  * Ref: https://xiph.org/flac/format.html#metadata_block_streaminfo
  */
-Metadata.BlockStreamInfo = {
+const BlockStreamInfo = {
     len: 34,
     get: (buf, off) => {
         return {
@@ -171,3 +167,4 @@ Metadata.BlockStreamInfo = {
         };
     }
 };
+//# sourceMappingURL=FlacParser.js.map

package/lib/id3v1/ID3v1Parser.d.ts

@@ -1,5 +1,5 @@
 import { BasicParser } from '../common/BasicParser.js';
-import { IRandomReader } from '../type.js';
+import type { IRandomReader } from '../type.js';
 /**
  * ID3v1 Genre mappings
  * Ref: https://de.wikipedia.org/wiki/Liste_der_ID3v1-Genres

package/lib/id3v1/ID3v1Parser.js

@@ -66,12 +66,13 @@ const Iid3v1Token = {
         } : null;
     }
 };
-class Id3v1StringType extends StringType {
+class Id3v1StringType {
     constructor(len) {
-        super(len, 'latin1');
+        this.len = len;
+        this.stringType = new StringType(len, 'latin1');
     }
     get(buf, off) {
-        let value = super.get(buf, off);
+        let value = this.stringType.get(buf, off);
         value = util.trimRightNull(value);
         value = value.trim();
         return value.length > 0 ? value : undefined;
@@ -103,7 +104,8 @@ export class ID3v1Parser extends BasicParser {
         const header = await this.tokenizer.readToken(Iid3v1Token, offset);
         if (header) {
             debug('ID3v1 header found at: pos=%s', this.tokenizer.fileInfo.size - Iid3v1Token.len);
-            for (const id of ['title', 'artist', 'album', 'comment', 'track', 'year']) {
+            const props = ['title', 'artist', 'album', 'comment', 'track', 'year'];
+            for (const id of props) {
                 if (header[id] && header[id] !== '')
                     await this.addTag(id, header[id]);
             }
@@ -127,3 +129,4 @@ export async function hasID3v1Header(reader) {
     }
     return false;
 }
+//# sourceMappingURL=ID3v1Parser.js.map

package/lib/id3v2/AbstractID3Parser.d.ts

@@ -1,4 +1,4 @@
-import { ITokenizer } from 'strtok3';
+import { type ITokenizer } from 'strtok3';
 import { BasicParser } from '../common/BasicParser.js';
 /**
  * Abstract parser which tries take ID3v2 and ID3v1 headers.

package/lib/id3v2/AbstractID3Parser.js

@@ -22,7 +22,7 @@ export class AbstractID3Parser extends BasicParser {
         }
         catch (err) {
             if (err instanceof EndOfStreamError) {
-                debug(`End-of-stream`);
+                debug("End-of-stream");
             }
             else {
                 throw err;
@@ -54,3 +54,4 @@ export class AbstractID3Parser extends BasicParser {
         }
     }
 }
+//# sourceMappingURL=AbstractID3Parser.js.map

package/lib/id3v2/FrameParser.d.ts

@@ -1,5 +1,29 @@
-import { ID3v2MajorVersion, ITextEncoding } from './ID3v2Token.js';
-import { IWarningCollector } from '../common/MetadataCollector.js';
+import { type ID3v2MajorVersion, type ITextEncoding } from './ID3v2Token.js';
+import type { IWarningCollector } from '../common/MetadataCollector.js';
+interface ICustomTag {
+    owner_identifier: string;
+}
+export interface ICustomDataTag extends ICustomTag {
+    data: Uint8Array;
+}
+export interface IIdentifierTag extends ICustomTag {
+    identifier: Uint8Array;
+}
+export interface ITextTag {
+    description: string;
+    text: string[];
+}
+export interface IPopularimeter {
+    email: string;
+    rating: number;
+    counter: number;
+}
+export interface IGeneralEncapsulatedObject {
+    type: string;
+    filename: string;
+    description: string;
+    data: Uint8Array;
+}
 export declare function parseGenre(origVal: string): string[];
 export declare class FrameParser {
     private major;
@@ -10,7 +34,7 @@ export declare class FrameParser {
      * @param warningCollector - Used to collect decode issue
      */
     constructor(major: ID3v2MajorVersion, warningCollector: IWarningCollector);
-    readData(uint8Array: Uint8Array, type: string, includeCovers: boolean): any;
+    readData(uint8Array: Uint8Array, type: string, includeCovers: boolean): unknown;
     protected static readNullTerminatedString(uint8Array: Uint8Array, encoding: ITextEncoding): {
         text: string;
         len: number;
@@ -33,3 +57,4 @@ export declare class FrameParser {
     private static readIdentifierAndData;
     private static getNullTerminatorLength;
 }
+export {};