valley-baileys 1.0.0

package/node_modules/music-metadata/lib/wav/BwfChunk.js

@@ -0,0 +1,26 @@
+import * as Token from 'token-types';
+import { stripNulls } from '../common/Util.js';
+/**
+ * Broadcast Audio Extension Chunk
+ * Ref: https://tech.ebu.ch/docs/tech/tech3285.pdf
+ */
+export const BroadcastAudioExtensionChunk = {
+    len: 420,
+    get: (uint8array, off) => {
+        return {
+            description: stripNulls(new Token.StringType(256, 'ascii').get(uint8array, off)).trim(),
+            originator: stripNulls(new Token.StringType(32, 'ascii').get(uint8array, off + 256)).trim(),
+            originatorReference: stripNulls(new Token.StringType(32, 'ascii').get(uint8array, off + 288)).trim(),
+            originationDate: stripNulls(new Token.StringType(10, 'ascii').get(uint8array, off + 320)).trim(),
+            originationTime: stripNulls(new Token.StringType(8, 'ascii').get(uint8array, off + 330)).trim(),
+            timeReferenceLow: Token.UINT32_LE.get(uint8array, off + 338),
+            timeReferenceHigh: Token.UINT32_LE.get(uint8array, off + 342),
+            version: Token.UINT16_LE.get(uint8array, off + 346),
+            umid: new Token.Uint8ArrayType(64).get(uint8array, off + 348),
+            loudnessValue: Token.UINT16_LE.get(uint8array, off + 412),
+            maxTruePeakLevel: Token.UINT16_LE.get(uint8array, off + 414),
+            maxMomentaryLoudness: Token.UINT16_LE.get(uint8array, off + 416),
+            maxShortTermLoudness: Token.UINT16_LE.get(uint8array, off + 418)
+        };
+    }
+};

package/node_modules/music-metadata/lib/wav/WaveChunk.d.ts

@@ -0,0 +1,104 @@
+import type { IGetToken } from 'strtok3';
+import type { IChunkHeader } from '../iff/index.js';
+declare const WaveContentError_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 WaveContentError extends WaveContentError_base {
+}
+/**
+ * Ref: https://msdn.microsoft.com/en-us/library/windows/desktop/dd317599(v=vs.85).aspx
+ */
+export declare const WaveFormat: {
+    PCM: number;
+    ADPCM: number;
+    IEEE_FLOAT: number;
+    ALAW: number;
+    MULAW: number;
+    DVI_ADPCM: number;
+    GSM610: number;
+    MPEG_ADTS_AAC: number;
+    MPEG_LOAS: number;
+    RAW_AAC1: number;
+    DOLBY_AC3_SPDIF: number;
+    DVM: number;
+    RAW_SPORT: number;
+    ESST_AC3: number;
+    DRM: number;
+    DTS2: number;
+    MPEG: number;
+    MPEGLAYER3: number;
+};
+export type WaveFormat = typeof WaveFormat[keyof typeof WaveFormat];
+export declare const WaveFormatNameMap: {
+    [WaveFormat.PCM]: string;
+    [WaveFormat.ADPCM]: string;
+    [WaveFormat.IEEE_FLOAT]: string;
+    [WaveFormat.ALAW]: string;
+    [WaveFormat.MULAW]: string;
+    [WaveFormat.DVI_ADPCM]: string;
+    [WaveFormat.GSM610]: string;
+    [WaveFormat.MPEG_ADTS_AAC]: string;
+    [WaveFormat.MPEG_LOAS]: string;
+    [WaveFormat.RAW_AAC1]: string;
+    [WaveFormat.DOLBY_AC3_SPDIF]: string;
+    [WaveFormat.DVM]: string;
+    [WaveFormat.RAW_SPORT]: string;
+    [WaveFormat.ESST_AC3]: string;
+    [WaveFormat.DRM]: string;
+    [WaveFormat.DTS2]: string;
+    [WaveFormat.MPEG]: string;
+    [WaveFormat.MPEGLAYER3]: string;
+};
+/**
+ * "fmt"  sub-chunk describes the sound data's format
+ * Ref: http://soundfile.sapp.org/doc/WaveFormat
+ */
+export interface IWaveFormat {
+    /**
+     * PCM = 1 (i.e. Linear quantization). Values other than 1 indicate some form of compression.
+     */
+    wFormatTag: WaveFormat;
+    /**
+     * Mono = 1, Stereo = 2, etc.
+     */
+    nChannels: number;
+    /**
+     * 8000, 44100, etc.
+     */
+    nSamplesPerSec: number;
+    nAvgBytesPerSec: number;
+    nBlockAlign: number;
+    wBitsPerSample: number;
+}
+/**
+ * format chunk; chunk-id is "fmt "
+ * http://soundfile.sapp.org/doc/WaveFormat/
+ */
+export declare class Format implements IGetToken<IWaveFormat> {
+    len: number;
+    constructor(header: IChunkHeader);
+    get(buf: Uint8Array, off: number): IWaveFormat;
+}
+export interface IFactChunk {
+    dwSampleLength: number;
+}
+/**
+ * Fact chunk; chunk-id is "fact"
+ * http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/WAVE/WAVE.html
+ * http://www.recordingblogs.com/wiki/fact-chunk-of-a-wave-file
+ */
+export declare class FactChunk implements IGetToken<IFactChunk> {
+    len: number;
+    constructor(header: IChunkHeader);
+    get(buf: Uint8Array, off: number): IFactChunk;
+}
+export {};

