@dragon708/docmind-markdown 1.2.1 → 1.2.3

package/node_modules/music-metadata/lib/core.js

@@ -0,0 +1,126 @@
+/**
+ * Primary entry point, Node.js specific entry point is MusepackParser.ts
+ */
+import { fromWebStream, fromBuffer, fromBlob } from 'strtok3';
+import { ParserFactory } from './ParserFactory.js';
+import { APEv2Parser } from './apev2/APEv2Parser.js';
+import { hasID3v1Header } from './id3v1/ID3v1Parser.js';
+import { getLyricsHeaderLength } from './lyrics3/Lyrics3.js';
+export { LyricsContentType, TimestampFormat } from './type.js';
+export { CouldNotDetermineFileTypeError, UnsupportedFileTypeError } from './ParseError.js';
+export * from './ParseError.js';
+/**
+ * Parse Web API File
+ * Requires Blob to be able to stream using a ReadableStreamBYOBReader, only available since Node.js ≥ 20
+ * @param blob - Blob to parse
+ * @param options - Parsing options
+ * @returns Metadata
+ */
+export async function parseBlob(blob, options = {}) {
+    const tokenizer = fromBlob(blob);
+    try {
+        return await parseFromTokenizer(tokenizer, options);
+    }
+    finally {
+        await tokenizer.close();
+    }
+}
+/**
+ * Parse audio from Web Stream.Readable
+ * @param webStream - WebStream to read the audio track from
+ * @param options - Parsing options
+ * @param fileInfo - File information object or MIME-type string
+ * @returns Metadata
+ */
+export async function parseWebStream(webStream, fileInfo, options = {}) {
+    const tokenizer = fromWebStream(webStream, { fileInfo: typeof fileInfo === 'string' ? { mimeType: fileInfo } : fileInfo });
+    try {
+        return await parseFromTokenizer(tokenizer, options);
+    }
+    finally {
+        await tokenizer.close();
+    }
+}
+/**
+ * Parse audio from memory
+ * @param uint8Array - Uint8Array holding audio data
+ * @param fileInfo - File information object or MIME-type string
+ * @param options - Parsing options
+ * @returns Metadata
+ * Ref: https://github.com/Borewit/strtok3/blob/e6938c81ff685074d5eb3064a11c0b03ca934c1d/src/index.ts#L15
+ */
+export async function parseBuffer(uint8Array, fileInfo, options = {}) {
+    const tokenizer = fromBuffer(uint8Array, { fileInfo: typeof fileInfo === 'string' ? { mimeType: fileInfo } : fileInfo });
+    return parseFromTokenizer(tokenizer, options);
+}
+/**
+ * Parse audio from ITokenizer source
+ * @param tokenizer - Audio source implementing the tokenizer interface
+ * @param options - Parsing options
+ * @returns Metadata
+ */
+export function parseFromTokenizer(tokenizer, options) {
+    const parserFactory = new ParserFactory();
+    return parserFactory.parse(tokenizer, undefined, options);
+}
+/**
+ * Create a dictionary ordered by their tag id (key)
+ * @param nativeTags list of tags
+ * @returns tags indexed by id
+ */
+export function orderTags(nativeTags) {
+    const tags = {};
+    for (const { id, value } of nativeTags) {
+        (tags[id] || (tags[id] = [])).push(value);
+    }
+    return tags;
+}
+/**
+ * Convert rating to 1-5 star rating
+ * @param rating Normalized rating [0..1] (common.rating[n].rating)
+ * @returns Number of stars: 1, 2, 3, 4 or 5 stars
+ */
+export function ratingToStars(rating) {
+    return rating === undefined ? 0 : 1 + Math.round(rating * 4);
+}
+/**
+ * Select most likely cover image.
+ * @param pictures Usually metadata.common.picture
+ * @return Cover image, if any, otherwise null
+ */
+export function selectCover(pictures) {
+    return pictures ? pictures.reduce((acc, cur) => {
+        if (cur.name && cur.name.toLowerCase() in ['front', 'cover', 'cover (front)'])
+            return cur;
+        return acc;
+    }) : null;
+}
+export async function scanAppendingHeaders(tokenizer, options = {}) {
+    let apeOffset = tokenizer.fileInfo.size;
+    if (await hasID3v1Header(tokenizer)) {
+        apeOffset -= 128;
+        const lyricsLen = await getLyricsHeaderLength(tokenizer);
+        apeOffset -= lyricsLen;
+    }
+    options.apeHeader = await APEv2Parser.findApeFooterOffset(tokenizer, apeOffset);
+}
+/**
+ * Implementation only available when loaded as Node.js
+ * This method will throw an Error, always.
+ */
+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 = {}) {
+    throw new Error('This function require a Node engine.');
+}
+/**
+ * Return a list of supported mime-types
+ */
+export function getSupportedMimeTypes() {
+    return new ParserFactory().getSupportedMimeTypes();
+}

