@agentdocumentformat/cli 0.7.2

package/dist/chunks/MpegParser-YW6LIUEW.mjs

@@ -0,0 +1,442 @@
+import { createRequire as __adfCreateRequire } from 'node:module';
+import { fileURLToPath as __adfFileURLToPath } from 'node:url';
+import { dirname as __adfDirname } from 'node:path';
+const require = __adfCreateRequire(import.meta.url);
+const __filename = __adfFileURLToPath(import.meta.url);
+const __dirname = __adfDirname(__filename);
+import {
+  AbstractID3Parser
+} from "./chunk-62NE4LG4.mjs";
+import "./chunk-XYTWGHFS.mjs";
+import "./chunk-VAUOM3IN.mjs";
+import "./chunk-DXWDD5XJ.mjs";
+import "./chunk-NBTUWMGP.mjs";
+import {
+  getBitAllignedNumber,
+  isBitSet,
+  stripNulls
+} from "./chunk-XX7OSWTO.mjs";
+import {
+  EndOfStreamError
+} from "./chunk-HBUENVQL.mjs";
+import {
+  INT16_BE,
+  StringType,
+  UINT16_BE,
+  UINT32_BE,
+  UINT8,
+  Uint8ArrayType,
+  makeUnexpectedFileContentError
+} from "./chunk-I2HJYHFT.mjs";
+import {
+  require_src
+} from "./chunk-AUYKRQPJ.mjs";
+import "./chunk-NZ7JTHEO.mjs";
+import {
+  __toESM
+} from "./chunk-M2RX3S2T.mjs";
+
+// node_modules/music-metadata/lib/mpeg/MpegParser.js
+var import_debug = __toESM(require_src(), 1);
+
+// node_modules/music-metadata/lib/mpeg/ReplayGainDataFormat.js
+var ReplayGain = {
+  len: 2,
+  get: (buf, off) => {
+    let gain_type = getBitAllignedNumber(buf, off, 0, 3), sign = getBitAllignedNumber(buf, off, 6, 1), gain_adj = getBitAllignedNumber(buf, off, 7, 9) / 10;
+    if (gain_type > 0)
+      return {
+        type: getBitAllignedNumber(buf, off, 0, 3),
+        origin: getBitAllignedNumber(buf, off, 3, 3),
+        adjustment: sign ? -gain_adj : gain_adj
+      };
+  }
+};
+
+// node_modules/music-metadata/lib/mpeg/ExtendedLameHeader.js
+var ExtendedLameHeader = {
+  len: 27,
+  get: (buf, off) => {
+    let track_peak = UINT32_BE.get(buf, off + 2);
+    return {
+      revision: getBitAllignedNumber(buf, off, 0, 4),
+      vbr_method: getBitAllignedNumber(buf, off, 4, 4),
+      lowpass_filter: 100 * 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),
+      music_length: UINT32_BE.get(buf, off + 20),
+      music_crc: UINT8.get(buf, off + 24),
+      header_crc: UINT16_BE.get(buf, off + 24)
+    };
+  }
+};
+
+// node_modules/music-metadata/lib/mpeg/XingTag.js
+var InfoTagHeaderTag = new StringType(4, "ascii"), LameEncoderVersion = new StringType(6, "ascii"), XingHeaderFlags = {
+  len: 4,
+  get: (buf, off) => ({
+    frames: isBitSet(buf, off, 31),
+    bytes: isBitSet(buf, off, 30),
+    toc: isBitSet(buf, off, 29),
+    vbrScale: isBitSet(buf, off, 28)
+  })
+};
+async function readXingHeader(tokenizer) {
+  let flags = await tokenizer.readToken(XingHeaderFlags), xingInfoTag = { numFrames: null, streamSize: null, vbrScale: null };
+  if (flags.frames && (xingInfoTag.numFrames = await tokenizer.readToken(UINT32_BE)), flags.bytes && (xingInfoTag.streamSize = await tokenizer.readToken(UINT32_BE)), flags.toc && (xingInfoTag.toc = new Uint8Array(100), await tokenizer.readBuffer(xingInfoTag.toc)), flags.vbrScale && (xingInfoTag.vbrScale = await tokenizer.readToken(UINT32_BE)), await tokenizer.peekToken(new StringType(4, "ascii")) === "LAME") {
+    await tokenizer.ignore(4), xingInfoTag.lame = {
+      version: await tokenizer.readToken(new StringType(5, "ascii"))
+    };
+    let match = xingInfoTag.lame.version.match(/\d+.\d+/g);
+    if (match !== null) {
+      let version = match[0].split(".").map((n) => Number.parseInt(n, 10));
+      version[0] >= 3 && version[1] >= 90 && (xingInfoTag.lame.extended = await tokenizer.readToken(ExtendedLameHeader));
+    }
+  }
+  return xingInfoTag;
+}
+
+// node_modules/music-metadata/lib/mpeg/MpegParser.js
+var debug = (0, import_debug.default)("music-metadata:parser:mpeg"), MpegContentError = class extends makeUnexpectedFileContentError("MPEG") {
+}, maxPeekLen = 1024, MPEG4 = {
+  /**
+   * Audio Object Types
+   */
+  AudioObjectTypes: [
+    "AAC Main",
+    "AAC LC",
+    // Low Complexity
+    "AAC SSR",
+    // Scalable Sample Rate
+    "AAC LTP"
+    // Long Term Prediction
+  ],
+  /**
+   * Sampling Frequencies
+   * https://wiki.multimedia.cx/index.php/MPEG-4_Audio#Sampling_Frequencies
+   */
+  SamplingFrequencies: [
+    96e3,
+    88200,
+    64e3,
+    48e3,
+    44100,
+    32e3,
+    24e3,
+    22050,
+    16e3,
+    12e3,
+    11025,
+    8e3,
+    7350,
+    null,
+    null,
+    null
+  ]
+  /**
+   * Channel Configurations
+   */
+}, MPEG4_ChannelConfigurations = [
+  void 0,
+  ["front-center"],
+  ["front-left", "front-right"],
+  ["front-center", "front-left", "front-right"],
+  ["front-center", "front-left", "front-right", "back-center"],
+  ["front-center", "front-left", "front-right", "back-left", "back-right"],
+  ["front-center", "front-left", "front-right", "back-left", "back-right", "LFE-channel"],
+  ["front-center", "front-left", "front-right", "side-left", "side-right", "back-left", "back-right", "LFE-channel"]
+], MpegFrameHeader = class _MpegFrameHeader {
+  constructor(buf, off) {
+    this.bitrateIndex = null, this.sampRateFreqIndex = null, this.padding = null, this.privateBit = null, this.channelModeIndex = null, this.modeExtension = null, this.isOriginalMedia = null, this.version = null, this.bitrate = null, this.samplingRate = null, this.frameLength = 0, this.versionIndex = getBitAllignedNumber(buf, off + 1, 3, 2), this.layer = _MpegFrameHeader.LayerDescription[getBitAllignedNumber(buf, off + 1, 5, 2)], this.versionIndex > 1 && this.layer === 0 ? this.parseAdtsHeader(buf, off) : this.parseMpegHeader(buf, off), this.isProtectedByCRC = !isBitSet(buf, off + 1, 7);
+  }
+  calcDuration(numFrames) {
+    return this.samplingRate == null ? null : numFrames * this.calcSamplesPerFrame() / this.samplingRate;
+  }
+  calcSamplesPerFrame() {
+    return _MpegFrameHeader.samplesInFrameTable[this.version === 1 ? 0 : 1][this.layer];
+  }
+  calculateSideInfoLength() {
+    if (this.layer !== 3)
+      return 2;
+    if (this.channelModeIndex === 3) {
+      if (this.version === 1)
+        return 17;
+      if (this.version === 2 || this.version === 2.5)
+        return 9;
+    } else {
+      if (this.version === 1)
+        return 32;
+      if (this.version === 2 || this.version === 2.5)
+        return 17;
+    }
+    return null;
+  }
+  calcSlotSize() {
+    return [null, 4, 1, 1][this.layer];
+  }
+  parseMpegHeader(buf, off) {
+    this.container = "MPEG", this.bitrateIndex = getBitAllignedNumber(buf, off + 2, 0, 4), this.sampRateFreqIndex = getBitAllignedNumber(buf, off + 2, 4, 2), this.padding = isBitSet(buf, off + 2, 6), this.privateBit = isBitSet(buf, off + 2, 7), this.channelModeIndex = getBitAllignedNumber(buf, off + 3, 0, 2), this.modeExtension = getBitAllignedNumber(buf, off + 3, 2, 2), this.isCopyrighted = isBitSet(buf, off + 3, 4), this.isOriginalMedia = isBitSet(buf, off + 3, 5), this.emphasis = getBitAllignedNumber(buf, off + 3, 7, 2), this.version = _MpegFrameHeader.VersionID[this.versionIndex], this.channelMode = _MpegFrameHeader.ChannelMode[this.channelModeIndex], this.codec = `MPEG ${this.version} Layer ${this.layer}`;
+    let bitrateInKbps = this.calcBitrate();
+    if (!bitrateInKbps)
+      throw new MpegContentError("Cannot determine bit-rate");
+    if (this.bitrate = bitrateInKbps * 1e3, this.samplingRate = this.calcSamplingRate(), this.samplingRate == null)
+      throw new MpegContentError("Cannot determine sampling-rate");
+  }
+  parseAdtsHeader(buf, off) {
+    debug("layer=0 => ADTS"), this.version = this.versionIndex === 2 ? 4 : 2, this.container = `ADTS/MPEG-${this.version}`;
+    let profileIndex = getBitAllignedNumber(buf, off + 2, 0, 2);
+    this.codec = "AAC", this.codecProfile = MPEG4.AudioObjectTypes[profileIndex], debug(`MPEG-4 audio-codec=${this.codec}`);
+    let samplingFrequencyIndex = getBitAllignedNumber(buf, off + 2, 2, 4);
+    this.samplingRate = MPEG4.SamplingFrequencies[samplingFrequencyIndex], debug(`sampling-rate=${this.samplingRate}`);
+    let channelIndex = getBitAllignedNumber(buf, off + 2, 7, 3);
+    this.mp4ChannelConfig = MPEG4_ChannelConfigurations[channelIndex], debug(`channel-config=${this.mp4ChannelConfig ? this.mp4ChannelConfig.join("+") : "?"}`), this.frameLength = getBitAllignedNumber(buf, off + 3, 6, 2) << 11;
+  }
+  calcBitrate() {
+    if (this.bitrateIndex === 0 || // free
+    this.bitrateIndex === 15)
+      return null;
+    if (this.version && this.bitrateIndex) {
+      let codecIndex = 10 * Math.floor(this.version) + this.layer;
+      return _MpegFrameHeader.bitrate_index[this.bitrateIndex][codecIndex];
+    }
+    return null;
+  }
+  calcSamplingRate() {
+    return this.sampRateFreqIndex === 3 || this.version === null || this.sampRateFreqIndex == null ? null : _MpegFrameHeader.sampling_rate_freq_index[this.version][this.sampRateFreqIndex];
+  }
+};
+MpegFrameHeader.SyncByte1 = 255;
+MpegFrameHeader.SyncByte2 = 224;
+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 }
+};
+MpegFrameHeader.sampling_rate_freq_index = {
+  1: { 0: 44100, 1: 48e3, 2: 32e3 },
+  2: { 0: 22050, 1: 24e3, 2: 16e3 },
+  2.5: { 0: 11025, 1: 12e3, 2: 8e3 }
+};
+MpegFrameHeader.samplesInFrameTable = [
+  /* Layer   I    II   III */
+  [0, 384, 1152, 1152],
+  // MPEG-1
+  [0, 384, 1152, 576]
+  // MPEG-2(.5
+];
+var FrameHeader = {
+  len: 4,
+  get: (buf, off) => new MpegFrameHeader(buf, off)
+};
+function getVbrCodecProfile(vbrScale) {
+  return `V${Math.floor((100 - vbrScale) / 10)}`;
+}
+var MpegParser = class extends AbstractID3Parser {
+  constructor() {
+    super(...arguments), this.frameCount = 0, this.syncFrameCount = -1, this.totalDataLength = 0, this.bitrates = [], this.offset = 0, this.frame_size = 0, this.calculateEofDuration = !1, this.samplesPerFrame = null, this.buf_frame_header = new Uint8Array(4), this.mpegOffset = null, this.syncPeek = {
+      buf: new Uint8Array(maxPeekLen),
+      len: 0
+    };
+  }
+  /**
+   * Called after ID3 headers have been parsed
+   */
+  async postId3v2Parse() {
+    this.metadata.setFormat("lossless", !1), this.metadata.setAudioOnly();
+    try {
+      let quit = !1;
+      for (; !quit; )
+        await this.sync(), quit = await this.parseCommonMpegHeader();
+    } catch (err) {
+      if (err instanceof EndOfStreamError) {
+        if (debug("End-of-stream"), this.calculateEofDuration && this.samplesPerFrame !== null) {
+          let numberOfSamples = this.frameCount * this.samplesPerFrame;
+          if (this.metadata.setFormat("numberOfSamples", numberOfSamples), this.metadata.format.sampleRate) {
+            let duration = numberOfSamples / this.metadata.format.sampleRate;
+            debug(`Calculate duration at EOF: ${duration} sec.`, duration), this.metadata.setFormat("duration", duration);
+          }
+        }
+      } else
+        throw err;
+    }
+  }
+  /**
+   * Called after file has been fully parsed, this allows, if present, to exclude the ID3v1.1 header length
+   */
+  finalize() {
+    let format = this.metadata.format, hasID3v1 = !!this.metadata.native.ID3v1;
+    if (this.mpegOffset !== null) {
+      if (format.duration && this.tokenizer.fileInfo.size) {
+        let mpegSize = this.tokenizer.fileInfo.size - this.mpegOffset - (hasID3v1 ? 128 : 0);
+        format.codecProfile && format.codecProfile[0] === "V" && this.metadata.setFormat("bitrate", mpegSize * 8 / format.duration);
+      }
+      if (this.tokenizer.fileInfo.size && format.codecProfile === "CBR") {
+        let mpegSize = this.tokenizer.fileInfo.size - this.mpegOffset - (hasID3v1 ? 128 : 0);
+        if (this.frame_size !== null && this.samplesPerFrame !== null) {
+          let numberOfSamples = Math.round(mpegSize / this.frame_size) * this.samplesPerFrame;
+          if (this.metadata.setFormat("numberOfSamples", numberOfSamples), format.sampleRate && !format.duration) {
+            let duration = numberOfSamples / format.sampleRate;
+            debug("Calculate CBR duration based on file size: %s", duration), this.metadata.setFormat("duration", duration);
+          }
+        }
+      }
+    }
+  }
+  async sync() {
+    let gotFirstSync = !1;
+    for (; ; ) {
+      let bo = 0;
+      if (this.syncPeek.len = await this.tokenizer.peekBuffer(this.syncPeek.buf, { length: maxPeekLen, mayBeLess: !0 }), this.syncPeek.len <= 163)
+        throw new EndOfStreamError();
+      for (; ; ) {
+        if (gotFirstSync && (this.syncPeek.buf[bo] & 224) === 224) {
+          this.buf_frame_header[0] = MpegFrameHeader.SyncByte1, this.buf_frame_header[1] = this.syncPeek.buf[bo], await this.tokenizer.ignore(bo), debug(`Sync at offset=${this.tokenizer.position - 1}, frameCount=${this.frameCount}`), this.syncFrameCount === this.frameCount && (debug(`Re-synced MPEG stream, frameCount=${this.frameCount}`), this.frameCount = 0, this.frame_size = 0), this.syncFrameCount = this.frameCount;
+          return;
+        }
+        if (gotFirstSync = !1, bo = this.syncPeek.buf.indexOf(MpegFrameHeader.SyncByte1, bo), bo === -1) {
+          if (this.syncPeek.len < this.syncPeek.buf.length)
+            throw new EndOfStreamError();
+          await this.tokenizer.ignore(this.syncPeek.len);
+          break;
+        }
+        ++bo, gotFirstSync = !0;
+      }
+    }
+  }
+  /**
+   * Combined ADTS & MPEG (MP2 & MP3) header handling
+   * @return {Promise<boolean>} true if parser should quit
+   */
+  async parseCommonMpegHeader() {
+    this.frameCount === 0 && (this.mpegOffset = this.tokenizer.position - 1), await this.tokenizer.peekBuffer(this.buf_frame_header.subarray(1), { length: 3 });
+    let header;
+    try {
+      header = FrameHeader.get(this.buf_frame_header, 0);
+    } catch (err) {
+      if (await this.tokenizer.ignore(1), err instanceof Error)
+        return this.metadata.addWarning(`Parse error: ${err.message}`), !1;
+      throw err;
+    }
+    return await this.tokenizer.ignore(3), this.metadata.setFormat("container", header.container), this.metadata.setFormat("codec", header.codec), this.metadata.setFormat("lossless", !1), this.metadata.setFormat("sampleRate", header.samplingRate), this.frameCount++, header.version !== null && header.version >= 2 && header.layer === 0 ? this.parseAdts(header) : this.parseAudioFrameHeader(header);
+  }
+  /**
+   * @return {Promise<boolean>} true if parser should quit
+   */
+  async parseAudioFrameHeader(header) {
+    this.metadata.setFormat("numberOfChannels", header.channelMode === "mono" ? 1 : 2), this.metadata.setFormat("bitrate", header.bitrate), this.frameCount < 20 * 1e4 && debug("offset=%s MP%s bitrate=%s sample-rate=%s", this.tokenizer.position - 4, header.layer, header.bitrate, header.samplingRate);
+    let slot_size = header.calcSlotSize();
+    if (slot_size === null)
+      throw new MpegContentError("invalid slot_size");
+    let samples_per_frame = header.calcSamplesPerFrame();
+    debug(`samples_per_frame=${samples_per_frame}`);
+    let bps = samples_per_frame / 8;
+    if (header.bitrate !== null && header.samplingRate != null) {
+      let fsize = bps * header.bitrate / header.samplingRate + (header.padding ? slot_size : 0);
+      this.frame_size = Math.floor(fsize);
+    }
+    if (this.audioFrameHeader = header, header.bitrate !== null && this.bitrates.push(header.bitrate), this.frameCount === 1)
+      return this.offset = FrameHeader.len, await this.skipSideInformation(), !1;
+    if (this.frameCount === 4) {
+      if (this.areAllSame(this.bitrates)) {
+        if (this.samplesPerFrame = samples_per_frame, this.metadata.setFormat("codecProfile", "CBR"), this.tokenizer.fileInfo.size)
+          return !0;
+      } else if (this.metadata.format.duration)
+        return !0;
+      if (!this.options.duration)
+        return !0;
+    }
+    return this.options.duration && this.frameCount === 4 && (this.samplesPerFrame = samples_per_frame, this.calculateEofDuration = !0), this.offset = 4, header.isProtectedByCRC ? (await this.parseCrc(), !1) : (await this.skipSideInformation(), !1);
+  }
+  async parseAdts(header) {
+    let buf = new Uint8Array(3);
+    if (await this.tokenizer.readBuffer(buf), header.frameLength += getBitAllignedNumber(buf, 0, 0, 11), this.totalDataLength += header.frameLength, this.samplesPerFrame = 1024, header.samplingRate !== null) {
+      let framesPerSec = header.samplingRate / this.samplesPerFrame, bitrate = 8 * (this.frameCount === 0 ? 0 : this.totalDataLength / this.frameCount) * framesPerSec + 0.5;
+      this.metadata.setFormat("bitrate", bitrate), debug(`frame-count=${this.frameCount}, size=${header.frameLength} bytes, bit-rate=${bitrate}`);
+    }
+    if (await this.tokenizer.ignore(header.frameLength > 7 ? header.frameLength - 7 : 1), this.frameCount === 3)
+      if (this.metadata.setFormat("codecProfile", header.codecProfile), header.mp4ChannelConfig && this.metadata.setFormat("numberOfChannels", header.mp4ChannelConfig.length), this.options.duration)
+        this.calculateEofDuration = !0;
+      else
+        return !0;
+    return !1;
+  }
+  async parseCrc() {
+    return await this.tokenizer.ignore(INT16_BE.len), this.offset += INT16_BE.len, this.skipSideInformation();
+  }
+  async skipSideInformation() {
+    if (this.audioFrameHeader) {
+      let sideinfo_length = this.audioFrameHeader.calculateSideInfoLength();
+      if (sideinfo_length !== null) {
+        await this.tokenizer.readToken(new Uint8ArrayType(sideinfo_length)), this.offset += sideinfo_length, await this.readXtraInfoHeader();
+        return;
+      }
+    }
+  }
+  async readXtraInfoHeader() {
+    let headerTag = await this.tokenizer.readToken(InfoTagHeaderTag);
+    switch (this.offset += InfoTagHeaderTag.len, headerTag) {
+      case "Info":
+        return this.metadata.setFormat("codecProfile", "CBR"), this.readXingInfoHeader();
+      case "Xing": {
+        let infoTag = await this.readXingInfoHeader();
+        if (infoTag.vbrScale !== null) {
+          let codecProfile = getVbrCodecProfile(infoTag.vbrScale);
+          this.metadata.setFormat("codecProfile", codecProfile);
+        }
+        return null;
+      }
+      case "Xtra":
+        break;
+      case "LAME": {
+        let version = await this.tokenizer.readToken(LameEncoderVersion);
+        if (this.frame_size !== null && this.frame_size >= this.offset + LameEncoderVersion.len)
+          return this.offset += LameEncoderVersion.len, this.metadata.setFormat("tool", `LAME ${version}`), await this.skipFrameData(this.frame_size - this.offset), null;
+        this.metadata.addWarning("Corrupt LAME header");
+        break;
+      }
+    }
+    let frameDataLeft = this.frame_size - this.offset;
+    return frameDataLeft < 0 ? this.metadata.addWarning(`Frame ${this.frameCount}corrupt: negative frameDataLeft`) : await this.skipFrameData(frameDataLeft), null;
+  }
+  /**
+   * Ref: http://gabriel.mp3-tech.org/mp3infotag.html
+   * @returns {Promise<string>}
+   */
+  async readXingInfoHeader() {
+    let offset = this.tokenizer.position, infoTag = await readXingHeader(this.tokenizer);
+    if (this.offset += this.tokenizer.position - offset, infoTag.lame && (this.metadata.setFormat("tool", `LAME ${stripNulls(infoTag.lame.version)}`), infoTag.lame.extended && (this.metadata.setFormat("trackPeakLevel", infoTag.lame.extended.track_peak), infoTag.lame.extended.track_gain && this.metadata.setFormat("trackGain", infoTag.lame.extended.track_gain.adjustment), infoTag.lame.extended.album_gain && this.metadata.setFormat("albumGain", infoTag.lame.extended.album_gain.adjustment), this.metadata.setFormat("duration", infoTag.lame.extended.music_length / 1e3))), infoTag.streamSize && this.audioFrameHeader && infoTag.numFrames !== null) {
+      let duration = this.audioFrameHeader.calcDuration(infoTag.numFrames);
+      return this.metadata.setFormat("duration", duration), debug("Get duration from Xing header: %s", this.metadata.format.duration), infoTag;
+    }
+    let frameDataLeft = this.frame_size - this.offset;
+    return await this.skipFrameData(frameDataLeft), infoTag;
+  }
+  async skipFrameData(frameDataLeft) {
+    if (frameDataLeft < 0)
+      throw new MpegContentError("frame-data-left cannot be negative");
+    await this.tokenizer.ignore(frameDataLeft);
+  }
+  areAllSame(array) {
+    let first = array[0];
+    return array.every((element) => element === first);
+  }
+};
+export {
+  MpegContentError,
+  MpegParser
+};