package/node_modules/music-metadata/lib/wav/WaveChunk.js

@@ -0,0 +1,88 @@
+import * as Token from 'token-types';
+import { makeUnexpectedFileContentError } from '../ParseError.js';
+export class WaveContentError extends makeUnexpectedFileContentError('Wave') {
+}
+/**
+ * Ref: https://msdn.microsoft.com/en-us/library/windows/desktop/dd317599(v=vs.85).aspx
+ */
+export const WaveFormat = {
+    PCM: 0x0001,
+    ADPCM: 0x0002,
+    IEEE_FLOAT: 0x0003,
+    ALAW: 0x0006,
+    MULAW: 0x0007,
+    DVI_ADPCM: 0x0011,
+    GSM610: 0x0031,
+    // MPEG-4 and AAC Audio Types
+    MPEG_ADTS_AAC: 0x1600,
+    MPEG_LOAS: 0x1602,
+    RAW_AAC1: 0x00FF,
+    // Dolby Audio Types
+    DOLBY_AC3_SPDIF: 0x0092,
+    DVM: 0x2000,
+    RAW_SPORT: 0x0240,
+    ESST_AC3: 0x0241,
+    DRM: 0x0009,
+    DTS2: 0x2001,
+    MPEG: 0x0050,
+    MPEGLAYER3: 0x0055
+};
+export const WaveFormatNameMap = {
+    [WaveFormat.PCM]: 'PCM',
+    [WaveFormat.ADPCM]: 'ADPCM',
+    [WaveFormat.IEEE_FLOAT]: 'IEEE_FLOAT',
+    [WaveFormat.ALAW]: 'ALAW',
+    [WaveFormat.MULAW]: 'MULAW',
+    [WaveFormat.DVI_ADPCM]: 'DVI_ADPCM',
+    [WaveFormat.GSM610]: 'GSM610',
+    [WaveFormat.MPEG_ADTS_AAC]: 'MPEG_ADTS_AAC',
+    [WaveFormat.MPEG_LOAS]: 'MPEG_LOAS',
+    [WaveFormat.RAW_AAC1]: 'RAW_AAC1',
+    [WaveFormat.DOLBY_AC3_SPDIF]: 'DOLBY_AC3_SPDIF',
+    [WaveFormat.DVM]: 'DVM',
+    [WaveFormat.RAW_SPORT]: 'RAW_SPORT',
+    [WaveFormat.ESST_AC3]: 'ESST_AC3',
+    [WaveFormat.DRM]: 'DRM',
+    [WaveFormat.DTS2]: 'DTS2',
+    [WaveFormat.MPEG]: 'MPEG',
+    [WaveFormat.MPEGLAYER3]: 'MPEGLAYER3'
+};
+/**
+ * format chunk; chunk-id is "fmt "
+ * http://soundfile.sapp.org/doc/WaveFormat/
+ */
+export class Format {
+    constructor(header) {
+        if (header.chunkSize < 16)
+            throw new WaveContentError('Invalid chunk size');
+        this.len = header.chunkSize;
+    }
+    get(buf, off) {
+        return {
+            wFormatTag: Token.UINT16_LE.get(buf, off),
+            nChannels: Token.UINT16_LE.get(buf, off + 2),
+            nSamplesPerSec: Token.UINT32_LE.get(buf, off + 4),
+            nAvgBytesPerSec: Token.UINT32_LE.get(buf, off + 8),
+            nBlockAlign: Token.UINT16_LE.get(buf, off + 12),
+            wBitsPerSample: Token.UINT16_LE.get(buf, off + 14)
+        };
+    }
+}
+/**
+ * Fact chunk; chunk-id is "fact"
+ * http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/WAVE/WAVE.html
+ * http://www.recordingblogs.com/wiki/fact-chunk-of-a-wave-file
+ */
+export class FactChunk {
+    constructor(header) {
+        if (header.chunkSize < 4) {
+            throw new WaveContentError('Invalid fact chunk size.');
+        }
+        this.len = header.chunkSize;
+    }
+    get(buf, off) {
+        return {
+            dwSampleLength: Token.UINT32_LE.get(buf, off)
+        };
+    }
+}

