@dragon708/docmind-markdown 1.2.5 → 1.2.6

package/node_modules/music-metadata/lib/mpeg/ExtendedLameHeader.d.ts

@@ -1,8 +1,8 @@
 /**
  * Extended Lame Header
  */
-import type { IGetToken } from 'strtok3';
-import { type IReplayGain } from './ReplayGainDataFormat.js';
+import { IGetToken } from 'strtok3/lib/core';
+import { IReplayGain } from './ReplayGainDataFormat';
 /**
  * LAME Tag, extends the Xing header format
  * First added in LAME 3.12 for VBR
@@ -12,9 +12,9 @@ export interface IExtendedLameHeader {
     revision: number;
     vbr_method: number;
     lowpass_filter: number;
-    track_peak?: number | null;
-    track_gain?: IReplayGain;
-    album_gain?: IReplayGain;
+    track_peak?: number;
+    track_gain: IReplayGain;
+    album_gain: IReplayGain;
     music_length: number;
     music_crc: number;
     header_crc: number;

package/node_modules/music-metadata/lib/mpeg/ExtendedLameHeader.js

@@ -1,15 +1,18 @@
+"use strict";
 /**
  * Extended Lame Header
  */
-import * as Token from 'token-types';
-import * as common from '../common/Util.js';
-import { ReplayGain } from './ReplayGainDataFormat.js';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtendedLameHeader = void 0;
+const Token = require("token-types");
+const common = require("../common/Util");
+const ReplayGainDataFormat_1 = require("./ReplayGainDataFormat");
 /**
  * Info Tag
  * @link http://gabriel.mp3-tech.org/mp3infotag.html
  * @link https://github.com/quodlibet/mutagen/blob/abd58ee58772224334a18817c3fb31103572f70e/mutagen/mp3/_util.py#L112
  */
