@archipelagolab/lobi 1.0.0 → 1.0.5

package/dist/MP4Parser-64RGJLUM.js

@@ -0,0 +1,1145 @@
+import "./chunk-5APBBTGW.js";
+import {
+  TrackType
+} from "./chunk-KSEANSJE.js";
+import {
+  Genres
+} from "./chunk-3TOEIHG5.js";
+import {
+  FourCcToken
+} from "./chunk-427SAQME.js";
+import "./chunk-E75BJJZ2.js";
+import "./chunk-LSVKDUNM.js";
+import {
+  getBit,
+  uint8ArrayToHex
+} from "./chunk-EHELTAAD.js";
+import {
+  BasicParser,
+  INT16_BE,
+  INT24_BE,
+  INT32_BE,
+  INT8,
+  StringType,
+  UINT16_BE,
+  UINT24_BE,
+  UINT32_BE,
+  UINT64_BE,
+  UINT8,
+  Uint8ArrayType,
+  lib_exports,
+  makeUnexpectedFileContentError,
+  require_src,
+  textDecode
+} from "./chunk-IU7EXXK7.js";
+import {
+  __toESM,
+  init_shims
+} from "./chunk-7FLQSTPG.js";
+
+// ../../node_modules/music-metadata/lib/mp4/MP4Parser.js
+init_shims();
+var import_debug3 = __toESM(require_src(), 1);
+
+// ../../node_modules/music-metadata/lib/mp4/Atom.js
+init_shims();
+var import_debug2 = __toESM(require_src(), 1);
+
+// ../../node_modules/music-metadata/lib/mp4/AtomToken.js
+init_shims();
+var import_debug = __toESM(require_src(), 1);
+var debug = (0, import_debug.default)("music-metadata:parser:MP4:atom");
+var Mp4ContentError = class extends makeUnexpectedFileContentError("MP4") {
+};
+var Header = {
+  len: 8,
+  get: (buf, off) => {
+    const 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));
+    return FourCcToken.put(buf, off + 4, hdr.name);
+  }
+};
+var ExtendedSize = UINT64_BE;
+var ftyp = {
+  len: 4,
+  get: (buf, off) => {
+    return {
+      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.`);
+    }
+    if (len > expLen) {
+      debug(`Warning: atom ${atomId} expected to be ${expLen}, but was actually ${len} bytes long.`);
+    }
+    this.len = len;
+  }
+};
+var SecondsSinceMacEpoch = {
+  len: 4,
+  get: (buf, off) => {
+    const secondsSinceUnixEpoch = UINT32_BE.get(buf, off) - 2082844800;
+    return new Date(secondsSinceUnixEpoch * 1e3);
+  }
+};
+var MdhdAtom = class extends FixedLengthAtom {
+  constructor(len) {
+    super(len, 24, "mdhd");
+  }
+  get(buf, off) {
+    return {
+      version: UINT8.get(buf, off + 0),
+      flags: UINT24_BE.get(buf, off + 1),
+      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)
+    };
+  }
+};
+var MvhdAtom = class extends FixedLengthAtom {
+  constructor(len) {
+    super(len, 100, "mvhd");
+  }
+  get(buf, off) {
+    return {
+      version: UINT8.get(buf, off),
+      flags: UINT24_BE.get(buf, off + 1),
+      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 reserver: 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)
+    };
+  }
+};
+var 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)
+    };
+  }
+};
+var 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)
+    };
+  }
+};
+var TrackHeaderAtom = class {
+  constructor(len) {
+    this.len = len;
+  }
+  get(buf, off) {
+    return {
+      version: UINT8.get(buf, off),
+      flags: UINT24_BE.get(buf, off + 1),
+      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),
+      layer: UINT16_BE.get(buf, off + 24),
+      alternateGroup: UINT16_BE.get(buf, off + 26),
+      volume: UINT16_BE.get(buf, off + 28)
+      // ToDo: fixed point
+      // ToDo: add remaining fields
+    };
+  }
+};
+var stsdHeader = {
+  len: 8,
+  get: (buf, off) => {
+    return {
+      version: UINT8.get(buf, off),
+      flags: UINT24_BE.get(buf, off + 1),
+      numberOfEntries: UINT32_BE.get(buf, off + 4)
+    };
+  }
+};
+var SampleDescriptionTable = class {
+  constructor(len) {
+    this.len = len;
+  }
+  get(buf, off) {
+    const 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
+    };
+  }
+};
+var StsdAtom = class {
+  constructor(len) {
+    this.len = len;
+  }
+  get(buf, off) {
+    const header = stsdHeader.get(buf, off);
+    off += stsdHeader.len;
+    const table = [];
+    for (let n = 0; n < header.numberOfEntries; ++n) {
+      const 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
+    };
+  }
+};
+var 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)
+    };
+  }
+};
+var 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
+    };
+  }
+};
+var SimpleTableAtom = class {
+  constructor(len, token) {
+    this.len = len;
+    this.token = token;
+  }
+  get(buf, off) {
+    const 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)
+    };
+  }
+};
+var TimeToSampleToken = {
+  len: 8,
+  get(buf, off) {
+    return {
+      count: INT32_BE.get(buf, off + 0),
+      duration: INT32_BE.get(buf, off + 4)
+    };
+  }
+};
+var SttsAtom = class extends SimpleTableAtom {
+  constructor(len) {
+    super(len, TimeToSampleToken);
+  }
+};
+var 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)
+    };
+  }
+};
+var StscAtom = class extends SimpleTableAtom {
+  constructor(len) {
+    super(len, SampleToChunkToken);
+  }
+};
+var StszAtom = class {
+  constructor(len) {
+    this.len = len;
+  }
+  get(buf, off) {
+    const 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)
+    };
+  }
+};
+var StcoAtom = class extends SimpleTableAtom {
+  constructor(len) {
+    super(len, INT32_BE);
+    this.len = len;
+  }
+};
+var ChapterText = class {
+  constructor(len) {
+    this.len = len;
+  }
+  get(buf, off) {
+    const titleLen = INT16_BE.get(buf, off + 0);
+    const str = new StringType(titleLen, "utf-8");
+    return str.get(buf, off + 2);
+  }
+};
+function readTokenTable(buf, token, off, remainingLen, numberOfEntries) {
+  debug(`remainingLen=${remainingLen}, numberOfEntries=${numberOfEntries} * token-len=${token.len}`);
+  if (remainingLen === 0)
+    return [];
+  if (remainingLen !== numberOfEntries * token.len)
+    throw new Mp4ContentError("mismatch number-of-entries with remaining atom-length");
+  const 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) {
+    const flagOffset = off + 1;
+    const 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)
+    };
+    let dynOffset = 8;
+    if (header.flags.baseDataOffsetPresent) {
+      header.baseDataOffset = UINT64_BE.get(buf, dynOffset);
+      dynOffset += 8;
+    }
+    if (header.flags.sampleDescriptionIndexPresent) {
+      header.sampleDescriptionIndex = UINT32_BE.get(buf, dynOffset);
+      dynOffset += 4;
+    }
+    if (header.flags.defaultSampleDurationPresent) {
+      header.defaultSampleDuration = UINT32_BE.get(buf, dynOffset);
+      dynOffset += 4;
+    }
+    if (header.flags.defaultSampleSizePresent) {
+      header.defaultSampleSize = UINT32_BE.get(buf, dynOffset);
+      dynOffset += 4;
+    }
+    if (header.flags.defaultSampleFlagsPresent) {
+      header.defaultSampleFlags = UINT32_BE.get(buf, dynOffset);
+    }
+    return header;
+  }
+};
+var TrackRunBox = class {
+  constructor(len) {
+    this.len = len;
+  }
+  get(buf, off) {
+    const flagOffset = off + 1;
+    const 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: []
+    };
+    let dynOffset = off + 8;
+    if (trun.flags.dataOffsetPresent) {
+      trun.dataOffset = UINT32_BE.get(buf, dynOffset);
+      dynOffset += 4;
+    }
+    if (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;
+      }
+      const sample = {};
+      if (trun.flags.sampleDurationPresent) {
+        sample.sampleDuration = UINT32_BE.get(buf, dynOffset);
+        dynOffset += 4;
+      }
+      if (trun.flags.sampleSizePresent) {
+        sample.sampleSize = UINT32_BE.get(buf, dynOffset);
+        dynOffset += 4;
+      }
+      if (trun.flags.sampleFlagsPresent) {
+        sample.sampleFlags = UINT32_BE.get(buf, dynOffset);
+        dynOffset += 4;
+      }
+      if (trun.flags.sampleCompositionTimeOffsetsPresent) {
+        sample.sampleCompositionTimeOffset = UINT32_BE.get(buf, dynOffset);
+        dynOffset += 4;
+      }
+      trun.samples.push(sample);
+    }
+    return trun;
+  }
+};
+var HandlerBox = class {
+  constructor(len) {
+    this.len = len;
+  }
+  get(buf, off) {
+    const _flagOffset = off + 1;
+    const 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)
+    };
+  }
+};
+var ChapterTrackReferenceBox = class {
+  constructor(len) {
+    this.len = len;
+  }
+  get(buf, off) {
+    let dynOffset = 0;
+    const trackIds = [];
+    while (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");
+var Atom = class _Atom {
+  static async readAtom(tokenizer, dataHandler, parent, remaining) {
+    const offset = tokenizer.position;
+    debug2(`Reading next token on offset=${offset}...`);
+    const header = await tokenizer.readToken(Header);
+    const extended = header.length === 1n;
+    if (extended) {
+      header.length = await tokenizer.readToken(ExtendedSize);
+    }
+    const atomBean = new _Atom(header, extended, parent);
+    const payloadLength = atomBean.getPayloadLength(remaining);
+    debug2(`parse atom name=${atomBean.atomPath}, extended=${atomBean.extended}, offset=${offset}, len=${atomBean.header.length}`);
+    await atomBean.readData(tokenizer, dataHandler, payloadLength);
+    return 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) {
+    while (size > 0) {
+      const 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": {
+        const peekHeader = await tokenizer.peekToken(Header);
+        const paddingLength = peekHeader.name === "hdlr" ? 0 : 4;
+        await tokenizer.ignore(paddingLength);
+        return 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");
+var tagFormat = "iTunes";
+var encoderDict = {
+  raw: {
+    lossy: false,
+    format: "raw"
+  },
+  MAC3: {
+    lossy: true,
+    format: "MACE 3:1"
+  },
+  MAC6: {
+    lossy: true,
+    format: "MACE 6:1"
+  },
+  ima4: {
+    lossy: true,
+    format: "IMA 4:1"
+  },
+  ulaw: {
+    lossy: true,
+    format: "uLaw 2:1"
+  },
+  alaw: {
+    lossy: true,
+    format: "uLaw 2:1"
+  },
+  Qclp: {
+    lossy: true,
+    format: "QUALCOMM PureVoice"
+  },
+  ".mp3": {
+    lossy: true,
+    format: "MPEG-1 layer 3"
+  },
+  alac: {
+    lossy: false,
+    format: "ALAC"
+  },
+  "ac-3": {
+    lossy: true,
+    format: "AC-3"
+  },
+  mp4a: {
+    lossy: true,
+    format: "MPEG-4/AAC"
+  },
+  mp4s: {
+    lossy: true,
+    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: true,
+    format: "CEA-608"
+  },
+  c708: {
+    lossy: true,
+    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 = false;
+    this.hasAudioTrack = true;
+    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) => {
+        const mvhd = await this.tokenizer.readToken(new MvhdAtom(len));
+        this.metadata.setFormat("creationTime", mvhd.creationTime);
+        this.metadata.setFormat("modificationTime", mvhd.modificationTime);
+      },
+      chap: async (len) => {
+        const td = this.getTrackDescription();
+        const trackIds = [];
+        while (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) {
+          const trackWithChapters = [...this.tracks.values()].filter((track) => track.chapterList);
+          if (trackWithChapters.length === 1) {
+            const chapterTrackIds = trackWithChapters[0].chapterList;
+            const 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) => {
+        const types = [];
+        while (len > 0) {
+          const ftype = await this.tokenizer.readToken(ftyp);
+          len -= ftyp.len;
+          const value = ftype.type.replace(/\W/g, "");
+          if (value.length > 0) {
+            types.push(value);
+          }
+        }
+        debug3(`ftyp: ${types.join("/")}`);
+        const x = types.filter(distinct).join("/");
+        this.metadata.setFormat("container", x);
+      },
+      /**
+       * Parse sample description atom
+       */
+      stsd: async (len) => {
+        const stsd = await this.tokenizer.readToken(new StsdAtom(len));
+        const trackDescription = this.getTrackDescription();
+        trackDescription.soundSampleDescription = stsd.table.map((dfEntry) => this.parseSoundSampleDescription(dfEntry));
+      },
+      /**
+       * Parse sample-sizes atom ('stsz')
+       */
+      stsz: async (len) => {
+        const stsz = await this.tokenizer.readToken(new StszAtom(len));
+        const td = this.getTrackDescription();
+        td.sampleSize = stsz.sampleSize;
+        td.sampleSizeTable = stsz.entries;
+      },
+      date: async (len) => {
+        const date = await this.tokenizer.readToken(new StringType(len, "utf-8"));
+        await this.addTag("date", date);
+      }
+    };
+  }
+  static read_BE_Integer(array, signed) {
+    const integerType = (signed ? "INT" : "UINT") + array.length * 8 + (array.length > 1 ? "_BE" : "");
+    const 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 = false;
+    this.hasAudioTrack = true;
+    this.tracks.clear();
+    let remainingFileSize = this.tokenizer.fileInfo.size || 0;
+    while (!this.tokenizer.fileInfo.size || remainingFileSize > 0) {
+      try {
+        const token = await this.tokenizer.peekToken(Header);
+        if (token.name === "\0\0\0\0") {
+          const errMsg = `Error at offset=${this.tokenizer.position}: box.id=0`;
+          debug3(errMsg);
+          this.addWarning(errMsg);
+          break;
+        }
+      } catch (error) {
+        if (error instanceof Error) {
+          const errMsg = `Error at offset=${this.tokenizer.position}: ${error.message}`;
+          debug3(errMsg);
+          this.addWarning(errMsg);
+        } else
+          throw error;
+        break;
+      }
+      const 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);
+    }
+    const formatList = [];
+    this.tracks.forEach((track) => {
+      const trackFormats = [];
+      track.soundSampleDescription.forEach((ssd) => {
+        const streamInfo = {};
+        const encoderInfo = encoderDict[ssd.dataFormat];
+        if (encoderInfo) {
+          trackFormats.push(encoderInfo.format);
+          streamInfo.codecName = encoderInfo.format;
+        } else {
+          streamInfo.codecName = `<${ssd.dataFormat}>`;
+        }
+        if (ssd.description) {
+          const { description } = ssd;
+          if (description.sampleRate > 0) {
+            streamInfo.type = TrackType.audio;
+            streamInfo.audio = {
+              samplingFrequency: description.sampleRate,
+              bitDepth: description.sampleSize,
+              channels: description.numAudioChannels
+            };
+          }
+        }
+        this.metadata.addStreamInfo(streamInfo);
+      });
+      if (trackFormats.length >= 1) {
+        formatList.push(trackFormats.join("/"));
+      }
+    });
+    if (formatList.length > 0) {
+      this.metadata.setFormat("codec", formatList.filter(distinct).join("+"));
+    }
+    const audioTracks = [...this.tracks.values()].filter((track) => {
+      return track.soundSampleDescription.length >= 1 && track.soundSampleDescription[0].description && track.soundSampleDescription[0].description.numAudioChannels > 0;
+    });
+    for (const audioTrack of audioTracks) {
+      if (audioTrack.media.header && audioTrack.media.header.timeScale > 0) {
+        audioTrack.sampleRate = audioTrack.media.header.timeScale;
+        if (audioTrack.media.header.duration > 0) {
+          debug3("Using duration defined on audio track");
+          audioTrack.samples = audioTrack.media.header.duration;
+          audioTrack.duration = audioTrack.samples / audioTrack.sampleRate;
+        }
+        if (audioTrack.fragments.length > 0) {
+          debug3("Calculate duration defined in track fragments");
+          let totalTimeUnits = 0;
+          audioTrack.sizeInBytes = 0;
+          for (const fragment of audioTrack.fragments) {
+            for (const sample of fragment.trackRun.samples) {
+              const dur = sample.sampleDuration ?? fragment.header.defaultSampleDuration ?? 0;
+              const 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;
+            }
+          }
+          if (!audioTrack.samples) {
+            audioTrack.samples = totalTimeUnits;
+          }
+          if (!audioTrack.duration) {
+            audioTrack.duration = totalTimeUnits / audioTrack.sampleRate;
+          }
+        } else if (audioTrack.sampleSizeTable.length > 0) {
+          audioTrack.sizeInBytes = audioTrack.sampleSizeTable.reduce((sum, n) => sum + n, 0);
+        }
+      }
+      const 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);
+        if (audioTrack.media.header.timeScale === 0 && audioTrack.timeToSampleTable.length > 0) {
+          const totalSampleSize = audioTrack.timeToSampleTable.map((ttstEntry) => ttstEntry.count * ttstEntry.duration).reduce((total, sampleSize) => total + sampleSize);
+          audioTrack.duration = totalSampleSize / ssd.description.sampleRate;
+        }
+      }
+      const encoderInfo = encoderDict[ssd.dataFormat];
+      if (encoderInfo) {
+        this.metadata.setFormat("lossless", !encoderInfo.lossy);
+      }
+    }
+    if (audioTracks.length >= 1) {
+      const firstAudioTrack = audioTracks[0];
+      if (firstAudioTrack.duration) {
+        this.metadata.setFormat("duration", firstAudioTrack.duration);
+        if (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":
+          switch (atom.header.name) {
+            case "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() {
+    const 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) => {
+      const payLoadLength = child.getPayloadLength(remaining);
+      switch (child.header.name) {
+        case "data":
+          return this.parseValueAtom(tagKey, child);
+        case "name":
+        // name atom (optional)
+        case "mean":
+        case "rate": {
+          const name = await this.tokenizer.readToken(new NameAtom(payLoadLength));
+          tagKey += `:${name.name}`;
+          break;
+        }
+        default: {
+          const 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) {
+    const 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": {
+            const num = UINT8.get(dataAtom.value, 3);
+            const of = UINT8.get(dataAtom.value, 5);
+            await this.addTag(tagKey, `${num}/${of}`);
+            break;
+          }
+          case "gnre": {
+            const genreInt = UINT8.get(dataAtom.value, 1);
+            const genreStr = Genres[genreInt - 1];
+            await this.addTag(tagKey, genreStr);
+            break;
+          }
+          case "rate": {
+            const 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, true));
+        break;
+      case 22:
+        await this.addTag(tagKey, _MP4Parser.read_BE_Integer(dataAtom.value, false));
+        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) {
+    const track = {
+      media: {},
+      fragments: []
+    };
+    await trakBox.readAtoms(this.tokenizer, async (child, remaining) => {
+      const payLoadLength = child.getPayloadLength(remaining);
+      switch (child.header.name) {
+        case "chap": {
+          const 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";
+          if (track.isAudio()) {
+            this.hasAudioTrack = true;
+          } else if (track.isVideo()) {
+            this.hasVideoTrack = true;
+          }
+          break;
+        case "mdhd": {
+          const mdhd_data = await this.tokenizer.readToken(new MdhdAtom(payLoadLength));
+          track.media.header = mdhd_data;
+          break;
+        }
+        case "stco": {
+          const stco = await this.tokenizer.readToken(new StcoAtom(payLoadLength));
+          track.chunkOffsetTable = stco.entries;
+          break;
+        }
+        case "stsc": {
+          const stsc = await this.tokenizer.readToken(new StscAtom(payLoadLength));
+          track.sampleToChunkTable = stsc.entries;
+          break;
+        }
+        case "stsd": {
+          const stsd = await this.tokenizer.readToken(new StsdAtom(payLoadLength));
+          track.soundSampleDescription = stsd.table.map((dfEntry) => this.parseSoundSampleDescription(dfEntry));
+          break;
+        }
+        case "stts": {
+          const stts = await this.tokenizer.readToken(new SttsAtom(payLoadLength));
+          track.timeToSampleTable = stts.entries;
+          break;
+        }
+        case "stsz": {
+          const 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) => {
+      const payLoadLength = child.getPayloadLength(remaining);
+      switch (child.header.name) {
+        case "tfhd": {
+          const fragmentHeaderBox = new TrackFragmentHeaderBox(child.getPayloadLength(remaining));
+          tfhd = await this.tokenizer.readToken(fragmentHeaderBox);
+          break;
+        }
+        case "tfdt":
+          await this.tokenizer.ignore(payLoadLength);
+          break;
+        case "trun": {
+          const trackRunBox = new TrackRunBox(payLoadLength);
+          const trun = await this.tokenizer.readToken(trackRunBox);
+          if (tfhd) {
+            const track = this.tracks.get(tfhd.trackId);
+            track?.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) {
+    const ssd = {
+      dataFormat: sampleDescription.dataFormat,
+      dataReferenceIndex: sampleDescription.dataReferenceIndex
+    };
+    let offset = 0;
+    if (sampleDescription.description) {
+      const version = SoundSampleDescriptionVersion.get(sampleDescription.description, offset);
+      offset += SoundSampleDescriptionVersion.len;
+      if (version.version === 0 || version.version === 1) {
+        ssd.description = SoundSampleDescriptionV0.get(sampleDescription.description, offset);
+      } else {
+        debug3(`Warning: sound-sample-description ${version} not implemented`);
+      }
+    }
+    return ssd;
+  }
+  async parseChapterTrack(chapterTrack, track, len) {
+    if (!chapterTrack.sampleSize) {
+      if (chapterTrack.chunkOffsetTable.length !== chapterTrack.sampleSizeTable.length)
+        throw new Error("Expected equal chunk-offset-table & sample-size-table length.");
+    }
+    const chapters = [];
+    for (let i = 0; i < chapterTrack.chunkOffsetTable.length && len > 0; ++i) {
+      const start = chapterTrack.timeToSampleTable.slice(0, i).reduce((acc, cur) => acc + cur.duration, 0);
+      const chunkOffset = chapterTrack.chunkOffsetTable[i];
+      const nextChunkLen = chunkOffset - this.tokenizer.position;
+      const sampleSize = chapterTrack.sampleSize > 0 ? chapterTrack.sampleSize : chapterTrack.sampleSizeTable[i];
+      len -= nextChunkLen + sampleSize;
+      if (len < 0)
+        throw new Mp4ContentError("Chapter chunk exceeding token length");
+      await this.tokenizer.ignore(nextChunkLen);
+      const title = await this.tokenizer.readToken(new ChapterText(sampleSize));
+      debug3(`Chapter ${i + 1}: ${title}`);
+      const 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;
+    while (chunkIndex < track.chunkOffsetTable.length && track.chunkOffsetTable[chunkIndex] < chapterOffset) {
+      ++chunkIndex;
+    }
+    return this.getChunkDuration(chunkIndex + 1, track);
+  }
+  getChunkDuration(chunkId, track) {
+    let ttsi = 0;
+    let ttsc = track.timeToSampleTable[ttsi].count;
+    let ttsd = track.timeToSampleTable[ttsi].duration;
+    let curChunkId = 1;
+    let samplesPerChunk = this.getSamplesPerChunk(curChunkId, track.sampleToChunkTable);
+    let totalDuration = 0;
+    while (curChunkId < chunkId) {
+      const nrOfSamples = Math.min(ttsc, samplesPerChunk);
+      totalDuration += nrOfSamples * ttsd;
+      ttsc -= nrOfSamples;
+      samplesPerChunk -= nrOfSamples;
+      if (samplesPerChunk === 0) {
+        ++curChunkId;
+        samplesPerChunk = this.getSamplesPerChunk(curChunkId, track.sampleToChunkTable);
+      } else {
+        ++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
+};
+//# sourceMappingURL=MP4Parser-64RGJLUM.js.map