package/node_modules/music-metadata/lib/wav/WaveLoader.d.ts

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

package/node_modules/music-metadata/lib/wav/WaveLoader.js

@@ -0,0 +1,8 @@
+export const riffParserLoader = {
+    parserType: 'riff',
+    extensions: ['.wav', 'wave', '.bwf'],
+    mimeTypes: ['audio/vnd.wave', 'audio/wav', 'audio/wave'],
+    async load() {
+        return (await import('./WaveParser.js')).WaveParser;
+    }
+};

package/node_modules/music-metadata/lib/wav/WaveParser.d.ts

@@ -0,0 +1,25 @@
+import * as riff from '../riff/RiffChunk.js';
+import { BasicParser } from '../common/BasicParser.js';
+/**
+ * Resource Interchange File Format (RIFF) Parser
+ *
+ * WAVE PCM soundfile format
+ *
+ * Ref:
+ * - http://www.johnloomis.org/cpe102/asgn/asgn1/riff.html
+ * - http://soundfile.sapp.org/doc/WaveFormat
+ *
+ * ToDo: Split WAVE part from RIFF parser
+ */
+export declare class WaveParser extends BasicParser {
+    private fact;
+    private blockAlign;
+    private avgBytesPerSec;
+    private header;
+    parse(): Promise<void>;
+    parseRiffChunk(chunkSize: number): Promise<void>;
+    readWaveChunk(remaining: number): Promise<void>;
+    parseListTag(listHeader: riff.IChunkHeader): Promise<void>;
+    private parseRiffInfoTags;
+    private addTag;
+}

package/node_modules/music-metadata/lib/wav/WaveParser.js