-export const ExtendedLameHeader = {
+exports.ExtendedLameHeader = {
     len: 27,
     get: (buf, off) => {
         const track_peak = Token.UINT32_BE.get(buf, off + 2);
@@ -17,9 +20,9 @@ export const ExtendedLameHeader = {
             revision: common.getBitAllignedNumber(buf, off, 0, 4),
             vbr_method: common.getBitAllignedNumber(buf, off, 4, 4),
             lowpass_filter: 100 * Token.UINT8.get(buf, off + 1),
-            track_peak: track_peak === 0 ? null : track_peak / 2 ** 23,
-            track_gain: ReplayGain.get(buf, 6),
-            album_gain: ReplayGain.get(buf, 8),
+            track_peak: track_peak === 0 ? undefined : track_peak / Math.pow(2, 23),
+            track_gain: ReplayGainDataFormat_1.ReplayGain.get(buf, 6),
+            album_gain: ReplayGainDataFormat_1.ReplayGain.get(buf, 8),
             music_length: Token.UINT32_BE.get(buf, off + 20),
             music_crc: Token.UINT8.get(buf, off + 24),
             header_crc: Token.UINT16_BE.get(buf, off + 24)

package/node_modules/music-metadata/lib/mpeg/MpegParser.d.ts

@@ -1,26 +1,14 @@
-import { AbstractID3Parser } from '../id3v2/AbstractID3Parser.js';
-declare const MpegContentError_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 MpegContentError extends MpegContentError_base {
-}
+import { AbstractID3Parser } from '../id3v2/AbstractID3Parser';
 export declare class MpegParser extends AbstractID3Parser {
     private frameCount;
     private syncFrameCount;
+    private countSkipFrameData;
     private totalDataLength;
-    private audioFrameHeader?;
+    private audioFrameHeader;
     private bitrates;
     private offset;
     private frame_size;
+    private crc;
     private calculateEofDuration;
     private samplesPerFrame;
     private buf_frame_header;
@@ -59,4 +47,3 @@ export declare class MpegParser extends AbstractID3Parser {
     private skipFrameData;
     private areAllSame;
 }
-export {};

package/node_modules/music-metadata/lib/mpeg/MpegParser.js

@@ -1,13 +1,13 @@
-import * as Token from 'token-types';
-import { EndOfStreamError } from 'strtok3';
-import initDebug from 'debug';
-import * as common from '../common/Util.js';
-import { AbstractID3Parser } from '../id3v2/AbstractID3Parser.js';
-import { InfoTagHeaderTag, LameEncoderVersion, readXingHeader } from './XingTag.js';
-import { makeUnexpectedFileContentError } from '../ParseError.js';
-const debug = initDebug('music-metadata:parser:mpeg');
-export class MpegContentError extends makeUnexpectedFileContentError('MPEG') {
-}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MpegParser = void 0;
+const Token = require("token-types");
+const core_1 = require("strtok3/lib/core");
+const debug_1 = require("debug");
+const common = require("../common/Util");
+const AbstractID3Parser_1 = require("../id3v2/AbstractID3Parser");
+const XingTag_1 = require("./XingTag");
+const debug = (0, debug_1.default)('music-metadata:parser:mpeg');
 /**
  * Cache buffer size used for searching synchronization preabmle
  */
@@ -22,8 +22,8 @@ const MPEG4 = {
      */
     AudioObjectTypes: [
         'AAC Main',
-        'AAC LC', // Low Complexity
-        'AAC SSR', // Scalable Sample Rate
+        'AAC LC',
+        'AAC SSR',
         'AAC LTP' // Long Term Prediction
     ],
     /**
@@ -31,7 +31,7 @@ const MPEG4 = {
      * https://wiki.multimedia.cx/index.php/MPEG-4_Audio#Sampling_Frequencies
      */
     SamplingFrequencies: [
-        96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000, 7350, null, null, -1
+        96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000, 7350, undefined, undefined, -1
     ]
     /**
      * Channel Configurations
@@ -55,24 +55,6 @@ const MPEG4_ChannelConfigurations = [
  */
 class MpegFrameHeader {
     constructor(buf, off) {
-        // E(15,12): Bitrate index
-        this.bitrateIndex = null;
-        // F(11,10): Sampling rate frequency index
-        this.sampRateFreqIndex = null;
-        // G(9): Padding bit
-        this.padding = null;
-        // H(8): Private bit
-        this.privateBit = null;
-        // I(7,6): Channel Mode
-        this.channelModeIndex = null;
-        // J(5,4): Mode extension (Only used in Joint stereo)
-        this.modeExtension = null;
-        // L(2): Original
-        this.isOriginalMedia = null;
-        this.version = null;
-        this.bitrate = null;
-        this.samplingRate = null;
-        this.frameLength = 0;
         // B(20,19): MPEG Audio versionIndex ID
         this.versionIndex = common.getBitAllignedNumber(buf, off + 1, 3, 2);
         // C(18,17): Layer description
@@ -87,7 +69,7 @@ class MpegFrameHeader {
         this.isProtectedByCRC = !common.isBitSet(buf, off + 1, 7);
     }
     calcDuration(numFrames) {
-        return this.samplingRate == null ? null : (numFrames * this.calcSamplesPerFrame() / this.samplingRate);
+        return numFrames * this.calcSamplesPerFrame() / this.samplingRate;
     }
     calcSamplesPerFrame() {
         return MpegFrameHeader.samplesInFrameTable[this.version === 1 ? 0 : 1][this.layer];
@@ -100,7 +82,7 @@ class MpegFrameHeader {
             if (this.version === 1) {
                 return 17;
             }
-            if (this.version === 2 || this.version === 2.5) {
+            else if (this.version === 2 || this.version === 2.5) {
                 return 9;
             }
         }
@@ -108,11 +90,10 @@ class MpegFrameHeader {
             if (this.version === 1) {
                 return 32;
             }
-            if (this.version === 2 || this.version === 2.5) {
+            else if (this.version === 2 || this.version === 2.5) {
                 return 17;
             }
         }
-        return null;
     }
     calcSlotSize() {
         return [null, 4, 1, 1][this.layer];
@@ -143,19 +124,19 @@ class MpegFrameHeader {
         // Calculate bitrate
         const bitrateInKbps = this.calcBitrate();
         if (!bitrateInKbps) {
-            throw new MpegContentError('Cannot determine bit-rate');
+            throw new Error('Cannot determine bit-rate');
         }
         this.bitrate = bitrateInKbps * 1000;
         // Calculate sampling rate
         this.samplingRate = this.calcSamplingRate();
         if (this.samplingRate == null) {
-            throw new MpegContentError('Cannot determine sampling-rate');
+            throw new Error('Cannot determine sampling-rate');
         }
     }
     parseAdtsHeader(buf, off) {
-        debug("layer=0 => ADTS");
+        debug(`layer=0 => ADTS`);
         this.version = this.versionIndex === 2 ? 4 : 2;
-        this.container = `ADTS/MPEG-${this.version}`;
+        this.container = 'ADTS/MPEG-' + this.version;
         const profileIndex = common.getBitAllignedNumber(buf, off + 2, 0, 2);
         this.codec = 'AAC';
         this.codecProfile = MPEG4.AudioObjectTypes[profileIndex];
@@ -165,22 +146,19 @@ class MpegFrameHeader {
         debug(`sampling-rate=${this.samplingRate}`);
         const channelIndex = common.getBitAllignedNumber(buf, off + 2, 7, 3);
         this.mp4ChannelConfig = MPEG4_ChannelConfigurations[channelIndex];
-        debug(`channel-config=${this.mp4ChannelConfig ? this.mp4ChannelConfig.join('+') : '?'}`);
+        debug(`channel-config=${this.mp4ChannelConfig.join('+')}`);
         this.frameLength = common.getBitAllignedNumber(buf, off + 3, 6, 2) << 11;
     }
     calcBitrate() {
         if (this.bitrateIndex === 0x00 || // free
             this.bitrateIndex === 0x0F) { // reserved
-            return null;
-        }
-        if (this.version && this.bitrateIndex) {
-            const codecIndex = 10 * Math.floor(this.version) + this.layer;
-            return MpegFrameHeader.bitrate_index[this.bitrateIndex][codecIndex];
+            return;
         }
-        return null;
+        const codecIndex = `${Math.floor(this.version)}${this.layer}`;
+        return MpegFrameHeader.bitrate_index[this.bitrateIndex][codecIndex];
     }
     calcSamplingRate() {
-        if (this.sampRateFreqIndex === 0x03 || this.version === null || this.sampRateFreqIndex == null)
+        if (this.sampRateFreqIndex === 0x03)
             return null; // 'reserved'
         return MpegFrameHeader.sampling_rate_freq_index[this.version][this.sampRateFreqIndex];
     }
@@ -191,29 +169,29 @@ MpegFrameHeader.VersionID = [2.5, null, 2, 1];
 MpegFrameHeader.LayerDescription = [0, 3, 2, 1];
 MpegFrameHeader.ChannelMode = ['stereo', 'joint_stereo', 'dual_channel', 'mono'];
 MpegFrameHeader.bitrate_index = {
-    1: { 11: 32, 12: 32, 13: 32, 21: 32, 22: 8, 23: 8 },
-    2: { 11: 64, 12: 48, 13: 40, 21: 48, 22: 16, 23: 16 },
-    3: { 11: 96, 12: 56, 13: 48, 21: 56, 22: 24, 23: 24 },
-    4: { 11: 128, 12: 64, 13: 56, 21: 64, 22: 32, 23: 32 },
-    5: { 11: 160, 12: 80, 13: 64, 21: 80, 22: 40, 23: 40 },
-    6: { 11: 192, 12: 96, 13: 80, 21: 96, 22: 48, 23: 48 },
-    7: { 11: 224, 12: 112, 13: 96, 21: 112, 22: 56, 23: 56 },
-    8: { 11: 256, 12: 128, 13: 112, 21: 128, 22: 64, 23: 64 },
-    9: { 11: 288, 12: 160, 13: 128, 21: 144, 22: 80, 23: 80 },
-    10: { 11: 320, 12: 192, 13: 160, 21: 160, 22: 96, 23: 96 },
-    11: { 11: 352, 12: 224, 13: 192, 21: 176, 22: 112, 23: 112 },
-    12: { 11: 384, 12: 256, 13: 224, 21: 192, 22: 128, 23: 128 },
-    13: { 11: 416, 12: 320, 13: 256, 21: 224, 22: 144, 23: 144 },
-    14: { 11: 448, 12: 384, 13: 320, 21: 256, 22: 160, 23: 160 }
+    0x01: { 11: 32, 12: 32, 13: 32, 21: 32, 22: 8, 23: 8 },
+    0x02: { 11: 64, 12: 48, 13: 40, 21: 48, 22: 16, 23: 16 },
+    0x03: { 11: 96, 12: 56, 13: 48, 21: 56, 22: 24, 23: 24 },
+    0x04: { 11: 128, 12: 64, 13: 56, 21: 64, 22: 32, 23: 32 },
+    0x05: { 11: 160, 12: 80, 13: 64, 21: 80, 22: 40, 23: 40 },
+    0x06: { 11: 192, 12: 96, 13: 80, 21: 96, 22: 48, 23: 48 },
+    0x07: { 11: 224, 12: 112, 13: 96, 21: 112, 22: 56, 23: 56 },
+    0x08: { 11: 256, 12: 128, 13: 112, 21: 128, 22: 64, 23: 64 },
+    0x09: { 11: 288, 12: 160, 13: 128, 21: 144, 22: 80, 23: 80 },
+    0x0A: { 11: 320, 12: 192, 13: 160, 21: 160, 22: 96, 23: 96 },
+    0x0B: { 11: 352, 12: 224, 13: 192, 21: 176, 22: 112, 23: 112 },
+    0x0C: { 11: 384, 12: 256, 13: 224, 21: 192, 22: 128, 23: 128 },
+    0x0D: { 11: 416, 12: 320, 13: 256, 21: 224, 22: 144, 23: 144 },
+    0x0E: { 11: 448, 12: 384, 13: 320, 21: 256, 22: 160, 23: 160 }
 };
 MpegFrameHeader.sampling_rate_freq_index = {
-    1: { 0: 44100, 1: 48000, 2: 32000 },
-    2: { 0: 22050, 1: 24000, 2: 16000 },
-    2.5: { 0: 11025, 1: 12000, 2: 8000 }
+    1: { 0x00: 44100, 0x01: 48000, 0x02: 32000 },
+    2: { 0x00: 22050, 0x01: 24000, 0x02: 16000 },
+    2.5: { 0x00: 11025, 0x01: 12000, 0x02: 8000 }
 };
 MpegFrameHeader.samplesInFrameTable = [
     /* Layer   I    II   III */
-    [0, 384, 1152, 1152], // MPEG-1
+    [0, 384, 1152, 1152],
     [0, 384, 1152, 576] // MPEG-2(.5
 ];
 /**
@@ -226,26 +204,20 @@ const FrameHeader = {
     }
 };
 function getVbrCodecProfile(vbrScale) {
-    return `V${Math.floor((100 - vbrScale) / 10)}`;
+    return 'V' + Math.floor((100 - vbrScale) / 10);
 }
-export class MpegParser extends AbstractID3Parser {
+class MpegParser extends AbstractID3Parser_1.AbstractID3Parser {
     constructor() {
         super(...arguments);
         this.frameCount = 0;
         this.syncFrameCount = -1;
+        this.countSkipFrameData = 0;
         this.totalDataLength = 0;
         this.bitrates = [];
-        this.offset = 0;
-        this.frame_size = 0;
         this.calculateEofDuration = false;
-        this.samplesPerFrame = null;
-        this.buf_frame_header = new Uint8Array(4);
-        /**
-         * Number of bytes already parsed since beginning of stream / file
-         */
-        this.mpegOffset = null;
+        this.buf_frame_header = Buffer.alloc(4);
         this.syncPeek = {
-            buf: new Uint8Array(maxPeekLen),
+            buf: Buffer.alloc(maxPeekLen),
             len: 0
         };
     }
@@ -254,7 +226,6 @@ export class MpegParser extends AbstractID3Parser {
      */
     async postId3v2Parse() {
         this.metadata.setFormat('lossless', false);
-        this.metadata.setAudioOnly();
         try {
             let quit = false;
             while (!quit) {
@@ -263,18 +234,14 @@ export class MpegParser extends AbstractID3Parser {
             }
         }
         catch (err) {
-            if (err instanceof EndOfStreamError) {
-                debug("End-of-stream");
+            if (err instanceof core_1.EndOfStreamError) {
+                debug(`End-of-stream`);
                 if (this.calculateEofDuration) {
-                    if (this.samplesPerFrame !== null) {
-                        const numberOfSamples = this.frameCount * this.samplesPerFrame;
-                        this.metadata.setFormat('numberOfSamples', numberOfSamples);
-                        if (this.metadata.format.sampleRate) {
-                            const duration = numberOfSamples / this.metadata.format.sampleRate;
-                            debug(`Calculate duration at EOF: ${duration} sec.`, duration);
-                            this.metadata.setFormat('duration', duration);
-                        }
-                    }
+                    const numberOfSamples = this.frameCount * this.samplesPerFrame;
+                    this.metadata.setFormat('numberOfSamples', numberOfSamples);
+                    const duration = numberOfSamples / this.metadata.format.sampleRate;
+                    debug(`Calculate duration at EOF: ${duration} sec.`, duration);
+                    this.metadata.setFormat('duration', duration);
                 }
             }
             else {
@@ -287,27 +254,21 @@ export class MpegParser extends AbstractID3Parser {
      */
     finalize() {
         const format = this.metadata.format;
-        const hasID3v1 = !!this.metadata.native.ID3v1;
-        if (this.mpegOffset !== null) {
-            if (format.duration && this.tokenizer.fileInfo.size) {
-                const mpegSize = this.tokenizer.fileInfo.size - this.mpegOffset - (hasID3v1 ? 128 : 0);
-                if (format.codecProfile && format.codecProfile[0] === 'V') {
-                    this.metadata.setFormat('bitrate', mpegSize * 8 / format.duration);
-                }
-            }
-            if (this.tokenizer.fileInfo.size && format.codecProfile === 'CBR') {
-                const mpegSize = this.tokenizer.fileInfo.size - this.mpegOffset - (hasID3v1 ? 128 : 0);
-                if (this.frame_size !== null && this.samplesPerFrame !== null) {
-                    const numberOfSamples = Math.round(mpegSize / this.frame_size) * this.samplesPerFrame;
-                    this.metadata.setFormat('numberOfSamples', numberOfSamples);
-                    if (format.sampleRate && !format.duration) {
-                        const duration = numberOfSamples / format.sampleRate;
-                        debug("Calculate CBR duration based on file size: %s", duration);
-                        this.metadata.setFormat('duration', duration);
-                    }
-                }
+        const hasID3v1 = this.metadata.native.hasOwnProperty('ID3v1');
+        if (format.duration && this.tokenizer.fileInfo.size) {
+            const mpegSize = this.tokenizer.fileInfo.size - this.mpegOffset - (hasID3v1 ? 128 : 0);
+            if (format.codecProfile && format.codecProfile[0] === 'V') {
+                this.metadata.setFormat('bitrate', mpegSize * 8 / format.duration);
             }
         }
+        else if (this.tokenizer.fileInfo.size && format.codecProfile === 'CBR') {
+            const mpegSize = this.tokenizer.fileInfo.size - this.mpegOffset - (hasID3v1 ? 128 : 0);
+            const numberOfSamples = Math.round(mpegSize / this.frame_size) * this.samplesPerFrame;
+            this.metadata.setFormat('numberOfSamples', numberOfSamples);
+            const duration = numberOfSamples / format.sampleRate;
+            debug("Calculate CBR duration based on file size: %s", duration);
+            this.metadata.setFormat('duration', duration);
+        }
     }
     async sync() {
         let gotFirstSync = false;
@@ -315,7 +276,7 @@ export class MpegParser extends AbstractID3Parser {
             let bo = 0;
             this.syncPeek.len = await this.tokenizer.peekBuffer(this.syncPeek.buf, { length: maxPeekLen, mayBeLess: true });
             if (this.syncPeek.len <= 163) {
-                throw new EndOfStreamError();
+                throw new core_1.EndOfStreamError();
             }
             while (true) {
                 if (gotFirstSync && (this.syncPeek.buf[bo] & 0xE0) === 0xE0) {
@@ -331,17 +292,21 @@ export class MpegParser extends AbstractID3Parser {
                     this.syncFrameCount = this.frameCount;
                     return; // sync
                 }
-                gotFirstSync = false;
-                bo = this.syncPeek.buf.indexOf(MpegFrameHeader.SyncByte1, bo);
-                if (bo === -1) {
-                    if (this.syncPeek.len < this.syncPeek.buf.length) {
-                        throw new EndOfStreamError();
+                else {
+                    gotFirstSync = false;
+                    bo = this.syncPeek.buf.indexOf(MpegFrameHeader.SyncByte1, bo);
+                    if (bo === -1) {
+                        if (this.syncPeek.len < this.syncPeek.buf.length) {
+                            throw new core_1.EndOfStreamError();
+                        }
+                        await this.tokenizer.ignore(this.syncPeek.len);
+                        break; // continue with next buffer
+                    }
+                    else {
+                        ++bo;
+                        gotFirstSync = true;
                     }
-                    await this.tokenizer.ignore(this.syncPeek.len);
-                    break; // continue with next buffer
                 }
-                ++bo;
-                gotFirstSync = true;
             }
         }
     }
@@ -353,18 +318,15 @@ export class MpegParser extends AbstractID3Parser {
         if (this.frameCount === 0) {
             this.mpegOffset = this.tokenizer.position - 1;
         }
-        await this.tokenizer.peekBuffer(this.buf_frame_header.subarray(1), { length: 3 });
+        await this.tokenizer.peekBuffer(this.buf_frame_header, { offset: 1, length: 3 });
         let header;
         try {
             header = FrameHeader.get(this.buf_frame_header, 0);
         }
         catch (err) {
             await this.tokenizer.ignore(1);
-            if (err instanceof Error) {
-                this.metadata.addWarning(`Parse error: ${err.message}`);
-                return false; // sync
-            }
-            throw err;
+            this.metadata.addWarning('Parse error: ' + err.message);
+            return false; // sync
         }
         await this.tokenizer.ignore(3);
         this.metadata.setFormat('container', header.container);
@@ -372,7 +334,7 @@ export class MpegParser extends AbstractID3Parser {
         this.metadata.setFormat('lossless', false);
         this.metadata.setFormat('sampleRate', header.samplingRate);
         this.frameCount++;
-        return header.version !== null && header.version >= 2 && header.layer === 0 ? this.parseAdts(header) : this.parseAudioFrameHeader(header);
+        return header.version >= 2 && header.layer === 0 ? this.parseAdts(header) : this.parseAudioFrameHeader(header);
     }
     /**
      * @return {Promise<boolean>} true if parser should quit
@@ -385,26 +347,23 @@ export class MpegParser extends AbstractID3Parser {
         }
         const slot_size = header.calcSlotSize();
         if (slot_size === null) {
-            throw new MpegContentError('invalid slot_size');
+            throw new Error('invalid slot_size');
         }
         const samples_per_frame = header.calcSamplesPerFrame();
         debug(`samples_per_frame=${samples_per_frame}`);
         const bps = samples_per_frame / 8.0;
-        if (header.bitrate !== null && header.samplingRate != null) {
-            const fsize = (bps * header.bitrate / header.samplingRate) + ((header.padding) ? slot_size : 0);
-            this.frame_size = Math.floor(fsize);
-        }
+        const fsize = (bps * header.bitrate / header.samplingRate) +
+            ((header.padding) ? slot_size : 0);
+        this.frame_size = Math.floor(fsize);
         this.audioFrameHeader = header;
-        if (header.bitrate !== null) {
-            this.bitrates.push(header.bitrate);
-        }
+        this.bitrates.push(header.bitrate);
         // xtra header only exists in first frame
         if (this.frameCount === 1) {
             this.offset = FrameHeader.len;
             await this.skipSideInformation();
             return false;
         }
-        if (this.frameCount === 4) {
+        if (this.frameCount === 3) {
             // the stream is CBR if the first 3 frame bitrates are the same
             if (this.areAllSame(this.bitrates)) {
                 // Actual calculation will be done in finalize
@@ -432,22 +391,22 @@ export class MpegParser extends AbstractID3Parser {
             await this.parseCrc();
             return false;
         }
-        await this.skipSideInformation();
-        return false;
+        else {
+            await this.skipSideInformation();
+            return false;
+        }
     }
     async parseAdts(header) {
-        const buf = new Uint8Array(3);
+        const buf = Buffer.alloc(3);
         await this.tokenizer.readBuffer(buf);
         header.frameLength += common.getBitAllignedNumber(buf, 0, 0, 11);
         this.totalDataLength += header.frameLength;
         this.samplesPerFrame = 1024;
-        if (header.samplingRate !== null) {
-            const framesPerSec = header.samplingRate / this.samplesPerFrame;
-            const bytesPerFrame = this.frameCount === 0 ? 0 : this.totalDataLength / this.frameCount;
-            const bitrate = 8 * bytesPerFrame * framesPerSec + 0.5;
-            this.metadata.setFormat('bitrate', bitrate);
-            debug(`frame-count=${this.frameCount}, size=${header.frameLength} bytes, bit-rate=${bitrate}`);
-        }
+        const framesPerSec = header.samplingRate / this.samplesPerFrame;
+        const bytesPerFrame = this.frameCount === 0 ? 0 : this.totalDataLength / this.frameCount;
+        const bitrate = 8 * bytesPerFrame * framesPerSec + 0.5;
+        this.metadata.setFormat('bitrate', bitrate);
+        debug(`frame-count=${this.frameCount}, size=${header.frameLength} bytes, bit-rate=${bitrate}`);
         await this.tokenizer.ignore(header.frameLength > 7 ? header.frameLength - 7 : 1);
         // Consume remaining header and frame data
         if (this.frameCount === 3) {
@@ -465,57 +424,51 @@ export class MpegParser extends AbstractID3Parser {
         return false;
     }
     async parseCrc() {
-        await this.tokenizer.ignore(Token.INT16_BE.len); // Ignore CRC
-        this.offset += Token.INT16_BE.len;
+        this.crc = await this.tokenizer.readNumber(Token.INT16_BE);
+        this.offset += 2;
         return this.skipSideInformation();
     }
     async skipSideInformation() {
-        if (this.audioFrameHeader) {
-            const sideinfo_length = this.audioFrameHeader.calculateSideInfoLength();
-            if (sideinfo_length !== null) {
-                await this.tokenizer.readToken(new Token.Uint8ArrayType(sideinfo_length));
-                // side information
-                this.offset += sideinfo_length;
-                await this.readXtraInfoHeader();
-                return;
-            }
-        }
+        const sideinfo_length = this.audioFrameHeader.calculateSideInfoLength();
+        // side information
+        await this.tokenizer.readToken(new Token.Uint8ArrayType(sideinfo_length));
+        this.offset += sideinfo_length;
+        await this.readXtraInfoHeader();
+        return;
     }
     async readXtraInfoHeader() {
-        const headerTag = await this.tokenizer.readToken(InfoTagHeaderTag);
-        this.offset += InfoTagHeaderTag.len; // 12
+        const headerTag = await this.tokenizer.readToken(XingTag_1.InfoTagHeaderTag);
+        this.offset += XingTag_1.InfoTagHeaderTag.len; // 12
         switch (headerTag) {
             case 'Info':
                 this.metadata.setFormat('codecProfile', 'CBR');
                 return this.readXingInfoHeader();
-            case 'Xing': {
+            case 'Xing':
                 const infoTag = await this.readXingInfoHeader();
-                if (infoTag.vbrScale !== null) {
-                    const codecProfile = getVbrCodecProfile(infoTag.vbrScale);
-                    this.metadata.setFormat('codecProfile', codecProfile);
-                }
+                const codecProfile = getVbrCodecProfile(infoTag.vbrScale);
+                this.metadata.setFormat('codecProfile', codecProfile);
                 return null;
-            }
             case 'Xtra':
                 // ToDo: ???
                 break;
-            case 'LAME': {
-                const version = await this.tokenizer.readToken(LameEncoderVersion);
-                if (this.frame_size !== null && this.frame_size >= this.offset + LameEncoderVersion.len) {
-                    this.offset += LameEncoderVersion.len;
-                    this.metadata.setFormat('tool', `LAME ${version}`);
+            case 'LAME':
+                const version = await this.tokenizer.readToken(XingTag_1.LameEncoderVersion);
+                if (this.frame_size >= this.offset + XingTag_1.LameEncoderVersion.len) {
+                    this.offset += XingTag_1.LameEncoderVersion.len;
+                    this.metadata.setFormat('tool', 'LAME ' + version);
                     await this.skipFrameData(this.frame_size - this.offset);
                     return null;
                 }
-                this.metadata.addWarning('Corrupt LAME header');
-                break;
-            }
+                else {
+                    this.metadata.addWarning('Corrupt LAME header');
+                    break;
+                }
             // ToDo: ???
         }
         // ToDo: promise duration???
         const frameDataLeft = this.frame_size - this.offset;
         if (frameDataLeft < 0) {
-            this.metadata.addWarning(`Frame ${this.frameCount}corrupt: negative frameDataLeft`);
+            this.metadata.addWarning('Frame ' + this.frameCount + 'corrupt: negative frameDataLeft');
         }
         else {
             await this.skipFrameData(frameDataLeft);
@@ -528,10 +481,10 @@ export class MpegParser extends AbstractID3Parser {
      */
     async readXingInfoHeader() {
         const offset = this.tokenizer.position;
-        const infoTag = await readXingHeader(this.tokenizer);
+        const infoTag = await (0, XingTag_1.readXingHeader)(this.tokenizer);
         this.offset += this.tokenizer.position - offset;
         if (infoTag.lame) {
-            this.metadata.setFormat('tool', `LAME ${common.stripNulls(infoTag.lame.version)}`);
+            this.metadata.setFormat('tool', 'LAME ' + common.stripNulls(infoTag.lame.version));
             if (infoTag.lame.extended) {
                 // this.metadata.setFormat('trackGain', infoTag.lame.extended.track_gain);
                 this.metadata.setFormat('trackPeakLevel', infoTag.lame.extended.track_peak);
@@ -544,7 +497,7 @@ export class MpegParser extends AbstractID3Parser {
                 this.metadata.setFormat('duration', infoTag.lame.extended.music_length / 1000);
             }
         }
-        if (infoTag.streamSize && this.audioFrameHeader && infoTag.numFrames !== null) {
+        if (infoTag.streamSize) {
             const duration = this.audioFrameHeader.calcDuration(infoTag.numFrames);
             this.metadata.setFormat('duration', duration);
             debug('Get duration from Xing header: %s', this.metadata.format.duration);
@@ -557,8 +510,9 @@ export class MpegParser extends AbstractID3Parser {
     }
     async skipFrameData(frameDataLeft) {
         if (frameDataLeft < 0)
-            throw new MpegContentError('frame-data-left cannot be negative');
+            throw new Error('frame-data-left cannot be negative');
         await this.tokenizer.ignore(frameDataLeft);
+        this.countSkipFrameData += frameDataLeft;
     }
     areAllSame(array) {
         const first = array[0];
@@ -567,3 +521,4 @@ export class MpegParser extends AbstractID3Parser {
         });
     }
 }
+exports.MpegParser = MpegParser;