@dragon708/docmind-markdown 1.2.5 → 1.2.7

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

@@ -1,15 +1,17 @@
-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');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaveParser = void 0;
+const strtok3 = require("strtok3/lib/core");
+const Token = require("token-types");
+const debug_1 = require("debug");
+const riff = require("../riff/RiffChunk");
+const WaveChunk = require("./../wav/WaveChunk");
+const ID3v2Parser_1 = require("../id3v2/ID3v2Parser");
+const util = require("../common/Util");
+const FourCC_1 = require("../common/FourCC");
+const BasicParser_1 = require("../common/BasicParser");
+const BwfChunk_1 = require("../wav/BwfChunk");
+const debug = (0, debug_1.default)('music-metadata:parser:RIFF');
 /**
  * Resource Interchange File Format (RIFF) Parser
  *
@@ -21,17 +23,12 @@ const debug = initDebug('music-metadata:parser:RIFF');
  *
  * ToDo: Split WAVE part from RIFF parser
  */
-export class WaveParser extends BasicParser {
-    constructor() {
-        super(...arguments);
-        this.blockAlign = 0;
-    }
+class WaveParser extends BasicParser_1.BasicParser {
     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;
@@ -39,13 +36,13 @@ export class WaveParser extends BasicParser {
         });
     }
     async parseRiffChunk(chunkSize) {
-        const type = await this.tokenizer.readToken(FourCcToken);
+        const type = await this.tokenizer.readToken(FourCC_1.FourCcToken);
         this.metadata.setFormat('container', type);
         switch (type) {
             case 'WAVE':
-                return this.readWaveChunk(chunkSize - FourCcToken.len);
+                return this.readWaveChunk(chunkSize - FourCC_1.FourCcToken.len);
             default:
-                throw new WaveContentError(`Unsupported RIFF format: RIFF/${type}`);
+                throw new Error(`Unsupported RIFF format: RIFF/${type}`);
         }
     }
     async readWaveChunk(remaining) {
@@ -65,12 +62,12 @@ export class WaveParser extends BasicParser {
                     this.metadata.setFormat('lossless', false);
                     this.fact = await this.tokenizer.readToken(new WaveChunk.FactChunk(header));
                     break;
-                case 'fmt ': { // The Util Chunk, non-PCM Formats
+                case 'fmt ': // The Util Chunk, non-PCM Formats
                     const fmt = await this.tokenizer.readToken(new WaveChunk.Format(header));
-                    let subFormat = WaveChunk.WaveFormatNameMap[fmt.wFormatTag];
+                    let subFormat = WaveChunk.WaveFormat[fmt.wFormatTag];
                     if (!subFormat) {
-                        debug(`WAVE/non-PCM format=${fmt.wFormatTag}`);
-                        subFormat = `non-PCM (${fmt.wFormatTag})`;
+                        debug('WAVE/non-PCM format=' + fmt.wFormatTag);
+                        subFormat = 'non-PCM (' + fmt.wFormatTag + ')';
                     }
                     this.metadata.setFormat('codec', subFormat);
                     this.metadata.setFormat('bitsPerSample', fmt.wBitsPerSample);
@@ -79,15 +76,13 @@ export class WaveParser extends BasicParser {
                     this.metadata.setFormat('bitrate', fmt.nBlockAlign * fmt.nSamplesPerSec * 8);
                     this.blockAlign = fmt.nBlockAlign;
                     break;
-                }
                 case 'id3 ': // The way Picard, FooBar currently stores, ID3 meta-data
-                case 'ID3 ': { // The way Mp3Tags 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);
+                    await new ID3v2Parser_1.ID3v2Parser().parse(this.metadata, rst, this.options);
                     break;
-                }
-                case 'data': { // PCM-data
+                case 'data': // PCM-data
                     if (this.metadata.format.lossless !== false) {
                         this.metadata.setFormat('lossless', true);
                     }
@@ -102,36 +97,32 @@ export class WaveParser extends BasicParser {
                     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);
-                        }
+                        this.metadata.setFormat('duration', numberOfSamples / this.metadata.format.sampleRate);
                     }
                     if (this.metadata.format.codec === 'ADPCM') { // ADPCM is 4 bits lossy encoding resulting in 352kbps
                         this.metadata.setFormat('bitrate', 352000);
                     }
-                    else if (this.metadata.format.sampleRate) {
+                    else {
                         this.metadata.setFormat('bitrate', this.blockAlign * this.metadata.format.sampleRate * 8);
                     }
                     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);
+                case 'bext': // Broadcast Audio Extension chunk	https://tech.ebu.ch/docs/tech/tech3285.pdf
+                    const bext = await this.tokenizer.readToken(BwfChunk_1.BroadcastAudioExtensionChunk);
                     Object.keys(bext).forEach(key => {
-                        this.metadata.addTag('exif', `bext.${key}`, bext[key]);
+                        this.metadata.addTag('exif', 'bext.' + key, bext[key]);
                     });
-                    const bextRemaining = header.chunkSize - BroadcastAudioExtensionChunk.len;
+                    const bextRemaining = header.chunkSize - BwfChunk_1.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}`);
+                    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}`);
+                    this.metadata.addWarning('Ignore chunk: RIFF/' + header.chunkID);
                     await this.tokenizer.ignore(header.chunkSize);
             }
             if (this.header.chunkSize % 2 === 1) {
@@ -141,14 +132,15 @@ export class WaveParser extends BasicParser {
         }
     }
     async parseListTag(listHeader) {
-        const listType = await this.tokenizer.readToken(new Token.StringType(4, 'latin1'));
+        const listType = await this.tokenizer.readToken(new Token.StringType(4, 'binary'));
         debug('pos=%s, parseListTag: chunkID=RIFF/WAVE/LIST/%s', this.tokenizer.position, listType);
         switch (listType) {
             case 'INFO':
                 return this.parseRiffInfoTags(listHeader.chunkSize - 4);
+            case 'adtl':
             default:
-                this.metadata.addWarning(`Ignore chunk: RIFF/WAVE/LIST/${listType}`);
-                debug(`Ignoring chunkID=RIFF/WAVE/LIST/${listType}`);
+                this.metadata.addWarning('Ignore chunk: RIFF/WAVE/LIST/' + listType);
+                debug('Ignoring chunkID=RIFF/WAVE/LIST/' + listType);
                 return this.tokenizer.ignore(listHeader.chunkSize - 4).then();
         }
     }