@@ -0,0 +1,171 @@
+import * as strtok3 from 'strtok3';
+import * as Token from 'token-types';
+import initDebug from 'debug';
+import * as riff from '../riff/RiffChunk.js';
+import * as WaveChunk from './WaveChunk.js';
+import { ID3v2Parser } from '../id3v2/ID3v2Parser.js';
+import * as util from '../common/Util.js';
+import { FourCcToken } from '../common/FourCC.js';
+import { BasicParser } from '../common/BasicParser.js';
+import { BroadcastAudioExtensionChunk } from './BwfChunk.js';
+import { WaveContentError } from './WaveChunk.js';
+const debug = initDebug('music-metadata:parser:RIFF');
+/**
+ * Resource Interchange File Format (RIFF) Parser
+ *
+ * WAVE PCM soundfile format
+ *
+ * Ref:
+ * - http://www.johnloomis.org/cpe102/asgn/asgn1/riff.html
+ * - http://soundfile.sapp.org/doc/WaveFormat
+ *
+ * ToDo: Split WAVE part from RIFF parser
+ */
+export class WaveParser extends BasicParser {
+    constructor() {
+        super(...arguments);
+        this.blockAlign = 0;
+        this.avgBytesPerSec = 0;
+    }
+    async parse() {
+        const riffHeader = await this.tokenizer.readToken(riff.Header);
+        debug(`pos=${this.tokenizer.position}, parse: chunkID=${riffHeader.chunkID}`);
+        if (riffHeader.chunkID !== 'RIFF')
+            return; // Not RIFF format
+        this.metadata.setAudioOnly();
+        return this.parseRiffChunk(riffHeader.chunkSize).catch(err => {
+            if (!(err instanceof strtok3.EndOfStreamError)) {
+                throw err;
+            }
+        });
+    }
+    async parseRiffChunk(chunkSize) {
+        const type = await this.tokenizer.readToken(FourCcToken);
+        this.metadata.setFormat('container', type);
+        switch (type) {
+            case 'WAVE':
+                return this.readWaveChunk(chunkSize - FourCcToken.len);
+            default:
+                throw new WaveContentError(`Unsupported RIFF format: RIFF/${type}`);
+        }
+    }
+    async readWaveChunk(remaining) {
+        while (remaining >= riff.Header.len) {
+            const header = await this.tokenizer.readToken(riff.Header);
+            remaining -= riff.Header.len + header.chunkSize;
+            if (header.chunkSize > remaining) {
+                this.metadata.addWarning('Data chunk size exceeds file size');
+            }
+            this.header = header;
+            debug(`pos=${this.tokenizer.position}, readChunk: chunkID=RIFF/WAVE/${header.chunkID}`);
+            switch (header.chunkID) {
+                case 'LIST':
+                    await this.parseListTag(header);
+                    break;
+                case 'fact': // extended Format chunk,
+                    this.metadata.setFormat('lossless', false);
+                    this.fact = await this.tokenizer.readToken(new WaveChunk.FactChunk(header));
+                    break;
+                case 'fmt ': { // The Util Chunk, non-PCM Formats
+                    const fmt = await this.tokenizer.readToken(new WaveChunk.Format(header));
+                    let subFormat = WaveChunk.WaveFormatNameMap[fmt.wFormatTag];
+                    if (!subFormat) {
+                        debug(`WAVE/non-PCM format=${fmt.wFormatTag}`);
+                        subFormat = `non-PCM (${fmt.wFormatTag})`;
+                    }
+                    this.metadata.setFormat('codec', subFormat);
+                    this.metadata.setFormat('bitsPerSample', fmt.wBitsPerSample);
+                    this.metadata.setFormat('sampleRate', fmt.nSamplesPerSec);
+                    this.metadata.setFormat('numberOfChannels', fmt.nChannels);
+                    this.blockAlign = fmt.nBlockAlign;
+                    this.avgBytesPerSec = fmt.nAvgBytesPerSec;
+                    break;
+                }
+                case 'id3 ': // The way Picard, FooBar currently stores, ID3 meta-data
+                case 'ID3 ': { // The way Mp3Tags stores ID3 meta-data
+                    const id3_data = await this.tokenizer.readToken(new Token.Uint8ArrayType(header.chunkSize));
+                    const rst = strtok3.fromBuffer(id3_data);
+                    await new ID3v2Parser().parse(this.metadata, rst, this.options);
+                    break;
+                }
+                case 'data': { // PCM-data
+                    if (this.metadata.format.lossless !== false) {
+                        this.metadata.setFormat('lossless', true);
+                    }
+                    let chunkSize = header.chunkSize;
+                    if (this.tokenizer.fileInfo.size) {
+                        const calcRemaining = this.tokenizer.fileInfo.size - this.tokenizer.position;
+                        if (calcRemaining < chunkSize) {
+                            this.metadata.addWarning('data chunk length exceeding file length');
+                            chunkSize = calcRemaining;
+                        }
+                    }
+                    const numberOfSamples = this.fact ? this.fact.dwSampleLength : (chunkSize === 0xffffffff ? undefined : chunkSize / this.blockAlign);
+                    if (numberOfSamples) {
+                        this.metadata.setFormat('numberOfSamples', numberOfSamples);
+                        if (this.metadata.format.sampleRate) {
+                            this.metadata.setFormat('duration', numberOfSamples / this.metadata.format.sampleRate);
+                        }
+                    }
+                    if (this.avgBytesPerSec > 0) {
+                        this.metadata.setFormat('bitrate', this.avgBytesPerSec * 8);
+                    }
+                    else if (this.metadata.format.duration) {
+                        this.metadata.setFormat('bitrate', chunkSize * 8 / this.metadata.format.duration);
+                    }
+                    await this.tokenizer.ignore(header.chunkSize);
+                    break;
+                }
+                case 'bext': { // Broadcast Audio Extension chunk	https://tech.ebu.ch/docs/tech/tech3285.pdf
+                    const bext = await this.tokenizer.readToken(BroadcastAudioExtensionChunk);
+                    Object.keys(bext).forEach(key => {
+                        this.metadata.addTag('exif', `bext.${key}`, bext[key]);
+                    });
+                    const bextRemaining = header.chunkSize - BroadcastAudioExtensionChunk.len;
+                    await this.tokenizer.ignore(bextRemaining);
+                    break;
+                }
+                case '\x00\x00\x00\x00': // padding ??
+                    debug(`Ignore padding chunk: RIFF/${header.chunkID} of ${header.chunkSize} bytes`);
+                    this.metadata.addWarning(`Ignore chunk: RIFF/${header.chunkID}`);
+                    await this.tokenizer.ignore(header.chunkSize);
+                    break;
+                default:
+                    debug(`Ignore chunk: RIFF/${header.chunkID} of ${header.chunkSize} bytes`);
+                    this.metadata.addWarning(`Ignore chunk: RIFF/${header.chunkID}`);
+                    await this.tokenizer.ignore(header.chunkSize);
+            }
+            if (this.header.chunkSize % 2 === 1) {
+                debug('Read odd padding byte'); // https://wiki.multimedia.cx/index.php/RIFF
+                await this.tokenizer.ignore(1);
+            }
+        }
+    }
+    async parseListTag(listHeader) {
+        const listType = await this.tokenizer.readToken(new Token.StringType(4, 'latin1'));
+        debug('pos=%s, parseListTag: chunkID=RIFF/WAVE/LIST/%s', this.tokenizer.position, listType);
+        switch (listType) {
+            case 'INFO':
+                return this.parseRiffInfoTags(listHeader.chunkSize - 4);
+            default:
+                this.metadata.addWarning(`Ignore chunk: RIFF/WAVE/LIST/${listType}`);
+                debug(`Ignoring chunkID=RIFF/WAVE/LIST/${listType}`);
+                return this.tokenizer.ignore(listHeader.chunkSize - 4).then();
+        }
+    }
+    async parseRiffInfoTags(chunkSize) {
+        while (chunkSize >= 8) {
+            const header = await this.tokenizer.readToken(riff.Header);
+            const valueToken = new riff.ListInfoTagValue(header);
+            const value = await this.tokenizer.readToken(valueToken);
+            this.addTag(header.chunkID, util.stripNulls(value));
+            chunkSize -= (8 + valueToken.len);
+        }
+        if (chunkSize !== 0) {
+            throw new WaveContentError(`Illegal remaining size: ${chunkSize}`);
+        }
+    }
+    addTag(id, value) {
+        this.metadata.addTag('exif', id, value);
+    }
+}