package/node_modules/music-metadata/lib/dsdiff/DsdiffLoader.d.ts

@@ -0,0 +1,2 @@
+import type { IParserLoader } from '../ParserFactory.js';
+export declare const dsdiffParserLoader: IParserLoader;

package/node_modules/music-metadata/lib/dsdiff/DsdiffLoader.js

@@ -0,0 +1,8 @@
+export const dsdiffParserLoader = {
+    parserType: 'dsdiff',
+    extensions: ['.dff'],
+    mimeTypes: ['audio/dsf', 'audio/dsd'],
+    async load() {
+        return (await import('./DsdiffParser.js')).DsdiffParser;
+    }
+};

package/node_modules/music-metadata/lib/dsdiff/DsdiffParser.d.ts

@@ -0,0 +1,29 @@
+import { BasicParser } from '../common/BasicParser.js';
+declare const DsdiffContentParseError_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;
+    stackTraceLimit: number;
+};
+export declare class DsdiffContentParseError extends DsdiffContentParseError_base {
+}
+/**
+ * DSDIFF - Direct Stream Digital Interchange File Format (Phillips)
+ *
+ * Ref:
+ * - http://www.sonicstudio.com/pdf/dsd/DSDIFF_1.5_Spec.pdf
+ */
+export declare class DsdiffParser extends BasicParser {
+    parse(): Promise<void>;
+    private readFmt8Chunks;
+    private readData;
+    private handleSoundPropertyChunks;
+    private handleChannelChunks;
+}
+export {};

package/node_modules/music-metadata/lib/dsdiff/DsdiffParser.js