@@ -161,10 +153,11 @@ export class WaveParser extends BasicParser {
             chunkSize -= (8 + valueToken.len);
         }
         if (chunkSize !== 0) {
-            throw new WaveContentError(`Illegal remaining size: ${chunkSize}`);
+            throw Error('Illegal remaining size: ' + chunkSize);
         }
     }
     addTag(id, value) {
         this.metadata.addTag('exif', id, value);
     }
 }
+exports.WaveParser = WaveParser;

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

@@ -1,18 +1,4 @@
-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 {
-}
+import { BasicParser } from '../common/BasicParser';
 /**
  * WavPack Parser
  */
@@ -22,9 +8,7 @@ export declare class WavPackParser extends BasicParser {
     parseWavPackBlocks(): Promise<void>;
     /**
      * Ref: http://www.wavpack.com/WavPack5FileFormat.pdf, 3.0 Metadata Sub-blocks
-     * @param header Header
-     * @param remainingLength Remaining length
+     * @param remainingLength
      */
     private parseMetadataSubBlock;
 }
-export {};

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

@@ -1,39 +1,33 @@
-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') {
-}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WavPackParser = void 0;
+const Token = require("token-types");
+const APEv2Parser_1 = require("../apev2/APEv2Parser");
+const FourCC_1 = require("../common/FourCC");
+const BasicParser_1 = require("../common/BasicParser");
+const WavPackToken_1 = require("./WavPackToken");
+const debug_1 = require("debug");
+const debug = (0, debug_1.default)('music-metadata:parser:WavPack');
 /**
  * WavPack Parser
  */
