@blockcast/mmt-container 0.1.0-main.0399efef1f07

package/dist/iso-bmff-timing.js

@@ -0,0 +1,618 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var __privateWrapper = (obj, member, setter, getter) => ({
+  set _(value) {
+    __privateSet(obj, member, value, setter);
+  },
+  get _() {
+    return __privateGet(obj, member, getter);
+  }
+});
+
+// src/iso-bmff-timing.ts
+var U64_MAX = 0xffffffffffffffffn;
+var I64_MIN = -0x8000000000000000n;
+var I64_MAX = 0x7fffffffffffffffn;
+var MICROSECONDS_PER_SECOND = 1000000n;
+var TFHD_BASE_DATA_OFFSET_PRESENT = 1;
+var TFHD_SAMPLE_DESCRIPTION_INDEX_PRESENT = 2;
+var TFHD_DEFAULT_SAMPLE_DURATION_PRESENT = 8;
+var TFHD_DEFAULT_SAMPLE_SIZE_PRESENT = 16;
+var TFHD_DEFAULT_SAMPLE_FLAGS_PRESENT = 32;
+var TFHD_DURATION_IS_EMPTY = 65536;
+var TFHD_DEFAULT_BASE_IS_MOOF = 131072;
+var TFHD_KNOWN_FLAGS = TFHD_BASE_DATA_OFFSET_PRESENT | TFHD_SAMPLE_DESCRIPTION_INDEX_PRESENT | TFHD_DEFAULT_SAMPLE_DURATION_PRESENT | TFHD_DEFAULT_SAMPLE_SIZE_PRESENT | TFHD_DEFAULT_SAMPLE_FLAGS_PRESENT | TFHD_DURATION_IS_EMPTY | TFHD_DEFAULT_BASE_IS_MOOF;
+var TRUN_DATA_OFFSET_PRESENT = 1;
+var TRUN_FIRST_SAMPLE_FLAGS_PRESENT = 4;
+var TRUN_SAMPLE_DURATION_PRESENT = 256;
+var TRUN_SAMPLE_SIZE_PRESENT = 512;
+var TRUN_SAMPLE_FLAGS_PRESENT = 1024;
+var TRUN_SAMPLE_CTS_OFFSET_PRESENT = 2048;
+var TRUN_KNOWN_FLAGS = TRUN_DATA_OFFSET_PRESENT | TRUN_FIRST_SAMPLE_FLAGS_PRESENT | TRUN_SAMPLE_DURATION_PRESENT | TRUN_SAMPLE_SIZE_PRESENT | TRUN_SAMPLE_FLAGS_PRESENT | TRUN_SAMPLE_CTS_OFFSET_PRESENT;
+function view(data) {
+  return new DataView(data.buffer, data.byteOffset, data.byteLength);
+}
+function boxType(data, offset) {
+  return String.fromCharCode(
+    data[offset],
+    data[offset + 1],
+    data[offset + 2],
+    data[offset + 3]
+  );
+}
+function readU64(data, offset) {
+  if (offset < 0 || offset + 8 > data.length) return null;
+  const dataView = view(data);
+  return BigInt(dataView.getUint32(offset, false)) << 32n | BigInt(dataView.getUint32(offset + 4, false));
+}
+function parseBox(data, start, limit) {
+  if (start < 0 || limit > data.length || start + 8 > limit) return null;
+  const dataView = view(data);
+  const shortSize = dataView.getUint32(start, false);
+  let headerSize = 8;
+  let size;
+  if (shortSize === 0) {
+    size = limit - start;
+  } else if (shortSize === 1) {
+    if (start + 16 > limit) return null;
+    const extendedSize = readU64(data, start + 8);
+    if (extendedSize === null || extendedSize > BigInt(Number.MAX_SAFE_INTEGER)) return null;
+    headerSize = 16;
+    size = Number(extendedSize);
+  } else {
+    size = shortSize;
+  }
+  if (size < headerSize || start + size > limit) return null;
+  return {
+    type: boxType(data, start + 4),
+    start,
+    bodyStart: start + headerSize,
+    end: start + size
+  };
+}
+function parseBoxes(data, start, end) {
+  if (start < 0 || end < start || end > data.length) return null;
+  const boxes = [];
+  let offset = start;
+  while (offset < end) {
+    const box = parseBox(data, offset, end);
+    if (!box || box.end <= offset) return null;
+    boxes.push(box);
+    offset = box.end;
+  }
+  return offset === end ? boxes : null;
+}
+function children(data, parent) {
+  return parseBoxes(data, parent.bodyStart, parent.end);
+}
+function exactlyOne(boxes, type) {
+  const matches = boxes.filter((box) => box.type === type);
+  return matches.length === 1 ? matches[0] : null;
+}
+function parseFullBox(data, box) {
+  if (box.bodyStart + 4 > box.end) return null;
+  const versionAndFlags = view(data).getUint32(box.bodyStart, false);
+  return {
+    version: versionAndFlags >>> 24,
+    flags: versionAndFlags & 16777215,
+    bodyStart: box.bodyStart + 4
+  };
+}
+function parseTkhdTrackId(data, box) {
+  const full = parseFullBox(data, box);
+  if (!full || full.flags & ~15) return null;
+  const bodyLength = box.end - full.bodyStart;
+  const trackIdOffset = full.version === 0 ? full.bodyStart + 8 : full.version === 1 ? full.bodyStart + 16 : -1;
+  const expectedBodyLength = full.version === 0 ? 80 : full.version === 1 ? 92 : -1;
+  if (trackIdOffset < 0 || bodyLength !== expectedBodyLength) return null;
+  return view(data).getUint32(trackIdOffset, false);
+}
+function parseMdhdTimescale(data, box) {
+  const full = parseFullBox(data, box);
+  if (!full || full.flags !== 0) return null;
+  const bodyLength = box.end - full.bodyStart;
+  const timescaleOffset = full.version === 0 ? full.bodyStart + 8 : full.version === 1 ? full.bodyStart + 16 : -1;
+  const expectedBodyLength = full.version === 0 ? 20 : full.version === 1 ? 32 : -1;
+  if (timescaleOffset < 0 || bodyLength !== expectedBodyLength) return null;
+  return view(data).getUint32(timescaleOffset, false);
+}
+function parseHandlerType(data, box) {
+  const full = parseFullBox(data, box);
+  if (!full || full.version !== 0 || full.flags !== 0 || full.bodyStart + 20 > box.end) {
+    return null;
+  }
+  return boxType(data, full.bodyStart + 4);
+}
+function editListHasEntries(data, box) {
+  const full = parseFullBox(data, box);
+  if (!full || full.flags !== 0 || full.version !== 0 && full.version !== 1) return null;
+  if (full.bodyStart + 4 > box.end) return null;
+  const entryCount = view(data).getUint32(full.bodyStart, false);
+  const entrySize = full.version === 0 ? 12 : 20;
+  const expectedEnd = full.bodyStart + 4 + entryCount * entrySize;
+  if (!Number.isSafeInteger(expectedEnd) || expectedEnd !== box.end) return null;
+  return entryCount !== 0;
+}
+function parseTrack(data, trak) {
+  const trakChildren = children(data, trak);
+  if (!trakChildren) return null;
+  const tkhd = exactlyOne(trakChildren, "tkhd");
+  const mdia = exactlyOne(trakChildren, "mdia");
+  if (!tkhd || !mdia) return null;
+  const trackId = parseTkhdTrackId(data, tkhd);
+  if (trackId === null || trackId === 0) return null;
+  const mdiaChildren = children(data, mdia);
+  if (!mdiaChildren) return null;
+  const mdhd = exactlyOne(mdiaChildren, "mdhd");
+  const hdlr = exactlyOne(mdiaChildren, "hdlr");
+  if (!mdhd || !hdlr) return null;
+  const timescale = parseMdhdTimescale(data, mdhd);
+  const handlerType = parseHandlerType(data, hdlr);
+  if (timescale === null || timescale === 0 || handlerType === null) return null;
+  const edtsBoxes = trakChildren.filter((box) => box.type === "edts");
+  if (edtsBoxes.length > 1) return null;
+  let hasEdits = false;
+  if (edtsBoxes.length === 1) {
+    const edtsChildren = children(data, edtsBoxes[0]);
+    if (!edtsChildren) return null;
+    const editLists = edtsChildren.filter((box) => box.type === "elst");
+    if (editLists.length > 1) return null;
+    if (editLists.length === 1) {
+      const result = editListHasEntries(data, editLists[0]);
+      if (result === null) return null;
+      hasEdits = result;
+    }
+  }
+  return { trackId, handlerType, timescale, hasEdits };
+}
+function parseTrex(data, box) {
+  const full = parseFullBox(data, box);
+  if (!full || full.version !== 0 || full.flags !== 0 || box.end - full.bodyStart !== 20) {
+    return null;
+  }
+  const dataView = view(data);
+  const trackId = dataView.getUint32(full.bodyStart, false);
+  const defaultSampleDuration = dataView.getUint32(full.bodyStart + 8, false);
+  const defaultSampleSize = dataView.getUint32(full.bodyStart + 12, false);
+  return {
+    trackId,
+    timescale: 0,
+    ...defaultSampleDuration === 0 ? {} : { defaultSampleDuration },
+    ...defaultSampleSize === 0 ? {} : { defaultSampleSize }
+  };
+}
+function parseIsoBmffInitializationTiming(data) {
+  const topLevel = parseBoxes(data, 0, data.length);
+  if (!topLevel) return null;
+  const ftyp = exactlyOne(topLevel, "ftyp");
+  const moov = exactlyOne(topLevel, "moov");
+  if (!ftyp || !moov || ftyp.start > moov.start) return null;
+  if (topLevel.some((box) => box.type === "moof" || box.type === "mdat")) return null;
+  const moovChildren = children(data, moov);
+  if (!moovChildren) return null;
+  const parsedTracks = [];
+  for (const trak of moovChildren.filter((box) => box.type === "trak")) {
+    const parsed = parseTrack(data, trak);
+    if (!parsed) return null;
+    parsedTracks.push(parsed);
+  }
+  const mediaTracks = parsedTracks.filter(
+    (track) => track.handlerType === "vide" || track.handlerType === "soun"
+  );
+  if (mediaTracks.length !== 1) return null;
+  const mediaTrack = mediaTracks[0];
+  if (mediaTrack.hasEdits) return null;
+  const mvex = exactlyOne(moovChildren, "mvex");
+  if (!mvex) return null;
+  const mvexChildren = children(data, mvex);
+  if (!mvexChildren) return null;
+  const trexEntries = [];
+  for (const trexBox of mvexChildren.filter((box) => box.type === "trex")) {
+    const trex2 = parseTrex(data, trexBox);
+    if (!trex2) return null;
+    trexEntries.push(trex2);
+  }
+  const matchingTrex = trexEntries.filter((trex2) => trex2.trackId === mediaTrack.trackId);
+  if (matchingTrex.length !== 1) return null;
+  const trex = matchingTrex[0];
+  return {
+    trackId: mediaTrack.trackId,
+    timescale: mediaTrack.timescale,
+    ...trex.defaultSampleDuration === void 0 ? {} : { defaultSampleDuration: trex.defaultSampleDuration },
+    ...trex.defaultSampleSize === void 0 ? {} : { defaultSampleSize: trex.defaultSampleSize }
+  };
+}
+function parseMfhdSequence(data, box) {
+  const full = parseFullBox(data, box);
+  if (!full || full.version !== 0 || full.flags !== 0 || box.end - full.bodyStart !== 4) {
+    return null;
+  }
+  return view(data).getUint32(full.bodyStart, false);
+}
+function parseTfhd(data, box) {
+  const full = parseFullBox(data, box);
+  if (!full || full.version !== 0 || (full.flags & ~TFHD_KNOWN_FLAGS) !== 0) return null;
+  if ((full.flags & TFHD_BASE_DATA_OFFSET_PRESENT) !== 0 || (full.flags & TFHD_DEFAULT_BASE_IS_MOOF) === 0 || (full.flags & TFHD_DURATION_IS_EMPTY) !== 0) {
+    return null;
+  }
+  const dataView = view(data);
+  let offset = full.bodyStart;
+  if (offset + 4 > box.end) return null;
+  const trackId = dataView.getUint32(offset, false);
+  offset += 4;
+  if ((full.flags & TFHD_SAMPLE_DESCRIPTION_INDEX_PRESENT) !== 0) {
+    if (offset + 4 > box.end) return null;
+    offset += 4;
+  }
+  let defaultSampleDuration;
+  if ((full.flags & TFHD_DEFAULT_SAMPLE_DURATION_PRESENT) !== 0) {
+    if (offset + 4 > box.end) return null;
+    defaultSampleDuration = dataView.getUint32(offset, false);
+    offset += 4;
+  }
+  let defaultSampleSize;
+  if ((full.flags & TFHD_DEFAULT_SAMPLE_SIZE_PRESENT) !== 0) {
+    if (offset + 4 > box.end) return null;
+    defaultSampleSize = dataView.getUint32(offset, false);
+    offset += 4;
+  }
+  if ((full.flags & TFHD_DEFAULT_SAMPLE_FLAGS_PRESENT) !== 0) {
+    if (offset + 4 > box.end) return null;
+    offset += 4;
+  }
+  if (offset !== box.end) return null;
+  return {
+    trackId,
+    ...defaultSampleDuration === void 0 ? {} : { defaultSampleDuration },
+    ...defaultSampleSize === void 0 ? {} : { defaultSampleSize }
+  };
+}
+function parseTfdt(data, box) {
+  const full = parseFullBox(data, box);
+  if (!full || full.flags !== 0) return null;
+  if (full.version === 0 && box.end - full.bodyStart === 4) {
+    return BigInt(view(data).getUint32(full.bodyStart, false));
+  }
+  if (full.version === 1 && box.end - full.bodyStart === 8) {
+    return readU64(data, full.bodyStart);
+  }
+  return null;
+}
+function parseMdatLayout(data, offset) {
+  if (offset < 0 || offset + 8 > data.length || boxType(data, offset + 4) !== "mdat") return null;
+  const dataView = view(data);
+  const shortSize = dataView.getUint32(offset, false);
+  let headerSize = 8;
+  let declaredSize;
+  if (shortSize === 0) {
+    return null;
+  } else if (shortSize === 1) {
+    const extended = readU64(data, offset + 8);
+    if (extended === null) return null;
+    headerSize = 16;
+    declaredSize = extended;
+  } else {
+    declaredSize = BigInt(shortSize);
+  }
+  if (declaredSize < BigInt(headerSize) || declaredSize < BigInt(data.length - offset)) {
+    return null;
+  }
+  const declaredEnd = BigInt(offset) + declaredSize;
+  if (declaredEnd > U64_MAX) return null;
+  return { dataStart: BigInt(offset + headerSize), declaredEnd };
+}
+function resolvedDefault(entryValue, tfhdValue, trexValue) {
+  const value = entryValue ?? tfhdValue ?? trexValue;
+  return value === void 0 || value === 0 ? null : value;
+}
+function parseTrunSamples(data, box, moofStart, baseDecodeTime, tfhd, track, mdat, maxSamples) {
+  const full = parseFullBox(data, box);
+  if (!full || full.version !== 0 && full.version !== 1 || (full.flags & ~TRUN_KNOWN_FLAGS) !== 0 || (full.flags & TRUN_DATA_OFFSET_PRESENT) === 0 || (full.flags & TRUN_FIRST_SAMPLE_FLAGS_PRESENT) !== 0 && (full.flags & TRUN_SAMPLE_FLAGS_PRESENT) !== 0) {
+    return null;
+  }
+  const dataView = view(data);
+  let offset = full.bodyStart;
+  if (offset + 8 > box.end) return null;
+  const sampleCount = dataView.getUint32(offset, false);
+  offset += 4;
+  if (sampleCount === 0 || sampleCount > maxSamples) return null;
+  const relativeDataOffset = dataView.getInt32(offset, false);
+  offset += 4;
+  if (relativeDataOffset < 0) return null;
+  const dataOffset = BigInt(relativeDataOffset);
+  const absoluteDataOffset = BigInt(moofStart) + dataOffset;
+  if (absoluteDataOffset > BigInt(data.length) || absoluteDataOffset < mdat.dataStart) return null;
+  if ((full.flags & TRUN_FIRST_SAMPLE_FLAGS_PRESENT) !== 0) {
+    if (offset + 4 > box.end) return null;
+    offset += 4;
+  }
+  let decodeTime = baseDecodeTime;
+  let bytePosition = dataOffset;
+  const samples = [];
+  for (let index = 0; index < sampleCount; index++) {
+    let entryDuration;
+    if ((full.flags & TRUN_SAMPLE_DURATION_PRESENT) !== 0) {
+      if (offset + 4 > box.end) return null;
+      entryDuration = dataView.getUint32(offset, false);
+      offset += 4;
+    }
+    let entrySize;
+    if ((full.flags & TRUN_SAMPLE_SIZE_PRESENT) !== 0) {
+      if (offset + 4 > box.end) return null;
+      entrySize = dataView.getUint32(offset, false);
+      offset += 4;
+    }
+    if ((full.flags & TRUN_SAMPLE_FLAGS_PRESENT) !== 0) {
+      if (offset + 4 > box.end) return null;
+      offset += 4;
+    }
+    let compositionOffset = 0;
+    if ((full.flags & TRUN_SAMPLE_CTS_OFFSET_PRESENT) !== 0) {
+      if (offset + 4 > box.end) return null;
+      compositionOffset = full.version === 1 ? dataView.getInt32(offset, false) : dataView.getUint32(offset, false);
+      offset += 4;
+    }
+    if (offset > box.end) return null;
+    const duration = resolvedDefault(
+      entryDuration,
+      tfhd.defaultSampleDuration,
+      track.defaultSampleDuration
+    );
+    const size = resolvedDefault(entrySize, tfhd.defaultSampleSize, track.defaultSampleSize);
+    if (duration === null || size === null) return null;
+    const sampleEnd = bytePosition + BigInt(size);
+    const absoluteSampleEnd = BigInt(moofStart) + sampleEnd;
+    if (absoluteSampleEnd > mdat.declaredEnd || absoluteSampleEnd > U64_MAX) return null;
+    const presentationTime = decodeTime + BigInt(compositionOffset);
+    if (presentationTime < I64_MIN || presentationTime > I64_MAX) return null;
+    samples.push({
+      decodeTime,
+      presentationTime,
+      duration,
+      timescale: track.timescale,
+      size,
+      bytePosition
+    });
+    decodeTime += BigInt(duration);
+    if (decodeTime > U64_MAX) return null;
+    bytePosition = sampleEnd;
+  }
+  return offset === box.end ? samples : null;
+}
+function parseIsoBmffMovieFragmentTiming(data, track, maxSamples) {
+  if (!Number.isInteger(maxSamples) || maxSamples <= 0) return null;
+  const first = parseBox(data, 0, data.length);
+  if (!first) return null;
+  const moof = first.type === "styp" ? parseBox(data, first.end, data.length) : first;
+  if (!moof || moof.type !== "moof" || moof.end >= data.length) return null;
+  const moofChildren = children(data, moof);
+  if (!moofChildren) return null;
+  const mfhd = exactlyOne(moofChildren, "mfhd");
+  const traf = exactlyOne(moofChildren, "traf");
+  if (!mfhd || !traf) return null;
+  const movieFragmentSequenceNumber = parseMfhdSequence(data, mfhd);
+  if (movieFragmentSequenceNumber === null || movieFragmentSequenceNumber === 0) return null;
+  const trafChildren = children(data, traf);
+  if (!trafChildren) return null;
+  const tfhdBox = exactlyOne(trafChildren, "tfhd");
+  const tfdtBox = exactlyOne(trafChildren, "tfdt");
+  const trunBox = exactlyOne(trafChildren, "trun");
+  if (!tfhdBox || !tfdtBox || !trunBox) return null;
+  const tfhd = parseTfhd(data, tfhdBox);
+  const baseDecodeTime = parseTfdt(data, tfdtBox);
+  if (!tfhd || tfhd.trackId !== track.trackId || baseDecodeTime === null) return null;
+  const mdat = parseMdatLayout(data, moof.end);
+  if (!mdat) return null;
+  const samples = parseTrunSamples(
+    data,
+    trunBox,
+    moof.start,
+    baseDecodeTime,
+    tfhd,
+    track,
+    mdat,
+    maxSamples
+  );
+  if (!samples) return null;
+  return { movieFragmentSequenceNumber, samples };
+}
+function sameTrack(a, b) {
+  return a.trackId === b.trackId && a.timescale === b.timescale && a.defaultSampleDuration === b.defaultSampleDuration && a.defaultSampleSize === b.defaultSampleSize;
+}
+function sameSample(a, b) {
+  return a.decodeTime === b.decodeTime && a.presentationTime === b.presentationTime && a.duration === b.duration && a.timescale === b.timescale && a.size === b.size && a.bytePosition === b.bytePosition;
+}
+var _track, _fragments, _pendingSamples, _evictedSamples, _lastMovieFragmentRejection, _IsoBmffTimingResolver_instances, evictOldestFragment_fn, clearSlot_fn;
+var IsoBmffTimingResolver = class {
+  constructor(maxPendingSamples) {
+    this.maxPendingSamples = maxPendingSamples;
+    __privateAdd(this, _IsoBmffTimingResolver_instances);
+    __privateAdd(this, _track, null);
+    __privateAdd(this, _fragments, /* @__PURE__ */ new Map());
+    __privateAdd(this, _pendingSamples, 0);
+    __privateAdd(this, _evictedSamples, 0);
+    __privateAdd(this, _lastMovieFragmentRejection, null);
+    if (!Number.isInteger(maxPendingSamples) || maxPendingSamples <= 0) {
+      throw new Error("[IsoBmffTimingResolver] maxPendingSamples must be a positive integer");
+    }
+  }
+  get pendingSampleCount() {
+    return __privateGet(this, _pendingSamples);
+  }
+  /**
+   * Slots reclaimed by window displacement rather than by delivery or
+   * abandonment. Deliberately separate from the combiner's own release count:
+   * "nobody ever saw this sample" and "the combiner gave up on it" are
+   * different failures with different owners, and one number cannot say which.
+   */
+  get evictedSampleCount() {
+    return __privateGet(this, _evictedSamples);
+  }
+  /** Typed reason for the most recent rejected movie fragment. */
+  get lastMovieFragmentRejection() {
+    return __privateGet(this, _lastMovieFragmentRejection);
+  }
+  addInitialization(data) {
+    const timing = parseIsoBmffInitializationTiming(data);
+    if (!timing) return false;
+    if (__privateGet(this, _track)) return sameTrack(__privateGet(this, _track), timing);
+    __privateSet(this, _track, timing);
+    return true;
+  }
+  addMovieFragment(mpuSequenceNumber, data, additionalSampleLimit = this.maxPendingSamples) {
+    __privateSet(this, _lastMovieFragmentRejection, null);
+    if (!Number.isInteger(additionalSampleLimit) || additionalSampleLimit < 0) {
+      __privateSet(this, _lastMovieFragmentRejection, "invalid");
+      return false;
+    }
+    if (!__privateGet(this, _track) || !isU32(mpuSequenceNumber)) {
+      __privateSet(this, _lastMovieFragmentRejection, "invalid");
+      return false;
+    }
+    const parsed = parseIsoBmffMovieFragmentTiming(
+      data,
+      __privateGet(this, _track),
+      this.maxPendingSamples
+    );
+    if (!parsed) {
+      __privateSet(this, _lastMovieFragmentRejection, "invalid");
+      return false;
+    }
+    const key = fragmentKey(mpuSequenceNumber, parsed.movieFragmentSequenceNumber);
+    const existing = __privateGet(this, _fragments).get(key);
+    if (existing) {
+      return existing.length === parsed.samples.length && existing.every(
+        (sample, index) => sample !== null && sameSample(sample, parsed.samples[index])
+      );
+    }
+    let freed = 0;
+    while (__privateGet(this, _fragments).size > 0 && (__privateGet(this, _pendingSamples) + parsed.samples.length > this.maxPendingSamples || parsed.samples.length - freed > additionalSampleLimit)) {
+      freed += __privateMethod(this, _IsoBmffTimingResolver_instances, evictOldestFragment_fn).call(this);
+    }
+    if (parsed.samples.length - freed > additionalSampleLimit) {
+      __privateSet(this, _lastMovieFragmentRejection, "budget");
+      return false;
+    }
+    if (__privateGet(this, _pendingSamples) + parsed.samples.length > this.maxPendingSamples) {
+      __privateSet(this, _lastMovieFragmentRejection, "budget");
+      return false;
+    }
+    __privateGet(this, _fragments).set(key, [...parsed.samples]);
+    __privateSet(this, _pendingSamples, __privateGet(this, _pendingSamples) + parsed.samples.length);
+    return true;
+  }
+  sampleTiming(mpuSequenceNumber, movieFragmentSequenceNumber, sampleNumber) {
+    if (!isU32(mpuSequenceNumber) || !isU32(movieFragmentSequenceNumber) || movieFragmentSequenceNumber === 0 || !isU32(sampleNumber) || sampleNumber === 0) {
+      return null;
+    }
+    const samples = __privateGet(this, _fragments).get(
+      fragmentKey(mpuSequenceNumber, movieFragmentSequenceNumber)
+    );
+    return samples?.[sampleNumber - 1] ?? null;
+  }
+  consumeSample(mpuSequenceNumber, movieFragmentSequenceNumber, sampleNumber, expected) {
+    const samples = __privateGet(this, _fragments).get(
+      fragmentKey(mpuSequenceNumber, movieFragmentSequenceNumber)
+    );
+    const sample = samples?.[sampleNumber - 1];
+    if (!sample || !sameSample(sample, expected)) return false;
+    return __privateMethod(this, _IsoBmffTimingResolver_instances, clearSlot_fn).call(this, mpuSequenceNumber, movieFragmentSequenceNumber, sampleNumber);
+  }
+  /**
+   * Free the budget slot of a sample that will never be delivered.
+   *
+   * `consumeSample` is the delivery path and is the only decrement on a
+   * healthy stream. A sample whose data units never complete is never
+   * delivered; window displacement in `addMovieFragment` eventually reclaims
+   * it, but only after it has aged out of the whole window. This path frees
+   * the slot as soon as the combiner knows the sample is gone, so the budget
+   * tracks what is actually in flight rather than what has merely aged.
+   *
+   * The caller is whoever abandoned the sample, so the release is driven by
+   * the abandonment itself rather than by a timer, an LRU, or an age bound --
+   * the slot is freed exactly when its sample provably cannot arrive, which
+   * is a protocol event the combiner already detects and counts.
+   *
+   * Deliberately takes no `expected` timing: the caller is discarding, not
+   * matching, and requiring it would make the release fail exactly when the
+   * timing entry is the thing being reclaimed. Returns false when the slot
+   * was already freed, so a double release cannot drive the count negative.
+   */
+  releaseSample(mpuSequenceNumber, movieFragmentSequenceNumber, sampleNumber) {
+    return __privateMethod(this, _IsoBmffTimingResolver_instances, clearSlot_fn).call(this, mpuSequenceNumber, movieFragmentSequenceNumber, sampleNumber);
+  }
+  reset() {
+    __privateSet(this, _track, null);
+    __privateGet(this, _fragments).clear();
+    __privateSet(this, _pendingSamples, 0);
+  }
+};
+_track = new WeakMap();
+_fragments = new WeakMap();
+_pendingSamples = new WeakMap();
+_evictedSamples = new WeakMap();
+_lastMovieFragmentRejection = new WeakMap();
+_IsoBmffTimingResolver_instances = new WeakSet();
+/**
+ * Drop the oldest pending fragment whole and return the slots it held.
+ *
+ * Oldest is insertion order, which for a moof stream is arrival order, so
+ * this is the least-recently-declared timing -- the entries least likely to
+ * still have data units in flight.
+ */
+evictOldestFragment_fn = function() {
+  const oldest = __privateGet(this, _fragments).keys().next().value;
+  if (oldest === void 0) return 0;
+  const samples = __privateGet(this, _fragments).get(oldest);
+  let live = 0;
+  for (const sample of samples) if (sample !== null) live++;
+  __privateGet(this, _fragments).delete(oldest);
+  __privateSet(this, _pendingSamples, __privateGet(this, _pendingSamples) - live);
+  __privateSet(this, _evictedSamples, __privateGet(this, _evictedSamples) + live);
+  return live;
+};
+/** Null one slot, decrement the budget, and drop the fragment when empty. */
+clearSlot_fn = function(mpuSequenceNumber, movieFragmentSequenceNumber, sampleNumber) {
+  if (!isU32(mpuSequenceNumber) || !isU32(movieFragmentSequenceNumber) || movieFragmentSequenceNumber === 0 || !isU32(sampleNumber) || sampleNumber === 0) {
+    return false;
+  }
+  const key = fragmentKey(mpuSequenceNumber, movieFragmentSequenceNumber);
+  const samples = __privateGet(this, _fragments).get(key);
+  const index = sampleNumber - 1;
+  if (!samples || !samples[index]) return false;
+  samples[index] = null;
+  __privateWrapper(this, _pendingSamples)._--;
+  if (samples.every((value) => value === null)) __privateGet(this, _fragments).delete(key);
+  return true;
+};
+function fragmentKey(mpuSequenceNumber, movieFragmentSequenceNumber) {
+  return `${mpuSequenceNumber}:${movieFragmentSequenceNumber}`;
+}
+function isU32(value) {
+  return Number.isInteger(value) && value >= 0 && value <= 4294967295;
+}
+function mediaTicksToMicroseconds(ticks, timescale) {
+  if (!Number.isInteger(timescale) || timescale <= 0) return null;
+  const numerator = ticks * MICROSECONDS_PER_SECOND;
+  const scale = BigInt(timescale);
+  const whole = numerator / scale;
+  const remainder = numerator % scale;
+  if (whole < BigInt(Number.MIN_SAFE_INTEGER) || whole > BigInt(Number.MAX_SAFE_INTEGER)) {
+    return null;
+  }
+  const result = Number(whole) + Number(remainder) / timescale;
+  return Number.isFinite(result) ? result : null;
+}
+export {
+  IsoBmffTimingResolver,
+  mediaTicksToMicroseconds,
+  parseIsoBmffInitializationTiming,
+  parseIsoBmffMovieFragmentTiming
+};
+//# sourceMappingURL=iso-bmff-timing.js.map