@@ -0,0 +1,154 @@
+import * as Token from 'token-types';
+import initDebug from 'debug';
+import * as strtok3 from 'strtok3';
+import { FourCcToken } from '../common/FourCC.js';
+import { BasicParser } from '../common/BasicParser.js';
+import { ID3v2Parser } from '../id3v2/ID3v2Parser.js';
+import { ChunkHeader64 } from './DsdiffToken.js';
+import { makeUnexpectedFileContentError } from '../ParseError.js';
+const debug = initDebug('music-metadata:parser:aiff');
+export class DsdiffContentParseError extends makeUnexpectedFileContentError('DSDIFF') {
+}
+/**
+ * DSDIFF - Direct Stream Digital Interchange File Format (Phillips)
+ *
+ * Ref:
+ * - http://www.sonicstudio.com/pdf/dsd/DSDIFF_1.5_Spec.pdf
+ */
+export class DsdiffParser extends BasicParser {
+    async parse() {
+        const header = await this.tokenizer.readToken(ChunkHeader64);
+        if (header.chunkID !== 'FRM8')
+            throw new DsdiffContentParseError('Unexpected chunk-ID');
+        this.metadata.setAudioOnly();
+        const type = (await this.tokenizer.readToken(FourCcToken)).trim();
+        switch (type) {
+            case 'DSD':
+                this.metadata.setFormat('container', `DSDIFF/${type}`);
+                this.metadata.setFormat('lossless', true);
+                return this.readFmt8Chunks(header.chunkSize - BigInt(FourCcToken.len));
+            default:
+                throw new DsdiffContentParseError(`Unsupported DSDIFF type: ${type}`);
+        }
+    }
+    async readFmt8Chunks(remainingSize) {
+        while (remainingSize >= ChunkHeader64.len) {
+            const chunkHeader = await this.tokenizer.readToken(ChunkHeader64);
+            //  If the data is an odd number of bytes in length, a pad byte must be added at the end
+            debug(`Chunk id=${chunkHeader.chunkID}`);
+            await this.readData(chunkHeader);
+            remainingSize -= (BigInt(ChunkHeader64.len) + chunkHeader.chunkSize);
+        }
+    }
+    async readData(header) {
+        debug(`Reading data of chunk[ID=${header.chunkID}, size=${header.chunkSize}]`);
+        const p0 = this.tokenizer.position;
+        switch (header.chunkID.trim()) {
+            case 'FVER': { // 3.1 FORMAT VERSION CHUNK
+                const version = await this.tokenizer.readToken(Token.UINT32_LE);
+                debug(`DSDIFF version=${version}`);
+                break;
+            }
+            case 'PROP': { // 3.2 PROPERTY CHUNK
+                const propType = await this.tokenizer.readToken(FourCcToken);
+                if (propType !== 'SND ')
+                    throw new DsdiffContentParseError('Unexpected PROP-chunk ID');
+                await this.handleSoundPropertyChunks(header.chunkSize - BigInt(FourCcToken.len));
+                break;
+            }
+            case 'ID3': { // Unofficial ID3 tag support
+                const id3_data = await this.tokenizer.readToken(new Token.Uint8ArrayType(Number(header.chunkSize)));
+                const rst = strtok3.fromBuffer(id3_data);
+                await new ID3v2Parser().parse(this.metadata, rst, this.options);
+                break;
+            }
+            case 'DSD':
+                if (this.metadata.format.numberOfChannels) {
+                    this.metadata.setFormat('numberOfSamples', Number(header.chunkSize * BigInt(8) / BigInt(this.metadata.format.numberOfChannels)));
+                }
+                if (this.metadata.format.numberOfSamples && this.metadata.format.sampleRate) {
+                    this.metadata.setFormat('duration', this.metadata.format.numberOfSamples / this.metadata.format.sampleRate);
+                }
+                break;
+            default:
+                debug(`Ignore chunk[ID=${header.chunkID}, size=${header.chunkSize}]`);
+                break;
+        }
+        const remaining = header.chunkSize - BigInt(this.tokenizer.position - p0);
+        if (remaining > 0) {
+            debug(`After Parsing chunk, remaining ${remaining} bytes`);
+            await this.tokenizer.ignore(Number(remaining));
+        }
+    }
+    async handleSoundPropertyChunks(remainingSize) {
+        debug(`Parsing sound-property-chunks, remainingSize=${remainingSize}`);
+        while (remainingSize > 0) {
+            const sndPropHeader = await this.tokenizer.readToken(ChunkHeader64);
+            debug(`Sound-property-chunk[ID=${sndPropHeader.chunkID}, size=${sndPropHeader.chunkSize}]`);
+            const p0 = this.tokenizer.position;
+            switch (sndPropHeader.chunkID.trim()) {
+                case 'FS': { // 3.2.1 Sample Rate Chunk
+                    const sampleRate = await this.tokenizer.readToken(Token.UINT32_BE);
+                    this.metadata.setFormat('sampleRate', sampleRate);
+                    break;
+                }
+                case 'CHNL': { // 3.2.2 Channels Chunk
+                    const numChannels = await this.tokenizer.readToken(Token.UINT16_BE);
+                    this.metadata.setFormat('numberOfChannels', numChannels);
+                    await this.handleChannelChunks(sndPropHeader.chunkSize - BigInt(Token.UINT16_BE.len));
+                    break;
+                }
+                case 'CMPR': { // 3.2.3 Compression Type Chunk
+                    const compressionIdCode = (await this.tokenizer.readToken(FourCcToken)).trim();
+                    const count = await this.tokenizer.readToken(Token.UINT8);
+                    const compressionName = await this.tokenizer.readToken(new Token.StringType(count, 'ascii'));
+                    if (compressionIdCode === 'DSD') {
+                        this.metadata.setFormat('lossless', true);
+                        this.metadata.setFormat('bitsPerSample', 1);
+                    }
+                    this.metadata.setFormat('codec', `${compressionIdCode} (${compressionName})`);
+                    break;
+                }
+                case 'ABSS': { // 3.2.4 Absolute Start Time Chunk
+                    const hours = await this.tokenizer.readToken(Token.UINT16_BE);
+                    const minutes = await this.tokenizer.readToken(Token.UINT8);
+                    const seconds = await this.tokenizer.readToken(Token.UINT8);
+                    const samples = await this.tokenizer.readToken(Token.UINT32_BE);
+                    debug(`ABSS ${hours}:${minutes}:${seconds}.${samples}`);
+                    break;
+                }
+                case 'LSCO': { // 3.2.5 Loudspeaker Configuration Chunk
+                    const lsConfig = await this.tokenizer.readToken(Token.UINT16_BE);
+                    debug(`LSCO lsConfig=${lsConfig}`);
+                    break;
+                }
+                default:
+                    debug(`Unknown sound-property-chunk[ID=${sndPropHeader.chunkID}, size=${sndPropHeader.chunkSize}]`);
+                    await this.tokenizer.ignore(Number(sndPropHeader.chunkSize));
+            }
+            const remaining = sndPropHeader.chunkSize - BigInt(this.tokenizer.position - p0);
+            if (remaining > 0) {
+                debug(`After Parsing sound-property-chunk ${sndPropHeader.chunkSize}, remaining ${remaining} bytes`);
+                await this.tokenizer.ignore(Number(remaining));
+            }
+            remainingSize -= BigInt(ChunkHeader64.len) + sndPropHeader.chunkSize;
+            debug(`Parsing sound-property-chunks, remainingSize=${remainingSize}`);
+        }
+        if (this.metadata.format.lossless && this.metadata.format.sampleRate && this.metadata.format.numberOfChannels && this.metadata.format.bitsPerSample) {
+            const bitrate = this.metadata.format.sampleRate * this.metadata.format.numberOfChannels * this.metadata.format.bitsPerSample;
+            this.metadata.setFormat('bitrate', bitrate);
+        }
+    }
+    async handleChannelChunks(remainingSize) {
+        debug(`Parsing channel-chunks, remainingSize=${remainingSize}`);
+        const channels = [];
+        while (remainingSize >= FourCcToken.len) {
+            const channelId = await this.tokenizer.readToken(FourCcToken);
+            debug(`Channel[ID=${channelId}]`);
+            channels.push(channelId);
+            remainingSize -= BigInt(FourCcToken.len);
+        }
+        debug(`Channels: ${channels.join(', ')}`);
+        return channels;
+    }
+}

