@agentdocumentformat/cli 0.7.2

package/dist/chunks/MP4Parser-66HBRUSX.mjs

@@ -0,0 +1,973 @@
+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 "./chunk-2DIECGFL.mjs";
+import {
+  TrackType
+} from "./chunk-EWL5FG4I.mjs";
+import {
+  Genres
+} from "./chunk-VAUOM3IN.mjs";
+import "./chunk-DXWDD5XJ.mjs";
+import {
+  FourCcToken
+} from "./chunk-NBTUWMGP.mjs";
+import {
+  getBit,
+  uint8ArrayToHex
+} from "./chunk-XX7OSWTO.mjs";
+import "./chunk-HBUENVQL.mjs";
+import {
+  BasicParser,
+  FieldDecodingError,
+  INT16_BE,
+  INT24_BE,
+  INT32_BE,
+  INT8,
+  StringType,
+  UINT16_BE,
+  UINT24_BE,
+  UINT32_BE,
+  UINT64_BE,
+  UINT8,
+  Uint8ArrayType,
+  lib_exports,
+  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/mp4/MP4Parser.js
+var import_debug3 = __toESM(require_src(), 1);
+
+// node_modules/music-metadata/lib/mp4/Atom.js
+var import_debug2 = __toESM(require_src(), 1);
+
+// node_modules/music-metadata/lib/mp4/AtomToken.js
+var import_debug = __toESM(require_src(), 1);
+var debug = (0, import_debug.default)("music-metadata:parser:MP4:atom"), Mp4ContentError = class extends makeUnexpectedFileContentError("MP4") {
+}, Header = {
+  len: 8,
+  get: (buf, off) => {
+    let length = UINT32_BE.get(buf, off);
+    if (length < 0)
+      throw new Mp4ContentError("Invalid atom header length");
+    return {
+      length: BigInt(length),
+      name: new StringType(4, "latin1").get(buf, off + 4)
+    };
+  },
+  put: (buf, off, hdr) => (UINT32_BE.put(buf, off, Number(hdr.length)), FourCcToken.put(buf, off + 4, hdr.name))
+}, ExtendedSize = UINT64_BE, ftyp = {
+  len: 4,
+  get: (buf, off) => ({
+    type: new StringType(4, "ascii").get(buf, off)
+  })
+};
+var FixedLengthAtom = class {
+  /**
+   *
+   * @param {number} len Length as specified in the size field
+   * @param {number} expLen Total length of sum of specified fields in the standard
+   * @param atomId Atom ID
+   */
+  constructor(len, expLen, atomId) {
+    if (len < expLen)
+      throw new Mp4ContentError(`Atom ${atomId} expected to be ${expLen}, but specifies ${len} bytes long.`);
+    len > expLen && debug(`Warning: atom ${atomId} expected to be ${expLen}, but was actually ${len} bytes long.`), this.len = len;
+  }
+}, SecondsSinceMacEpoch = {
+  len: 4,
+  get: (buf, off) => {
+    let secondsSinceUnixEpoch = UINT32_BE.get(buf, off) - 2082844800;
+    return new Date(secondsSinceUnixEpoch * 1e3);
+  }
+}, SecondsSinceMacEpoch64 = {
+  len: 8,
+  get: (buf, off) => {
+    let secondsSinceUnixEpoch = Number(UINT64_BE.get(buf, off)) - 2082844800;
+    return new Date(secondsSinceUnixEpoch * 1e3);
+  }
+}, MdhdAtom = class extends FixedLengthAtom {
+  constructor(len) {
+    super(len, 24, "mdhd");
+  }
+  get(buf, off) {
+    let version = UINT8.get(buf, off + 0), flags = UINT24_BE.get(buf, off + 1);
+    switch (version) {
+      case 0:
+        return {
+          version,
+          flags,
+          creationTime: SecondsSinceMacEpoch.get(buf, off + 4),
+          modificationTime: SecondsSinceMacEpoch.get(buf, off + 8),
+          timeScale: UINT32_BE.get(buf, off + 12),
+          duration: UINT32_BE.get(buf, off + 16),
+          language: UINT16_BE.get(buf, off + 20),
+          quality: UINT16_BE.get(buf, off + 22)
+        };
+      case 1:
+        return {
+          version,
+          flags,
+          creationTime: SecondsSinceMacEpoch64.get(buf, off + 4),
+          modificationTime: SecondsSinceMacEpoch64.get(buf, off + 12),
+          timeScale: UINT32_BE.get(buf, off + 20),
+          duration: Number(UINT64_BE.get(buf, off + 24)),
+          language: UINT16_BE.get(buf, off + 32),
+          quality: UINT16_BE.get(buf, off + 34)
+        };
+      default:
+        throw new FieldDecodingError("Invalid mdhd version header");
+    }
+  }
+}, MvhdAtom = class extends FixedLengthAtom {
+  constructor(len) {
+    super(len, 100, "mvhd");
+  }
+  get(buf, off) {
+    let version = UINT8.get(buf, off), flags = UINT24_BE.get(buf, off + 1);
+    return version === 1 ? {
+      version,
+      flags,
+      creationTime: SecondsSinceMacEpoch64.get(buf, off + 4),
+      modificationTime: SecondsSinceMacEpoch64.get(buf, off + 12),
+      timeScale: UINT32_BE.get(buf, off + 20),
+      duration: Number(UINT64_BE.get(buf, off + 24)),
+      preferredRate: UINT32_BE.get(buf, off + 32),
+      preferredVolume: UINT16_BE.get(buf, off + 36),
+      // ignore reserved: 10 bytes
+      // ignore matrix structure: 36 bytes
+      previewTime: UINT32_BE.get(buf, off + 84),
+      previewDuration: UINT32_BE.get(buf, off + 88),
+      posterTime: UINT32_BE.get(buf, off + 92),
+      selectionTime: UINT32_BE.get(buf, off + 96),
+      selectionDuration: UINT32_BE.get(buf, off + 100),
+      currentTime: UINT32_BE.get(buf, off + 104),
+      nextTrackID: UINT32_BE.get(buf, off + 108)
+    } : {
+      version,
+      flags,
+      creationTime: SecondsSinceMacEpoch.get(buf, off + 4),
+      modificationTime: SecondsSinceMacEpoch.get(buf, off + 8),
+      timeScale: UINT32_BE.get(buf, off + 12),
+      duration: UINT32_BE.get(buf, off + 16),
+      preferredRate: UINT32_BE.get(buf, off + 20),
+      preferredVolume: UINT16_BE.get(buf, off + 24),
+      // ignore reserved: 10 bytes
+      // ignore matrix structure: 36 bytes
+      previewTime: UINT32_BE.get(buf, off + 72),
+      previewDuration: UINT32_BE.get(buf, off + 76),
+      posterTime: UINT32_BE.get(buf, off + 80),
+      selectionTime: UINT32_BE.get(buf, off + 84),
+      selectionDuration: UINT32_BE.get(buf, off + 88),
+      currentTime: UINT32_BE.get(buf, off + 92),
+      nextTrackID: UINT32_BE.get(buf, off + 96)
+    };
+  }
+}, DataAtom = class {
+  constructor(len) {
+    this.len = len;
+  }
+  get(buf, off) {
+    return {
+      type: {
+        set: UINT8.get(buf, off + 0),
+        type: UINT24_BE.get(buf, off + 1)
+      },
+      locale: UINT24_BE.get(buf, off + 4),
+      value: new Uint8ArrayType(this.len - 8).get(buf, off + 8)
+    };
+  }
+}, NameAtom = class {
+  constructor(len) {
+    this.len = len;
+  }
+  get(buf, off) {
+    return {
+      version: UINT8.get(buf, off),
+      flags: UINT24_BE.get(buf, off + 1),
+      name: new StringType(this.len - 4, "utf-8").get(buf, off + 4)
+    };
+  }
+}, TrackHeaderAtom = class {
+  constructor(len) {
+    this.len = len;
+  }
+  get(buf, off) {
+    let version = UINT8.get(buf, off), flags = UINT24_BE.get(buf, off + 1);
+    switch (version) {
+      case 0:
+        return {
+          version,
+          flags,
+          creationTime: SecondsSinceMacEpoch.get(buf, off + 4),
+          modificationTime: SecondsSinceMacEpoch.get(buf, off + 8),
+          trackId: UINT32_BE.get(buf, off + 12),
+          // reserved 4 bytes
+          duration: UINT32_BE.get(buf, off + 20),
+          // reserved 8 bytes
+          layer: UINT16_BE.get(buf, off + 32),
+          alternateGroup: UINT16_BE.get(buf, off + 34),
+          volume: UINT16_BE.get(buf, off + 36)
+          // ToDo: fixed point
+          // ToDo: add remaining fields
+        };
+      case 1:
+        return {
+          version,
+          flags,
+          creationTime: SecondsSinceMacEpoch64.get(buf, off + 4),
+          modificationTime: SecondsSinceMacEpoch64.get(buf, off + 12),
+          trackId: UINT32_BE.get(buf, off + 20),
+          // reserved 4 bytes
+          duration: Number(UINT64_BE.get(buf, off + 28)),
+          // reserved 8 bytes
+          layer: UINT16_BE.get(buf, off + 44),
+          alternateGroup: UINT16_BE.get(buf, off + 46),
+          volume: UINT16_BE.get(buf, off + 48)
+          // ToDo: fixed point
+          // ToDo: add remaining fields
+        };
+      default:
+        throw new FieldDecodingError("Invalid tkhd version header");
+    }
+  }
+}, stsdHeader = {
+  len: 8,
+  get: (buf, off) => ({
+    version: UINT8.get(buf, off),
+    flags: UINT24_BE.get(buf, off + 1),
+    numberOfEntries: UINT32_BE.get(buf, off + 4)
+  })
+}, SampleDescriptionTable = class {
+  constructor(len) {
+    this.len = len;
+  }
+  get(buf, off) {
+    let descrLen = this.len - 12;
+    return {
+      dataFormat: FourCcToken.get(buf, off),
+      dataReferenceIndex: UINT16_BE.get(buf, off + 10),
+      description: descrLen > 0 ? new Uint8ArrayType(descrLen).get(buf, off + 12) : void 0
+    };
+  }
+}, StsdAtom = class {
+  constructor(len) {
+    this.len = len;
+  }
+  get(buf, off) {
+    let header = stsdHeader.get(buf, off);
+    off += stsdHeader.len;
+    let table = [];
+    for (let n = 0; n < header.numberOfEntries; ++n) {
+      let size = UINT32_BE.get(buf, off);
+      off += UINT32_BE.len, table.push(new SampleDescriptionTable(size - UINT32_BE.len).get(buf, off)), off += size;
+    }
+    return {
+      header,
+      table
+    };
+  }
+}, SoundSampleDescriptionVersion = {
+  len: 8,
+  get(buf, off) {
+    return {
+      version: INT16_BE.get(buf, off),
+      revision: INT16_BE.get(buf, off + 2),
+      vendor: INT32_BE.get(buf, off + 4)
+    };
+  }
+}, SoundSampleDescriptionV0 = {
+  len: 12,
+  get(buf, off) {
+    return {
+      numAudioChannels: INT16_BE.get(buf, off + 0),
+      sampleSize: INT16_BE.get(buf, off + 2),
+      compressionId: INT16_BE.get(buf, off + 4),
+      packetSize: INT16_BE.get(buf, off + 6),
+      sampleRate: UINT16_BE.get(buf, off + 8) + UINT16_BE.get(buf, off + 10) / 1e4
+    };
+  }
+}, SimpleTableAtom = class {
+  constructor(len, token) {
+    this.len = len, this.token = token;
+  }
+  get(buf, off) {
+    let nrOfEntries = INT32_BE.get(buf, off + 4);
+    return {
+      version: INT8.get(buf, off + 0),
+      flags: INT24_BE.get(buf, off + 1),
+      numberOfEntries: nrOfEntries,
+      entries: readTokenTable(buf, this.token, off + 8, this.len - 8, nrOfEntries)
+    };
+  }
+}, TimeToSampleToken = {
+  len: 8,
+  get(buf, off) {
+    return {
+      count: INT32_BE.get(buf, off + 0),
+      duration: INT32_BE.get(buf, off + 4)
+    };
+  }
+}, SttsAtom = class extends SimpleTableAtom {
+  constructor(len) {
+    super(len, TimeToSampleToken);
+  }
+}, SampleToChunkToken = {
+  len: 12,
+  get(buf, off) {
+    return {
+      firstChunk: INT32_BE.get(buf, off),
+      samplesPerChunk: INT32_BE.get(buf, off + 4),
+      sampleDescriptionId: INT32_BE.get(buf, off + 8)
+    };
+  }
+}, StscAtom = class extends SimpleTableAtom {
+  constructor(len) {
+    super(len, SampleToChunkToken);
+  }
+}, StszAtom = class {
+  constructor(len) {
+    this.len = len;
+  }
+  get(buf, off) {
+    let nrOfEntries = INT32_BE.get(buf, off + 8);
+    return {
+      version: INT8.get(buf, off),
+      flags: INT24_BE.get(buf, off + 1),
+      sampleSize: INT32_BE.get(buf, off + 4),
+      numberOfEntries: nrOfEntries,
+      entries: readTokenTable(buf, INT32_BE, off + 12, this.len - 12, nrOfEntries)
+    };
+  }
+}, StcoAtom = class extends SimpleTableAtom {
+  constructor(len) {
+    super(len, INT32_BE), this.len = len;
+  }
+}, ChapterText = class {
+  constructor(len) {
+    this.len = len;
+  }
+  get(buf, off) {
+    let titleLen = INT16_BE.get(buf, off + 0);
+    return new StringType(titleLen, "utf-8").get(buf, off + 2);
+  }
+};
+function readTokenTable(buf, token, off, remainingLen, numberOfEntries) {
+  if (debug(`remainingLen=${remainingLen}, numberOfEntries=${numberOfEntries} * token-len=${token.len}`), remainingLen === 0)
+    return [];
+  if (remainingLen !== numberOfEntries * token.len)
+    throw new Mp4ContentError("mismatch number-of-entries with remaining atom-length");
+  let entries = [];
+  for (let n = 0; n < numberOfEntries; ++n)
+    entries.push(token.get(buf, off)), off += token.len;
+  return entries;
+}
+var TrackFragmentHeaderBox = class {
+  constructor(len) {
+    this.len = len;
+  }
+  get(buf, off) {
+    let flagOffset = off + 1, header = {
+      version: INT8.get(buf, off),
+      flags: {
+        baseDataOffsetPresent: getBit(buf, flagOffset + 2, 0),
+        sampleDescriptionIndexPresent: getBit(buf, flagOffset + 2, 1),
+        defaultSampleDurationPresent: getBit(buf, flagOffset + 2, 3),
+        defaultSampleSizePresent: getBit(buf, flagOffset + 2, 4),
+        defaultSampleFlagsPresent: getBit(buf, flagOffset + 2, 5),
+        defaultDurationIsEmpty: getBit(buf, flagOffset, 0),
+        defaultBaseIsMoof: getBit(buf, flagOffset, 1)
+      },
+      trackId: UINT32_BE.get(buf, 4)
+    }, dynOffset = 8;
+    return header.flags.baseDataOffsetPresent && (header.baseDataOffset = UINT64_BE.get(buf, dynOffset), dynOffset += 8), header.flags.sampleDescriptionIndexPresent && (header.sampleDescriptionIndex = UINT32_BE.get(buf, dynOffset), dynOffset += 4), header.flags.defaultSampleDurationPresent && (header.defaultSampleDuration = UINT32_BE.get(buf, dynOffset), dynOffset += 4), header.flags.defaultSampleSizePresent && (header.defaultSampleSize = UINT32_BE.get(buf, dynOffset), dynOffset += 4), header.flags.defaultSampleFlagsPresent && (header.defaultSampleFlags = UINT32_BE.get(buf, dynOffset)), header;
+  }
+}, TrackRunBox = class {
+  constructor(len) {
+    this.len = len;
+  }
+  get(buf, off) {
+    let flagOffset = off + 1, trun = {
+      version: INT8.get(buf, off),
+      flags: {
+        dataOffsetPresent: getBit(buf, flagOffset + 2, 0),
+        firstSampleFlagsPresent: getBit(buf, flagOffset + 2, 2),
+        sampleDurationPresent: getBit(buf, flagOffset + 1, 0),
+        sampleSizePresent: getBit(buf, flagOffset + 1, 1),
+        sampleFlagsPresent: getBit(buf, flagOffset + 1, 2),
+        sampleCompositionTimeOffsetsPresent: getBit(buf, flagOffset + 1, 3)
+      },
+      sampleCount: UINT32_BE.get(buf, off + 4),
+      samples: []
+    }, dynOffset = off + 8;
+    trun.flags.dataOffsetPresent && (trun.dataOffset = UINT32_BE.get(buf, dynOffset), dynOffset += 4), trun.flags.firstSampleFlagsPresent && (trun.firstSampleFlags = UINT32_BE.get(buf, dynOffset), dynOffset += 4);
+    for (let n = 0; n < trun.sampleCount; ++n) {
+      if (dynOffset >= this.len) {
+        debug("TrackRunBox size mismatch");
+        break;
+      }
+      let sample = {};
+      trun.flags.sampleDurationPresent && (sample.sampleDuration = UINT32_BE.get(buf, dynOffset), dynOffset += 4), trun.flags.sampleSizePresent && (sample.sampleSize = UINT32_BE.get(buf, dynOffset), dynOffset += 4), trun.flags.sampleFlagsPresent && (sample.sampleFlags = UINT32_BE.get(buf, dynOffset), dynOffset += 4), trun.flags.sampleCompositionTimeOffsetsPresent && (sample.sampleCompositionTimeOffset = UINT32_BE.get(buf, dynOffset), dynOffset += 4), trun.samples.push(sample);
+    }
+    return trun;
+  }
+}, HandlerBox = class {
+  constructor(len) {
+    this.len = len;
+  }
+  get(buf, off) {
+    let _flagOffset = off + 1, charTypeToken = new StringType(4, "utf-8");
+    return {
+      version: INT8.get(buf, off),
+      flags: UINT24_BE.get(buf, off + 1),
+      componentType: charTypeToken.get(buf, off + 4),
+      handlerType: charTypeToken.get(buf, off + 8),
+      componentName: new StringType(this.len - 28, "utf-8").get(buf, off + 28)
+    };
+  }
+}, ChapterTrackReferenceBox = class {
+  constructor(len) {
+    this.len = len;
+  }
+  get(buf, off) {
+    let dynOffset = 0, trackIds = [];
+    for (; dynOffset < this.len; )
+      trackIds.push(UINT32_BE.get(buf, off + dynOffset)), dynOffset += 4;
+    return trackIds;
+  }
+};
+
+// node_modules/music-metadata/lib/mp4/Atom.js
+var debug2 = (0, import_debug2.default)("music-metadata:parser:MP4:Atom"), Atom = class _Atom {
+  static async readAtom(tokenizer, dataHandler, parent, remaining) {
+    let offset = tokenizer.position;
+    debug2(`Reading next token on offset=${offset}...`);
+    let header = await tokenizer.readToken(Header), extended = header.length === 1n;
+    extended && (header.length = await tokenizer.readToken(ExtendedSize));
+    let atomBean = new _Atom(header, extended, parent), payloadLength = atomBean.getPayloadLength(remaining);
+    return debug2(`parse atom name=${atomBean.atomPath}, extended=${atomBean.extended}, offset=${offset}, len=${atomBean.header.length}`), await atomBean.readData(tokenizer, dataHandler, payloadLength), atomBean;
+  }
+  constructor(header, extended, parent) {
+    this.header = header, this.extended = extended, this.parent = parent, this.children = [], this.atomPath = (this.parent ? `${this.parent.atomPath}.` : "") + this.header.name;
+  }
+  getHeaderLength() {
+    return this.extended ? 16 : 8;
+  }
+  getPayloadLength(remaining) {
+    return (this.header.length === 0n ? remaining : Number(this.header.length)) - this.getHeaderLength();
+  }
+  async readAtoms(tokenizer, dataHandler, size) {
+    for (; size > 0; ) {
+      let atomBean = await _Atom.readAtom(tokenizer, dataHandler, this, size);
+      this.children.push(atomBean), size -= atomBean.header.length === 0n ? size : Number(atomBean.header.length);
+    }
+  }
+  async readData(tokenizer, dataHandler, remaining) {
+    switch (this.header.name) {
+      // "Container" atoms, contains nested atoms
+      case "moov":
+      // The Movie Atom: contains other atoms
+      case "udta":
+      // User defined atom
+      case "mdia":
+      // Media atom
+      case "minf":
+      // Media Information Atom
+      case "stbl":
+      // The Sample Table Atom
+      case "<id>":
+      case "ilst":
+      case "tref":
+      case "moof":
+        return this.readAtoms(tokenizer, dataHandler, this.getPayloadLength(remaining));
+      case "meta": {
+        let paddingLength = (await tokenizer.peekToken(Header)).name === "hdlr" ? 0 : 4;
+        return await tokenizer.ignore(paddingLength), this.readAtoms(tokenizer, dataHandler, this.getPayloadLength(remaining) - paddingLength);
+      }
+      default:
+        return dataHandler(this, remaining);
+    }
+  }
+};
+
+// node_modules/music-metadata/lib/mp4/MP4Parser.js
+var debug3 = (0, import_debug3.default)("music-metadata:parser:MP4"), tagFormat = "iTunes", encoderDict = {
+  raw: {
+    lossy: !1,
+    format: "raw"
+  },
+  MAC3: {
+    lossy: !0,
+    format: "MACE 3:1"
+  },
+  MAC6: {
+    lossy: !0,
+    format: "MACE 6:1"
+  },
+  ima4: {
+    lossy: !0,
+    format: "IMA 4:1"
+  },
+  ulaw: {
+    lossy: !0,
+    format: "uLaw 2:1"
+  },
+  alaw: {
+    lossy: !0,
+    format: "uLaw 2:1"
+  },
+  Qclp: {
+    lossy: !0,
+    format: "QUALCOMM PureVoice"
+  },
+  ".mp3": {
+    lossy: !0,
+    format: "MPEG-1 layer 3"
+  },
+  alac: {
+    lossy: !1,
+    format: "ALAC"
+  },
+  "ac-3": {
+    lossy: !0,
+    format: "AC-3"
+  },
+  mp4a: {
+    lossy: !0,
+    format: "MPEG-4/AAC"
+  },
+  mp4s: {
+    lossy: !0,
+    format: "MP4S"
+  },
+  // Closed Captioning Media, https://developer.apple.com/library/archive/documentation/QuickTime/QTFF/QTFFChap3/qtff3.html#//apple_ref/doc/uid/TP40000939-CH205-SW87
+  c608: {
+    lossy: !0,
+    format: "CEA-608"
+  },
+  c708: {
+    lossy: !0,
+    format: "CEA-708"
+  }
+};
+function distinct(value, index, self) {
+  return self.indexOf(value) === index;
+}
+var MP4Parser = class _MP4Parser extends BasicParser {
+  constructor() {
+    super(...arguments), this.tracks = /* @__PURE__ */ new Map(), this.hasVideoTrack = !1, this.hasAudioTrack = !0, this.atomParsers = {
+      /**
+       * Parse movie header (mvhd) atom
+       * Ref: https://developer.apple.com/library/archive/documentation/QuickTime/QTFF/QTFFChap2/qtff2.html#//apple_ref/doc/uid/TP40000939-CH204-56313
+       */
+      mvhd: async (len) => {
+        let mvhd = await this.tokenizer.readToken(new MvhdAtom(len));
+        this.metadata.setFormat("creationTime", mvhd.creationTime), this.metadata.setFormat("modificationTime", mvhd.modificationTime);
+      },
+      chap: async (len) => {
+        let td = this.getTrackDescription(), trackIds = [];
+        for (; len >= UINT32_BE.len; )
+          trackIds.push(await this.tokenizer.readNumber(UINT32_BE)), len -= UINT32_BE.len;
+        td.chapterList = trackIds;
+      },
+      /**
+       * Parse mdat atom.
+       * Will scan for chapters
+       */
+      mdat: async (len) => {
+        if (this.options.includeChapters) {
+          let trackWithChapters = [...this.tracks.values()].filter((track) => track.chapterList);
+          if (trackWithChapters.length === 1) {
+            let chapterTrackIds = trackWithChapters[0].chapterList, chapterTracks = [...this.tracks.values()].filter((track) => chapterTrackIds.indexOf(track.header.trackId) !== -1);
+            if (chapterTracks.length === 1)
+              return this.parseChapterTrack(chapterTracks[0], trackWithChapters[0], len);
+          }
+        }
+        await this.tokenizer.ignore(len);
+      },
+      ftyp: async (len) => {
+        let types = [];
+        for (; len > 0; ) {
+          let ftype = await this.tokenizer.readToken(ftyp);
+          len -= ftyp.len;
+          let value = ftype.type.replace(/\W/g, "");
+          value.length > 0 && types.push(value);
+        }
+        debug3(`ftyp: ${types.join("/")}`);
+        let x = types.filter(distinct).join("/");
+        this.metadata.setFormat("container", x);
+      },
+      /**
+       * Parse sample description atom
+       */
+      stsd: async (len) => {
+        let stsd = await this.tokenizer.readToken(new StsdAtom(len)), trackDescription = this.getTrackDescription();
+        trackDescription.soundSampleDescription = stsd.table.map((dfEntry) => this.parseSoundSampleDescription(dfEntry));
+      },
+      /**
+       * Parse sample-sizes atom ('stsz')
+       */
+      stsz: async (len) => {
+        let stsz = await this.tokenizer.readToken(new StszAtom(len)), td = this.getTrackDescription();
+        td.sampleSize = stsz.sampleSize, td.sampleSizeTable = stsz.entries;
+      },
+      date: async (len) => {
+        let date = await this.tokenizer.readToken(new StringType(len, "utf-8"));
+        await this.addTag("date", date);
+      }
+    };
+  }
+  static read_BE_Integer(array, signed) {
+    let integerType = (signed ? "INT" : "UINT") + array.length * 8 + (array.length > 1 ? "_BE" : ""), token = lib_exports[integerType];
+    if (!token)
+      throw new Mp4ContentError(`Token for integer type not found: "${integerType}"`);
+    return Number(token.get(array, 0));
+  }
+  async parse() {
+    this.hasVideoTrack = !1, this.hasAudioTrack = !0, this.tracks.clear();
+    let remainingFileSize = this.tokenizer.fileInfo.size || 0;
+    for (; !this.tokenizer.fileInfo.size || remainingFileSize > 0; ) {
+      try {
+        if ((await this.tokenizer.peekToken(Header)).name === "\0\0\0\0") {
+          let errMsg = `Error at offset=${this.tokenizer.position}: box.id=0`;
+          debug3(errMsg), this.addWarning(errMsg);
+          break;
+        }
+      } catch (error) {
+        if (error instanceof Error) {
+          let errMsg = `Error at offset=${this.tokenizer.position}: ${error.message}`;
+          debug3(errMsg), this.addWarning(errMsg);
+        } else
+          throw error;
+        break;
+      }
+      let rootAtom = await Atom.readAtom(this.tokenizer, (atom, remaining) => this.handleAtom(atom, remaining), null, remainingFileSize);
+      remainingFileSize -= rootAtom.header.length === BigInt(0) ? remainingFileSize : Number(rootAtom.header.length);
+    }
+    let formatList = [];
+    this.tracks.forEach((track) => {
+      let trackFormats = [];
+      track.soundSampleDescription.forEach((ssd) => {
+        let streamInfo = {}, encoderInfo = encoderDict[ssd.dataFormat];
+        if (encoderInfo ? (trackFormats.push(encoderInfo.format), streamInfo.codecName = encoderInfo.format) : streamInfo.codecName = `<${ssd.dataFormat}>`, ssd.description) {
+          let { description } = ssd;
+          description.sampleRate > 0 && (streamInfo.type = TrackType.audio, streamInfo.audio = {
+            samplingFrequency: description.sampleRate,
+            bitDepth: description.sampleSize,
+            channels: description.numAudioChannels
+          });
+        }
+        this.metadata.addStreamInfo(streamInfo);
+      }), trackFormats.length >= 1 && formatList.push(trackFormats.join("/"));
+    }), formatList.length > 0 && this.metadata.setFormat("codec", formatList.filter(distinct).join("+"));
+    let audioTracks = [...this.tracks.values()].filter((track) => track.soundSampleDescription.length >= 1 && track.soundSampleDescription[0].description && track.soundSampleDescription[0].description.numAudioChannels > 0);
+    for (let audioTrack of audioTracks) {
+      if (audioTrack.media.header && audioTrack.media.header.timeScale > 0)
+        if (audioTrack.sampleRate = audioTrack.media.header.timeScale, audioTrack.media.header.duration > 0 && (debug3("Using duration defined on audio track"), audioTrack.samples = audioTrack.media.header.duration, audioTrack.duration = audioTrack.samples / audioTrack.sampleRate), audioTrack.fragments.length > 0) {
+          debug3("Calculate duration defined in track fragments");
+          let totalTimeUnits = 0;
+          audioTrack.sizeInBytes = 0;
+          for (let fragment of audioTrack.fragments)
+            for (let sample of fragment.trackRun.samples) {
+              let dur = sample.sampleDuration ?? fragment.header.defaultSampleDuration ?? 0, size = sample.sampleSize ?? fragment.header.defaultSampleSize ?? 0;
+              if (dur === 0)
+                throw new Error("Missing sampleDuration and no defaultSampleDuration in track fragment header");
+              if (size === 0)
+                throw new Error("Missing sampleSize and no defaultSampleSize in track fragment header");
+              totalTimeUnits += dur, audioTrack.sizeInBytes += size;
+            }
+          audioTrack.samples || (audioTrack.samples = totalTimeUnits), audioTrack.duration || (audioTrack.duration = totalTimeUnits / audioTrack.sampleRate);
+        } else audioTrack.sampleSizeTable.length > 0 && (audioTrack.sizeInBytes = audioTrack.sampleSizeTable.reduce((sum, n) => sum + n, 0));
+      let ssd = audioTrack.soundSampleDescription[0];
+      if (ssd.description && audioTrack.media.header && (this.metadata.setFormat("sampleRate", ssd.description.sampleRate), this.metadata.setFormat("bitsPerSample", ssd.description.sampleSize), this.metadata.setFormat("numberOfChannels", ssd.description.numAudioChannels), audioTrack.media.header.timeScale === 0 && audioTrack.timeToSampleTable.length > 0)) {
+        let totalSampleSize = audioTrack.timeToSampleTable.map((ttstEntry) => ttstEntry.count * ttstEntry.duration).reduce((total, sampleSize) => total + sampleSize);
+        audioTrack.duration = totalSampleSize / ssd.description.sampleRate;
+      }
+      let encoderInfo = encoderDict[ssd.dataFormat];
+      encoderInfo && this.metadata.setFormat("lossless", !encoderInfo.lossy);
+    }
+    if (audioTracks.length >= 1) {
+      let firstAudioTrack = audioTracks[0];
+      firstAudioTrack.duration && (this.metadata.setFormat("duration", firstAudioTrack.duration), firstAudioTrack.sizeInBytes && this.metadata.setFormat("bitrate", 8 * firstAudioTrack.sizeInBytes / firstAudioTrack.duration));
+    }
+    this.metadata.setFormat("hasAudio", this.hasAudioTrack), this.metadata.setFormat("hasVideo", this.hasVideoTrack);
+  }
+  async handleAtom(atom, remaining) {
+    if (atom.parent)
+      switch (atom.parent.header.name) {
+        case "ilst":
+        case "<id>":
+          return this.parseMetadataItemData(atom);
+        case "moov":
+          switch (atom.header.name) {
+            case "trak":
+              return this.parseTrackBox(atom);
+            case "udta":
+              return this.parseTrackBox(atom);
+          }
+          break;
+        case "moof":
+          if (atom.header.name === "traf")
+            return this.parseTrackFragmentBox(atom);
+      }
+    if (this.atomParsers[atom.header.name])
+      return this.atomParsers[atom.header.name](remaining);
+    debug3(`No parser for atom path=${atom.atomPath}, payload-len=${remaining}, ignoring atom`), await this.tokenizer.ignore(remaining);
+  }
+  getTrackDescription() {
+    let tracks = [...this.tracks.values()];
+    return tracks[tracks.length - 1];
+  }
+  async addTag(id, value) {
+    await this.metadata.addTag(tagFormat, id, value);
+  }
+  addWarning(message) {
+    debug3(`Warning: ${message}`), this.metadata.addWarning(message);
+  }
+  /**
+   * Parse data of Meta-item-list-atom (item of 'ilst' atom)
+   * @param metaAtom
+   * Ref: https://developer.apple.com/library/content/documentation/QuickTime/QTFF/Metadata/Metadata.html#//apple_ref/doc/uid/TP40000939-CH1-SW8
+   */
+  parseMetadataItemData(metaAtom) {
+    let tagKey = metaAtom.header.name;
+    return metaAtom.readAtoms(this.tokenizer, async (child, remaining) => {
+      let payLoadLength = child.getPayloadLength(remaining);
+      switch (child.header.name) {
+        case "data":
+          return this.parseValueAtom(tagKey, child);
+        case "name":
+        // name atom (optional)
+        case "mean":
+        case "rate": {
+          let name = await this.tokenizer.readToken(new NameAtom(payLoadLength));
+          tagKey += `:${name.name}`;
+          break;
+        }
+        default: {
+          let uint8Array = await this.tokenizer.readToken(new Uint8ArrayType(payLoadLength));
+          this.addWarning(`Unsupported meta-item: ${tagKey}[${child.header.name}] => value=${uint8ArrayToHex(uint8Array)} ascii=${textDecode(uint8Array, "ascii")}`);
+        }
+      }
+    }, metaAtom.getPayloadLength(0));
+  }
+  async parseValueAtom(tagKey, metaAtom) {
+    let dataAtom = await this.tokenizer.readToken(new DataAtom(Number(metaAtom.header.length) - Header.len));
+    if (dataAtom.type.set !== 0)
+      throw new Mp4ContentError(`Unsupported type-set != 0: ${dataAtom.type.set}`);
+    switch (dataAtom.type.type) {
+      case 0:
+        switch (tagKey) {
+          case "trkn":
+          case "disk": {
+            let num = UINT8.get(dataAtom.value, 3), of = UINT8.get(dataAtom.value, 5);
+            await this.addTag(tagKey, `${num}/${of}`);
+            break;
+          }
+          case "gnre": {
+            let genreInt = UINT8.get(dataAtom.value, 1), genreStr = Genres[genreInt - 1];
+            await this.addTag(tagKey, genreStr);
+            break;
+          }
+          case "rate": {
+            let rate = textDecode(dataAtom.value, "ascii");
+            await this.addTag(tagKey, rate);
+            break;
+          }
+          default:
+            debug3(`unknown proprietary value type for: ${metaAtom.atomPath}`);
+        }
+        break;
+      case 1:
+      // UTF-8: Without any count or NULL terminator
+      case 18:
+        await this.addTag(tagKey, textDecode(dataAtom.value));
+        break;
+      case 13:
+        if (this.options.skipCovers)
+          break;
+        await this.addTag(tagKey, {
+          format: "image/jpeg",
+          data: Uint8Array.from(dataAtom.value)
+        });
+        break;
+      case 14:
+        if (this.options.skipCovers)
+          break;
+        await this.addTag(tagKey, {
+          format: "image/png",
+          data: Uint8Array.from(dataAtom.value)
+        });
+        break;
+      case 21:
+        await this.addTag(tagKey, _MP4Parser.read_BE_Integer(dataAtom.value, !0));
+        break;
+      case 22:
+        await this.addTag(tagKey, _MP4Parser.read_BE_Integer(dataAtom.value, !1));
+        break;
+      case 65:
+        await this.addTag(tagKey, UINT8.get(dataAtom.value, 0));
+        break;
+      case 66:
+        await this.addTag(tagKey, UINT16_BE.get(dataAtom.value, 0));
+        break;
+      case 67:
+        await this.addTag(tagKey, UINT32_BE.get(dataAtom.value, 0));
+        break;
+      default:
+        this.addWarning(`atom key=${tagKey}, has unknown well-known-type (data-type): ${dataAtom.type.type}`);
+    }
+  }
+  async parseTrackBox(trakBox) {
+    let track = {
+      media: {},
+      fragments: []
+    };
+    await trakBox.readAtoms(this.tokenizer, async (child, remaining) => {
+      let payLoadLength = child.getPayloadLength(remaining);
+      switch (child.header.name) {
+        case "chap": {
+          let chap = await this.tokenizer.readToken(new ChapterTrackReferenceBox(remaining));
+          track.chapterList = chap;
+          break;
+        }
+        case "tkhd":
+          track.header = await this.tokenizer.readToken(new TrackHeaderAtom(payLoadLength));
+          break;
+        case "hdlr":
+          track.handler = await this.tokenizer.readToken(new HandlerBox(payLoadLength)), track.isAudio = () => track.handler.handlerType === "audi" || track.handler.handlerType === "soun", track.isVideo = () => track.handler.handlerType === "vide", track.isAudio() ? this.hasAudioTrack = !0 : track.isVideo() && (this.hasVideoTrack = !0);
+          break;
+        case "mdhd": {
+          let mdhd_data = await this.tokenizer.readToken(new MdhdAtom(payLoadLength));
+          track.media.header = mdhd_data;
+          break;
+        }
+        case "stco": {
+          let stco = await this.tokenizer.readToken(new StcoAtom(payLoadLength));
+          track.chunkOffsetTable = stco.entries;
+          break;
+        }
+        case "stsc": {
+          let stsc = await this.tokenizer.readToken(new StscAtom(payLoadLength));
+          track.sampleToChunkTable = stsc.entries;
+          break;
+        }
+        case "stsd": {
+          let stsd = await this.tokenizer.readToken(new StsdAtom(payLoadLength));
+          track.soundSampleDescription = stsd.table.map((dfEntry) => this.parseSoundSampleDescription(dfEntry));
+          break;
+        }
+        case "stts": {
+          let stts = await this.tokenizer.readToken(new SttsAtom(payLoadLength));
+          track.timeToSampleTable = stts.entries;
+          break;
+        }
+        case "stsz": {
+          let stsz = await this.tokenizer.readToken(new StszAtom(payLoadLength));
+          track.sampleSize = stsz.sampleSize, track.sampleSizeTable = stsz.entries;
+          break;
+        }
+        case "dinf":
+        case "vmhd":
+        case "smhd":
+          debug3(`Ignoring: ${child.header.name}`), await this.tokenizer.ignore(payLoadLength);
+          break;
+        default:
+          debug3(`Unexpected track box: ${child.header.name}`), await this.tokenizer.ignore(payLoadLength);
+      }
+    }, trakBox.getPayloadLength(0)), this.tracks.set(track.header.trackId, track);
+  }
+  parseTrackFragmentBox(trafBox) {
+    let tfhd;
+    return trafBox.readAtoms(this.tokenizer, async (child, remaining) => {
+      let payLoadLength = child.getPayloadLength(remaining);
+      switch (child.header.name) {
+        case "tfhd": {
+          let fragmentHeaderBox = new TrackFragmentHeaderBox(child.getPayloadLength(remaining));
+          tfhd = await this.tokenizer.readToken(fragmentHeaderBox);
+          break;
+        }
+        case "tfdt":
+          await this.tokenizer.ignore(payLoadLength);
+          break;
+        case "trun": {
+          let trackRunBox = new TrackRunBox(payLoadLength), trun = await this.tokenizer.readToken(trackRunBox);
+          tfhd && this.tracks.get(tfhd.trackId)?.fragments.push({ header: tfhd, trackRun: trun });
+          break;
+        }
+        default:
+          debug3(`Unexpected box: ${child.header.name}`), await this.tokenizer.ignore(payLoadLength);
+      }
+    }, trafBox.getPayloadLength(0));
+  }
+  /**
+   * @param sampleDescription
+   * Ref: https://developer.apple.com/library/archive/documentation/QuickTime/QTFF/QTFFChap3/qtff3.html#//apple_ref/doc/uid/TP40000939-CH205-128916
+   */
+  parseSoundSampleDescription(sampleDescription) {
+    let ssd = {
+      dataFormat: sampleDescription.dataFormat,
+      dataReferenceIndex: sampleDescription.dataReferenceIndex
+    }, offset = 0;
+    if (sampleDescription.description) {
+      let version = SoundSampleDescriptionVersion.get(sampleDescription.description, offset);
+      offset += SoundSampleDescriptionVersion.len, version.version === 0 || version.version === 1 ? ssd.description = SoundSampleDescriptionV0.get(sampleDescription.description, offset) : debug3(`Warning: sound-sample-description ${version} not implemented`);
+    }
+    return ssd;
+  }
+  async parseChapterTrack(chapterTrack, track, len) {
+    if (!chapterTrack.sampleSize && chapterTrack.chunkOffsetTable.length !== chapterTrack.sampleSizeTable.length)
+      throw new Error("Expected equal chunk-offset-table & sample-size-table length.");
+    let chapters = [];
+    for (let i = 0; i < chapterTrack.chunkOffsetTable.length && len > 0; ++i) {
+      let start = chapterTrack.timeToSampleTable.slice(0, i).reduce((acc, cur) => acc + cur.duration, 0), nextChunkLen = chapterTrack.chunkOffsetTable[i] - this.tokenizer.position, sampleSize = chapterTrack.sampleSize > 0 ? chapterTrack.sampleSize : chapterTrack.sampleSizeTable[i];
+      if (len -= nextChunkLen + sampleSize, len < 0)
+        throw new Mp4ContentError("Chapter chunk exceeding token length");
+      await this.tokenizer.ignore(nextChunkLen);
+      let title = await this.tokenizer.readToken(new ChapterText(sampleSize));
+      debug3(`Chapter ${i + 1}: ${title}`);
+      let chapter = {
+        title,
+        timeScale: chapterTrack.media.header ? chapterTrack.media.header.timeScale : 0,
+        start,
+        sampleOffset: this.findSampleOffset(track, this.tokenizer.position)
+      };
+      debug3(`Chapter title=${chapter.title}, offset=${chapter.sampleOffset}/${track.header.duration}`), chapters.push(chapter);
+    }
+    this.metadata.setFormat("chapters", chapters), await this.tokenizer.ignore(len);
+  }
+  findSampleOffset(track, chapterOffset) {
+    let chunkIndex = 0;
+    for (; chunkIndex < track.chunkOffsetTable.length && track.chunkOffsetTable[chunkIndex] < chapterOffset; )
+      ++chunkIndex;
+    return this.getChunkDuration(chunkIndex + 1, track);
+  }
+  getChunkDuration(chunkId, track) {
+    let ttsi = 0, ttsc = track.timeToSampleTable[ttsi].count, ttsd = track.timeToSampleTable[ttsi].duration, curChunkId = 1, samplesPerChunk = this.getSamplesPerChunk(curChunkId, track.sampleToChunkTable), totalDuration = 0;
+    for (; curChunkId < chunkId; ) {
+      let nrOfSamples = Math.min(ttsc, samplesPerChunk);
+      totalDuration += nrOfSamples * ttsd, ttsc -= nrOfSamples, samplesPerChunk -= nrOfSamples, samplesPerChunk === 0 ? (++curChunkId, samplesPerChunk = this.getSamplesPerChunk(curChunkId, track.sampleToChunkTable)) : (++ttsi, ttsc = track.timeToSampleTable[ttsi].count, ttsd = track.timeToSampleTable[ttsi].duration);
+    }
+    return totalDuration;
+  }
+  getSamplesPerChunk(chunkId, stcTable) {
+    for (let i = 0; i < stcTable.length - 1; ++i)
+      if (chunkId >= stcTable[i].firstChunk && chunkId < stcTable[i + 1].firstChunk)
+        return stcTable[i].samplesPerChunk;
+    return stcTable[stcTable.length - 1].samplesPerChunk;
+  }
+};
+export {
+  MP4Parser
+};