-export class WavPackParser extends BasicParser {
-    constructor() {
-        super(...arguments);
-        this.audioDataSize = 0;
-    }
+class WavPackParser extends BasicParser_1.BasicParser {
     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);
+        return APEv2Parser_1.APEv2Parser.tryParseApeHeader(this.metadata, this.tokenizer, this.options);
     }
     async parseWavPackBlocks() {
         do {
-            const blockId = await this.tokenizer.peekToken(FourCcToken);
+            const blockId = await this.tokenizer.peekToken(FourCC_1.FourCcToken);
             if (blockId !== 'wvpk')
                 break;
-            const header = await this.tokenizer.readToken(BlockHeaderToken);
+            const header = await this.tokenizer.readToken(WavPackToken_1.WavPack.BlockHeaderToken);
             if (header.BlockID !== 'wvpk')
-                throw new WavPackContentError('Invalid WavPack Block-ID');
-            debug(`WavPack header blockIndex=${header.blockIndex}, len=${BlockHeaderToken.len}`);
+                throw new Error('Invalid WavPack Block-ID');
+            debug(`WavPack header blockIndex=${header.blockIndex}, len=${WavPackToken_1.WavPack.BlockHeaderToken.len}`);
             if (header.blockIndex === 0 && !this.metadata.format.container) {
                 this.metadata.setFormat('container', 'WavPack');
                 this.metadata.setFormat('lossless', !header.flags.isHybrid);
@@ -48,43 +42,38 @@ export class WavPackParser extends BasicParser {
                 this.metadata.setFormat('numberOfSamples', header.totalSamples);
                 this.metadata.setFormat('codec', header.flags.isDSD ? 'DSD' : 'PCM');
             }
-            const ignoreBytes = header.blockSize - (BlockHeaderToken.len - 8);
+            const ignoreBytes = header.blockSize - (WavPackToken_1.WavPack.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);
-        }
+        } while (!this.tokenizer.fileInfo.size || this.tokenizer.fileInfo.size - this.tokenizer.position >= WavPackToken_1.WavPack.BlockHeaderToken.len);
+        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
+     * @param remainingLength
      */
     async parseMetadataSubBlock(header, remainingLength) {
-        let remaining = remainingLength;
-        while (remaining > MetadataIdToken.len) {
-            const id = await this.tokenizer.readToken(MetadataIdToken);
+        while (remainingLength > WavPackToken_1.WavPack.MetadataIdToken.len) {
+            const id = await this.tokenizer.readToken(WavPackToken_1.WavPack.MetadataIdToken);
             const dataSizeInWords = await this.tokenizer.readNumber(id.largeBlock ? Token.UINT24_LE : Token.UINT8);
-            const data = new Uint8Array(dataSizeInWords * 2 - (id.isOddSize ? 1 : 0));
+            const data = Buffer.alloc(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
+                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 mp = 1 << data.readUInt8(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');
+                        throw new Error('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;
@@ -92,18 +81,19 @@ export class WavPackParser extends BasicParser {
                     this.metadata.setFormat('audioMD5', data);
                     break;
                 case 0x2f: // ID_BLOCK_CHECKSUM
-                    debug(`ID_BLOCK_CHECKSUM: checksum=${uint8ArrayToHex(data)}`);
+                    debug(`ID_BLOCK_CHECKSUM: checksum=${data.toString('hex')}`);
                     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}`);
+            remainingLength -= WavPackToken_1.WavPack.MetadataIdToken.len + (id.largeBlock ? Token.UINT24_LE.len : Token.UINT8.len) + dataSizeInWords * 2;
+            debug(`remainingLength=${remainingLength}`);
             if (id.isOddSize)
                 this.tokenizer.ignore(1);
         }
-        if (remaining !== 0)
-            throw new WavPackContentError('metadata-sub-block should fit it remaining length');
+        if (remainingLength !== 0)
+            throw new Error('metadata-sub-block should fit it remaining length');
     }
 }
+exports.WavPackParser = WavPackParser;

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

@@ -1,4 +1,4 @@
-import type { IGetToken } from 'strtok3';
+import { IGetToken } from 'strtok3/lib/core';
 /**
  * WavPack Block Header
  *
@@ -45,16 +45,20 @@ export interface IMetadataId {
      */
     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>;
+export declare class WavPack {
+    /**
+     * 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")
+     */
+    static BlockHeaderToken: IGetToken<IBlockHeader>;
+    /**
+     * 3.0 Metadata Sub-Blocks
+     * Ref: http://www.wavpack.com/WavPack5FileFormat.pdf (page 4/6: 3.0 "Metadata Sub-Block")
+     */
+    static MetadataIdToken: IGetToken<IMetadataId>;
+    private static isBitSet;
+    private static getBitAllignedNumber;
+}

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

@@ -1,7 +1,18 @@
-import * as Token from 'token-types';
-import { FourCcToken } from '../common/FourCC.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WavPack = void 0;
+const Token = require("token-types");
+const FourCC_1 = require("../common/FourCC");
 const SampleRates = [6000, 8000, 9600, 11025, 12000, 16000, 22050, 24000, 32000, 44100,
     48000, 64000, 88200, 96000, 192000, -1];
+class WavPack {
+    static isBitSet(flags, bitOffset) {
+        return WavPack.getBitAllignedNumber(flags, bitOffset, 1) === 1;
+    }
+    static getBitAllignedNumber(flags, bitOffset, len) {
+        return (flags >>> bitOffset) & (0xffffffff >>> (32 - len));
+    }
+}
 /**
  * WavPack Block Header
  *
@@ -9,13 +20,13 @@ const SampleRates = [6000, 8000, 9600, 11025, 12000, 16000, 22050, 24000, 32000,
  *
  * Ref: http://www.wavpack.com/WavPack5FileFormat.pdf (page 2/6: 2.0 "Block Header")
  */
-export const BlockHeaderToken = {
+WavPack.BlockHeaderToken = {
     len: 32,
     get: (buf, off) => {
         const flags = Token.UINT32_LE.get(buf, off + 24);
         const res = {
             // should equal 'wvpk'
-            BlockID: FourCcToken.get(buf, off),
+            BlockID: FourCC_1.FourCcToken.get(buf, off),
             //  0x402 to 0x410 are valid for decode
             blockSize: Token.UINT32_LE.get(buf, off + 4),
             //  0x402 (1026) to 0x410 are valid for decode
@@ -28,15 +39,15 @@ export const BlockHeaderToken = {
             blockSamples: Token.UINT32_LE.get(buf, off + 20),
             // various flags for id and decoding
             flags: {
-                bitsPerSample: (1 + getBitAllignedNumber(flags, 0, 2)) * 8,
-                isMono: isBitSet(flags, 2),
-                isHybrid: isBitSet(flags, 3),
-                isJointStereo: isBitSet(flags, 4),
-                crossChannel: isBitSet(flags, 5),
-                hybridNoiseShaping: isBitSet(flags, 6),
-                floatingPoint: isBitSet(flags, 7),
-                samplingRate: SampleRates[getBitAllignedNumber(flags, 23, 4)],
-                isDSD: isBitSet(flags, 31)
+                bitsPerSample: (1 + WavPack.getBitAllignedNumber(flags, 0, 2)) * 8,
+                isMono: WavPack.isBitSet(flags, 2),
+                isHybrid: WavPack.isBitSet(flags, 3),
+                isJointStereo: WavPack.isBitSet(flags, 4),
+                crossChannel: WavPack.isBitSet(flags, 5),
+                hybridNoiseShaping: WavPack.isBitSet(flags, 6),
+                floatingPoint: WavPack.isBitSet(flags, 7),
+                samplingRate: SampleRates[WavPack.getBitAllignedNumber(flags, 23, 4)],
+                isDSD: WavPack.isBitSet(flags, 31)
             },
             // crc for actual decoded data
             crc: new Token.Uint8ArrayType(4).get(buf, off + 28)
@@ -51,20 +62,15 @@ export const BlockHeaderToken = {
  * 3.0 Metadata Sub-Blocks
  * Ref: http://www.wavpack.com/WavPack5FileFormat.pdf (page 4/6: 3.0 "Metadata Sub-Block")
  */
-export const MetadataIdToken = {
+WavPack.MetadataIdToken = {
     len: 1,
     get: (buf, off) => {
         return {
-            functionId: getBitAllignedNumber(buf[off], 0, 6), // functionId overlaps with isOptional flag
-            isOptional: isBitSet(buf[off], 5),
-            isOddSize: isBitSet(buf[off], 6),
-            largeBlock: isBitSet(buf[off], 7)
+            functionId: WavPack.getBitAllignedNumber(buf[off], 0, 6),
+            isOptional: WavPack.isBitSet(buf[off], 5),
+            isOddSize: WavPack.isBitSet(buf[off], 6),
+            largeBlock: WavPack.isBitSet(buf[off], 7)
         };
     }
 };
-function isBitSet(flags, bitOffset) {
-    return getBitAllignedNumber(flags, bitOffset, 1) === 1;
-}
-function getBitAllignedNumber(flags, bitOffset, len) {
-    return (flags >>> bitOffset) & (0xffffffff >>> (32 - len));
-}
+exports.WavPack = WavPack;