package/node_modules/music-metadata/lib/dsdiff/DsdiffToken.d.ts

@@ -0,0 +1,9 @@
+import type { IGetToken } from 'strtok3';
+import 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
+ * Ref: http://www.sonicstudio.com/pdf/dsd/DSDIFF_1.5_Spec.pdf
+ */
+export declare const ChunkHeader64: IGetToken<IChunkHeader64>;

package/node_modules/music-metadata/lib/dsdiff/DsdiffToken.js

@@ -0,0 +1,18 @@
+import * as Token from 'token-types';
+import { FourCcToken } from '../common/FourCC.js';
+/**
+ * DSDIFF chunk header
+ * The data-size encoding is deviating from EA-IFF 85
+ * Ref: http://www.sonicstudio.com/pdf/dsd/DSDIFF_1.5_Spec.pdf
+ */
+export const ChunkHeader64 = {
+    len: 12,
+    get: (buf, off) => {
+        return {
+            // Group-ID
+            chunkID: FourCcToken.get(buf, off),
+            // Size
+            chunkSize: Token.INT64_BE.get(buf, off + 4)
+        };
+    }
+};

package/node_modules/music-metadata/lib/dsf/DsfChunk.d.ts

@@ -0,0 +1,87 @@
+import type { IGetToken } from 'strtok3';
+/**
+ * Common interface for the common chunk DSD header
+ */
+export interface IChunkHeader {
+    /**
+     * Chunk ID
+     */
+    id: string;
+    /**
+     * Chunk size
+     */
+    size: bigint;
+}
+/**
+ * Common chunk DSD header: the 'chunk name (Four-CC)' & chunk size
+ */
+export declare const ChunkHeader: IGetToken<IChunkHeader>;
+/**
+ * Interface to DSD payload chunk
+ */
+export interface IDsdChunk {
+    /**
+     * Total file size
+     */
+    fileSize: bigint;
+    /**
+     * If Metadata doesn’t exist, set 0. If the file has ID3v2 tag, then set the pointer to it.
+     * ID3v2 tag should be located in the end of the file.
+     */
+    metadataPointer: bigint;
+}
+/**
+ * Common chunk DSD header: the 'chunk name (Four-CC)' & chunk size
+ */
+export declare const DsdChunk: IGetToken<IDsdChunk>;
+export declare const ChannelType: {
+    mono: number;
+    stereo: number;
+    channels: number;
+    quad: number;
+    '4 channels': number;
+    '5 channels': number;
+    '5.1 channels': number;
+};
+export type ChannelType = typeof ChannelType[keyof typeof ChannelType];
+/**
+ * Interface to format chunk payload chunk
+ */
+export interface IFormatChunk {
+    /**
+     * Version of this file format
+     */
+    formatVersion: number;
+    /**
+     * Format ID
+     */
+    formatID: number;
+    /**
+     * Channel Type
+     */
+    channelType: ChannelType;
+    /**
+     * Channel num
+     */
+    channelNum: number;
+    /**
+     * Sampling frequency
+     */
+    samplingFrequency: number;
+    /**
+     * Bits per sample
+     */
+    bitsPerSample: number;
+    /**
+     * Sample count
+     */
+    sampleCount: bigint;
+    /**
+     * Block size per channel
+     */
+    blockSizePerChannel: number;
+}
+/**
+ * Common chunk DSD header: the 'chunk name (Four-CC)' & chunk size
+ */
+export declare const FormatChunk: IGetToken<IFormatChunk>;

