@agentdocumentformat/cli 0.7.2

package/dist/chunks/MusepackParser-PAUSXP7D.mjs

@@ -0,0 +1,252 @@
+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 {
+  FourCcToken,
+  tryParseApeHeader
+} from "./chunk-NBTUWMGP.mjs";
+import {
+  getBitAllignedNumber,
+  isBitSet
+} from "./chunk-XX7OSWTO.mjs";
+import "./chunk-HBUENVQL.mjs";
+import {
+  BasicParser,
+  StringType,
+  UINT16_LE,
+  UINT32_LE,
+  UINT8,
+  makeUnexpectedFileContentError,
+  textDecode
+} 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/musepack/MusepackParser.js
+var import_debug4 = __toESM(require_src(), 1);
+
+// node_modules/music-metadata/lib/musepack/sv8/MpcSv8Parser.js
+var import_debug2 = __toESM(require_src(), 1);
+
+// node_modules/music-metadata/lib/musepack/sv8/StreamVersion8.js
+var import_debug = __toESM(require_src(), 1);
+var debug = (0, import_debug.default)("music-metadata:parser:musepack:sv8"), PacketKey = new StringType(2, "latin1"), SH_part1 = {
+  len: 5,
+  get: (buf, off) => ({
+    crc: UINT32_LE.get(buf, off),
+    streamVersion: UINT8.get(buf, off + 4)
+  })
+}, SH_part3 = {
+  len: 2,
+  get: (buf, off) => ({
+    sampleFrequency: [44100, 48e3, 37800, 32e3][getBitAllignedNumber(buf, off, 0, 3)],
+    maxUsedBands: getBitAllignedNumber(buf, off, 3, 5),
+    channelCount: getBitAllignedNumber(buf, off + 1, 0, 4) + 1,
+    msUsed: isBitSet(buf, off + 1, 4),
+    audioBlockFrames: getBitAllignedNumber(buf, off + 1, 5, 3)
+  })
+}, StreamReader = class {
+  get tokenizer() {
+    return this._tokenizer;
+  }
+  set tokenizer(value) {
+    this._tokenizer = value;
+  }
+  constructor(_tokenizer) {
+    this._tokenizer = _tokenizer;
+  }
+  async readPacketHeader() {
+    let key = await this.tokenizer.readToken(PacketKey), size = await this.readVariableSizeField();
+    return {
+      key,
+      payloadLength: size.value - 2 - size.len
+    };
+  }
+  async readStreamHeader(size) {
+    let streamHeader = {};
+    debug(`Reading SH at offset=${this.tokenizer.position}`);
+    let part1 = await this.tokenizer.readToken(SH_part1);
+    size -= SH_part1.len, Object.assign(streamHeader, part1), debug(`SH.streamVersion = ${part1.streamVersion}`);
+    let sampleCount = await this.readVariableSizeField();
+    size -= sampleCount.len, streamHeader.sampleCount = sampleCount.value;
+    let bs = await this.readVariableSizeField();
+    size -= bs.len, streamHeader.beginningOfSilence = bs.value;
+    let part3 = await this.tokenizer.readToken(SH_part3);
+    return size -= SH_part3.len, Object.assign(streamHeader, part3), await this.tokenizer.ignore(size), streamHeader;
+  }
+  async readVariableSizeField(len = 1, hb = 0) {
+    let n = await this.tokenizer.readNumber(UINT8);
+    return (n & 128) === 0 ? { len, value: hb + n } : (n &= 127, n += hb, this.readVariableSizeField(len + 1, n << 7));
+  }
+};
+
+// node_modules/music-metadata/lib/musepack/MusepackConentError.js
+var MusepackContentError = class extends makeUnexpectedFileContentError("Musepack") {
+};
+
+// node_modules/music-metadata/lib/musepack/sv8/MpcSv8Parser.js
+var debug2 = (0, import_debug2.default)("music-metadata:parser:musepack"), MpcSv8Parser = class extends BasicParser {
+  constructor() {
+    super(...arguments), this.audioLength = 0;
+  }
+  async parse() {
+    if (await this.tokenizer.readToken(FourCcToken) !== "MPCK")
+      throw new MusepackContentError("Invalid Magic number");
+    return this.metadata.setFormat("container", "Musepack, SV8"), this.parsePacket();
+  }
+  async parsePacket() {
+    let sv8reader = new StreamReader(this.tokenizer);
+    do {
+      let header = await sv8reader.readPacketHeader();
+      switch (debug2(`packet-header key=${header.key}, payloadLength=${header.payloadLength}`), header.key) {
+        case "SH": {
+          let sh = await sv8reader.readStreamHeader(header.payloadLength);
+          this.metadata.setFormat("numberOfSamples", sh.sampleCount), this.metadata.setFormat("sampleRate", sh.sampleFrequency), this.metadata.setFormat("duration", sh.sampleCount / sh.sampleFrequency), this.metadata.setFormat("numberOfChannels", sh.channelCount);
+          break;
+        }
+        case "AP":
+          this.audioLength += header.payloadLength, await this.tokenizer.ignore(header.payloadLength);
+          break;
+        case "RG":
+        // Replaygain
+        case "EI":
+        // Encoder Info
+        case "SO":
+        // Seek Table Offset
+        case "ST":
+        // Seek Table
+        case "CT":
+          await this.tokenizer.ignore(header.payloadLength);
+          break;
+        case "SE":
+          return this.metadata.format.duration && this.metadata.setFormat("bitrate", this.audioLength * 8 / this.metadata.format.duration), tryParseApeHeader(this.metadata, this.tokenizer, this.options);
+        default:
+          throw new MusepackContentError(`Unexpected header: ${header.key}`);
+      }
+    } while (!0);
+  }
+};
+
+// node_modules/music-metadata/lib/musepack/sv7/MpcSv7Parser.js
+var import_debug3 = __toESM(require_src(), 1);
+
+// node_modules/music-metadata/lib/musepack/sv7/BitReader.js
+var BitReader = class {
+  constructor(tokenizer) {
+    this.pos = 0, this.dword = null, this.tokenizer = tokenizer;
+  }
+  /**
+   *
+   * @param bits 1..30 bits
+   */
+  async read(bits) {
+    for (; this.dword === null; )
+      this.dword = await this.tokenizer.readToken(UINT32_LE);
+    let out = this.dword;
+    return this.pos += bits, this.pos < 32 ? (out >>>= 32 - this.pos, out & (1 << bits) - 1) : (this.pos -= 32, this.pos === 0 ? (this.dword = null, out & (1 << bits) - 1) : (this.dword = await this.tokenizer.readToken(UINT32_LE), this.pos && (out <<= this.pos, out |= this.dword >>> 32 - this.pos), out & (1 << bits) - 1));
+  }
+  async ignore(bits) {
+    if (this.pos > 0) {
+      let remaining = 32 - this.pos;
+      this.dword = null, bits -= remaining, this.pos = 0;
+    }
+    let remainder = bits % 32, numOfWords = (bits - remainder) / 32;
+    return await this.tokenizer.ignore(numOfWords * 4), this.read(remainder);
+  }
+};
+
+// node_modules/music-metadata/lib/musepack/sv7/StreamVersion7.js
+var Header = {
+  len: 24,
+  get: (buf, off) => {
+    let header = {
+      // word 0
+      signature: textDecode(buf.subarray(off, off + 3), "latin1"),
+      // versionIndex number * 1000 (3.81 = 3810) (remember that 4-byte alignment causes this to take 4-bytes)
+      streamMinorVersion: getBitAllignedNumber(buf, off + 3, 0, 4),
+      streamMajorVersion: getBitAllignedNumber(buf, off + 3, 4, 4),
+      // word 1
+      frameCount: UINT32_LE.get(buf, off + 4),
+      // word 2
+      maxLevel: UINT16_LE.get(buf, off + 8),
+      sampleFrequency: [44100, 48e3, 37800, 32e3][getBitAllignedNumber(buf, off + 10, 0, 2)],
+      link: getBitAllignedNumber(buf, off + 10, 2, 2),
+      profile: getBitAllignedNumber(buf, off + 10, 4, 4),
+      maxBand: getBitAllignedNumber(buf, off + 11, 0, 6),
+      intensityStereo: isBitSet(buf, off + 11, 6),
+      midSideStereo: isBitSet(buf, off + 11, 7),
+      // word 3
+      titlePeak: UINT16_LE.get(buf, off + 12),
+      titleGain: UINT16_LE.get(buf, off + 14),
+      // word 4
+      albumPeak: UINT16_LE.get(buf, off + 16),
+      albumGain: UINT16_LE.get(buf, off + 18),
+      // word
+      lastFrameLength: UINT32_LE.get(buf, off + 20) >>> 20 & 2047,
+      trueGapless: isBitSet(buf, off + 23, 0)
+    };
+    return header.lastFrameLength = header.trueGapless ? UINT32_LE.get(buf, 20) >>> 20 & 2047 : 0, header;
+  }
+};
+
+// node_modules/music-metadata/lib/musepack/sv7/MpcSv7Parser.js
+var debug3 = (0, import_debug3.default)("music-metadata:parser:musepack"), MpcSv7Parser = class extends BasicParser {
+  constructor() {
+    super(...arguments), this.bitreader = null, this.audioLength = 0, this.duration = null;
+  }
+  async parse() {
+    let header = await this.tokenizer.readToken(Header);
+    if (header.signature !== "MP+")
+      throw new MusepackContentError("Unexpected magic number");
+    debug3(`stream-version=${header.streamMajorVersion}.${header.streamMinorVersion}`), this.metadata.setFormat("container", "Musepack, SV7"), this.metadata.setFormat("sampleRate", header.sampleFrequency);
+    let numberOfSamples = 1152 * (header.frameCount - 1) + header.lastFrameLength;
+    this.metadata.setFormat("numberOfSamples", numberOfSamples), this.duration = numberOfSamples / header.sampleFrequency, this.metadata.setFormat("duration", this.duration), this.bitreader = new BitReader(this.tokenizer), this.metadata.setFormat("numberOfChannels", header.midSideStereo || header.intensityStereo ? 2 : 1);
+    let version = await this.bitreader.read(8);
+    return this.metadata.setFormat("codec", (version / 100).toFixed(2)), await this.skipAudioData(header.frameCount), debug3(`End of audio stream, switching to APEv2, offset=${this.tokenizer.position}`), tryParseApeHeader(this.metadata, this.tokenizer, this.options);
+  }
+  async skipAudioData(frameCount) {
+    for (; frameCount-- > 0; ) {
+      let frameLength = await this.bitreader.read(20);
+      this.audioLength += 20 + frameLength, await this.bitreader.ignore(frameLength);
+    }
+    let lastFrameLength = await this.bitreader.read(11);
+    this.audioLength += lastFrameLength, this.duration !== null && this.metadata.setFormat("bitrate", this.audioLength / this.duration);
+  }
+};
+
+// node_modules/music-metadata/lib/musepack/MusepackParser.js
+var debug4 = (0, import_debug4.default)("music-metadata:parser:musepack"), MusepackParser = class extends AbstractID3Parser {
+  async postId3v2Parse() {
+    let signature = await this.tokenizer.peekToken(new StringType(3, "latin1")), mpcParser;
+    switch (signature) {
+      case "MP+": {
+        debug4("Stream-version 7"), mpcParser = new MpcSv7Parser(this.metadata, this.tokenizer, this.options);
+        break;
+      }
+      case "MPC": {
+        debug4("Stream-version 8"), mpcParser = new MpcSv8Parser(this.metadata, this.tokenizer, this.options);
+        break;
+      }
+      default:
+        throw new MusepackContentError("Invalid signature prefix");
+    }
+    return this.metadata.setAudioOnly(), mpcParser.parse();
+  }
+};
+export {
+  MusepackParser
+};