package/node_modules/music-metadata/lib/wavpack/WavPackLoader.d.ts

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

package/node_modules/music-metadata/lib/wavpack/WavPackLoader.js

@@ -0,0 +1,8 @@
+export const wavpackParserLoader = {
+    parserType: 'wavpack',
+    extensions: ['.wv', '.wvp'],
+    mimeTypes: ['audio/wavpack'],
+    async load() {
+        return (await import('./WavPackParser.js')).WavPackParser;
+    }
+};

package/node_modules/music-metadata/lib/wavpack/WavPackParser.d.ts

@@ -0,0 +1,30 @@
+import { BasicParser } from '../common/BasicParser.js';
+declare const WavPackContentError_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 WavPackContentError extends WavPackContentError_base {
+}
+/**
+ * WavPack Parser
+ */
+export declare class WavPackParser extends BasicParser {
+    private audioDataSize;
+    parse(): Promise<void>;
+    parseWavPackBlocks(): Promise<void>;
+    /**
+     * Ref: http://www.wavpack.com/WavPack5FileFormat.pdf, 3.0 Metadata Sub-blocks
+     * @param header Header
+     * @param remainingLength Remaining length
+     */
+    private parseMetadataSubBlock;
+}
+export {};

package/node_modules/music-metadata/lib/wavpack/WavPackParser.js