package/node_modules/music-metadata/lib/dsf/DsfChunk.js

@@ -0,0 +1,50 @@
+import * as Token from 'token-types';
+import { FourCcToken } from '../common/FourCC.js';
+/**
+ * Common chunk DSD header: the 'chunk name (Four-CC)' & chunk size
+ */
+export const ChunkHeader = {
+    len: 12,
+    get: (buf, off) => {
+        return { id: FourCcToken.get(buf, off), size: Token.UINT64_LE.get(buf, off + 4) };
+    }
+};
+/**
+ * Common chunk DSD header: the 'chunk name (Four-CC)' & chunk size
+ */
+export const DsdChunk = {
+    len: 16,
+    get: (buf, off) => {
+        return {
+            fileSize: Token.INT64_LE.get(buf, off),
+            metadataPointer: Token.INT64_LE.get(buf, off + 8)
+        };
+    }
+};
+export const ChannelType = {
+    mono: 1,
+    stereo: 2,
+    channels: 3,
+    quad: 4,
+    '4 channels': 5,
+    '5 channels': 6,
+    '5.1 channels': 7
+};
+/**
+ * Common chunk DSD header: the 'chunk name (Four-CC)' & chunk size
+ */
+export const FormatChunk = {
+    len: 40,
+    get: (buf, off) => {
+        return {
+            formatVersion: Token.INT32_LE.get(buf, off),
+            formatID: Token.INT32_LE.get(buf, off + 4),
+            channelType: Token.INT32_LE.get(buf, off + 8),
+            channelNum: Token.INT32_LE.get(buf, off + 12),
+            samplingFrequency: Token.INT32_LE.get(buf, off + 16),
+            bitsPerSample: Token.INT32_LE.get(buf, off + 20),
+            sampleCount: Token.INT64_LE.get(buf, off + 24),
+            blockSizePerChannel: Token.INT32_LE.get(buf, off + 32)
+        };
+    }
+};

package/node_modules/music-metadata/lib/dsf/DsfLoader.d.ts

