agdi 3.3.6 → 3.3.8

package/dist/OggParser-KRV5QCGZ.js

@@ -0,0 +1,435 @@
+import {
+  BlockHeader,
+  BlockStreamInfo,
+  BlockType,
+  FlacParser,
+  VorbisPictureToken,
+  VorbisStream
+} from "./chunk-AGSFUVRG.js";
+import "./chunk-3JKZUGPJ.js";
+import "./chunk-65JVFJ3X.js";
+import "./chunk-2B4QMSZW.js";
+import {
+  FourCcToken
+} from "./chunk-YIHDW7JC.js";
+import {
+  EndOfStreamError
+} from "./chunk-HNLU36CC.js";
+import "./chunk-LREP5CZP.js";
+import {
+  getBit,
+  trimRightNull
+} from "./chunk-GD35BJSH.js";
+import {
+  BasicParser,
+  INT32_LE,
+  StringType,
+  UINT16_BE,
+  UINT16_LE,
+  UINT24_BE,
+  UINT32_LE,
+  UINT64_LE,
+  UINT8,
+  Uint8ArrayType,
+  makeUnexpectedFileContentError,
+  require_src
+} from "./chunk-VGOIHW7D.js";
+import {
+  __toESM
+} from "./chunk-4VNS5WPM.js";
+
+// ../../node_modules/.pnpm/music-metadata@11.12.0/node_modules/music-metadata/lib/ogg/OggParser.js
+var import_debug4 = __toESM(require_src(), 1);
+
+// ../../node_modules/.pnpm/music-metadata@11.12.0/node_modules/music-metadata/lib/ogg/opus/Opus.js
+var OpusContentError = class extends makeUnexpectedFileContentError("Opus") {
+};
+var 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/.pnpm/music-metadata@11.12.0/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 = true;
+  }
+  /**
+   * Parse first Opus Ogg page
+   * @param {IPageHeader} header
+   * @param {Uint8Array} pageData
+   */
+  parseFirstPage(_header, pageData) {
+    this.metadata.setFormat("codec", "Opus");
+    this.idHeader = new IdHeader(pageData.length).get(pageData, 0);
+    if (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) {
+    const magicSignature = new StringType(8, "ascii").get(pageData, 0);
+    switch (magicSignature) {
+      case "OpusTags":
+        await this.parseUserCommentList(pageData, 8);
+        this.lastPos = this.tokenizer.position - pageData.length;
+        break;
+      default:
+        break;
+    }
+  }
+  calculateDuration(enfOfStream) {
+    if (this.lastPageHeader && (enfOfStream || this.lastPageHeader.headerType.lastPage) && this.metadata.format.sampleRate && this.lastPageHeader.absoluteGranulePosition >= 0) {
+      const pos_48bit = this.lastPageHeader.absoluteGranulePosition - this.idHeader.preSkip;
+      this.metadata.setFormat("numberOfSamples", pos_48bit);
+      this.metadata.setFormat("duration", pos_48bit / 48e3);
+      if (this.lastPos !== -1 && this.tokenizer.fileInfo.size && this.metadata.format.duration) {
+        const dataSize = this.tokenizer.fileInfo.size - this.lastPos;
+        this.metadata.setFormat("bitrate", 8 * dataSize / this.metadata.format.duration);
+      }
+    }
+  }
+};
+
+// ../../node_modules/.pnpm/music-metadata@11.12.0/node_modules/music-metadata/lib/ogg/speex/SpeexStream.js
+var import_debug = __toESM(require_src(), 1);
+
+// ../../node_modules/.pnpm/music-metadata@11.12.0/node_modules/music-metadata/lib/ogg/speex/Speex.js
+var Header = {
+  len: 80,
+  get: (buf, off) => {
+    return {
+      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/.pnpm/music-metadata@11.12.0/node_modules/music-metadata/lib/ogg/speex/SpeexStream.js
+var debug = (0, import_debug.default)("music-metadata:parser:ogg:speex");
+var 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");
+    const 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);
+    if (speexHeader.bitrate !== -1) {
+      this.metadata.setFormat("bitrate", speexHeader.bitrate);
+    }
+    this.metadata.setAudioOnly();
+  }
+};
+
+// ../../node_modules/.pnpm/music-metadata@11.12.0/node_modules/music-metadata/lib/ogg/theora/TheoraStream.js
+var import_debug2 = __toESM(require_src(), 1);
+
+// ../../node_modules/.pnpm/music-metadata@11.12.0/node_modules/music-metadata/lib/ogg/theora/Theora.js
+var IdentificationHeader = {
+  len: 42,
+  get: (buf, off) => {
+    return {
+      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/.pnpm/music-metadata@11.12.0/node_modules/music-metadata/lib/ogg/theora/TheoraStream.js
+var debug2 = (0, import_debug2.default)("music-metadata:parser:ogg:theora");
+var TheoraStream = class {
+  constructor(metadata, _options, _tokenizer) {
+    this.durationOnLastPage = false;
+    this.metadata = metadata;
+  }
+  /**
+   * Vorbis 1 parser
+   * @param header Ogg Page Header
+   * @param pageData Page data
+   */
+  async parsePage(header, pageData) {
+    if (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");
+    const idHeader = IdentificationHeader.get(pageData, 0);
+    this.metadata.setFormat("bitrate", idHeader.nombr);
+    this.metadata.setFormat("hasVideo", true);
+  }
+  flush() {
+    return Promise.resolve();
+  }
+};
+
+// ../../node_modules/.pnpm/music-metadata@11.12.0/node_modules/music-metadata/lib/ogg/OggToken.js
+var PageHeader = {
+  len: 27,
+  get: (buf, off) => {
+    return {
+      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)
+    };
+  }
+};
+var SegmentTable = class _SegmentTable {
+  static sum(buf, off, len) {
+    const dv = new DataView(buf.buffer, 0);
+    let 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/.pnpm/music-metadata@11.12.0/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");
+var FlacStream = class {
+  constructor(metadata, options, tokenizer) {
+    this.durationOnLastPage = false;
+    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) {
+    if (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) {
+    debug3("First Ogg/FLAC page");
+    const fourCC = await FourCcToken.get(pageData, 9);
+    if (fourCC.toString() !== "fLaC") {
+      throw new Error("Invalid FLAC preamble");
+    }
+    const blockHeader = await BlockHeader.get(pageData, 13);
+    await this.parseDataBlock(blockHeader, pageData.subarray(13 + BlockHeader.len));
+  }
+  async parseDataBlock(blockHeader, pageData) {
+    debug3(`blockHeader type=${blockHeader.type}, length=${blockHeader.length}`);
+    switch (blockHeader.type) {
+      case BlockType.STREAMINFO: {
+        const 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) {
+          const 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/.pnpm/music-metadata@11.12.0/node_modules/music-metadata/lib/ogg/OggParser.js
+var OggContentError = class extends makeUnexpectedFileContentError("Ogg") {
+};
+var debug4 = (0, import_debug4.default)("music-metadata:parser:ogg");
+var OggStream = class {
+  constructor(metadata, streamSerial, options) {
+    this.pageNumber = 0;
+    this.closed = false;
+    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);
+    const segmentTable = await tokenizer.readToken(new SegmentTable(header));
+    debug4("totalPageSize=%s", segmentTable.totalPageSize);
+    const pageData = await tokenizer.readToken(new Uint8ArrayType(segmentTable.totalPageSize));
+    debug4("firstPage=%s, lastPage=%s, continued=%s", header.headerType.firstPage, header.headerType.lastPage, header.headerType.continued);
+    if (header.headerType.firstPage) {
+      this.metadata.setFormat("container", "Ogg");
+      const idData = pageData.subarray(0, 7);
+      const 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 = true;
+    }
+    if (this.pageConsumer) {
+      await this.pageConsumer.parsePage(header, pageData);
+    } else
+      throw new Error("pageConsumer should be initialized");
+  }
+};
+var 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 = false;
+    let header;
+    try {
+      do {
+        header = await this.tokenizer.readToken(PageHeader);
+        if (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);
+        if (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 = true;
+      } else if (err instanceof OggContentError) {
+        this.metadata.addWarning(`Corrupt Ogg content at ${this.tokenizer.position}`);
+      } else
+        throw err;
+    }
+    for (const stream of this.streams.values()) {
+      if (!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
+};

package/dist/WavPackParser-XPZSQFVS.js

@@ -0,0 +1,203 @@
+import {
+  FourCcToken,
+  tryParseApeHeader
+} from "./chunk-YIHDW7JC.js";
+import "./chunk-HNLU36CC.js";
+import {
+  uint8ArrayToHex
+} from "./chunk-GD35BJSH.js";
+import {
+  BasicParser,
+  UINT16_LE,
+  UINT24_LE,
+  UINT32_LE,
+  UINT8,
+  Uint8ArrayType,
+  makeUnexpectedFileContentError,
+  require_src
+} from "./chunk-VGOIHW7D.js";
+import {
+  __toESM
+} from "./chunk-4VNS5WPM.js";
+
+// ../../node_modules/.pnpm/music-metadata@11.12.0/node_modules/music-metadata/lib/wavpack/WavPackToken.js
+var SampleRates = [
+  6e3,
+  8e3,
+  9600,
+  11025,
+  12e3,
+  16e3,
+  22050,
+  24e3,
+  32e3,
+  44100,
+  48e3,
+  64e3,
+  88200,
+  96e3,
+  192e3,
+  -1
+];
+var BlockHeaderToken = {
+  len: 32,
+  get: (buf, off) => {
+    const flags = UINT32_LE.get(buf, off + 24);
+    const res = {
+      // should equal 'wvpk'
+      BlockID: FourCcToken.get(buf, off),
+      //  0x402 to 0x410 are valid for decode
+      blockSize: UINT32_LE.get(buf, off + 4),
+      //  0x402 (1026) to 0x410 are valid for decode
+      version: UINT16_LE.get(buf, off + 8),
+      //  40-bit total samples for entire file (if block_index == 0 and a value of -1 indicates an unknown length)
+      totalSamples: (
+        /* replace with bigint? (Token.UINT8.get(buf, off + 11) << 32) + */
+        UINT32_LE.get(buf, off + 12)
+      ),
+      // 40-bit block_index
+      blockIndex: (
+        /* replace with bigint? (Token.UINT8.get(buf, off + 10) << 32) + */
+        UINT32_LE.get(buf, off + 16)
+      ),
+      // 40-bit total samples for entire file (if block_index == 0 and a value of -1 indicates an unknown length)
+      blockSamples: 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)
+      },
+      // crc for actual decoded data
+      crc: new Uint8ArrayType(4).get(buf, off + 28)
+    };
+    if (res.flags.isDSD) {
+      res.totalSamples *= 8;
+    }
+    return res;
+  }
+};
+var 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)
+    };
+  }
+};
+function isBitSet(flags, bitOffset) {
+  return getBitAllignedNumber(flags, bitOffset, 1) === 1;
+}
+function getBitAllignedNumber(flags, bitOffset, len) {
+  return flags >>> bitOffset & 4294967295 >>> 32 - len;
+}
+
+// ../../node_modules/.pnpm/music-metadata@11.12.0/node_modules/music-metadata/lib/wavpack/WavPackParser.js
+var import_debug = __toESM(require_src(), 1);
+var debug = (0, import_debug.default)("music-metadata:parser:WavPack");
+var WavPackContentError = class extends makeUnexpectedFileContentError("WavPack") {
+};
+var WavPackParser = class extends BasicParser {
+  constructor() {
+    super(...arguments);
+    this.audioDataSize = 0;
+  }
+  async parse() {
+    this.metadata.setAudioOnly();
+    this.audioDataSize = 0;
+    await this.parseWavPackBlocks();
+    return tryParseApeHeader(this.metadata, this.tokenizer, this.options);
+  }
+  async parseWavPackBlocks() {
+    do {
+      const blockId = await this.tokenizer.peekToken(FourCcToken);
+      if (blockId !== "wvpk")
+        break;
+      const header = await this.tokenizer.readToken(BlockHeaderToken);
+      if (header.BlockID !== "wvpk")
+        throw new WavPackContentError("Invalid WavPack Block-ID");
+      debug(`WavPack header blockIndex=${header.blockIndex}, len=${BlockHeaderToken.len}`);
+      if (header.blockIndex === 0 && !this.metadata.format.container) {
+        this.metadata.setFormat("container", "WavPack");
+        this.metadata.setFormat("lossless", !header.flags.isHybrid);
+        this.metadata.setFormat("bitsPerSample", header.flags.bitsPerSample);
+        if (!header.flags.isDSD) {
+          this.metadata.setFormat("sampleRate", header.flags.samplingRate);
+          this.metadata.setFormat("duration", header.totalSamples / header.flags.samplingRate);
+        }
+        this.metadata.setFormat("numberOfChannels", header.flags.isMono ? 1 : 2);
+        this.metadata.setFormat("numberOfSamples", header.totalSamples);
+        this.metadata.setFormat("codec", header.flags.isDSD ? "DSD" : "PCM");
+      }
+      const ignoreBytes = header.blockSize - (BlockHeaderToken.len - 8);
+      await (header.blockIndex === 0 ? this.parseMetadataSubBlock(header, ignoreBytes) : this.tokenizer.ignore(ignoreBytes));
+      if (header.blockSamples > 0) {
+        this.audioDataSize += header.blockSize;
+      }
+    } while (!this.tokenizer.fileInfo.size || this.tokenizer.fileInfo.size - this.tokenizer.position >= BlockHeaderToken.len);
+    if (this.metadata.format.duration) {
+      this.metadata.setFormat("bitrate", this.audioDataSize * 8 / this.metadata.format.duration);
+    }
+  }
+  /**
+   * Ref: http://www.wavpack.com/WavPack5FileFormat.pdf, 3.0 Metadata Sub-blocks
+   * @param header Header
+   * @param remainingLength Remaining length
+   */
+  async parseMetadataSubBlock(header, remainingLength) {
+    let remaining = remainingLength;
+    while (remaining > MetadataIdToken.len) {
+      const id = await this.tokenizer.readToken(MetadataIdToken);
+      const dataSizeInWords = await this.tokenizer.readNumber(id.largeBlock ? UINT24_LE : UINT8);
+      const data = new Uint8Array(dataSizeInWords * 2 - (id.isOddSize ? 1 : 0));
+      await this.tokenizer.readBuffer(data);
+      debug(`Metadata Sub-Blocks functionId=0x${id.functionId.toString(16)}, id.largeBlock=${id.largeBlock},data-size=${data.length}`);
+      switch (id.functionId) {
+        case 0:
+          break;
+        case 14: {
+          debug("ID_DSD_BLOCK");
+          const mp = 1 << UINT8.get(data, 0);
+          const samplingRate = header.flags.samplingRate * mp * 8;
+          if (!header.flags.isDSD)
+            throw new WavPackContentError("Only expect DSD block if DSD-flag is set");
+          this.metadata.setFormat("sampleRate", samplingRate);
+          this.metadata.setFormat("duration", header.totalSamples / samplingRate);
+          break;
+        }
+        case 36:
+          debug("ID_ALT_TRAILER: trailer for non-wav files");
+          break;
+        case 38:
+          this.metadata.setFormat("audioMD5", data);
+          break;
+        case 47:
+          debug(`ID_BLOCK_CHECKSUM: checksum=${uint8ArrayToHex(data)}`);
+          break;
+        default:
+          debug(`Ignore unsupported meta-sub-block-id functionId=0x${id.functionId.toString(16)}`);
+          break;
+      }
+      remaining -= MetadataIdToken.len + (id.largeBlock ? UINT24_LE.len : UINT8.len) + dataSizeInWords * 2;
+      debug(`remainingLength=${remaining}`);
+      if (id.isOddSize)
+        this.tokenizer.ignore(1);
+    }
+    if (remaining !== 0)
+      throw new WavPackContentError("metadata-sub-block should fit it remaining length");
+  }
+};
+export {
+  WavPackContentError,
+  WavPackParser
+};