@@ -0,0 +1,109 @@
+import * as Token from 'token-types';
+import { tryParseApeHeader } from '../apev2/APEv2Parser.js';
+import { FourCcToken } from '../common/FourCC.js';
+import { BasicParser } from '../common/BasicParser.js';
+import { BlockHeaderToken, MetadataIdToken } from './WavPackToken.js';
+import initDebug from 'debug';
+import { uint8ArrayToHex } from 'uint8array-extras';
+import { makeUnexpectedFileContentError } from '../ParseError.js';
+const debug = initDebug('music-metadata:parser:WavPack');
+export class WavPackContentError extends makeUnexpectedFileContentError('WavPack') {
+}
+/**
+ * WavPack Parser
+ */
+export class WavPackParser extends BasicParser {
+    constructor() {
+        super(...arguments);
+        this.audioDataSize = 0;
+    }
+    async parse() {
+        this.metadata.setAudioOnly();
+        this.audioDataSize = 0;
+        // First parse all WavPack blocks
+        await this.parseWavPackBlocks();
+        // try to parse APEv2 header
+        return tryParseApeHeader(this.metadata, this.tokenizer, this.options);
+    }
+    async parseWavPackBlocks() {
+        do {
+            const blockId = await this.tokenizer.peekToken(FourCcToken);
+            if (blockId !== 'wvpk')
+                break;
+            const header = await this.tokenizer.readToken(BlockHeaderToken);
+            if (header.BlockID !== 'wvpk')
+                throw new WavPackContentError('Invalid WavPack Block-ID');
+            debug(`WavPack header blockIndex=${header.blockIndex}, len=${BlockHeaderToken.len}`);
+            if (header.blockIndex === 0 && !this.metadata.format.container) {
+                this.metadata.setFormat('container', 'WavPack');
+                this.metadata.setFormat('lossless', !header.flags.isHybrid);
+                // tagTypes: this.type,
+                this.metadata.setFormat('bitsPerSample', header.flags.bitsPerSample);
+                if (!header.flags.isDSD) {
+                    // In case isDSD, these values will ne set in ID_DSD_BLOCK
+                    this.metadata.setFormat('sampleRate', header.flags.samplingRate);
+                    this.metadata.setFormat('duration', header.totalSamples / header.flags.samplingRate);
+                }
+                this.metadata.setFormat('numberOfChannels', header.flags.isMono ? 1 : 2);
+                this.metadata.setFormat('numberOfSamples', header.totalSamples);
+                this.metadata.setFormat('codec', header.flags.isDSD ? 'DSD' : 'PCM');
+            }
+            const ignoreBytes = header.blockSize - (BlockHeaderToken.len - 8);
+            await (header.blockIndex === 0 ? this.parseMetadataSubBlock(header, ignoreBytes) : this.tokenizer.ignore(ignoreBytes));
+            if (header.blockSamples > 0) {
+                this.audioDataSize += header.blockSize; // Count audio data for bit-rate calculation
+            }
+        } while (!this.tokenizer.fileInfo.size || this.tokenizer.fileInfo.size - this.tokenizer.position >= BlockHeaderToken.len);
+        if (this.metadata.format.duration) {
+            this.metadata.setFormat('bitrate', this.audioDataSize * 8 / this.metadata.format.duration);
+        }
+    }
+    /**
+     * Ref: http://www.wavpack.com/WavPack5FileFormat.pdf, 3.0 Metadata Sub-blocks
+     * @param header Header
+     * @param remainingLength Remaining length
+     */
+    async parseMetadataSubBlock(header, remainingLength) {
+        let remaining = remainingLength;
+        while (remaining > MetadataIdToken.len) {
+            const id = await this.tokenizer.readToken(MetadataIdToken);
+            const dataSizeInWords = await this.tokenizer.readNumber(id.largeBlock ? Token.UINT24_LE : Token.UINT8);
+            const data = new Uint8Array(dataSizeInWords * 2 - (id.isOddSize ? 1 : 0));
+            await this.tokenizer.readBuffer(data);
+            debug(`Metadata Sub-Blocks functionId=0x${id.functionId.toString(16)}, id.largeBlock=${id.largeBlock},data-size=${data.length}`);
+            switch (id.functionId) {
+                case 0x0: // ID_DUMMY: could be used to pad WavPack blocks
+                    break;
+                case 0xe: { // ID_DSD_BLOCK
+                    debug('ID_DSD_BLOCK');
+                    // https://github.com/dbry/WavPack/issues/71#issuecomment-483094813
+                    const mp = 1 << Token.UINT8.get(data, 0);
+                    const samplingRate = header.flags.samplingRate * mp * 8; // ToDo: second factor should be read from DSD-metadata block https://github.com/dbry/WavPack/issues/71#issuecomment-483094813
+                    if (!header.flags.isDSD)
+                        throw new WavPackContentError('Only expect DSD block if DSD-flag is set');
+                    this.metadata.setFormat('sampleRate', samplingRate);
+                    this.metadata.setFormat('duration', header.totalSamples / samplingRate);
+                    break;
+                }
+                case 0x24: // ID_ALT_TRAILER: maybe used to embed original ID3 tag header
+                    debug('ID_ALT_TRAILER: trailer for non-wav files');
+                    break;
+                case 0x26: // ID_MD5_CHECKSUM
+                    this.metadata.setFormat('audioMD5', data);
+                    break;
+                case 0x2f: // ID_BLOCK_CHECKSUM
+                    debug(`ID_BLOCK_CHECKSUM: checksum=${uint8ArrayToHex(data)}`);
+                    break;
+                default:
+                    debug(`Ignore unsupported meta-sub-block-id functionId=0x${id.functionId.toString(16)}`);
+                    break;
+            }
+            remaining -= MetadataIdToken.len + (id.largeBlock ? Token.UINT24_LE.len : Token.UINT8.len) + dataSizeInWords * 2;
+            debug(`remainingLength=${remaining}`);
+            if (id.isOddSize)
+                this.tokenizer.ignore(1);
+        }
+        if (remaining !== 0)
+            throw new WavPackContentError('metadata-sub-block should fit it remaining length');
+    }
+}