@@ -0,0 +1,2 @@
+import type { IParserLoader } from '../ParserFactory.js';
+export declare const dsfParserLoader: IParserLoader;

package/node_modules/music-metadata/lib/dsf/DsfLoader.js

@@ -0,0 +1,8 @@
+export const dsfParserLoader = {
+    parserType: 'dsf',
+    extensions: ['.dsf'],
+    mimeTypes: ['audio/dsf'],
+    async load() {
+        return (await import('./DsfParser.js')).DsfParser;
+    }
+};

package/node_modules/music-metadata/lib/dsf/DsfParser.d.ts

@@ -0,0 +1,24 @@
+import { AbstractID3Parser } from '../id3v2/AbstractID3Parser.js';
+declare const DsdContentParseError_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;
+    stackTraceLimit: number;
+};
+export declare class DsdContentParseError extends DsdContentParseError_base {
+}
+/**
+ * DSF (dsd stream file) File Parser
+ * Ref: https://dsd-guide.com/sites/default/files/white-papers/DSFFileFormatSpec_E.pdf
+ */
+export declare class DsfParser extends AbstractID3Parser {
+    postId3v2Parse(): Promise<void>;
+    private parseChunks;
+}
+export {};

package/node_modules/music-metadata/lib/dsf/DsfParser.js

@@ -0,0 +1,57 @@
+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
+ */
+export class DsfParser extends AbstractID3Parser {
+    async postId3v2Parse() {
+        const p0 = this.tokenizer.position; // mark start position, normally 0
+        const chunkHeader = await this.tokenizer.readToken(ChunkHeader);
+        if (chunkHeader.id !== 'DSD ')
+            throw new DsdContentParseError('Invalid chunk signature');
+        this.metadata.setFormat('container', 'DSF');
+        this.metadata.setFormat('lossless', true);
+        this.metadata.setAudioOnly();
+        const dsdChunk = await this.tokenizer.readToken(DsdChunk);
+        if (dsdChunk.metadataPointer === BigInt(0)) {
+            debug("No ID3v2 tag present");
+        }
+        else {
+            debug(`expect ID3v2 at offset=${dsdChunk.metadataPointer}`);
+            await this.parseChunks(dsdChunk.fileSize - chunkHeader.size);
+            // Jump to ID3 header
+            await this.tokenizer.ignore(Number(dsdChunk.metadataPointer) - this.tokenizer.position - p0);
+            return new ID3v2Parser().parse(this.metadata, this.tokenizer, this.options);
+        }
+    }
+    async parseChunks(bytesRemaining) {
+        while (bytesRemaining >= ChunkHeader.len) {
+            const chunkHeader = await this.tokenizer.readToken(ChunkHeader);
+            debug(`Parsing chunk name=${chunkHeader.id} size=${chunkHeader.size}`);
+            switch (chunkHeader.id) {
+                case 'fmt ': {
+                    const formatChunk = await this.tokenizer.readToken(FormatChunk);
+                    this.metadata.setFormat('numberOfChannels', formatChunk.channelNum);
+                    this.metadata.setFormat('sampleRate', formatChunk.samplingFrequency);
+                    this.metadata.setFormat('bitsPerSample', formatChunk.bitsPerSample);
+                    this.metadata.setFormat('numberOfSamples', formatChunk.sampleCount);
+                    this.metadata.setFormat('duration', Number(formatChunk.sampleCount) / formatChunk.samplingFrequency);
+                    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;
+            }
+            bytesRemaining -= chunkHeader.size;
+        }
+    }
+}

package/node_modules/music-metadata/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;
+    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 const ParseAction: {
+    readonly ReadNext: 0;
+    readonly IgnoreElement: 2;
+    readonly SkipSiblings: 3;
+    readonly TerminateParsing: 4;
+    readonly SkipElement: 5;
+};
+export type ParseAction = typeof ParseAction[keyof typeof ParseAction];
+/**
+ * @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 parserMap;
+    private ebmlMaxIDLength;
+    private ebmlMaxSizeLength;
+    private tokenizer;
+    /**
+     * @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 {};