package/dist/chunks/OggParser-NUBV3GWC.mjs

@@ -0,0 +1,359 @@
+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 {
+  BlockHeader,
+  BlockStreamInfo,
+  BlockType,
+  FlacParser,
+  VorbisPictureToken,
+  VorbisStream
+} from "./chunk-7T2YMTWL.mjs";
+import "./chunk-62NE4LG4.mjs";
+import "./chunk-XYTWGHFS.mjs";
+import "./chunk-VAUOM3IN.mjs";
+import "./chunk-DXWDD5XJ.mjs";
+import {
+  FourCcToken
+} from "./chunk-NBTUWMGP.mjs";
+import {
+  getBit,
+  trimRightNull
+} from "./chunk-XX7OSWTO.mjs";
+import {
+  EndOfStreamError
+} from "./chunk-HBUENVQL.mjs";
+import {
+  BasicParser,
+  INT32_LE,
+  StringType,
+  UINT16_BE,
+  UINT16_LE,
+  UINT24_BE,
+  UINT32_LE,
+  UINT64_LE,
+  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/ogg/OggParser.js
+var import_debug4 = __toESM(require_src(), 1);
+
+// node_modules/music-metadata/lib/ogg/opus/Opus.js
+var OpusContentError = class extends makeUnexpectedFileContentError("Opus") {
+}, IdHeader = class {
+  constructor(len) {
+    if (len < 19)
+      throw new OpusContentError("ID-header-page 0 should be at least 19 bytes long");
+    this.len = len;
+  }
+  get(buf, off) {
+    return {
+      magicSignature: new StringType(8, "ascii").get(buf, off + 0),
+      version: UINT8.get(buf, off + 8),
+      channelCount: UINT8.get(buf, off + 9),
+      preSkip: UINT16_LE.get(buf, off + 10),
+      inputSampleRate: UINT32_LE.get(buf, off + 12),
+      outputGain: UINT16_LE.get(buf, off + 16),
+      channelMapping: UINT8.get(buf, off + 18)
+    };
+  }
+};
+
+// node_modules/music-metadata/lib/ogg/opus/OpusStream.js
+var OpusStream = class extends VorbisStream {
+  constructor(metadata, options, tokenizer) {
+    super(metadata, options), this.idHeader = null, this.lastPos = -1, this.tokenizer = tokenizer, this.durationOnLastPage = !0;
+  }
+  /**
+   * Parse first Opus Ogg page
+   * @param {IPageHeader} header
+   * @param {Uint8Array} pageData
+   */
+  parseFirstPage(_header, pageData) {
+    if (this.metadata.setFormat("codec", "Opus"), this.idHeader = new IdHeader(pageData.length).get(pageData, 0), this.idHeader.magicSignature !== "OpusHead")
+      throw new OpusContentError("Illegal ogg/Opus magic-signature");
+    this.metadata.setFormat("sampleRate", this.idHeader.inputSampleRate), this.metadata.setFormat("numberOfChannels", this.idHeader.channelCount), this.metadata.setAudioOnly();
+  }
+  async parseFullPage(pageData) {
+    new StringType(8, "ascii").get(pageData, 0) === "OpusTags" && (await this.parseUserCommentList(pageData, 8), this.lastPos = this.tokenizer.position - pageData.length);
+  }
+  calculateDuration(enfOfStream) {
+    if (this.lastPageHeader && (enfOfStream || this.lastPageHeader.headerType.lastPage) && this.metadata.format.sampleRate && this.lastPageHeader.absoluteGranulePosition >= 0) {
+      let pos_48bit = this.lastPageHeader.absoluteGranulePosition - this.idHeader.preSkip;
+      if (this.metadata.setFormat("numberOfSamples", pos_48bit), this.metadata.setFormat("duration", pos_48bit / 48e3), this.lastPos !== -1 && this.tokenizer.fileInfo.size && this.metadata.format.duration) {
+        let dataSize = this.tokenizer.fileInfo.size - this.lastPos;
+        this.metadata.setFormat("bitrate", 8 * dataSize / this.metadata.format.duration);
+      }
+    }
+  }
+};
+
+// node_modules/music-metadata/lib/ogg/speex/SpeexStream.js
+var import_debug = __toESM(require_src(), 1);
+
+// node_modules/music-metadata/lib/ogg/speex/Speex.js
+var Header = {
+  len: 80,
+  get: (buf, off) => ({
+    speex: new StringType(8, "ascii").get(buf, off + 0),
+    version: trimRightNull(new StringType(20, "ascii").get(buf, off + 8)),
+    version_id: INT32_LE.get(buf, off + 28),
+    header_size: INT32_LE.get(buf, off + 32),
+    rate: INT32_LE.get(buf, off + 36),
+    mode: INT32_LE.get(buf, off + 40),
+    mode_bitstream_version: INT32_LE.get(buf, off + 44),
+    nb_channels: INT32_LE.get(buf, off + 48),
+    bitrate: INT32_LE.get(buf, off + 52),
+    frame_size: INT32_LE.get(buf, off + 56),
+    vbr: INT32_LE.get(buf, off + 60),
+    frames_per_packet: INT32_LE.get(buf, off + 64),
+    extra_headers: INT32_LE.get(buf, off + 68),
+    reserved1: INT32_LE.get(buf, off + 72),
+    reserved2: INT32_LE.get(buf, off + 76)
+  })
+};
+
+// node_modules/music-metadata/lib/ogg/speex/SpeexStream.js
+var debug = (0, import_debug.default)("music-metadata:parser:ogg:speex"), SpeexStream = class extends VorbisStream {
+  constructor(metadata, options, _tokenizer) {
+    super(metadata, options);
+  }
+  /**
+   * Parse first Speex Ogg page
+   * @param {IPageHeader} header
+   * @param {Uint8Array} pageData
+   */
+  parseFirstPage(_header, pageData) {
+    debug("First Ogg/Speex page");
+    let speexHeader = Header.get(pageData, 0);
+    this.metadata.setFormat("codec", `Speex ${speexHeader.version}`), this.metadata.setFormat("numberOfChannels", speexHeader.nb_channels), this.metadata.setFormat("sampleRate", speexHeader.rate), speexHeader.bitrate !== -1 && this.metadata.setFormat("bitrate", speexHeader.bitrate), this.metadata.setAudioOnly();
+  }
+};
+
+// node_modules/music-metadata/lib/ogg/theora/TheoraStream.js
+var import_debug2 = __toESM(require_src(), 1);
+
+// node_modules/music-metadata/lib/ogg/theora/Theora.js
+var IdentificationHeader = {
+  len: 42,
+  get: (buf, off) => ({
+    id: new StringType(7, "ascii").get(buf, off),
+    vmaj: UINT8.get(buf, off + 7),
+    vmin: UINT8.get(buf, off + 8),
+    vrev: UINT8.get(buf, off + 9),
+    vmbw: UINT16_BE.get(buf, off + 10),
+    vmbh: UINT16_BE.get(buf, off + 17),
+    nombr: UINT24_BE.get(buf, off + 37),
+    nqual: UINT8.get(buf, off + 40)
+  })
+};
+
+// node_modules/music-metadata/lib/ogg/theora/TheoraStream.js
+var debug2 = (0, import_debug2.default)("music-metadata:parser:ogg:theora"), TheoraStream = class {
+  constructor(metadata, _options, _tokenizer) {
+    this.durationOnLastPage = !1, this.metadata = metadata;
+  }
+  /**
+   * Vorbis 1 parser
+   * @param header Ogg Page Header
+   * @param pageData Page data
+   */
+  async parsePage(header, pageData) {
+    header.headerType.firstPage && await this.parseFirstPage(header, pageData);
+  }
+  calculateDuration() {
+    debug2("duration calculation not implemented");
+  }
+  /**
+   * Parse first Theora Ogg page. the initial identification header packet
+   */
+  async parseFirstPage(_header, pageData) {
+    debug2("First Ogg/Theora page"), this.metadata.setFormat("codec", "Theora");
+    let idHeader = IdentificationHeader.get(pageData, 0);
+    this.metadata.setFormat("bitrate", idHeader.nombr), this.metadata.setFormat("hasVideo", !0);
+  }
+  flush() {
+    return Promise.resolve();
+  }
+};
+
+// node_modules/music-metadata/lib/ogg/OggToken.js
+var PageHeader = {
+  len: 27,
+  get: (buf, off) => ({
+    capturePattern: new StringType(4, "latin1").get(buf, off),
+    version: UINT8.get(buf, off + 4),
+    headerType: {
+      continued: getBit(buf, off + 5, 0),
+      firstPage: getBit(buf, off + 5, 1),
+      lastPage: getBit(buf, off + 5, 2)
+    },
+    // packet_flag: Token.UINT8.get(buf, off + 5),
+    absoluteGranulePosition: Number(UINT64_LE.get(buf, off + 6)),
+    streamSerialNumber: UINT32_LE.get(buf, off + 14),
+    pageSequenceNo: UINT32_LE.get(buf, off + 18),
+    pageChecksum: UINT32_LE.get(buf, off + 22),
+    page_segments: UINT8.get(buf, off + 26)
+  })
+}, SegmentTable = class _SegmentTable {
+  static sum(buf, off, len) {
+    let dv = new DataView(buf.buffer, 0), s = 0;
+    for (let i = off; i < off + len; ++i)
+      s += dv.getUint8(i);
+    return s;
+  }
+  constructor(header) {
+    this.len = header.page_segments;
+  }
+  get(buf, off) {
+    return {
+      totalPageSize: _SegmentTable.sum(buf, off, this.len)
+    };
+  }
+};
+
+// node_modules/music-metadata/lib/ogg/flac/FlacStream.js
+var import_debug3 = __toESM(require_src(), 1);
+var debug3 = (0, import_debug3.default)("music-metadata:parser:ogg:theora"), FlacStream = class {
+  constructor(metadata, options, tokenizer) {
+    this.durationOnLastPage = !1, this.metadata = metadata, this.options = options, this.tokenizer = tokenizer, this.flacParser = new FlacParser(this.metadata, this.tokenizer, options);
+  }
+  /**
+   * Vorbis 1 parser
+   * @param header Ogg Page Header
+   * @param pageData Page data
+   */
+  async parsePage(header, pageData) {
+    header.headerType.firstPage && await this.parseFirstPage(header, pageData);
+  }
+  calculateDuration() {
+    debug3("duration calculation not implemented");
+  }
+  /**
+   * Parse first Theora Ogg page. the initial identification header packet
+   */
+  async parseFirstPage(_header, pageData) {
+    if (debug3("First Ogg/FLAC page"), (await FourCcToken.get(pageData, 9)).toString() !== "fLaC")
+      throw new Error("Invalid FLAC preamble");
+    let blockHeader = await BlockHeader.get(pageData, 13);
+    await this.parseDataBlock(blockHeader, pageData.subarray(13 + BlockHeader.len));
+  }
+  async parseDataBlock(blockHeader, pageData) {
+    switch (debug3(`blockHeader type=${blockHeader.type}, length=${blockHeader.length}`), blockHeader.type) {
+      case BlockType.STREAMINFO: {
+        let streamInfo = BlockStreamInfo.get(pageData, 0);
+        return this.flacParser.processsStreamInfo(streamInfo);
+      }
+      case BlockType.PADDING:
+        break;
+      case BlockType.APPLICATION:
+        break;
+      case BlockType.SEEKTABLE:
+        break;
+      case BlockType.VORBIS_COMMENT:
+        return this.flacParser.parseComment(pageData);
+      case BlockType.PICTURE:
+        if (!this.options.skipCovers) {
+          let picture = new VorbisPictureToken(pageData.length).get(pageData, 0);
+          return this.flacParser.addPictureTag(picture);
+        }
+        break;
+      default:
+        this.metadata.addWarning(`Unknown block type: ${blockHeader.type}`);
+    }
+    return this.tokenizer.ignore(blockHeader.length).then();
+  }
+  flush() {
+    return Promise.resolve();
+  }
+};
+
+// node_modules/music-metadata/lib/ogg/OggParser.js
+var OggContentError = class extends makeUnexpectedFileContentError("Ogg") {
+}, debug4 = (0, import_debug4.default)("music-metadata:parser:ogg"), OggStream = class {
+  constructor(metadata, streamSerial, options) {
+    this.pageNumber = 0, this.closed = !1, this.metadata = metadata, this.streamSerial = streamSerial, this.options = options;
+  }
+  async parsePage(tokenizer, header) {
+    this.pageNumber = header.pageSequenceNo, debug4("serial=%s page#=%s, Ogg.id=%s", header.streamSerialNumber, header.pageSequenceNo, header.capturePattern);
+    let segmentTable = await tokenizer.readToken(new SegmentTable(header));
+    debug4("totalPageSize=%s", segmentTable.totalPageSize);
+    let pageData = await tokenizer.readToken(new Uint8ArrayType(segmentTable.totalPageSize));
+    if (debug4("firstPage=%s, lastPage=%s, continued=%s", header.headerType.firstPage, header.headerType.lastPage, header.headerType.continued), header.headerType.firstPage) {
+      this.metadata.setFormat("container", "Ogg");
+      let idData = pageData.subarray(0, 7), asciiId = Array.from(idData).filter((b) => b >= 32 && b <= 126).map((b) => String.fromCharCode(b)).join("");
+      switch (asciiId) {
+        case "vorbis":
+          debug4(`Set Ogg stream serial ${header.streamSerialNumber}, codec=Vorbis`), this.pageConsumer = new VorbisStream(this.metadata, this.options);
+          break;
+        case "OpusHea":
+          debug4("Set page consumer to Ogg/Opus"), this.pageConsumer = new OpusStream(this.metadata, this.options, tokenizer);
+          break;
+        case "Speex  ":
+          debug4("Set page consumer to Ogg/Speex"), this.pageConsumer = new SpeexStream(this.metadata, this.options, tokenizer);
+          break;
+        case "fishead":
+        case "theora":
+          debug4("Set page consumer to Ogg/Theora"), this.pageConsumer = new TheoraStream(this.metadata, this.options, tokenizer);
+          break;
+        case "FLAC":
+          debug4("Set page consumer to Vorbis"), this.pageConsumer = new FlacStream(this.metadata, this.options, tokenizer);
+          break;
+        default:
+          throw new OggContentError(`Ogg codec not recognized (id=${asciiId}`);
+      }
+    }
+    if (header.headerType.lastPage && (this.closed = !0), this.pageConsumer)
+      await this.pageConsumer.parsePage(header, pageData);
+    else
+      throw new Error("pageConsumer should be initialized");
+  }
+}, OggParser = class extends BasicParser {
+  constructor() {
+    super(...arguments), this.streams = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Parse page
+   * @returns {Promise<void>}
+   */
+  async parse() {
+    this.streams = /* @__PURE__ */ new Map();
+    let enfOfStream = !1, header;
+    try {
+      do {
+        if (header = await this.tokenizer.readToken(PageHeader), header.capturePattern !== "OggS")
+          throw new OggContentError("Invalid Ogg capture pattern");
+        let stream = this.streams.get(header.streamSerialNumber);
+        if (stream || (stream = new OggStream(this.metadata, header.streamSerialNumber, this.options), this.streams.set(header.streamSerialNumber, stream)), await stream.parsePage(this.tokenizer, header), stream.pageNumber > 12 && !(this.options.duration && [...this.streams.values()].find((stream2) => stream2.pageConsumer?.durationOnLastPage))) {
+          debug4("Stop processing Ogg stream");
+          break;
+        }
+      } while (![...this.streams.values()].every((item) => item.closed));
+    } catch (err) {
+      if (err instanceof EndOfStreamError)
+        debug4("Reached end-of-stream"), enfOfStream = !0;
+      else if (err instanceof OggContentError)
+        this.metadata.addWarning(`Corrupt Ogg content at ${this.tokenizer.position}`);
+      else
+        throw err;
+    }
+    for (let stream of this.streams.values())
+      stream.closed || (this.metadata.addWarning(`End-of-stream reached before reaching last page in Ogg stream serial=${stream.streamSerial}`), await stream.pageConsumer?.flush()), stream.pageConsumer?.calculateDuration(enfOfStream);
+  }
+};
+export {
+  OggContentError,
+  OggParser
+};