music-metadata 10.1.0 → 10.3.0

package/lib/dsf/DsfParser.js

@@ -2,7 +2,10 @@ import initDebug from 'debug';
 import { AbstractID3Parser } from '../id3v2/AbstractID3Parser.js';
 import { ChunkHeader, DsdChunk, FormatChunk } from './DsfChunk.js';
 import { ID3v2Parser } from "../id3v2/ID3v2Parser.js";
+import { makeUnexpectedFileContentError } from '../ParseError.js';
 const debug = initDebug('music-metadata:parser:DSF');
+export class DsdContentParseError extends makeUnexpectedFileContentError('DSD') {
+}
 /**
  * DSF (dsd stream file) File Parser
  * Ref: https://dsd-guide.com/sites/default/files/white-papers/DSFFileFormatSpec_E.pdf
@@ -12,7 +15,7 @@ export class DsfParser extends AbstractID3Parser {
         const p0 = this.tokenizer.position; // mark start position, normally 0
         const chunkHeader = await this.tokenizer.readToken(ChunkHeader);
         if (chunkHeader.id !== 'DSD ')
-            throw new Error('Invalid chunk signature');
+            throw new DsdContentParseError('Invalid chunk signature');
         this.metadata.setFormat('container', 'DSF');
         this.metadata.setFormat('lossless', true);
         const dsdChunk = await this.tokenizer.readToken(DsdChunk);

package/lib/ebml/EbmlIterator.d.ts

@@ -0,0 +1,67 @@
+import { type ITokenizer } from 'strtok3';
+import { type IElementType, type ITree, type ValueType } from './types.js';
+declare const EbmlContentError_base: {
+    new (message: string): {
+        readonly fileType: string;
+        toString(): string;
+        name: "UnexpectedFileContentError";
+        message: string;
+        stack?: string;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+export declare class EbmlContentError extends EbmlContentError_base {
+}
+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;
+export {};

package/lib/ebml/EbmlIterator.js

@@ -0,0 +1,223 @@
+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';
+import { makeUnexpectedFileContentError } from '../ParseError.js';
+const debug = initDebug('music-metadata:parser:ebml');
+export class EbmlContentError extends makeUnexpectedFileContentError('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 EbmlContentError('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 EbmlContentError(`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.js

@@ -6,7 +6,10 @@ import { AbstractID3Parser } from '../id3v2/AbstractID3Parser.js';
 import { FourCcToken } from '../common/FourCC.js';
 import { VorbisParser } from '../ogg/vorbis/VorbisParser.js';
 import { VorbisDecoder } from '../ogg/vorbis/VorbisDecoder.js';
+import { makeUnexpectedFileContentError } from '../ParseError.js';
 const debug = initDebug('music-metadata:parser:FLAC');
+class FlacContentError extends makeUnexpectedFileContentError('FLAC') {
+}
 /**
  * FLAC supports up to 128 kinds of metadata blocks; currently the following are defined:
  * ref: https://xiph.org/flac/format.html#metadata_block
@@ -40,7 +43,7 @@ export class FlacParser extends AbstractID3Parser {
     async postId3v2Parse() {
         const fourCC = await this.tokenizer.readToken(FourCcToken);
         if (fourCC.toString() !== 'fLaC') {
-            throw new Error('Invalid FLAC preamble');
+            throw new FlacContentError('Invalid FLAC preamble');
         }
         let blockHeader;
         do {
@@ -84,7 +87,7 @@ export class FlacParser extends AbstractID3Parser {
      */
     async parseBlockStreamInfo(dataLen) {
         if (dataLen !== BlockStreamInfo.len)
-            throw new Error('Unexpected block-stream-info length');
+            throw new FlacContentError('Unexpected block-stream-info length');
         const streamInfo = await this.tokenizer.readToken(BlockStreamInfo);
         this.metadata.setFormat('container', 'FLAC');
         this.metadata.setFormat('codec', 'FLAC');

package/lib/id3v2/FrameParser.d.ts

@@ -57,4 +57,18 @@ export declare class FrameParser {
     private static readIdentifierAndData;
     private static getNullTerminatorLength;
 }
+declare const Id3v2ContentError_base: {
+    new (message: string): {
+        readonly fileType: string;
+        toString(): string;
+        name: "UnexpectedFileContentError";
+        message: string;
+        stack?: string;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+export declare class Id3v2ContentError extends Id3v2ContentError_base {
+}
 export {};

package/lib/id3v2/FrameParser.js

@@ -3,6 +3,7 @@ import * as Token from 'token-types';
 import * as util from '../common/Util.js';
 import { AttachedPictureType, SyncTextHeader, TextEncodingToken, TextHeader } from './ID3v2Token.js';
 import { Genres } from '../id3v1/ID3v1Parser.js';
+import { makeUnexpectedFileContentError } from '../ParseError.js';
 const debug = initDebug('music-metadata:id3v2:frame-parser');
 const defaultEnc = 'latin1'; // latin1 == iso-8859-1;
 export function parseGenre(origVal) {
@@ -158,7 +159,7 @@ export class FrameParser {
                             offset = fzero + 1;
                             break;
                         default:
-                            throw new Error(`Warning: unexpected major versionIndex: ${this.major}`);
+                            throw makeUnexpectedMajorVersionError(this.major);
                     }
                     pic.format = FrameParser.fixPictureMimeType(pic.format);
                     pic.type = AttachedPictureType[uint8Array[offset]];
@@ -370,4 +371,9 @@ export class FrameParser {
         return enc === 'utf-16le' ? 2 : 1;
     }
 }
+export class Id3v2ContentError extends makeUnexpectedFileContentError('id3v2') {
+}
+function makeUnexpectedMajorVersionError(majorVer) {
+    throw new Id3v2ContentError(`Unexpected majorVer: ${majorVer}`);
+}
 //# sourceMappingURL=FrameParser.js.map

package/lib/id3v2/ID3v2Parser.js

@@ -1,6 +1,6 @@
 import * as Token from 'token-types';
 import * as util from '../common/Util.js';
-import { FrameParser } from './FrameParser.js';
+import { FrameParser, Id3v2ContentError } from './FrameParser.js';
 import { ExtendedHeader, ID3v2Header, UINT32SYNCSAFE } from './ID3v2Token.js';
 const asciiDecoder = new TextDecoder('ascii');
 export class ID3v2Parser {
@@ -34,7 +34,7 @@ export class ID3v2Parser {
             case 4:
                 return 10;
             default:
-                throw new Error('header versionIndex is incorrect');
+                throw makeUnexpectedMajorVersionError(majorVer);
         }
     }
     static readFrameFlags(b) {
@@ -54,22 +54,21 @@ export class ID3v2Parser {
         };
     }
     static readFrameData(uint8Array, frameHeader, majorVer, includeCovers, warningCollector) {
-        var _a, _b;
         const frameParser = new FrameParser(majorVer, warningCollector);
         switch (majorVer) {
             case 2:
                 return frameParser.readData(uint8Array, frameHeader.id, includeCovers);
             case 3:
             case 4:
-                if ((_a = frameHeader.flags) === null || _a === void 0 ? void 0 : _a.format.unsynchronisation) {
+                if (frameHeader.flags?.format.unsynchronisation) {
                     uint8Array = ID3v2Parser.removeUnsyncBytes(uint8Array);
                 }
-                if ((_b = frameHeader.flags) === null || _b === void 0 ? void 0 : _b.format.data_length_indicator) {
+                if (frameHeader.flags?.format.data_length_indicator) {
                     uint8Array = uint8Array.slice(4, uint8Array.length);
                 }
                 return frameParser.readData(uint8Array, frameHeader.id, includeCovers);
             default:
-                throw new Error(`Unexpected majorVer: ${majorVer}`);
+                throw makeUnexpectedMajorVersionError(majorVer);
         }
     }
     /**
@@ -87,7 +86,7 @@ export class ID3v2Parser {
         this.options = options;
         const id3Header = await this.tokenizer.readToken(ID3v2Header);
         if (id3Header.fileIdentifier !== 'ID3') {
-            throw new Error('expected ID3-header file-identifier \'ID3\' was not found');
+            throw new Id3v2ContentError('expected ID3-header file-identifier \'ID3\' was not found');
         }
         this.id3Header = id3Header;
         this.headerType = (`ID3v2.${id3Header.version.major}`);
@@ -169,9 +168,12 @@ export class ID3v2Parser {
                 }
                 break;
             default:
-                throw new Error(`Unexpected majorVer: ${majorVer}`);
+                throw makeUnexpectedMajorVersionError(majorVer);
         }
         return header;
     }
 }
+function makeUnexpectedMajorVersionError(majorVer) {
+    throw new Id3v2ContentError(`Unexpected majorVer: ${majorVer}`);
+}
 //# sourceMappingURL=ID3v2Parser.js.map

package/lib/matroska/MatroskaDtd.d.ts

@@ -1,8 +1,8 @@
-import { type IContainerType } from './types.js';
+import { type IElementType } from '../ebml/types.js';
 /**
  * Elements of document type description
  * Derived from https://github.com/tungol/EBML/blob/master/doctypes/matroska.dtd
  * Extended with:
  * - https://www.matroska.org/technical/specs/index.html
  */
-export declare const elements: IContainerType;
+export declare const matroskaDtd: IElementType;