package/node_modules/music-metadata/lib/wavpack/WavPackToken.d.ts

@@ -0,0 +1,60 @@
+import type { IGetToken } from 'strtok3';
+/**
+ * WavPack Block Header
+ *
+ * 32-byte little-endian header at the front of every WavPack block
+ *
+ * Ref:
+ * - http://www.wavpack.com/WavPack5FileFormat.pdf (page 2/6: 2.0 "Block Header")
+ */
+export interface IBlockHeader {
+    BlockID: string;
+    blockSize: number;
+    version: number;
+    blockIndex: number;
+    totalSamples: number;
+    blockSamples: number;
+    flags: {
+        bitsPerSample: number;
+        isMono: boolean;
+        isHybrid: boolean;
+        isJointStereo: boolean;
+        crossChannel: boolean;
+        hybridNoiseShaping: boolean;
+        floatingPoint: boolean;
+        samplingRate: number;
+        isDSD: boolean;
+    };
+    crc: Uint8Array;
+}
+export interface IMetadataId {
+    /**
+     * metadata function id
+     */
+    functionId: number;
+    /**
+     * If true, audio-decoder does not need to understand the metadata field
+     */
+    isOptional: boolean;
+    /**
+     * actual data byte length is 1 less
+     */
+    isOddSize: boolean;
+    /**
+     * large block (> 255 words)
+     */
+    largeBlock: boolean;
+}
+/**
+ * WavPack Block Header
+ *
+ * 32-byte little-endian header at the front of every WavPack block
+ *
+ * Ref: http://www.wavpack.com/WavPack5FileFormat.pdf (page 2/6: 2.0 "Block Header")
+ */
+export declare const BlockHeaderToken: IGetToken<IBlockHeader>;
+/**
+ * 3.0 Metadata Sub-Blocks
+ * Ref: http://www.wavpack.com/WavPack5FileFormat.pdf (page 4/6: 3.0 "Metadata Sub-Block")
+ */
+export declare const MetadataIdToken: IGetToken<IMetadataId>;