https://kakspy.com/wp-includes/js/dist/script-modules/video-conversion/worker.min.js?ver=4d3627c45251ceb4f9a2

172// node_modules/mediabunny/dist/modules/src/misc.js
173function assert(x) {
174  if (!x) {
175    throw new Error("Assertion failed.");
176  }
177}
178var normalizeRotation = (rotation) => {
179  const mappedRotation = (rotation % 360 + 360) % 360;
180  if (mappedRotation === 0 || mappedRotation === 90 || mappedRotation === 180 || mappedRotation === 270) {
181    return mappedRotation;
182  } else {
183    throw new Error(\`Invalid rotation \${rotation}.\`);
184  }
185};
186var last = (arr) => {
187  return arr && arr[arr.length - 1];
188};
189var isU32 = (value) => {
190  return value >= 0 && value < 2 ** 32;
191};
192var readExpGolomb = (bitstream) => {
193  let leadingZeroBits = 0;
194  while (bitstream.readBits(1) === 0 && leadingZeroBits < 32) {
195    leadingZeroBits++;
196  }
197  if (leadingZeroBits >= 32) {
198    throw new Error("Invalid exponential-Golomb code.");
199  }
200  const result = (1 << leadingZeroBits) - 1 + bitstream.readBits(leadingZeroBits);
201  return result;
202};
203var readSignedExpGolomb = (bitstream) => {
204  const codeNum = readExpGolomb(bitstream);
205  return (codeNum & 1) === 0 ? -(codeNum >> 1) : codeNum + 1 >> 1;
206};
207var writeBits = (bytes2, start, end, value) => {
208  for (let i2 = start; i2 < end; i2++) {
209    const byteIndex = Math.floor(i2 / 8);
210    let byte = bytes2[byteIndex];
211    const bitIndex = 7 - (i2 & 7);
212    byte &= ~(1 << bitIndex);
213    byte |= (value & 1 << end - i2 - 1) >> end - i2 - 1 << bitIndex;
214    bytes2[byteIndex] = byte;
215  }
216};
217var toUint8Array = (source) => {
218  if (source.constructor === Uint8Array) {
219    return source;
220  } else if (ArrayBuffer.isView(source)) {
221    return new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
222  } else {
223    return new Uint8Array(source);
224  }
225};
226var toDataView = (source) => {
227  if (source.constructor === DataView) {
228    return source;
229  } else if (ArrayBuffer.isView(source)) {
230    return new DataView(source.buffer, source.byteOffset, source.byteLength);
231  } else {
232    return new DataView(source);
233  }
234};
235var textEncoder = /* @__PURE__ */ new TextEncoder();
236var COLOR_PRIMARIES_MAP = {
237  bt709: 1,
238  // ITU-R BT.709
239  bt470bg: 5,
240  // ITU-R BT.470BG
241  smpte170m: 6,
242  // ITU-R BT.601 525 - SMPTE 170M
243  bt2020: 9,
244  // ITU-R BT.202
245  smpte432: 12
246  // SMPTE EG 432-1
247};
248var TRANSFER_CHARACTERISTICS_MAP = {
249  "bt709": 1,
250  // ITU-R BT.709
251  "smpte170m": 6,
252  // SMPTE 170M
253  "linear": 8,
254  // Linear transfer characteristics
255  "iec61966-2-1": 13,
256  // IEC 61966-2-1
257  "pq": 16,
258  // Rec. ITU-R BT.2100-2 perceptual quantization (PQ) system
259  "hlg": 18
260  // Rec. ITU-R BT.2100-2 hybrid loggamma (HLG) system
261};
262var MATRIX_COEFFICIENTS_MAP = {
263  "rgb": 0,
264  // Identity
265  "bt709": 1,
266  // ITU-R BT.709
267  "bt470bg": 5,
268  // ITU-R BT.470BG
269  "smpte170m": 6,
270  // SMPTE 170M
271  "bt2020-ncl": 9
272  // ITU-R BT.2020-2 (non-constant luminance)
273};
274var colorSpaceIsComplete = (colorSpace) => {
275  return !!colorSpace && !!colorSpace.primaries && !!colorSpace.transfer && !!colorSpace.matrix && colorSpace.fullRange !== void 0;
276};
277var isAllowSharedBufferSource = (x) => {
278  return x instanceof ArrayBuffer || typeof SharedArrayBuffer !== "undefined" && x instanceof SharedArrayBuffer || ArrayBuffer.isView(x);
279};
280var AsyncMutex = class {
281  constructor() {
282    this.currentPromise = Promise.resolve();
283    this.pending = 0;
284  }
285  async acquire() {
286    let resolver;
287    const nextPromise = new Promise((resolve) => {
288      let resolved = false;
289      resolver = () => {
290        if (resolved) {
291          return;
292        }
293        resolve();
294        this.pending--;
295        resolved = true;
296      };
297    });
298    const currentPromiseAlias = this.currentPromise;
299    this.currentPromise = nextPromise;
300    this.pending++;
301    await currentPromiseAlias;
302    return resolver;
303  }
304};
305var binarySearchLessOrEqual = (arr, key, valueGetter) => {
306  let low = 0;
307  let high = arr.length - 1;
308  let ans = -1;
309  while (low <= high) {
310    const mid = low + (high - low + 1) / 2 | 0;
311    const midVal = valueGetter(arr[mid]);
312    if (midVal <= key) {
313      ans = mid;
314      low = mid + 1;
315    } else {
316      high = mid - 1;
317    }
318  }
319  return ans;
320};
321var promiseWithResolvers = () => {
322  let resolve;
323  let reject;
324  const promise = new Promise((res, rej) => {
325    resolve = res;
326    reject = rej;
327  });
328  return { promise, resolve, reject };
329};
330var assertNever = (x) => {
331  throw new Error(\`Unexpected value: \${x}\`);
332};
333var getUint24 = (view2, byteOffset, littleEndian) => {
334  const byte1 = view2.getUint8(byteOffset);
335  const byte2 = view2.getUint8(byteOffset + 1);
336  const byte3 = view2.getUint8(byteOffset + 2);
337  if (littleEndian) {
338    return byte1 | byte2 << 8 | byte3 << 16;
339  } else {
340    return byte1 << 16 | byte2 << 8 | byte3;
341  }
342};
343var setUint24 = (view2, byteOffset, value, littleEndian) => {
344  value = value >>> 0;
345  value = value & 16777215;
346  if (littleEndian) {
347    view2.setUint8(byteOffset, value & 255);
348    view2.setUint8(byteOffset + 1, value >>> 8 & 255);
349    view2.setUint8(byteOffset + 2, value >>> 16 & 255);
350  } else {
351    view2.setUint8(byteOffset, value >>> 16 & 255);
352    view2.setUint8(byteOffset + 1, value >>> 8 & 255);
353    view2.setUint8(byteOffset + 2, value & 255);
354  }
355};
356var UNDETERMINED_LANGUAGE = "und";
357var roundToMultiple = (value, multiple) => {
358  return Math.round(value / multiple) * multiple;
359};
360var roundToDivisor = (value, multiple) => {
361  return Math.round(value * multiple) / multiple;
362};
363var floorToDivisor = (value, multiple) => {
364  return Math.floor(value * multiple) / multiple;
365};
366var ISO_639_2_REGEX = /^[a-z]{3}$/;
367var isIso639Dash2LanguageCode = (x) => {
368  return ISO_639_2_REGEX.test(x);
369};
370var SECOND_TO_MICROSECOND_FACTOR = 1e6 * (1 + Number.EPSILON);
371var computeRationalApproximation = (x, maxDenominator) => {
372  const sign = x < 0 ? -1 : 1;
373  x = Math.abs(x);
374  let prevNumerator = 0, prevDenominator = 1;
375  let currNumerator = 1, currDenominator = 0;
376  let remainder = x;
377  while (true) {
378    const integer = Math.floor(remainder);
379    const nextNumerator = integer * currNumerator + prevNumerator;
380    const nextDenominator = integer * currDenominator + prevDenominator;
381    if (nextDenominator > maxDenominator) {
382      return {
383        num: sign * currNumerator,
384        den: currDenominator
385      };
386    }
387    prevNumerator = currNumerator;
388    prevDenominator = currDenominator;
389    currNumerator = nextNumerator;
390    currDenominator = nextDenominator;
391    remainder = 1 / (remainder - integer);
392    if (!isFinite(remainder)) {
393      break;
394    }
395  }
396  return {
397    num: sign * currNumerator,
398    den: currDenominator
399  };
400};
401var CallSerializer = class {
402  constructor() {
403    this.currentPromise = Promise.resolve();
404  }
405  call(fn) {
406    return this.currentPromise = this.currentPromise.then(fn);
407  }
408};
409var isFirefoxCache = null;
410var isFirefox = () => {
411  if (isFirefoxCache !== null) {
412    return isFirefoxCache;
413  }
414  return isFirefoxCache = typeof navigator !== "undefined" && navigator.userAgent?.includes("Firefox");
415};
416var isChromiumCache = null;
417var isChromium = () => {
418  if (isChromiumCache !== null) {
419    return isChromiumCache;
420  }
421  return isChromiumCache = !!(typeof navigator !== "undefined" && (navigator.vendor?.includes("Google Inc") || /Chrome/.test(navigator.userAgent)));
422};
423var chromiumVersionCache = null;
424var getChromiumVersion = () => {
425  if (chromiumVersionCache !== null) {
426    return chromiumVersionCache;
427  }
428  if (typeof navigator === "undefined") {
429    return null;
430  }
431  const match = /\\bChrome\\/(\\d+)/.exec(navigator.userAgent);
432  if (!match) {
433    return null;
434  }
435  return chromiumVersionCache = Number(match[1]);
436};
437var keyValueIterator = function* (object) {
438  for (const key in object) {
439    const value = object[key];
440    if (value === void 0) {
441      continue;
442    }
443    yield { key, value };
444  }
445};
446var imageMimeTypeToExtension = (mimeType) => {
447  switch (mimeType.toLowerCase()) {
448    case "image/jpeg":
449    case "image/jpg":
450      return ".jpg";
451    case "image/png":
452      return ".png";
453    case "image/gif":
454      return ".gif";
455    case "image/webp":
456      return ".webp";
457    case "image/bmp":
458      return ".bmp";
459    case "image/svg+xml":
460      return ".svg";
461    case "image/tiff":
462      return ".tiff";
463    case "image/avif":
464      return ".avif";
465    case "image/x-icon":
466    case "image/vnd.microsoft.icon":
467      return ".ico";
468    default:
469      return null;
470  }
471};
472var uint8ArraysAreEqual = (a2, b) => {
473  if (a2.length !== b.length) {
474    return false;
475  }
476  for (let i2 = 0; i2 < a2.length; i2++) {
477    if (a2[i2] !== b[i2]) {
478      return false;
479    }
480  }
481  return true;
482};
483var polyfillSymbolDispose = () => {
484  Symbol.dispose ??= /* @__PURE__ */ Symbol("Symbol.dispose");
485};
486var arrayArgmin = (array, getValue) => {
487  let minIndex = -1;
488  let minValue = Infinity;
489  for (let i2 = 0; i2 < array.length; i2++) {
490    const value = getValue(array[i2]);
491    if (value < minValue) {
492      minValue = value;
493      minIndex = i2;
494    }
495  }
496  return minIndex;
497};
498var simplifyRational = (rational) => {
499  assert(Number.isInteger(rational.num));
500  assert(Number.isInteger(rational.den));
501  assert(rational.den !== 0);
502  let a2 = Math.abs(rational.num);
503  let b = Math.abs(rational.den);
504  while (b !== 0) {
505    const t2 = a2 % b;
506    a2 = b;
507    b = t2;
508  }
509  const gcd = a2 || 1;
510  return {
511    num: rational.num / gcd,
512    den: rational.den / gcd
513  };
514};
515var validateRectangle = (rect, propertyPath) => {
516  if (typeof rect !== "object" || !rect) {
517    throw new TypeError(\`\${propertyPath} must be an object.\`);
518  }
519  if (!Number.isInteger(rect.left) || rect.left < 0) {
520    throw new TypeError(\`\${propertyPath}.left must be a non-negative integer.\`);
521  }
522  if (!Number.isInteger(rect.top) || rect.top < 0) {
523    throw new TypeError(\`\${propertyPath}.top must be a non-negative integer.\`);
524  }
525  if (!Number.isInteger(rect.width) || rect.width < 0) {
526    throw new TypeError(\`\${propertyPath}.width must be a non-negative integer.\`);
527  }
528  if (!Number.isInteger(rect.height) || rect.height < 0) {
529    throw new TypeError(\`\${propertyPath}.height must be a non-negative integer.\`);
530  }
531};
532var toArray = (x) => {
533  if (Array.isArray(x)) {
534    return x;
535  } else {
536    return [x];
537  }
538};
539var EventEmitter = class {
540  constructor() {
541    this._listeners = /* @__PURE__ */ new Map();
542  }
543  /** Registers a listener for the given event. Returns a function that, when called, removes the listener again. */
544  on(event, listener, options) {
545    if (!this._listeners.has(event)) {
546      this._listeners.set(event, /* @__PURE__ */ new Set());
547    }
548    const entry = { fn: listener, once: options?.once ?? false };
549    this._listeners.get(event).add(entry);
550    return () => {
551      this._listeners.get(event)?.delete(entry);
552    };
553  }
554  /** @internal */
555  _emit(...args) {
556    const [event, data] = args;
557    const listeners = this._listeners.get(event);
558    if (!listeners) {
559      return;
560    }
561    for (const entry of listeners) {
562      try {
563        entry.fn(data);
564      } catch (error) {
565        console.error(error);
566      }
567      if (entry.once) {
568        listeners.delete(entry);
569      }
570    }
571  }
572};
573var isRecordStringString = (value) => {
574  return value !== null && typeof value === "object" && Object.getPrototypeOf(value) === Object.prototype && Object.values(value).every((x) => typeof x === "string");
575};
576

577// node_modules/mediabunny/dist/modules/src/logging.js
578var LogLevel;
579(function(LogLevel2) {
580  LogLevel2[LogLevel2["Silent"] = 0] = "Silent";
581  LogLevel2[LogLevel2["Errors"] = 1] = "Errors";
582  LogLevel2[LogLevel2["Warnings"] = 2] = "Warnings";
583  LogLevel2[LogLevel2["Info"] = 3] = "Info";
584})(LogLevel || (LogLevel = {}));
585var Logging = class _Logging {
586  constructor() {
587  }
588  /** The current log level. Defaults to {@link LogLevel.Info}. */
589  static get level() {
590    return _Logging._level;
591  }
592  static set level(value) {
593    if (value !== LogLevel.Silent && value !== LogLevel.Errors && value !== LogLevel.Warnings && value !== LogLevel.Info) {
594      throw new TypeError("Invalid log level. Use one of the values of the LogLevel enum.");
595    }
596    _Logging._level = value;
597  }
598  /** @internal */
599  static get _emitter() {
600    return _Logging._emitterInstance ??= new EventEmitter();
601  }
602  /** Registers a listener for a log event. Returns a function that, when called, removes the listener again. */
603  static on(event, listener, options) {
604    return _Logging._emitter.on(event, listener, options);
605  }
606  /** @internal */
607  static _error(...args) {
608    _Logging._emitter._emit("error", args);
609    if (_Logging._level >= LogLevel.Errors) {
610      console.error(...args);
611    }
612  }
613  /** @internal */
614  static _warn(...args) {
615    _Logging._emitter._emit("warn", args);
616    if (_Logging._level >= LogLevel.Warnings) {
617      console.warn(...args);
618    }
619  }
620  /** @internal */
621  static _info(...args) {
622    _Logging._emitter._emit("info", args);
623    if (_Logging._level >= LogLevel.Info) {
624      console.info(...args);
625    }
626  }
627};
628Logging._level = LogLevel.Info;
629Logging._emitterInstance = null;
630

631// node_modules/mediabunny/dist/modules/src/metadata.js
632var RichImageData = class {
633  /** Creates a new {@link RichImageData}. */
634  constructor(data, mimeType) {
635    this.data = data;
636    this.mimeType = mimeType;
637    if (!(data instanceof Uint8Array)) {
638      throw new TypeError("data must be a Uint8Array.");
639    }
640    if (typeof mimeType !== "string") {
641      throw new TypeError("mimeType must be a string.");
642    }
643  }
644};
645var AttachedFile = class {
646  /** Creates a new {@link AttachedFile}. */
647  constructor(data, mimeType, name, description) {
648    this.data = data;
649    this.mimeType = mimeType;
650    this.name = name;
651    this.description = description;
652    if (!(data instanceof Uint8Array)) {
653      throw new TypeError("data must be a Uint8Array.");
654    }
655    if (mimeType !== void 0 && typeof mimeType !== "string") {
656      throw new TypeError("mimeType, when provided, must be a string.");
657    }
658    if (name !== void 0 && typeof name !== "string") {
659      throw new TypeError("name, when provided, must be a string.");
660    }
661    if (description !== void 0 && typeof description !== "string") {
662      throw new TypeError("description, when provided, must be a string.");
663    }
664  }
665};
666var validateMetadataTags = (tags) => {
667  if (!tags || typeof tags !== "object") {
668    throw new TypeError("tags must be an object.");
669  }
670  if (tags.title !== void 0 && typeof tags.title !== "string") {
671    throw new TypeError("tags.title, when provided, must be a string.");
672  }
673  if (tags.description !== void 0 && typeof tags.description !== "string") {
674    throw new TypeError("tags.description, when provided, must be a string.");
675  }
676  if (tags.artist !== void 0 && typeof tags.artist !== "string") {
677    throw new TypeError("tags.artist, when provided, must be a string.");
678  }
679  if (tags.album !== void 0 && typeof tags.album !== "string") {
680    throw new TypeError("tags.album, when provided, must be a string.");
681  }
682  if (tags.albumArtist !== void 0 && typeof tags.albumArtist !== "string") {
683    throw new TypeError("tags.albumArtist, when provided, must be a string.");
684  }
685  if (tags.trackNumber !== void 0 && (!Number.isInteger(tags.trackNumber) || tags.trackNumber <= 0)) {
686    throw new TypeError("tags.trackNumber, when provided, must be a positive integer.");
687  }
688  if (tags.tracksTotal !== void 0 && (!Number.isInteger(tags.tracksTotal) || tags.tracksTotal <= 0)) {
689    throw new TypeError("tags.tracksTotal, when provided, must be a positive integer.");
690  }
691  if (tags.discNumber !== void 0 && (!Number.isInteger(tags.discNumber) || tags.discNumber <= 0)) {
692    throw new TypeError("tags.discNumber, when provided, must be a positive integer.");
693  }
694  if (tags.discsTotal !== void 0 && (!Number.isInteger(tags.discsTotal) || tags.discsTotal <= 0)) {
695    throw new TypeError("tags.discsTotal, when provided, must be a positive integer.");
696  }
697  if (tags.genre !== void 0 && typeof tags.genre !== "string") {
698    throw new TypeError("tags.genre, when provided, must be a string.");
699  }
700  if (tags.date !== void 0 && (!(tags.date instanceof Date) || Number.isNaN(tags.date.getTime()))) {
701    throw new TypeError("tags.date, when provided, must be a valid Date.");
702  }
703  if (tags.lyrics !== void 0 && typeof tags.lyrics !== "string") {
704    throw new TypeError("tags.lyrics, when provided, must be a string.");
705  }
706  if (tags.images !== void 0) {
707    if (!Array.isArray(tags.images)) {
708      throw new TypeError("tags.images, when provided, must be an array.");
709    }
710    for (const image of tags.images) {
711      if (!image || typeof image !== "object") {
712        throw new TypeError("Each image in tags.images must be an object.");
713      }
714      if (!(image.data instanceof Uint8Array)) {
715        throw new TypeError("Each image.data must be a Uint8Array.");
716      }
717      if (typeof image.mimeType !== "string") {
718        throw new TypeError("Each image.mimeType must be a string.");
719      }
720      if (!["coverFront", "coverBack", "unknown"].includes(image.kind)) {
721        throw new TypeError("Each image.kind must be 'coverFront', 'coverBack', or 'unknown'.");
722      }
723    }
724  }
725  if (tags.comment !== void 0 && typeof tags.comment !== "string") {
726    throw new TypeError("tags.comment, when provided, must be a string.");
727  }
728  if (tags.raw !== void 0) {
729    if (!tags.raw || typeof tags.raw !== "object") {
730      throw new TypeError("tags.raw, when provided, must be an object.");
731    }
732    for (const value of Object.values(tags.raw)) {
733      if (value !== null && typeof value !== "string" && !(value instanceof Uint8Array) && !(value instanceof RichImageData) && !(value instanceof AttachedFile) && !isRecordStringString(value)) {
734        throw new TypeError("Each value in tags.raw must be a string, Uint8Array, RichImageData, AttachedFile, Record<string, string>, or null.");
735      }
736    }
737  }
738};
739var validateTrackDisposition = (disposition) => {
740  if (!disposition || typeof disposition !== "object") {
741    throw new TypeError("disposition must be an object.");
742  }
743  if (disposition.default !== void 0 && typeof disposition.default !== "boolean") {
744    throw new TypeError("disposition.default must be a boolean.");
745  }
746  if (disposition.primary !== void 0 && typeof disposition.primary !== "boolean") {
747    throw new TypeError("disposition.primary must be a boolean.");
748  }
749  if (disposition.forced !== void 0 && typeof disposition.forced !== "boolean") {
750    throw new TypeError("disposition.forced must be a boolean.");
751  }
752  if (disposition.original !== void 0 && typeof disposition.original !== "boolean") {
753    throw new TypeError("disposition.original must be a boolean.");
754  }
755  if (disposition.commentary !== void 0 && typeof disposition.commentary !== "boolean") {
756    throw new TypeError("disposition.commentary must be a boolean.");
757  }
758  if (disposition.hearingImpaired !== void 0 && typeof disposition.hearingImpaired !== "boolean") {
759    throw new TypeError("disposition.hearingImpaired must be a boolean.");
760  }
761  if (disposition.visuallyImpaired !== void 0 && typeof disposition.visuallyImpaired !== "boolean") {
762    throw new TypeError("disposition.visuallyImpaired must be a boolean.");
763  }
764};
765

766// node_modules/mediabunny/dist/modules/shared/bitstream.js
767var Bitstream = class _Bitstream {
768  constructor(bytes2) {
769    this.bytes = bytes2;
770    this.pos = 0;
771  }
772  seekToByte(byteOffset) {
773    this.pos = 8 * byteOffset;
774  }
775  readBit() {
776    const byteIndex = Math.floor(this.pos / 8);
777    const byte = this.bytes[byteIndex] ?? 0;
778    const bitIndex = 7 - (this.pos & 7);
779    const bit = (byte & 1 << bitIndex) >> bitIndex;
780    this.pos++;
781    return bit;
782  }
783  readBits(n2) {
784    if (n2 === 1) {
785      return this.readBit();
786    }
787    let result = 0;
788    for (let i2 = 0; i2 < n2; i2++) {
789      result <<= 1;
790      result |= this.readBit();
791    }
792    return result;
793  }
794  writeBits(n2, value) {
795    const end = this.pos + n2;
796    for (let i2 = this.pos; i2 < end; i2++) {
797      const byteIndex = Math.floor(i2 / 8);
798      let byte = this.bytes[byteIndex];
799      const bitIndex = 7 - (i2 & 7);
800      byte &= ~(1 << bitIndex);
801      byte |= (value & 1 << end - i2 - 1) >> end - i2 - 1 << bitIndex;
802      this.bytes[byteIndex] = byte;
803    }
804    this.pos = end;
805  }
806  readAlignedByte() {
807    if (this.pos % 8 !== 0) {
808      throw new Error("Bitstream is not byte-aligned.");
809    }
810    const byteIndex = this.pos / 8;
811    const byte = this.bytes[byteIndex] ?? 0;
812    this.pos += 8;
813    return byte;
814  }
815  skipBits(n2) {
816    this.pos += n2;
817  }
818  getBitsLeft() {
819    return this.bytes.length * 8 - this.pos;
820  }
821  clone() {
822    const clone = new _Bitstream(this.bytes);
823    clone.pos = this.pos;
824    return clone;
825  }
826};
827

828// node_modules/mediabunny/dist/modules/shared/aac-misc.js
829var aacFrequencyTable = [
830  96e3,
831  88200,
832  64e3,
833  48e3,
834  44100,
835  32e3,
836  24e3,
837  22050,
838  16e3,
839  12e3,
840  11025,
841  8e3,
842  7350
843];
844var aacChannelMap = [-1, 1, 2, 3, 4, 5, 6, 8];
845var buildAacAudioSpecificConfig = (config) => {
846  let frequencyIndex = aacFrequencyTable.indexOf(config.sampleRate);
847  let customSampleRate = null;
848  if (frequencyIndex === -1) {
849    frequencyIndex = 15;
850    customSampleRate = config.sampleRate;
851  }
852  const channelConfiguration = aacChannelMap.indexOf(config.numberOfChannels);
853  if (channelConfiguration === -1) {
854    throw new TypeError(\`Unsupported number of channels: \${config.numberOfChannels}\`);
855  }
856  let bitCount = 5 + 4 + 4;
857  if (config.objectType >= 32) {
858    bitCount += 6;
859  }
860  if (frequencyIndex === 15) {
861    bitCount += 24;
862  }
863  const byteCount = Math.ceil(bitCount / 8);
864  const bytes2 = new Uint8Array(byteCount);
865  const bitstream = new Bitstream(bytes2);
866  if (config.objectType < 32) {
867    bitstream.writeBits(5, config.objectType);
868  } else {
869    bitstream.writeBits(5, 31);
870    bitstream.writeBits(6, config.objectType - 32);
871  }
872  bitstream.writeBits(4, frequencyIndex);
873  if (frequencyIndex === 15) {
874    bitstream.writeBits(24, customSampleRate);
875  }
876  bitstream.writeBits(4, channelConfiguration);
877  return bytes2;
878};
879

880// node_modules/mediabunny/dist/modules/src/codec.js
881var VIDEO_CODECS = [
882  "avc",
883  "hevc",
884  "vp9",
885  "av1",
886  "vp8"
887];
888var PCM_AUDIO_CODECS = [
889  "pcm-s16",
890  // We don't prefix 'le' so we're compatible with the WebCodecs-registered PCM codec strings
891  "pcm-s16be",
892  "pcm-s24",
893  "pcm-s24be",
894  "pcm-s32",
895  "pcm-s32be",
896  "pcm-f32",
897  "pcm-f32be",
898  "pcm-f64",
899  "pcm-f64be",
900  "pcm-u8",
901  "pcm-s8",
902  "ulaw",
903  "alaw"
904];
905var NON_PCM_AUDIO_CODECS = [
906  "aac",
907  "opus",
908  "mp3",
909  "vorbis",
910  "flac",
911  "ac3",
912  "eac3"
913];
914var AUDIO_CODECS = [
915  ...NON_PCM_AUDIO_CODECS,
916  ...PCM_AUDIO_CODECS
917];
918var SUBTITLE_CODECS = [
919  "webvtt"
920];
921var AVC_LEVEL_TABLE = [
922  { maxMacroblocks: 99, maxBitrate: 64e3, maxDpbMbs: 396, level: 10 },
923  // Level 1
924  { maxMacroblocks: 396, maxBitrate: 192e3, maxDpbMbs: 900, level: 11 },
925  // Level 1.1
926  { maxMacroblocks: 396, maxBitrate: 384e3, maxDpbMbs: 2376, level: 12 },
927  // Level 1.2
928  { maxMacroblocks: 396, maxBitrate: 768e3, maxDpbMbs: 2376, level: 13 },
929  // Level 1.3
930  { maxMacroblocks: 396, maxBitrate: 2e6, maxDpbMbs: 2376, level: 20 },
931  // Level 2
932  { maxMacroblocks: 792, maxBitrate: 4e6, maxDpbMbs: 4752, level: 21 },
933  // Level 2.1
934  { maxMacroblocks: 1620, maxBitrate: 4e6, maxDpbMbs: 8100, level: 22 },
935  // Level 2.2
936  { maxMacroblocks: 1620, maxBitrate: 1e7, maxDpbMbs: 8100, level: 30 },
937  // Level 3
938  { maxMacroblocks: 3600, maxBitrate: 14e6, maxDpbMbs: 18e3, level: 31 },
939  // Level 3.1
940  { maxMacroblocks: 5120, maxBitrate: 2e7, maxDpbMbs: 20480, level: 32 },
941  // Level 3.2
942  { maxMacroblocks: 8192, maxBitrate: 2e7, maxDpbMbs: 32768, level: 40 },
943  // Level 4
944  { maxMacroblocks: 8192, maxBitrate: 5e7, maxDpbMbs: 32768, level: 41 },
945  // Level 4.1
946  { maxMacroblocks: 8704, maxBitrate: 5e7, maxDpbMbs: 34816, level: 42 },
947  // Level 4.2
948  { maxMacroblocks: 22080, maxBitrate: 135e6, maxDpbMbs: 110400, level: 50 },
949  // Level 5
950  { maxMacroblocks: 36864, maxBitrate: 24e7, maxDpbMbs: 184320, level: 51 },
951  // Level 5.1
952  { maxMacroblocks: 36864, maxBitrate: 24e7, maxDpbMbs: 184320, level: 52 },
953  // Level 5.2
954  { maxMacroblocks: 139264, maxBitrate: 24e7, maxDpbMbs: 696320, level: 60 },
955  // Level 6
956  { maxMacroblocks: 139264, maxBitrate: 48e7, maxDpbMbs: 696320, level: 61 },
957  // Level 6.1
958  { maxMacroblocks: 139264, maxBitrate: 8e8, maxDpbMbs: 696320, level: 62 }
959  // Level 6.2
960];
961var HEVC_LEVEL_TABLE = [
962  { maxPictureSize: 36864, maxBitrate: 128e3, tier: "L", level: 30 },
963  // Level 1 (Low Tier)
964  { maxPictureSize: 122880, maxBitrate: 15e5, tier: "L", level: 60 },
965  // Level 2 (Low Tier)
966  { maxPictureSize: 245760, maxBitrate: 3e6, tier: "L", level: 63 },
967  // Level 2.1 (Low Tier)
968  { maxPictureSize: 552960, maxBitrate: 6e6, tier: "L", level: 90 },
969  // Level 3 (Low Tier)
970  { maxPictureSize: 983040, maxBitrate: 1e7, tier: "L", level: 93 },
971  // Level 3.1 (Low Tier)
972  { maxPictureSize: 2228224, maxBitrate: 12e6, tier: "L", level: 120 },
973  // Level 4 (Low Tier)
974  { maxPictureSize: 2228224, maxBitrate: 3e7, tier: "H", level: 120 },
975  // Level 4 (High Tier)
976  { maxPictureSize: 2228224, maxBitrate: 2e7, tier: "L", level: 123 },
977  // Level 4.1 (Low Tier)
978  { maxPictureSize: 2228224, maxBitrate: 5e7, tier: "H", level: 123 },
979  // Level 4.1 (High Tier)
980  { maxPictureSize: 8912896, maxBitrate: 25e6, tier: "L", level: 150 },
981  // Level 5 (Low Tier)
982  { maxPictureSize: 8912896, maxBitrate: 1e8, tier: "H", level: 150 },
983  // Level 5 (High Tier)
984  { maxPictureSize: 8912896, maxBitrate: 4e7, tier: "L", level: 153 },
985  // Level 5.1 (Low Tier)
986  { maxPictureSize: 8912896, maxBitrate: 16e7, tier: "H", level: 153 },
987  // Level 5.1 (High Tier)
988  { maxPictureSize: 8912896, maxBitrate: 6e7, tier: "L", level: 156 },
989  // Level 5.2 (Low Tier)
990  { maxPictureSize: 8912896, maxBitrate: 24e7, tier: "H", level: 156 },
991  // Level 5.2 (High Tier)
992  { maxPictureSize: 35651584, maxBitrate: 6e7, tier: "L", level: 180 },
993  // Level 6 (Low Tier)
994  { maxPictureSize: 35651584, maxBitrate: 24e7, tier: "H", level: 180 },
995  // Level 6 (High Tier)
996  { maxPictureSize: 35651584, maxBitrate: 12e7, tier: "L", level: 183 },
997  // Level 6.1 (Low Tier)
998  { maxPictureSize: 35651584, maxBitrate: 48e7, tier: "H", level: 183 },
999  // Level 6.1 (High Tier)
1000  { maxPictureSize: 35651584, maxBitrate: 24e7, tier: "L", level: 186 },
1001  // Level 6.2 (Low Tier)
1002  { maxPictureSize: 35651584, maxBitrate: 8e8, tier: "H", level: 186 }
1003  // Level 6.2 (High Tier)
1004];
1005var VP9_LEVEL_TABLE = [
1006  { maxPictureSize: 36864, maxBitrate: 2e5, level: 10 },
1007  // Level 1
1008  { maxPictureSize: 73728, maxBitrate: 8e5, level: 11 },
1009  // Level 1.1
1010  { maxPictureSize: 122880, maxBitrate: 18e5, level: 20 },
1011  // Level 2
1012  { maxPictureSize: 245760, maxBitrate: 36e5, level: 21 },
1013  // Level 2.1
1014  { maxPictureSize: 552960, maxBitrate: 72e5, level: 30 },
1015  // Level 3
1016  { maxPictureSize: 983040, maxBitrate: 12e6, level: 31 },
1017  // Level 3.1
1018  { maxPictureSize: 2228224, maxBitrate: 18e6, level: 40 },
1019  // Level 4
1020  { maxPictureSize: 2228224, maxBitrate: 3e7, level: 41 },
1021  // Level 4.1
1022  { maxPictureSize: 8912896, maxBitrate: 6e7, level: 50 },
1023  // Level 5
1024  { maxPictureSize: 8912896, maxBitrate: 12e7, level: 51 },
1025  // Level 5.1
1026  { maxPictureSize: 8912896, maxBitrate: 18e7, level: 52 },
1027  // Level 5.2
1028  { maxPictureSize: 35651584, maxBitrate: 18e7, level: 60 },
1029  // Level 6
1030  { maxPictureSize: 35651584, maxBitrate: 24e7, level: 61 },
1031  // Level 6.1
1032  { maxPictureSize: 35651584, maxBitrate: 48e7, level: 62 }
1033  // Level 6.2
1034];
1035var AV1_LEVEL_TABLE = [
1036  { maxPictureSize: 147456, maxBitrate: 15e5, tier: "M", level: 0 },
1037  // Level 2.0 (Main Tier)
1038  { maxPictureSize: 278784, maxBitrate: 3e6, tier: "M", level: 1 },
1039  // Level 2.1 (Main Tier)
1040  { maxPictureSize: 665856, maxBitrate: 6e6, tier: "M", level: 4 },
1041  // Level 3.0 (Main Tier)
1042  { maxPictureSize: 1065024, maxBitrate: 1e7, tier: "M", level: 5 },
1043  // Level 3.1 (Main Tier)
1044  { maxPictureSize: 2359296, maxBitrate: 12e6, tier: "M", level: 8 },
1045  // Level 4.0 (Main Tier)
1046  { maxPictureSize: 2359296, maxBitrate: 3e7, tier: "H", level: 8 },
1047  // Level 4.0 (High Tier)
1048  { maxPictureSize: 2359296, maxBitrate: 2e7, tier: "M", level: 9 },
1049  // Level 4.1 (Main Tier)
1050  { maxPictureSize: 2359296, maxBitrate: 5e7, tier: "H", level: 9 },
1051  // Level 4.1 (High Tier)
1052  { maxPictureSize: 8912896, maxBitrate: 3e7, tier: "M", level: 12 },
1053  // Level 5.0 (Main Tier)
1054  { maxPictureSize: 8912896, maxBitrate: 1e8, tier: "H", level: 12 },
1055  // Level 5.0 (High Tier)
1056  { maxPictureSize: 8912896, maxBitrate: 4e7, tier: "M", level: 13 },
1057  // Level 5.1 (Main Tier)
1058  { maxPictureSize: 8912896, maxBitrate: 16e7, tier: "H", level: 13 },
1059  // Level 5.1 (High Tier)
1060  { maxPictureSize: 8912896, maxBitrate: 6e7, tier: "M", level: 14 },
1061  // Level 5.2 (Main Tier)
1062  { maxPictureSize: 8912896, maxBitrate: 24e7, tier: "H", level: 14 },
1063  // Level 5.2 (High Tier)
1064  { maxPictureSize: 35651584, maxBitrate: 6e7, tier: "M", level: 15 },
1065  // Level 5.3 (Main Tier)
1066  { maxPictureSize: 35651584, maxBitrate: 24e7, tier: "H", level: 15 },
1067  // Level 5.3 (High Tier)
1068  { maxPictureSize: 35651584, maxBitrate: 6e7, tier: "M", level: 16 },
1069  // Level 6.0 (Main Tier)
1070  { maxPictureSize: 35651584, maxBitrate: 24e7, tier: "H", level: 16 },
1071  // Level 6.0 (High Tier)
1072  { maxPictureSize: 35651584, maxBitrate: 1e8, tier: "M", level: 17 },
1073  // Level 6.1 (Main Tier)
1074  { maxPictureSize: 35651584, maxBitrate: 48e7, tier: "H", level: 17 },
1075  // Level 6.1 (High Tier)
1076  { maxPictureSize: 35651584, maxBitrate: 16e7, tier: "M", level: 18 },
1077  // Level 6.2 (Main Tier)
1078  { maxPictureSize: 35651584, maxBitrate: 8e8, tier: "H", level: 18 },
1079  // Level 6.2 (High Tier)
1080  { maxPictureSize: 35651584, maxBitrate: 16e7, tier: "M", level: 19 },
1081  // Level 6.3 (Main Tier)
1082  { maxPictureSize: 35651584, maxBitrate: 8e8, tier: "H", level: 19 }
1083  // Level 6.3 (High Tier)
1084];
1085var buildVideoCodecString = (codec, width, height, bitrate) => {
1086  if (codec === "avc") {
1087    const profileIndication = 100;
1088    const totalMacroblocks = Math.ceil(width / 16) * Math.ceil(height / 16);
1089    const levelInfo = AVC_LEVEL_TABLE.find((level) => totalMacroblocks <= level.maxMacroblocks && bitrate <= level.maxBitrate) ?? last(AVC_LEVEL_TABLE);
1090    const levelIndication = levelInfo ? levelInfo.level : 0;
1091    const hexProfileIndication = profileIndication.toString(16).padStart(2, "0");
1092    const hexProfileCompatibility = "00";
1093    const hexLevelIndication = levelIndication.toString(16).padStart(2, "0");
1094    return \`avc1.\${hexProfileIndication}\${hexProfileCompatibility}\${hexLevelIndication}\`;
1095  } else if (codec === "hevc") {
1096    const profilePrefix = "";
1097    const profileIdc = 1;
1098    const compatibilityFlags = "6";
1099    const pictureSize = width * height;
1100    const levelInfo = HEVC_LEVEL_TABLE.find((level) => pictureSize <= level.maxPictureSize && bitrate <= level.maxBitrate) ?? last(HEVC_LEVEL_TABLE);
1101    const constraintFlags = "B0";
1102    return \`hev1.\${profilePrefix}\${profileIdc}.\${compatibilityFlags}.\${levelInfo.tier}\${levelInfo.level}.\${constraintFlags}\`;
1103  } else if (codec === "vp8") {
1104    return "vp8";
1105  } else if (codec === "vp9") {
1106    const profile = "00";
1107    const pictureSize = width * height;
1108    const levelInfo = VP9_LEVEL_TABLE.find((level) => pictureSize <= level.maxPictureSize && bitrate <= level.maxBitrate) ?? last(VP9_LEVEL_TABLE);
1109    const bitDepth = "08";
1110    return \`vp09.\${profile}.\${levelInfo.level.toString().padStart(2, "0")}.\${bitDepth}\`;
1111  } else if (codec === "av1") {
1112    const profile = 0;
1113    const pictureSize = width * height;
1114    const levelInfo = AV1_LEVEL_TABLE.find((level2) => pictureSize <= level2.maxPictureSize && bitrate <= level2.maxBitrate) ?? last(AV1_LEVEL_TABLE);
1115    const level = levelInfo.level.toString().padStart(2, "0");
1116    const bitDepth = "08";
1117    return \`av01.\${profile}.\${level}\${levelInfo.tier}.\${bitDepth}\`;
1118  }
1119  throw new TypeError(\`Unhandled codec '\${codec}'.\`);
1120};
1121var generateVp9CodecConfigurationFromCodecString = (codecString) => {
1122  const parts = codecString.split(".");
1123  const profile = Number(parts[1]);
1124  const level = Number(parts[2]);
1125  const bitDepth = Number(parts[3]);
1126  const chromaSubsampling = parts[4] ? Number(parts[4]) : 1;
1127  return [
1128    1,
1129    1,
1130    profile,
1131    2,
1132    1,
1133    level,
1134    3,
1135    1,
1136    bitDepth,
1137    4,
1138    1,
1139    chromaSubsampling
1140  ];
1141};
1142var generateAv1CodecConfigurationFromCodecString = (codecString) => {
1143  const parts = codecString.split(".");
1144  const marker = 1;
1145  const version = 1;
1146  const firstByte = (marker << 7) + version;
1147  const profile = Number(parts[1]);
1148  const levelAndTier = parts[2];
1149  const level = Number(levelAndTier.slice(0, -1));
1150  const secondByte = (profile << 5) + level;
1151  const tier = levelAndTier.slice(-1) === "H" ? 1 : 0;
1152  const bitDepth = Number(parts[3]);
1153  const highBitDepth = bitDepth === 8 ? 0 : 1;
1154  const twelveBit = 0;
1155  const monochrome = parts[4] ? Number(parts[4]) : 0;
1156  const chromaSubsamplingX = parts[5] ? Number(parts[5][0]) : 1;
1157  const chromaSubsamplingY = parts[5] ? Number(parts[5][1]) : 1;
1158  const chromaSamplePosition = parts[5] ? Number(parts[5][2]) : 0;
1159  const thirdByte = (tier << 7) + (highBitDepth << 6) + (twelveBit << 5) + (monochrome << 4) + (chromaSubsamplingX << 3) + (chromaSubsamplingY << 2) + chromaSamplePosition;
1160  const initialPresentationDelayPresent = 0;
1161  const fourthByte = initialPresentationDelayPresent;
1162  return [firstByte, secondByte, thirdByte, fourthByte];
1163};
1164var OPUS_SAMPLE_RATE = 48e3;
1165var PCM_CODEC_REGEX = /^pcm-([usf])(\\d+)(be)?$/;
1166var parsePcmCodec = (codec) => {
1167  assert(PCM_AUDIO_CODECS.includes(codec));
1168  if (codec === "ulaw") {
1169    return { dataType: "ulaw", sampleSize: 1, littleEndian: true, silentValue: 255 };
1170  } else if (codec === "alaw") {
1171    return { dataType: "alaw", sampleSize: 1, littleEndian: true, silentValue: 213 };
1172  }
1173  const match = PCM_CODEC_REGEX.exec(codec);
1174  assert(match);
1175  let dataType;
1176  if (match[1] === "u") {
1177    dataType = "unsigned";
1178  } else if (match[1] === "s") {
1179    dataType = "signed";
1180  } else {
1181    dataType = "float";
1182  }
1183  const sampleSize = Number(match[2]) / 8;
1184  const littleEndian = match[3] !== "be";
1185  const silentValue = codec === "pcm-u8" ? 2 ** 7 : 0;
1186  return { dataType, sampleSize, littleEndian, silentValue };
1187};
1188var inferCodecFromCodecString = (codecString) => {
1189  if (codecString.startsWith("avc1") || codecString.startsWith("avc3")) {
1190    return "avc";
1191  } else if (codecString.startsWith("hev1") || codecString.startsWith("hvc1")) {
1192    return "hevc";
1193  } else if (codecString === "vp8") {
1194    return "vp8";
1195  } else if (codecString.startsWith("vp09")) {
1196    return "vp9";
1197  } else if (codecString.startsWith("av01")) {
1198    return "av1";
1199  }
1200  if (codecString === "mp3" || codecString === "mp4a.69" || codecString === "mp4a.6B" || codecString === "mp4a.6b" || codecString === "mp4a.40.34") {
1201    return "mp3";
1202  } else if (codecString.startsWith("mp4a.40.") || codecString === "mp4a.67") {
1203    return "aac";
1204  } else if (codecString === "opus") {
1205    return "opus";
1206  } else if (codecString === "vorbis") {
1207    return "vorbis";
1208  } else if (codecString === "flac") {
1209    return "flac";
1210  } else if (codecString === "ac-3" || codecString === "ac3") {
1211    return "ac3";
1212  } else if (codecString === "ec-3" || codecString === "eac3") {
1213    return "eac3";
1214  } else if (codecString === "ulaw") {
1215    return "ulaw";
1216  } else if (codecString === "alaw") {
1217    return "alaw";
1218  } else if (PCM_CODEC_REGEX.test(codecString)) {
1219    return codecString;
1220  }
1221  if (codecString === "webvtt") {
1222    return "webvtt";
1223  }
1224  return null;
1225};
1226var getVideoEncoderConfigExtension = (codec) => {
1227  if (codec === "avc") {
1228    return {
1229      avc: {
1230        format: "avc"
1231        // Ensure the format is not Annex B
1232      }
1233    };
1234  } else if (codec === "hevc") {
1235    return {
1236      hevc: {
1237        format: "hevc"
1238        // Ensure the format is not Annex B
1239      }
1240    };
1241  }
1242  return {};
1243};
1244var VALID_VIDEO_CODEC_STRING_PREFIXES = ["avc1", "avc3", "hev1", "hvc1", "vp8", "vp09", "av01"];
1245var AVC_CODEC_STRING_REGEX = /^(avc1|avc3)\\.[0-9a-fA-F]{6}$/;
1246var HEVC_CODEC_STRING_REGEX = /^(hev1|hvc1)\\.(?:[ABC]?\\d+)\\.[0-9a-fA-F]{1,8}\\.[LH]\\d+(?:\\.[0-9a-fA-F]{1,2}){0,6}$/;
1247var VP9_CODEC_STRING_REGEX = /^vp09(?:\\.\\d{2}){3}(?:(?:\\.\\d{2}){5})?$/;
1248var AV1_CODEC_STRING_REGEX = /^av01\\.\\d\\.\\d{2}[MH]\\.\\d{2}(?:\\.\\d\\.\\d{3}\\.\\d{2}\\.\\d{2}\\.\\d{2}\\.\\d)?$/;
1249var validateVideoChunkMetadata = (metadata) => {
1250  if (!metadata) {
1251    throw new TypeError("Video chunk metadata must be provided.");
1252  }
1253  if (typeof metadata !== "object") {
1254    throw new TypeError("Video chunk metadata must be an object.");
1255  }
1256  if (!metadata.decoderConfig) {
1257    throw new TypeError("Video chunk metadata must include a decoder configuration.");
1258  }
1259  if (typeof metadata.decoderConfig !== "object") {
1260    throw new TypeError("Video chunk metadata decoder configuration must be an object.");
1261  }
1262  if (typeof metadata.decoderConfig.codec !== "string") {
1263    throw new TypeError("Video chunk metadata decoder configuration must specify a codec string.");
1264  }
1265  if (!VALID_VIDEO_CODEC_STRING_PREFIXES.some((prefix) => metadata.decoderConfig.codec.startsWith(prefix))) {
1266    throw new TypeError("Video chunk metadata decoder configuration codec string must be a valid video codec string as specified in the Mediabunny Codec Registry.");
1267  }
1268  if (!Number.isInteger(metadata.decoderConfig.codedWidth) || metadata.decoderConfig.codedWidth <= 0) {
1269    throw new TypeError("Video chunk metadata decoder configuration must specify a valid codedWidth (positive integer).");
1270  }
1271  if (!Number.isInteger(metadata.decoderConfig.codedHeight) || metadata.decoderConfig.codedHeight <= 0) {
1272    throw new TypeError("Video chunk metadata decoder configuration must specify a valid codedHeight (positive integer).");
1273  }
1274  if (metadata.decoderConfig.displayAspectWidth !== void 0 && (!Number.isInteger(metadata.decoderConfig.displayAspectWidth) || metadata.decoderConfig.displayAspectWidth <= 0)) {
1275    throw new TypeError("Video chunk metadata decoder configuration displayAspectWidth, when defined, must be a positive integer.");
1276  }
1277  if (metadata.decoderConfig.displayAspectHeight !== void 0 && (!Number.isInteger(metadata.decoderConfig.displayAspectHeight) || metadata.decoderConfig.displayAspectHeight <= 0)) {
1278    throw new TypeError("Video chunk metadata decoder configuration displayAspectHeight, when defined, must be a positive integer.");
1279  }
1280  if (metadata.decoderConfig.displayAspectWidth !== void 0 !== (metadata.decoderConfig.displayAspectHeight !== void 0)) {
1281    throw new TypeError("Video chunk metadata decoder configuration must specify both displayAspectWidth and displayAspectHeight, or neither.");
1282  }
1283  if (metadata.decoderConfig.description !== void 0) {
1284    if (!isAllowSharedBufferSource(metadata.decoderConfig.description)) {
1285      throw new TypeError("Video chunk metadata decoder configuration description, when defined, must be an ArrayBuffer or an ArrayBuffer view.");
1286    }
1287  }
1288  if (metadata.decoderConfig.colorSpace !== void 0) {
1289    const { colorSpace } = metadata.decoderConfig;
1290    if (typeof colorSpace !== "object") {
1291      throw new TypeError("Video chunk metadata decoder configuration colorSpace, when provided, must be an object.");
1292    }
1293    const primariesValues = Object.keys(COLOR_PRIMARIES_MAP);
1294    if (colorSpace.primaries != null && !primariesValues.includes(colorSpace.primaries)) {
1295      throw new TypeError(\`Video chunk metadata decoder configuration colorSpace primaries, when defined, must be one of \${primariesValues.join(", ")}.\`);
1296    }
1297    const transferValues = Object.keys(TRANSFER_CHARACTERISTICS_MAP);
1298    if (colorSpace.transfer != null && !transferValues.includes(colorSpace.transfer)) {
1299      throw new TypeError(\`Video chunk metadata decoder configuration colorSpace transfer, when defined, must be one of \${transferValues.join(", ")}.\`);
1300    }
1301    const matrixValues = Object.keys(MATRIX_COEFFICIENTS_MAP);
1302    if (colorSpace.matrix != null && !matrixValues.includes(colorSpace.matrix)) {
1303      throw new TypeError(\`Video chunk metadata decoder configuration colorSpace matrix, when defined, must be one of \${matrixValues.join(", ")}.\`);
1304    }
1305    if (colorSpace.fullRange != null && typeof colorSpace.fullRange !== "boolean") {
1306      throw new TypeError("Video chunk metadata decoder configuration colorSpace fullRange, when defined, must be a boolean.");
1307    }
1308  }
1309  if (metadata.decoderConfig.codec.startsWith("avc1") || metadata.decoderConfig.codec.startsWith("avc3")) {
1310    if (!AVC_CODEC_STRING_REGEX.test(metadata.decoderConfig.codec)) {
1311      throw new TypeError("Video chunk metadata decoder configuration codec string for AVC must be a valid AVC codec string as specified in Section 3.4 of RFC 6381.");
1312    }
1313  } else if (metadata.decoderConfig.codec.startsWith("hev1") || metadata.decoderConfig.codec.startsWith("hvc1")) {
1314    if (!HEVC_CODEC_STRING_REGEX.test(metadata.decoderConfig.codec)) {
1315      throw new TypeError("Video chunk metadata decoder configuration codec string for HEVC must be a valid HEVC codec string as specified in Section E.3 of ISO 14496-15.");
1316    }
1317  } else if (metadata.decoderConfig.codec.startsWith("vp8")) {
1318    if (metadata.decoderConfig.codec !== "vp8") {
1319      throw new TypeError('Video chunk metadata decoder configuration codec string for VP8 must be "vp8".');
1320    }
1321  } else if (metadata.decoderConfig.codec.startsWith("vp09")) {
1322    if (!VP9_CODEC_STRING_REGEX.test(metadata.decoderConfig.codec)) {
1323      throw new TypeError('Video chunk metadata decoder configuration codec string for VP9 must be a valid VP9 codec string as specified in Section "Codecs Parameter String" of https://www.webmproject.org/vp9/mp4/.');
1324    }
1325  } else if (metadata.decoderConfig.codec.startsWith("av01")) {
1326    if (!AV1_CODEC_STRING_REGEX.test(metadata.decoderConfig.codec)) {
1327      throw new TypeError('Video chunk metadata decoder configuration codec string for AV1 must be a valid AV1 codec string as specified in Section "Codecs Parameter String" of https://aomediacodec.github.io/av1-isobmff/.');
1328    }
1329  }
1330};
1331var VALID_AUDIO_CODEC_STRING_PREFIXES = [
1332  "mp4a",
1333  "mp3",
1334  "opus",
1335  "vorbis",
1336  "flac",
1337  "ulaw",
1338  "alaw",
1339  "pcm",
1340  "ac-3",
1341  "ec-3"
1342];
1343var validateAudioChunkMetadata = (metadata) => {
1344  if (!metadata) {
1345    throw new TypeError("Audio chunk metadata must be provided.");
1346  }
1347  if (typeof metadata !== "object") {
1348    throw new TypeError("Audio chunk metadata must be an object.");
1349  }
1350  if (!metadata.decoderConfig) {
1351    throw new TypeError("Audio chunk metadata must include a decoder configuration.");
1352  }
1353  if (typeof metadata.decoderConfig !== "object") {
1354    throw new TypeError("Audio chunk metadata decoder configuration must be an object.");
1355  }
1356  if (typeof metadata.decoderConfig.codec !== "string") {
1357    throw new TypeError("Audio chunk metadata decoder configuration must specify a codec string.");
1358  }
1359  if (!VALID_AUDIO_CODEC_STRING_PREFIXES.some((prefix) => metadata.decoderConfig.codec.startsWith(prefix))) {
1360    throw new TypeError("Audio chunk metadata decoder configuration codec string must be a valid audio codec string as specified in the Mediabunny Codec Registry.");
1361  }
1362  if (!Number.isInteger(metadata.decoderConfig.sampleRate) || metadata.decoderConfig.sampleRate <= 0) {
1363    throw new TypeError("Audio chunk metadata decoder configuration must specify a valid sampleRate (positive integer).");
1364  }
1365  if (!Number.isInteger(metadata.decoderConfig.numberOfChannels) || metadata.decoderConfig.numberOfChannels <= 0) {
1366    throw new TypeError("Audio chunk metadata decoder configuration must specify a valid numberOfChannels (positive integer).");
1367  }
1368  if (metadata.decoderConfig.description !== void 0) {
1369    if (!isAllowSharedBufferSource(metadata.decoderConfig.description)) {
1370      throw new TypeError("Audio chunk metadata decoder configuration description, when defined, must be an ArrayBuffer or an ArrayBuffer view.");
1371    }
1372  }
1373  if (metadata.decoderConfig.codec.startsWith("mp4a") && metadata.decoderConfig.codec !== "mp4a.69" && metadata.decoderConfig.codec !== "mp4a.6B" && metadata.decoderConfig.codec !== "mp4a.6b") {
1374    const validStrings = ["mp4a.40.2", "mp4a.40.02", "mp4a.40.5", "mp4a.40.05", "mp4a.40.29", "mp4a.67"];
1375    if (!validStrings.includes(metadata.decoderConfig.codec)) {
1376      throw new TypeError("Audio chunk metadata decoder configuration codec string for AAC must be a valid AAC codec string as specified in https://www.w3.org/TR/webcodecs-aac-codec-registration/.");
1377    }
1378  } else if (metadata.decoderConfig.codec.startsWith("mp3") || metadata.decoderConfig.codec.startsWith("mp4a")) {
1379    if (metadata.decoderConfig.codec !== "mp3" && metadata.decoderConfig.codec !== "mp4a.69" && metadata.decoderConfig.codec !== "mp4a.6B" && metadata.decoderConfig.codec !== "mp4a.6b") {
1380      throw new TypeError('Audio chunk metadata decoder configuration codec string for MP3 must be "mp3", "mp4a.69" or "mp4a.6B".');
1381    }
1382  } else if (metadata.decoderConfig.codec.startsWith("opus")) {
1383    if (metadata.decoderConfig.codec !== "opus") {
1384      throw new TypeError('Audio chunk metadata decoder configuration codec string for Opus must be "opus".');
1385    }
1386    if (metadata.decoderConfig.description && metadata.decoderConfig.description.byteLength < 18) {
1387      throw new TypeError("Audio chunk metadata decoder configuration description, when specified, is expected to be an Identification Header as specified in Section 5.1 of RFC 7845.");
1388    }
1389  } else if (metadata.decoderConfig.codec.startsWith("vorbis")) {
1390    if (metadata.decoderConfig.codec !== "vorbis") {
1391      throw new TypeError('Audio chunk metadata decoder configuration codec string for Vorbis must be "vorbis".');
1392    }
1393    if (!metadata.decoderConfig.description) {
1394      throw new TypeError("Audio chunk metadata decoder configuration for Vorbis must include a description, which is expected to adhere to the format described in https://www.w3.org/TR/webcodecs-vorbis-codec-registration/.");
1395    }
1396  } else if (metadata.decoderConfig.codec.startsWith("flac")) {
1397    if (metadata.decoderConfig.codec !== "flac") {
1398      throw new TypeError('Audio chunk metadata decoder configuration codec string for FLAC must be "flac".');
1399    }
1400    const minDescriptionSize = 4 + 4 + 34;
1401    if (!metadata.decoderConfig.description || metadata.decoderConfig.description.byteLength < minDescriptionSize) {
1402      throw new TypeError("Audio chunk metadata decoder configuration for FLAC must include a description, which is expected to adhere to the format described in https://www.w3.org/TR/webcodecs-flac-codec-registration/.");
1403    }
1404  } else if (metadata.decoderConfig.codec.startsWith("ac-3") || metadata.decoderConfig.codec.startsWith("ac3")) {
1405    if (metadata.decoderConfig.codec !== "ac-3") {
1406      throw new TypeError('Audio chunk metadata decoder configuration codec string for AC-3 must be "ac-3".');
1407    }
1408  } else if (metadata.decoderConfig.codec.startsWith("ec-3") || metadata.decoderConfig.codec.startsWith("eac3")) {
1409    if (metadata.decoderConfig.codec !== "ec-3") {
1410      throw new TypeError('Audio chunk metadata decoder configuration codec string for EC-3 must be "ec-3".');
1411    }
1412  } else if (metadata.decoderConfig.codec.startsWith("pcm") || metadata.decoderConfig.codec.startsWith("ulaw") || metadata.decoderConfig.codec.startsWith("alaw")) {
1413    if (!PCM_AUDIO_CODECS.includes(metadata.decoderConfig.codec)) {
1414      throw new TypeError(\`Audio chunk metadata decoder configuration codec string for PCM must be one of the supported PCM codecs (\${PCM_AUDIO_CODECS.join(", ")}).\`);
1415    }
1416  }
1417};
1418var validateSubtitleMetadata = (metadata) => {
1419  if (!metadata) {
1420    throw new TypeError("Subtitle metadata must be provided.");
1421  }
1422  if (typeof metadata !== "object") {
1423    throw new TypeError("Subtitle metadata must be an object.");
1424  }
1425  if (!metadata.config) {
1426    throw new TypeError("Subtitle metadata must include a config object.");
1427  }
1428  if (typeof metadata.config !== "object") {
1429    throw new TypeError("Subtitle metadata config must be an object.");
1430  }
1431  if (typeof metadata.config.description !== "string") {
1432    throw new TypeError("Subtitle metadata config description must be a string.");
1433  }
1434};
1435

1436// node_modules/mediabunny/dist/modules/shared/ac3-misc.js
1437var AC3_SAMPLE_RATES = [48e3, 44100, 32e3];
1438var EAC3_REDUCED_SAMPLE_RATES = [24e3, 22050, 16e3];
1439

1440// node_modules/mediabunny/dist/modules/src/codec-data.js
1441var AvcNalUnitType;
1442(function(AvcNalUnitType2) {
1443  AvcNalUnitType2[AvcNalUnitType2["NON_IDR_SLICE"] = 1] = "NON_IDR_SLICE";
1444  AvcNalUnitType2[AvcNalUnitType2["SLICE_DPA"] = 2] = "SLICE_DPA";
1445  AvcNalUnitType2[AvcNalUnitType2["SLICE_DPB"] = 3] = "SLICE_DPB";
1446  AvcNalUnitType2[AvcNalUnitType2["SLICE_DPC"] = 4] = "SLICE_DPC";
1447  AvcNalUnitType2[AvcNalUnitType2["IDR"] = 5] = "IDR";
1448  AvcNalUnitType2[AvcNalUnitType2["SEI"] = 6] = "SEI";
1449  AvcNalUnitType2[AvcNalUnitType2["SPS"] = 7] = "SPS";
1450  AvcNalUnitType2[AvcNalUnitType2["PPS"] = 8] = "PPS";
1451  AvcNalUnitType2[AvcNalUnitType2["AUD"] = 9] = "AUD";
1452  AvcNalUnitType2[AvcNalUnitType2["SPS_EXT"] = 13] = "SPS_EXT";
1453})(AvcNalUnitType || (AvcNalUnitType = {}));
1454var HevcNalUnitType;
1455(function(HevcNalUnitType2) {
1456  HevcNalUnitType2[HevcNalUnitType2["RASL_N"] = 8] = "RASL_N";
1457  HevcNalUnitType2[HevcNalUnitType2["RASL_R"] = 9] = "RASL_R";
1458  HevcNalUnitType2[HevcNalUnitType2["BLA_W_LP"] = 16] = "BLA_W_LP";
1459  HevcNalUnitType2[HevcNalUnitType2["RSV_IRAP_VCL23"] = 23] = "RSV_IRAP_VCL23";
1460  HevcNalUnitType2[HevcNalUnitType2["VPS_NUT"] = 32] = "VPS_NUT";
1461  HevcNalUnitType2[HevcNalUnitType2["SPS_NUT"] = 33] = "SPS_NUT";
1462  HevcNalUnitType2[HevcNalUnitType2["PPS_NUT"] = 34] = "PPS_NUT";
1463  HevcNalUnitType2[HevcNalUnitType2["AUD_NUT"] = 35] = "AUD_NUT";
1464  HevcNalUnitType2[HevcNalUnitType2["PREFIX_SEI_NUT"] = 39] = "PREFIX_SEI_NUT";
1465  HevcNalUnitType2[HevcNalUnitType2["SUFFIX_SEI_NUT"] = 40] = "SUFFIX_SEI_NUT";
1466})(HevcNalUnitType || (HevcNalUnitType = {}));
1467var iterateNalUnitsInAnnexB = function* (packetData) {
1468  let i2 = 0;
1469  let nalStart = -1;
1470  while (i2 < packetData.length - 2) {
1471    const zeroIndex = packetData.indexOf(0, i2);
1472    if (zeroIndex === -1 || zeroIndex >= packetData.length - 2) {
1473      break;
1474    }
1475    i2 = zeroIndex;
1476    let startCodeLength = 0;
1477    if (i2 + 3 < packetData.length && packetData[i2 + 1] === 0 && packetData[i2 + 2] === 0 && packetData[i2 + 3] === 1) {
1478      startCodeLength = 4;
1479    } else if (packetData[i2 + 1] === 0 && packetData[i2 + 2] === 1) {
1480      startCodeLength = 3;
1481    }
1482    if (startCodeLength === 0) {
1483      i2++;
1484      continue;
1485    }
1486    if (nalStart !== -1 && i2 > nalStart) {
1487      yield {
1488        offset: nalStart,
1489        length: i2 - nalStart
1490      };
1491    }
1492    nalStart = i2 + startCodeLength;
1493    i2 = nalStart;
1494  }
1495  if (nalStart !== -1 && nalStart < packetData.length) {
1496    yield {
1497      offset: nalStart,
1498      length: packetData.length - nalStart
1499    };
1500  }
1501};
1502var iterateNalUnitsInLengthPrefixed = function* (packetData, lengthSize) {
1503  let offset = 0;
1504  const dataView = new DataView(packetData.buffer, packetData.byteOffset, packetData.byteLength);
1505  while (offset + lengthSize <= packetData.length) {
1506    let nalUnitLength;
1507    if (lengthSize === 1) {
1508      nalUnitLength = dataView.getUint8(offset);
1509    } else if (lengthSize === 2) {
1510      nalUnitLength = dataView.getUint16(offset, false);
1511    } else if (lengthSize === 3) {
1512      nalUnitLength = getUint24(dataView, offset, false);
1513    } else {
1514      assert(lengthSize === 4);
1515      nalUnitLength = dataView.getUint32(offset, false);
1516    }
1517    offset += lengthSize;
1518    yield {
1519      offset,
1520      length: nalUnitLength
1521    };
1522    offset += nalUnitLength;
1523  }
1524};
1525var iterateAvcNalUnits = (packetData, decoderConfig) => {
1526  if (decoderConfig.description) {
1527    const bytes2 = toUint8Array(decoderConfig.description);
1528    const lengthSizeMinusOne = bytes2[4] & 3;
1529    const lengthSize = lengthSizeMinusOne + 1;
1530    return iterateNalUnitsInLengthPrefixed(packetData, lengthSize);
1531  } else {
1532    return iterateNalUnitsInAnnexB(packetData);
1533  }
1534};
1535var extractNalUnitTypeForAvc = (byte) => {
1536  return byte & 31;
1537};
1538var removeEmulationPreventionBytes = (data) => {
1539  const result = [];
1540  const len = data.length;
1541  for (let i2 = 0; i2 < len; i2++) {
1542    if (i2 + 2 < len && data[i2] === 0 && data[i2 + 1] === 0 && data[i2 + 2] === 3) {
1543      result.push(0, 0);
1544      i2 += 2;
1545    } else {
1546      result.push(data[i2]);
1547    }
1548  }
1549  return new Uint8Array(result);
1550};
1551var ANNEX_B_START_CODE = new Uint8Array([0, 0, 0, 1]);
1552var concatNalUnitsInLengthPrefixed = (nalUnits, lengthSize) => {
1553  const totalLength = nalUnits.reduce((a2, b) => a2 + lengthSize + b.byteLength, 0);
1554  const result = new Uint8Array(totalLength);
1555  let offset = 0;
1556  for (const nalUnit of nalUnits) {
1557    const dataView = new DataView(result.buffer, result.byteOffset, result.byteLength);
1558    switch (lengthSize) {
1559      case 1:
1560        dataView.setUint8(offset, nalUnit.byteLength);
1561        break;
1562      case 2:
1563        dataView.setUint16(offset, nalUnit.byteLength, false);
1564        break;
1565      case 3:
1566        setUint24(dataView, offset, nalUnit.byteLength, false);
1567        break;
1568      case 4:
1569        dataView.setUint32(offset, nalUnit.byteLength, false);
1570        break;
1571    }
1572    offset += lengthSize;
1573    result.set(nalUnit, offset);
1574    offset += nalUnit.byteLength;
1575  }
1576  return result;
1577};
1578var extractAvcDecoderConfigurationRecord = (packetData) => {
1579  try {
1580    const spsUnits = [];
1581    const ppsUnits = [];
1582    const spsExtUnits = [];
1583    for (const loc of iterateNalUnitsInAnnexB(packetData)) {
1584      const nalUnit = packetData.subarray(loc.offset, loc.offset + loc.length);
1585      const type = extractNalUnitTypeForAvc(nalUnit[0]);
1586      if (type === AvcNalUnitType.SPS) {
1587        spsUnits.push(nalUnit);
1588      } else if (type === AvcNalUnitType.PPS) {
1589        ppsUnits.push(nalUnit);
1590      } else if (type === AvcNalUnitType.SPS_EXT) {
1591        spsExtUnits.push(nalUnit);
1592      }
1593    }
1594    if (spsUnits.length === 0) {
1595      return null;
1596    }
1597    if (ppsUnits.length === 0) {
1598      return null;
1599    }
1600    const spsData = spsUnits[0];
1601    const spsInfo = parseAvcSps(spsData);
1602    assert(spsInfo !== null);
1603    const hasExtendedData = spsInfo.profileIdc === 100 || spsInfo.profileIdc === 110 || spsInfo.profileIdc === 122 || spsInfo.profileIdc === 144;
1604    return {
1605      configurationVersion: 1,
1606      avcProfileIndication: spsInfo.profileIdc,
1607      profileCompatibility: spsInfo.constraintFlags,
1608      avcLevelIndication: spsInfo.levelIdc,
1609      lengthSizeMinusOne: 3,
1610      // Typically 4 bytes for length field
1611      sequenceParameterSets: spsUnits,
1612      pictureParameterSets: ppsUnits,
1613      chromaFormat: hasExtendedData ? spsInfo.chromaFormatIdc : null,
1614      bitDepthLumaMinus8: hasExtendedData ? spsInfo.bitDepthLumaMinus8 : null,
1615      bitDepthChromaMinus8: hasExtendedData ? spsInfo.bitDepthChromaMinus8 : null,
1616      sequenceParameterSetExt: hasExtendedData ? spsExtUnits : null
1617    };
1618  } catch (error) {
1619    Logging._error("Error building AVC Decoder Configuration Record:", error);
1620    return null;
1621  }
1622};
1623var serializeAvcDecoderConfigurationRecord = (record) => {
1624  const bytes2 = [];
1625  bytes2.push(record.configurationVersion);
1626  bytes2.push(record.avcProfileIndication);
1627  bytes2.push(record.profileCompatibility);
1628  bytes2.push(record.avcLevelIndication);
1629  bytes2.push(252 | record.lengthSizeMinusOne & 3);
1630  bytes2.push(224 | record.sequenceParameterSets.length & 31);
1631  for (const sps of record.sequenceParameterSets) {
1632    const length = sps.byteLength;
1633    bytes2.push(length >> 8);
1634    bytes2.push(length & 255);
1635    for (let i2 = 0; i2 < length; i2++) {
1636      bytes2.push(sps[i2]);
1637    }
1638  }
1639  bytes2.push(record.pictureParameterSets.length);
1640  for (const pps of record.pictureParameterSets) {
1641    const length = pps.byteLength;
1642    bytes2.push(length >> 8);
1643    bytes2.push(length & 255);
1644    for (let i2 = 0; i2 < length; i2++) {
1645      bytes2.push(pps[i2]);
1646    }
1647  }
1648  if (record.avcProfileIndication === 100 || record.avcProfileIndication === 110 || record.avcProfileIndication === 122 || record.avcProfileIndication === 144) {
1649    assert(record.chromaFormat !== null);
1650    assert(record.bitDepthLumaMinus8 !== null);
1651    assert(record.bitDepthChromaMinus8 !== null);
1652    assert(record.sequenceParameterSetExt !== null);
1653    bytes2.push(252 | record.chromaFormat & 3);
1654    bytes2.push(248 | record.bitDepthLumaMinus8 & 7);
1655    bytes2.push(248 | record.bitDepthChromaMinus8 & 7);
1656    bytes2.push(record.sequenceParameterSetExt.length);
1657    for (const spsExt of record.sequenceParameterSetExt) {
1658      const length = spsExt.byteLength;
1659      bytes2.push(length >> 8);
1660      bytes2.push(length & 255);
1661      for (let i2 = 0; i2 < length; i2++) {
1662        bytes2.push(spsExt[i2]);
1663      }
1664    }
1665  }
1666  return new Uint8Array(bytes2);
1667};
1668var AVC_HEVC_ASPECT_RATIO_IDC_TABLE = {
1669  1: { num: 1, den: 1 },
1670  2: { num: 12, den: 11 },
1671  3: { num: 10, den: 11 },
1672  4: { num: 16, den: 11 },
1673  5: { num: 40, den: 33 },
1674  6: { num: 24, den: 11 },
1675  7: { num: 20, den: 11 },
1676  8: { num: 32, den: 11 },
1677  9: { num: 80, den: 33 },
1678  10: { num: 18, den: 11 },
1679  11: { num: 15, den: 11 },
1680  12: { num: 64, den: 33 },
1681  13: { num: 160, den: 99 },
1682  14: { num: 4, den: 3 },
1683  15: { num: 3, den: 2 },
1684  16: { num: 2, den: 1 }
1685};
1686var parseAvcSps = (sps) => {
1687  try {
1688    const bitstream = new Bitstream(removeEmulationPreventionBytes(sps));
1689    bitstream.skipBits(1);
1690    bitstream.skipBits(2);
1691    const nalUnitType = bitstream.readBits(5);
1692    if (nalUnitType !== 7) {
1693      return null;
1694    }
1695    const profileIdc = bitstream.readAlignedByte();
1696    const constraintFlags = bitstream.readAlignedByte();
1697    const levelIdc = bitstream.readAlignedByte();
1698    readExpGolomb(bitstream);
1699    let chromaFormatIdc = 1;
1700    let bitDepthLumaMinus8 = 0;
1701    let bitDepthChromaMinus8 = 0;
1702    let separateColourPlaneFlag = 0;
1703    if (profileIdc === 100 || profileIdc === 110 || profileIdc === 122 || profileIdc === 244 || profileIdc === 44 || profileIdc === 83 || profileIdc === 86 || profileIdc === 118 || profileIdc === 128) {
1704      chromaFormatIdc = readExpGolomb(bitstream);
1705      if (chromaFormatIdc === 3) {
1706        separateColourPlaneFlag = bitstream.readBits(1);
1707      }
1708      bitDepthLumaMinus8 = readExpGolomb(bitstream);
1709      bitDepthChromaMinus8 = readExpGolomb(bitstream);
1710      bitstream.skipBits(1);
1711      const seqScalingMatrixPresentFlag = bitstream.readBits(1);
1712      if (seqScalingMatrixPresentFlag) {
1713        for (let i2 = 0; i2 < (chromaFormatIdc !== 3 ? 8 : 12); i2++) {
1714          const seqScalingListPresentFlag = bitstream.readBits(1);
1715          if (seqScalingListPresentFlag) {
1716            const sizeOfScalingList = i2 < 6 ? 16 : 64;
1717            let lastScale = 8;
1718            let nextScale = 8;
1719            for (let j = 0; j < sizeOfScalingList; j++) {
1720              if (nextScale !== 0) {
1721                const deltaScale = readSignedExpGolomb(bitstream);
1722                nextScale = (lastScale + deltaScale + 256) % 256;
1723              }
1724              lastScale = nextScale === 0 ? lastScale : nextScale;
1725            }
1726          }
1727        }
1728      }
1729    }
1730    readExpGolomb(bitstream);
1731    const picOrderCntType = readExpGolomb(bitstream);
1732    if (picOrderCntType === 0) {
1733      readExpGolomb(bitstream);
1734    } else if (picOrderCntType === 1) {
1735      bitstream.skipBits(1);
1736      readSignedExpGolomb(bitstream);
1737      readSignedExpGolomb(bitstream);
1738      const numRefFramesInPicOrderCntCycle = readExpGolomb(bitstream);
1739      for (let i2 = 0; i2 < numRefFramesInPicOrderCntCycle; i2++) {
1740        readSignedExpGolomb(bitstream);
1741      }
1742    }
1743    readExpGolomb(bitstream);
1744    bitstream.skipBits(1);
1745    const picWidthInMbsMinus1 = readExpGolomb(bitstream);
1746    const picHeightInMapUnitsMinus1 = readExpGolomb(bitstream);
1747    const codedWidth = 16 * (picWidthInMbsMinus1 + 1);
1748    const codedHeight = 16 * (picHeightInMapUnitsMinus1 + 1);
1749    let displayWidth = codedWidth;
1750    let displayHeight = codedHeight;
1751    const frameMbsOnlyFlag = bitstream.readBits(1);
1752    if (!frameMbsOnlyFlag) {
1753      bitstream.skipBits(1);
1754    }
1755    bitstream.skipBits(1);
1756    const frameCroppingFlag = bitstream.readBits(1);
1757    if (frameCroppingFlag) {
1758      const frameCropLeftOffset = readExpGolomb(bitstream);
1759      const frameCropRightOffset = readExpGolomb(bitstream);
1760      const frameCropTopOffset = readExpGolomb(bitstream);
1761      const frameCropBottomOffset = readExpGolomb(bitstream);
1762      let cropUnitX;
1763      let cropUnitY;
1764      const chromaArrayType = separateColourPlaneFlag === 0 ? chromaFormatIdc : 0;
1765      if (chromaArrayType === 0) {
1766        cropUnitX = 1;
1767        cropUnitY = 2 - frameMbsOnlyFlag;
1768      } else {
1769        const subWidthC = chromaFormatIdc === 3 ? 1 : 2;
1770        const subHeightC = chromaFormatIdc === 1 ? 2 : 1;
1771        cropUnitX = subWidthC;
1772        cropUnitY = subHeightC * (2 - frameMbsOnlyFlag);
1773      }
1774      displayWidth -= cropUnitX * (frameCropLeftOffset + frameCropRightOffset);
1775      displayHeight -= cropUnitY * (frameCropTopOffset + frameCropBottomOffset);
1776    }
1777    let colourPrimaries = 2;
1778    let transferCharacteristics = 2;
1779    let matrixCoefficients = 2;
1780    let fullRangeFlag = 0;
1781    let pixelAspectRatio = { num: 1, den: 1 };
1782    let numReorderFrames = null;
1783    let maxDecFrameBuffering = null;
1784    const vuiParametersPresentFlag = bitstream.readBits(1);
1785    if (vuiParametersPresentFlag) {
1786      const aspectRatioInfoPresentFlag = bitstream.readBits(1);
1787      if (aspectRatioInfoPresentFlag) {
1788        const aspectRatioIdc = bitstream.readBits(8);
1789        if (aspectRatioIdc === 255) {
1790          pixelAspectRatio = {
1791            num: bitstream.readBits(16),
1792            den: bitstream.readBits(16)
1793          };
1794        } else {
1795          const aspectRatio = AVC_HEVC_ASPECT_RATIO_IDC_TABLE[aspectRatioIdc];
1796          if (aspectRatio) {
1797            pixelAspectRatio = aspectRatio;
1798          }
1799        }
1800      }
1801      const overscanInfoPresentFlag = bitstream.readBits(1);
1802      if (overscanInfoPresentFlag) {
1803        bitstream.skipBits(1);
1804      }
1805      const videoSignalTypePresentFlag = bitstream.readBits(1);
1806      if (videoSignalTypePresentFlag) {
1807        bitstream.skipBits(3);
1808        fullRangeFlag = bitstream.readBits(1);
1809        const colourDescriptionPresentFlag = bitstream.readBits(1);
1810        if (colourDescriptionPresentFlag) {
1811          colourPrimaries = bitstream.readBits(8);
1812          transferCharacteristics = bitstream.readBits(8);
1813          matrixCoefficients = bitstream.readBits(8);
1814        }
1815      }
1816      const chromaLocInfoPresentFlag = bitstream.readBits(1);
1817      if (chromaLocInfoPresentFlag) {
1818        readExpGolomb(bitstream);
1819        readExpGolomb(bitstream);
1820      }
1821      const timingInfoPresentFlag = bitstream.readBits(1);
1822      if (timingInfoPresentFlag) {
1823        bitstream.skipBits(32);
1824        bitstream.skipBits(32);
1825        bitstream.skipBits(1);
1826      }
1827      const nalHrdParametersPresentFlag = bitstream.readBits(1);
1828      if (nalHrdParametersPresentFlag) {
1829        skipAvcHrdParameters(bitstream);
1830      }
1831      const vclHrdParametersPresentFlag = bitstream.readBits(1);
1832      if (vclHrdParametersPresentFlag) {
1833        skipAvcHrdParameters(bitstream);
1834      }
1835      if (nalHrdParametersPresentFlag || vclHrdParametersPresentFlag) {
1836        bitstream.skipBits(1);
1837      }
1838      bitstream.skipBits(1);
1839      const bitstreamRestrictionFlag = bitstream.readBits(1);
1840      if (bitstreamRestrictionFlag) {
1841        bitstream.skipBits(1);
1842        readExpGolomb(bitstream);
1843        readExpGolomb(bitstream);
1844        readExpGolomb(bitstream);
1845        readExpGolomb(bitstream);
1846        numReorderFrames = readExpGolomb(bitstream);
1847        maxDecFrameBuffering = readExpGolomb(bitstream);
1848      }
1849    }
1850    if (numReorderFrames === null) {
1851      assert(maxDecFrameBuffering === null);
1852      const constraintSet3Flag = constraintFlags & 16;
1853      if ((profileIdc === 44 || profileIdc === 86 || profileIdc === 100 || profileIdc === 110 || profileIdc === 122 || profileIdc === 244) && constraintSet3Flag) {
1854        numReorderFrames = 0;
1855        maxDecFrameBuffering = 0;
1856      } else {
1857        const picWidthInMbs = picWidthInMbsMinus1 + 1;
1858        const picHeightInMapUnits = picHeightInMapUnitsMinus1 + 1;
1859        const frameHeightInMbs = (2 - frameMbsOnlyFlag) * picHeightInMapUnits;
1860        const levelInfo = AVC_LEVEL_TABLE.find((x) => x.level >= levelIdc) ?? last(AVC_LEVEL_TABLE);
1861        const maxDpbFrames = Math.min(Math.floor(levelInfo.maxDpbMbs / (picWidthInMbs * frameHeightInMbs)), 16);
1862        numReorderFrames = maxDpbFrames;
1863        maxDecFrameBuffering = maxDpbFrames;
1864      }
1865    }
1866    assert(maxDecFrameBuffering !== null);
1867    return {
1868      profileIdc,
1869      constraintFlags,
1870      levelIdc,
1871      frameMbsOnlyFlag,
1872      chromaFormatIdc,
1873      bitDepthLumaMinus8,
1874      bitDepthChromaMinus8,
1875      codedWidth,
1876      codedHeight,
1877      displayWidth,
1878      displayHeight,
1879      pixelAspectRatio,
1880      colourPrimaries,
1881      matrixCoefficients,
1882      transferCharacteristics,
1883      fullRangeFlag,
1884      numReorderFrames,
1885      maxDecFrameBuffering
1886    };
1887  } catch (error) {
1888    Logging._error("Error parsing AVC SPS:", error);
1889    return null;
1890  }
1891};
1892var skipAvcHrdParameters = (bitstream) => {
1893  const cpb_cnt_minus1 = readExpGolomb(bitstream);
1894  bitstream.skipBits(4);
1895  bitstream.skipBits(4);
1896  for (let i2 = 0; i2 <= cpb_cnt_minus1; i2++) {
1897    readExpGolomb(bitstream);
1898    readExpGolomb(bitstream);
1899    bitstream.skipBits(1);
1900  }
1901  bitstream.skipBits(5);
1902  bitstream.skipBits(5);
1903  bitstream.skipBits(5);
1904  bitstream.skipBits(5);
1905};
1906var iterateHevcNalUnits = (packetData, decoderConfig) => {
1907  if (decoderConfig.description) {
1908    const bytes2 = toUint8Array(decoderConfig.description);
1909    const lengthSizeMinusOne = bytes2[21] & 3;
1910    const lengthSize = lengthSizeMinusOne + 1;
1911    return iterateNalUnitsInLengthPrefixed(packetData, lengthSize);
1912  } else {
1913    return iterateNalUnitsInAnnexB(packetData);
1914  }
1915};
1916var extractNalUnitTypeForHevc = (byte) => {
1917  return byte >> 1 & 63;
1918};
1919var parseHevcSps = (sps) => {
1920  try {
1921    const bitstream = new Bitstream(removeEmulationPreventionBytes(sps));
1922    bitstream.skipBits(16);
1923    bitstream.readBits(4);
1924    const spsMaxSubLayersMinus1 = bitstream.readBits(3);
1925    const spsTemporalIdNestingFlag = bitstream.readBits(1);
1926    const { general_profile_space, general_tier_flag, general_profile_idc, general_profile_compatibility_flags, general_constraint_indicator_flags, general_level_idc } = parseProfileTierLevel(bitstream, spsMaxSubLayersMinus1);
1927    readExpGolomb(bitstream);
1928    const chromaFormatIdc = readExpGolomb(bitstream);
1929    let separateColourPlaneFlag = 0;
1930    if (chromaFormatIdc === 3) {
1931      separateColourPlaneFlag = bitstream.readBits(1);
1932    }
1933    const picWidthInLumaSamples = readExpGolomb(bitstream);
1934    const picHeightInLumaSamples = readExpGolomb(bitstream);
1935    let displayWidth = picWidthInLumaSamples;
1936    let displayHeight = picHeightInLumaSamples;
1937    if (bitstream.readBits(1)) {
1938      const confWinLeftOffset = readExpGolomb(bitstream);
1939      const confWinRightOffset = readExpGolomb(bitstream);
1940      const confWinTopOffset = readExpGolomb(bitstream);
1941      const confWinBottomOffset = readExpGolomb(bitstream);
1942      let subWidthC = 1;
1943      let subHeightC = 1;
1944      const chromaArrayType = separateColourPlaneFlag === 0 ? chromaFormatIdc : 0;
1945      if (chromaArrayType === 1) {
1946        subWidthC = 2;
1947        subHeightC = 2;
1948      } else if (chromaArrayType === 2) {
1949        subWidthC = 2;
1950        subHeightC = 1;
1951      }
1952      displayWidth -= (confWinLeftOffset + confWinRightOffset) * subWidthC;
1953      displayHeight -= (confWinTopOffset + confWinBottomOffset) * subHeightC;
1954    }
1955    const bitDepthLumaMinus8 = readExpGolomb(bitstream);
1956    const bitDepthChromaMinus8 = readExpGolomb(bitstream);
1957    readExpGolomb(bitstream);
1958    const spsSubLayerOrderingInfoPresentFlag = bitstream.readBits(1);
1959    const startI = spsSubLayerOrderingInfoPresentFlag ? 0 : spsMaxSubLayersMinus1;
1960    let spsMaxNumReorderPics = 0;
1961    for (let i2 = startI; i2 <= spsMaxSubLayersMinus1; i2++) {
1962      readExpGolomb(bitstream);
1963      spsMaxNumReorderPics = readExpGolomb(bitstream);
1964      readExpGolomb(bitstream);
1965    }
1966    readExpGolomb(bitstream);
1967    readExpGolomb(bitstream);
1968    readExpGolomb(bitstream);
1969    readExpGolomb(bitstream);
1970    readExpGolomb(bitstream);
1971    readExpGolomb(bitstream);
1972    if (bitstream.readBits(1)) {
1973      if (bitstream.readBits(1)) {
1974        skipScalingListData(bitstream);
1975      }
1976    }
1977    bitstream.skipBits(1);
1978    bitstream.skipBits(1);
1979    if (bitstream.readBits(1)) {
1980      bitstream.skipBits(4);
1981      bitstream.skipBits(4);
1982      readExpGolomb(bitstream);
1983      readExpGolomb(bitstream);
1984      bitstream.skipBits(1);
1985    }
1986    const numShortTermRefPicSets = readExpGolomb(bitstream);
1987    skipAllStRefPicSets(bitstream, numShortTermRefPicSets);
1988    if (bitstream.readBits(1)) {
1989      const numLongTermRefPicsSps = readExpGolomb(bitstream);
1990      for (let i2 = 0; i2 < numLongTermRefPicsSps; i2++) {
1991        readExpGolomb(bitstream);
1992        bitstream.skipBits(1);
1993      }
1994    }
1995    bitstream.skipBits(1);
1996    bitstream.skipBits(1);
1997    let colourPrimaries = 2;
1998    let transferCharacteristics = 2;
1999    let matrixCoefficients = 2;
2000    let fullRangeFlag = 0;
2001    let minSpatialSegmentationIdc = 0;
2002    let pixelAspectRatio = { num: 1, den: 1 };
2003    if (bitstream.readBits(1)) {
2004      const vui = parseHevcVui(bitstream, spsMaxSubLayersMinus1);
2005      pixelAspectRatio = vui.pixelAspectRatio;
2006      colourPrimaries = vui.colourPrimaries;
2007      transferCharacteristics = vui.transferCharacteristics;
2008      matrixCoefficients = vui.matrixCoefficients;
2009      fullRangeFlag = vui.fullRangeFlag;
2010      minSpatialSegmentationIdc = vui.minSpatialSegmentationIdc;
2011    }
2012    return {
2013      displayWidth,
2014      displayHeight,
2015      pixelAspectRatio,
2016      colourPrimaries,
2017      transferCharacteristics,
2018      matrixCoefficients,
2019      fullRangeFlag,
2020      maxDecFrameBuffering: spsMaxNumReorderPics + 1,
2021      spsMaxSubLayersMinus1,
2022      spsTemporalIdNestingFlag,
2023      generalProfileSpace: general_profile_space,
2024      generalTierFlag: general_tier_flag,
2025      generalProfileIdc: general_profile_idc,
2026      generalProfileCompatibilityFlags: general_profile_compatibility_flags,
2027      generalConstraintIndicatorFlags: general_constraint_indicator_flags,
2028      generalLevelIdc: general_level_idc,
2029      chromaFormatIdc,
2030      bitDepthLumaMinus8,
2031      bitDepthChromaMinus8,
2032      minSpatialSegmentationIdc
2033    };
2034  } catch (error) {
2035    Logging._error("Error parsing HEVC SPS:", error);
2036    return null;
2037  }
2038};
2039var extractHevcDecoderConfigurationRecord = (packetData) => {
2040  try {
2041    const vpsUnits = [];
2042    const spsUnits = [];
2043    const ppsUnits = [];
2044    const seiUnits = [];
2045    for (const loc of iterateNalUnitsInAnnexB(packetData)) {
2046      const nalUnit = packetData.subarray(loc.offset, loc.offset + loc.length);
2047      const type = extractNalUnitTypeForHevc(nalUnit[0]);
2048      if (type === HevcNalUnitType.VPS_NUT) {
2049        vpsUnits.push(nalUnit);
2050      } else if (type === HevcNalUnitType.SPS_NUT) {
2051        spsUnits.push(nalUnit);
2052      } else if (type === HevcNalUnitType.PPS_NUT) {
2053        ppsUnits.push(nalUnit);
2054      } else if (type === HevcNalUnitType.PREFIX_SEI_NUT || type === HevcNalUnitType.SUFFIX_SEI_NUT) {
2055        seiUnits.push(nalUnit);
2056      }
2057    }
2058    if (spsUnits.length === 0 || ppsUnits.length === 0)
2059      return null;
2060    const spsInfo = parseHevcSps(spsUnits[0]);
2061    if (!spsInfo)
2062      return null;
2063    let parallelismType = 0;
2064    if (ppsUnits.length > 0) {
2065      const pps = ppsUnits[0];
2066      const ppsBitstream = new Bitstream(removeEmulationPreventionBytes(pps));
2067      ppsBitstream.skipBits(16);
2068      readExpGolomb(ppsBitstream);
2069      readExpGolomb(ppsBitstream);
2070      ppsBitstream.skipBits(1);
2071      ppsBitstream.skipBits(1);
2072      ppsBitstream.skipBits(3);
2073      ppsBitstream.skipBits(1);
2074      ppsBitstream.skipBits(1);
2075      readExpGolomb(ppsBitstream);
2076      readExpGolomb(ppsBitstream);
2077      readSignedExpGolomb(ppsBitstream);
2078      ppsBitstream.skipBits(1);
2079      ppsBitstream.skipBits(1);
2080      if (ppsBitstream.readBits(1)) {
2081        readExpGolomb(ppsBitstream);
2082      }
2083      readSignedExpGolomb(ppsBitstream);
2084      readSignedExpGolomb(ppsBitstream);
2085      ppsBitstream.skipBits(1);
2086      ppsBitstream.skipBits(1);
2087      ppsBitstream.skipBits(1);
2088      ppsBitstream.skipBits(1);
2089      const tiles_enabled_flag = ppsBitstream.readBits(1);
2090      const entropy_coding_sync_enabled_flag = ppsBitstream.readBits(1);
2091      if (!tiles_enabled_flag && !entropy_coding_sync_enabled_flag)
2092        parallelismType = 0;
2093      else if (tiles_enabled_flag && !entropy_coding_sync_enabled_flag)
2094        parallelismType = 2;
2095      else if (!tiles_enabled_flag && entropy_coding_sync_enabled_flag)
2096        parallelismType = 3;
2097      else
2098        parallelismType = 0;
2099    }
2100    const arrays = [
2101      ...vpsUnits.length ? [
2102        {
2103          arrayCompleteness: 1,
2104          nalUnitType: HevcNalUnitType.VPS_NUT,
2105          nalUnits: vpsUnits
2106        }
2107      ] : [],
2108      ...spsUnits.length ? [
2109        {
2110          arrayCompleteness: 1,
2111          nalUnitType: HevcNalUnitType.SPS_NUT,
2112          nalUnits: spsUnits
2113        }
2114      ] : [],
2115      ...ppsUnits.length ? [
2116        {
2117          arrayCompleteness: 1,
2118          nalUnitType: HevcNalUnitType.PPS_NUT,
2119          nalUnits: ppsUnits
2120        }
2121      ] : [],
2122      ...seiUnits.length ? [
2123        {
2124          arrayCompleteness: 1,
2125          nalUnitType: extractNalUnitTypeForHevc(seiUnits[0][0]),
2126          nalUnits: seiUnits
2127        }
2128      ] : []
2129    ];
2130    const record = {
2131      configurationVersion: 1,
2132      generalProfileSpace: spsInfo.generalProfileSpace,
2133      generalTierFlag: spsInfo.generalTierFlag,
2134      generalProfileIdc: spsInfo.generalProfileIdc,
2135      generalProfileCompatibilityFlags: spsInfo.generalProfileCompatibilityFlags,
2136      generalConstraintIndicatorFlags: spsInfo.generalConstraintIndicatorFlags,
2137      generalLevelIdc: spsInfo.generalLevelIdc,
2138      minSpatialSegmentationIdc: spsInfo.minSpatialSegmentationIdc,
2139      parallelismType,
2140      chromaFormatIdc: spsInfo.chromaFormatIdc,
2141      bitDepthLumaMinus8: spsInfo.bitDepthLumaMinus8,
2142      bitDepthChromaMinus8: spsInfo.bitDepthChromaMinus8,
2143      avgFrameRate: 0,
2144      constantFrameRate: 0,
2145      numTemporalLayers: spsInfo.spsMaxSubLayersMinus1 + 1,
2146      temporalIdNested: spsInfo.spsTemporalIdNestingFlag,
2147      lengthSizeMinusOne: 3,
2148      arrays
2149    };
2150    return record;
2151  } catch (error) {
2152    Logging._error("Error building HEVC Decoder Configuration Record:", error);
2153    return null;
2154  }
2155};
2156var parseProfileTierLevel = (bitstream, maxNumSubLayersMinus1) => {
2157  const general_profile_space = bitstream.readBits(2);
2158  const general_tier_flag = bitstream.readBits(1);
2159  const general_profile_idc = bitstream.readBits(5);
2160  let general_profile_compatibility_flags = 0;
2161  for (let i2 = 0; i2 < 32; i2++) {
2162    general_profile_compatibility_flags = general_profile_compatibility_flags << 1 | bitstream.readBits(1);
2163  }
2164  const general_constraint_indicator_flags = new Uint8Array(6);
2165  for (let i2 = 0; i2 < 6; i2++) {
2166    general_constraint_indicator_flags[i2] = bitstream.readBits(8);
2167  }
2168  const general_level_idc = bitstream.readBits(8);
2169  const sub_layer_profile_present_flag = [];
2170  const sub_layer_level_present_flag = [];
2171  for (let i2 = 0; i2 < maxNumSubLayersMinus1; i2++) {
2172    sub_layer_profile_present_flag.push(bitstream.readBits(1));
2173    sub_layer_level_present_flag.push(bitstream.readBits(1));
2174  }
2175  if (maxNumSubLayersMinus1 > 0) {
2176    for (let i2 = maxNumSubLayersMinus1; i2 < 8; i2++) {
2177      bitstream.skipBits(2);
2178    }
2179  }
2180  for (let i2 = 0; i2 < maxNumSubLayersMinus1; i2++) {
2181    if (sub_layer_profile_present_flag[i2])
2182      bitstream.skipBits(88);
2183    if (sub_layer_level_present_flag[i2])
2184      bitstream.skipBits(8);
2185  }
2186  return {
2187    general_profile_space,
2188    general_tier_flag,
2189    general_profile_idc,
2190    general_profile_compatibility_flags,
2191    general_constraint_indicator_flags,
2192    general_level_idc
2193  };
2194};
2195var skipScalingListData = (bitstream) => {
2196  for (let sizeId = 0; sizeId < 4; sizeId++) {
2197    for (let matrixId = 0; matrixId < (sizeId === 3 ? 2 : 6); matrixId++) {
2198      const scaling_list_pred_mode_flag = bitstream.readBits(1);
2199      if (!scaling_list_pred_mode_flag) {
2200        readExpGolomb(bitstream);
2201      } else {
2202        const coefNum = Math.min(64, 1 << 4 + (sizeId << 1));
2203        if (sizeId > 1) {
2204          readSignedExpGolomb(bitstream);
2205        }
2206        for (let i2 = 0; i2 < coefNum; i2++) {
2207          readSignedExpGolomb(bitstream);
2208        }
2209      }
2210    }
2211  }
2212};
2213var skipAllStRefPicSets = (bitstream, num_short_term_ref_pic_sets) => {
2214  const NumDeltaPocs = [];
2215  for (let stRpsIdx = 0; stRpsIdx < num_short_term_ref_pic_sets; stRpsIdx++) {
2216    NumDeltaPocs[stRpsIdx] = skipStRefPicSet(bitstream, stRpsIdx, num_short_term_ref_pic_sets, NumDeltaPocs);
2217  }
2218};
2219var skipStRefPicSet = (bitstream, stRpsIdx, num_short_term_ref_pic_sets, NumDeltaPocs) => {
2220  let NumDeltaPocsThis = 0;
2221  let inter_ref_pic_set_prediction_flag = 0;
2222  let RefRpsIdx = 0;
2223  if (stRpsIdx !== 0) {
2224    inter_ref_pic_set_prediction_flag = bitstream.readBits(1);
2225  }
2226  if (inter_ref_pic_set_prediction_flag) {
2227    if (stRpsIdx === num_short_term_ref_pic_sets) {
2228      const delta_idx_minus1 = readExpGolomb(bitstream);
2229      RefRpsIdx = stRpsIdx - (delta_idx_minus1 + 1);
2230    } else {
2231      RefRpsIdx = stRpsIdx - 1;
2232    }
2233    bitstream.readBits(1);
2234    readExpGolomb(bitstream);
2235    const numDelta = NumDeltaPocs[RefRpsIdx] ?? 0;
2236    for (let j = 0; j <= numDelta; j++) {
2237      const used_by_curr_pic_flag = bitstream.readBits(1);
2238      if (!used_by_curr_pic_flag) {
2239        bitstream.readBits(1);
2240      }
2241    }
2242    NumDeltaPocsThis = NumDeltaPocs[RefRpsIdx];
2243  } else {
2244    const num_negative_pics = readExpGolomb(bitstream);
2245    const num_positive_pics = readExpGolomb(bitstream);
2246    for (let i2 = 0; i2 < num_negative_pics; i2++) {
2247      readExpGolomb(bitstream);
2248      bitstream.readBits(1);
2249    }
2250    for (let i2 = 0; i2 < num_positive_pics; i2++) {
2251      readExpGolomb(bitstream);
2252      bitstream.readBits(1);
2253    }
2254    NumDeltaPocsThis = num_negative_pics + num_positive_pics;
2255  }
2256  return NumDeltaPocsThis;
2257};
2258var parseHevcVui = (bitstream, sps_max_sub_layers_minus1) => {
2259  let colourPrimaries = 2;
2260  let transferCharacteristics = 2;
2261  let matrixCoefficients = 2;
2262  let fullRangeFlag = 0;
2263  let minSpatialSegmentationIdc = 0;
2264  let pixelAspectRatio = { num: 1, den: 1 };
2265  if (bitstream.readBits(1)) {
2266    const aspect_ratio_idc = bitstream.readBits(8);
2267    if (aspect_ratio_idc === 255) {
2268      pixelAspectRatio = {
2269        num: bitstream.readBits(16),
2270        den: bitstream.readBits(16)
2271      };
2272    } else {
2273      const aspectRatio = AVC_HEVC_ASPECT_RATIO_IDC_TABLE[aspect_ratio_idc];
2274      if (aspectRatio) {
2275        pixelAspectRatio = aspectRatio;
2276      }
2277    }
2278  }
2279  if (bitstream.readBits(1)) {
2280    bitstream.readBits(1);
2281  }
2282  if (bitstream.readBits(1)) {
2283    bitstream.readBits(3);
2284    fullRangeFlag = bitstream.readBits(1);
2285    if (bitstream.readBits(1)) {
2286      colourPrimaries = bitstream.readBits(8);
2287      transferCharacteristics = bitstream.readBits(8);
2288      matrixCoefficients = bitstream.readBits(8);
2289    }
2290  }
2291  if (bitstream.readBits(1)) {
2292    readExpGolomb(bitstream);
2293    readExpGolomb(bitstream);
2294  }
2295  bitstream.readBits(1);
2296  bitstream.readBits(1);
2297  bitstream.readBits(1);
2298  if (bitstream.readBits(1)) {
2299    readExpGolomb(bitstream);
2300    readExpGolomb(bitstream);
2301    readExpGolomb(bitstream);
2302    readExpGolomb(bitstream);
2303  }
2304  if (bitstream.readBits(1)) {
2305    bitstream.readBits(32);
2306    bitstream.readBits(32);
2307    if (bitstream.readBits(1)) {
2308      readExpGolomb(bitstream);
2309    }
2310    if (bitstream.readBits(1)) {
2311      skipHevcHrdParameters(bitstream, true, sps_max_sub_layers_minus1);
2312    }
2313  }
2314  if (bitstream.readBits(1)) {
2315    bitstream.readBits(1);
2316    bitstream.readBits(1);
2317    bitstream.readBits(1);
2318    minSpatialSegmentationIdc = readExpGolomb(bitstream);
2319    readExpGolomb(bitstream);
2320    readExpGolomb(bitstream);
2321    readExpGolomb(bitstream);
2322    readExpGolomb(bitstream);
2323  }
2324  return {
2325    pixelAspectRatio,
2326    colourPrimaries,
2327    transferCharacteristics,
2328    matrixCoefficients,
2329    fullRangeFlag,
2330    minSpatialSegmentationIdc
2331  };
2332};
2333var skipHevcHrdParameters = (bitstream, commonInfPresentFlag, maxNumSubLayersMinus1) => {
2334  let nal_hrd_parameters_present_flag = false;
2335  let vcl_hrd_parameters_present_flag = false;
2336  let sub_pic_hrd_params_present_flag = false;
2337  if (commonInfPresentFlag) {
2338    nal_hrd_parameters_present_flag = bitstream.readBits(1) === 1;
2339    vcl_hrd_parameters_present_flag = bitstream.readBits(1) === 1;
2340    if (nal_hrd_parameters_present_flag || vcl_hrd_parameters_present_flag) {
2341      sub_pic_hrd_params_present_flag = bitstream.readBits(1) === 1;
2342      if (sub_pic_hrd_params_present_flag) {
2343        bitstream.readBits(8);
2344        bitstream.readBits(5);
2345        bitstream.readBits(1);
2346        bitstream.readBits(5);
2347      }
2348      bitstream.readBits(4);
2349      bitstream.readBits(4);
2350      if (sub_pic_hrd_params_present_flag) {
2351        bitstream.readBits(4);
2352      }
2353      bitstream.readBits(5);
2354      bitstream.readBits(5);
2355      bitstream.readBits(5);
2356    }
2357  }
2358  for (let i2 = 0; i2 <= maxNumSubLayersMinus1; i2++) {
2359    const fixed_pic_rate_general_flag = bitstream.readBits(1) === 1;
2360    let fixed_pic_rate_within_cvs_flag = true;
2361    if (!fixed_pic_rate_general_flag) {
2362      fixed_pic_rate_within_cvs_flag = bitstream.readBits(1) === 1;
2363    }
2364    let low_delay_hrd_flag = false;
2365    if (fixed_pic_rate_within_cvs_flag) {
2366      readExpGolomb(bitstream);
2367    } else {
2368      low_delay_hrd_flag = bitstream.readBits(1) === 1;
2369    }
2370    let CpbCnt = 1;
2371    if (!low_delay_hrd_flag) {
2372      const cpb_cnt_minus1 = readExpGolomb(bitstream);
2373      CpbCnt = cpb_cnt_minus1 + 1;
2374    }
2375    if (nal_hrd_parameters_present_flag) {
2376      skipSubLayerHrdParameters(bitstream, CpbCnt, sub_pic_hrd_params_present_flag);
2377    }
2378    if (vcl_hrd_parameters_present_flag) {
2379      skipSubLayerHrdParameters(bitstream, CpbCnt, sub_pic_hrd_params_present_flag);
2380    }
2381  }
2382};
2383var skipSubLayerHrdParameters = (bitstream, CpbCnt, sub_pic_hrd_params_present_flag) => {
2384  for (let i2 = 0; i2 < CpbCnt; i2++) {
2385    readExpGolomb(bitstream);
2386    readExpGolomb(bitstream);
2387    if (sub_pic_hrd_params_present_flag) {
2388      readExpGolomb(bitstream);
2389      readExpGolomb(bitstream);
2390    }
2391    bitstream.readBits(1);
2392  }
2393};
2394var serializeHevcDecoderConfigurationRecord = (record) => {
2395  const bytes2 = [];
2396  bytes2.push(record.configurationVersion);
2397  bytes2.push((record.generalProfileSpace & 3) << 6 | (record.generalTierFlag & 1) << 5 | record.generalProfileIdc & 31);
2398  bytes2.push(record.generalProfileCompatibilityFlags >>> 24 & 255);
2399  bytes2.push(record.generalProfileCompatibilityFlags >>> 16 & 255);
2400  bytes2.push(record.generalProfileCompatibilityFlags >>> 8 & 255);
2401  bytes2.push(record.generalProfileCompatibilityFlags & 255);
2402  bytes2.push(...record.generalConstraintIndicatorFlags);
2403  bytes2.push(record.generalLevelIdc & 255);
2404  bytes2.push(240 | record.minSpatialSegmentationIdc >> 8 & 15);
2405  bytes2.push(record.minSpatialSegmentationIdc & 255);
2406  bytes2.push(252 | record.parallelismType & 3);
2407  bytes2.push(252 | record.chromaFormatIdc & 3);
2408  bytes2.push(248 | record.bitDepthLumaMinus8 & 7);
2409  bytes2.push(248 | record.bitDepthChromaMinus8 & 7);
2410  bytes2.push(record.avgFrameRate >> 8 & 255);
2411  bytes2.push(record.avgFrameRate & 255);
2412  bytes2.push((record.constantFrameRate & 3) << 6 | (record.numTemporalLayers & 7) << 3 | (record.temporalIdNested & 1) << 2 | record.lengthSizeMinusOne & 3);
2413  bytes2.push(record.arrays.length & 255);
2414  for (const arr of record.arrays) {
2415    bytes2.push((arr.arrayCompleteness & 1) << 7 | 0 << 6 | arr.nalUnitType & 63);
2416    bytes2.push(arr.nalUnits.length >> 8 & 255);
2417    bytes2.push(arr.nalUnits.length & 255);
2418    for (const nal of arr.nalUnits) {
2419      bytes2.push(nal.length >> 8 & 255);
2420      bytes2.push(nal.length & 255);
2421      for (let i2 = 0; i2 < nal.length; i2++) {
2422        bytes2.push(nal[i2]);
2423      }
2424    }
2425  }
2426  return new Uint8Array(bytes2);
2427};
2428var HevcNaluOrderState;
2429(function(HevcNaluOrderState2) {
2430  HevcNaluOrderState2[HevcNaluOrderState2["audAllowed"] = 0] = "audAllowed";
2431  HevcNaluOrderState2[HevcNaluOrderState2["beforeFirstVcl"] = 1] = "beforeFirstVcl";
2432  HevcNaluOrderState2[HevcNaluOrderState2["afterFirstVcl"] = 2] = "afterFirstVcl";
2433  HevcNaluOrderState2[HevcNaluOrderState2["eoBitstreamAllowed"] = 3] = "eoBitstreamAllowed";
2434  HevcNaluOrderState2[HevcNaluOrderState2["noMoreDataAllowed"] = 4] = "noMoreDataAllowed";
2435})(HevcNaluOrderState || (HevcNaluOrderState = {}));
2436var iterateAv1PacketObus = function* (packet) {
2437  const bitstream = new Bitstream(packet);
2438  const readLeb128 = () => {
2439    let value = 0;
2440    for (let i2 = 0; i2 < 8; i2++) {
2441      const byte = bitstream.readAlignedByte();
2442      value |= (byte & 127) << i2 * 7;
2443      if (!(byte & 128)) {
2444        break;
2445      }
2446      if (i2 === 7 && byte & 128) {
2447        return null;
2448      }
2449    }
2450    if (value >= 2 ** 32 - 1) {
2451      return null;
2452    }
2453    return value;
2454  };
2455  while (bitstream.getBitsLeft() >= 8) {
2456    bitstream.skipBits(1);
2457    const obuType = bitstream.readBits(4);
2458    const obuExtension = bitstream.readBits(1);
2459    const obuHasSizeField = bitstream.readBits(1);
2460    bitstream.skipBits(1);
2461    if (obuExtension) {
2462      bitstream.skipBits(8);
2463    }
2464    let obuSize;
2465    if (obuHasSizeField) {
2466      const obuSizeValue = readLeb128();
2467      if (obuSizeValue === null)
2468        return;
2469      obuSize = obuSizeValue;
2470    } else {
2471      obuSize = Math.floor(bitstream.getBitsLeft() / 8);
2472    }
2473    assert(bitstream.pos % 8 === 0);
2474    yield {
2475      type: obuType,
2476      data: packet.subarray(bitstream.pos / 8, bitstream.pos / 8 + obuSize)
2477    };
2478    bitstream.skipBits(obuSize * 8);
2479  }
2480};
2481var parseOpusIdentificationHeader = (bytes2) => {
2482  const view2 = toDataView(bytes2);
2483  const outputChannelCount = view2.getUint8(9);
2484  const preSkip = view2.getUint16(10, true);
2485  const inputSampleRate = view2.getUint32(12, true);
2486  const outputGain = view2.getInt16(16, true);
2487  const channelMappingFamily = view2.getUint8(18);
2488  let channelMappingTable = null;
2489  if (channelMappingFamily) {
2490    channelMappingTable = bytes2.subarray(19, 19 + 2 + outputChannelCount);
2491  }
2492  return {
2493    outputChannelCount,
2494    preSkip,
2495    inputSampleRate,
2496    outputGain,
2497    channelMappingFamily,
2498    channelMappingTable
2499  };
2500};
2501var determineVideoPacketType = (codec, decoderConfig, packetData) => {
2502  switch (codec) {
2503    case "avc":
2504      {
2505        for (const loc of iterateAvcNalUnits(packetData, decoderConfig)) {
2506          const nalTypeByte = packetData[loc.offset];
2507          const type = extractNalUnitTypeForAvc(nalTypeByte);
2508          if (type >= AvcNalUnitType.NON_IDR_SLICE && type <= AvcNalUnitType.SLICE_DPC) {
2509            return "delta";
2510          }
2511          if (type === AvcNalUnitType.IDR) {
2512            return "key";
2513          }
2514          if (type === AvcNalUnitType.SEI && (!isChromium() || getChromiumVersion() >= 144)) {
2515            const nalUnit = packetData.subarray(loc.offset, loc.offset + loc.length);
2516            const bytes2 = removeEmulationPreventionBytes(nalUnit);
2517            let pos = 1;
2518            do {
2519              let payloadType = 0;
2520              while (true) {
2521                const nextByte = bytes2[pos++];
2522                if (nextByte === void 0)
2523                  break;
2524                payloadType += nextByte;
2525                if (nextByte < 255) {
2526                  break;
2527                }
2528              }
2529              let payloadSize = 0;
2530              while (true) {
2531                const nextByte = bytes2[pos++];
2532                if (nextByte === void 0)
2533                  break;
2534                payloadSize += nextByte;
2535                if (nextByte < 255) {
2536                  break;
2537                }
2538              }
2539              const PAYLOAD_TYPE_RECOVERY_POINT = 6;
2540              if (payloadType === PAYLOAD_TYPE_RECOVERY_POINT) {
2541                const bitstream = new Bitstream(bytes2);
2542                bitstream.pos = 8 * pos;
2543                const recoveryFrameCount = readExpGolomb(bitstream);
2544                const exactMatchFlag = bitstream.readBits(1);
2545                if (recoveryFrameCount === 0 && exactMatchFlag === 1) {
2546                  return "key";
2547                }
2548              }
2549              pos += payloadSize;
2550            } while (pos < bytes2.length - 1);
2551          }
2552        }
2553        return "delta";
2554      }
2555      ;
2556    case "hevc":
2557      {
2558        for (const loc of iterateHevcNalUnits(packetData, decoderConfig)) {
2559          const type = extractNalUnitTypeForHevc(packetData[loc.offset]);
2560          if (type < HevcNalUnitType.BLA_W_LP) {
2561            return "delta";
2562          }
2563          if (type <= HevcNalUnitType.RSV_IRAP_VCL23) {
2564            return "key";
2565          }
2566        }
2567        return "delta";
2568      }
2569      ;
2570    case "vp8":
2571      {
2572        const frameType = packetData[0] & 1;
2573        return frameType === 0 ? "key" : "delta";
2574      }
2575      ;
2576    case "vp9":
2577      {
2578        const bitstream = new Bitstream(packetData);
2579        if (bitstream.readBits(2) !== 2) {
2580          return null;
2581        }
2582        ;
2583        const profileLowBit = bitstream.readBits(1);
2584        const profileHighBit = bitstream.readBits(1);
2585        const profile = (profileHighBit << 1) + profileLowBit;
2586        if (profile === 3) {
2587          bitstream.skipBits(1);
2588        }
2589        const showExistingFrame = bitstream.readBits(1);
2590        if (showExistingFrame) {
2591          return null;
2592        }
2593        const frameType = bitstream.readBits(1);
2594        return frameType === 0 ? "key" : "delta";
2595      }
2596      ;
2597    case "av1":
2598      {
2599        let reducedStillPictureHeader = false;
2600        for (const { type, data } of iterateAv1PacketObus(packetData)) {
2601          if (type === 1) {
2602            const bitstream = new Bitstream(data);
2603            bitstream.skipBits(4);
2604            reducedStillPictureHeader = !!bitstream.readBits(1);
2605          } else if (type === 3 || type === 6 || type === 7) {
2606            if (reducedStillPictureHeader) {
2607              return "key";
2608            }
2609            const bitstream = new Bitstream(data);
2610            const showExistingFrame = bitstream.readBits(1);
2611            if (showExistingFrame) {
2612              return null;
2613            }
2614            const frameType = bitstream.readBits(2);
2615            return frameType === 0 ? "key" : "delta";
2616          }
2617        }
2618        return null;
2619      }
2620      ;
2621    default:
2622      {
2623        assertNever(codec);
2624        assert(false);
2625      }
2626      ;
2627  }
2628};
2629var FlacBlockType;
2630(function(FlacBlockType2) {
2631  FlacBlockType2[FlacBlockType2["STREAMINFO"] = 0] = "STREAMINFO";
2632  FlacBlockType2[FlacBlockType2["VORBIS_COMMENT"] = 4] = "VORBIS_COMMENT";
2633  FlacBlockType2[FlacBlockType2["PICTURE"] = 6] = "PICTURE";
2634})(FlacBlockType || (FlacBlockType = {}));
2635var parseAc3SyncFrame = (data) => {
2636  if (data.length < 7) {
2637    return null;
2638  }
2639  if (data[0] !== 11 || data[1] !== 119) {
2640    return null;
2641  }
2642  const bitstream = new Bitstream(data);
2643  bitstream.skipBits(16);
2644  bitstream.skipBits(16);
2645  const fscod = bitstream.readBits(2);
2646  if (fscod === 3) {
2647    return null;
2648  }
2649  const frmsizecod = bitstream.readBits(6);
2650  const bsid = bitstream.readBits(5);
2651  if (bsid > 8) {
2652    return null;
2653  }
2654  const bsmod = bitstream.readBits(3);
2655  const acmod = bitstream.readBits(3);
2656  if ((acmod & 1) !== 0 && acmod !== 1) {
2657    bitstream.skipBits(2);
2658  }
2659  if ((acmod & 4) !== 0) {
2660    bitstream.skipBits(2);
2661  }
2662  if (acmod === 2) {
2663    bitstream.skipBits(2);
2664  }
2665  const lfeon = bitstream.readBits(1);
2666  const bitRateCode = Math.floor(frmsizecod / 2);
2667  return { fscod, bsid, bsmod, acmod, lfeon, bitRateCode };
2668};
2669var AC3_FRAME_SIZES = [
2670  // frmsizecod, [48kHz, 44.1kHz, 32kHz] in bytes
2671  64 * 2,
2672  69 * 2,
2673  96 * 2,
2674  64 * 2,
2675  70 * 2,
2676  96 * 2,
2677  80 * 2,
2678  87 * 2,
2679  120 * 2,
2680  80 * 2,
2681  88 * 2,
2682  120 * 2,
2683  96 * 2,
2684  104 * 2,
2685  144 * 2,
2686  96 * 2,
2687  105 * 2,
2688  144 * 2,
2689  112 * 2,
2690  121 * 2,
2691  168 * 2,
2692  112 * 2,
2693  122 * 2,
2694  168 * 2,
2695  128 * 2,
2696  139 * 2,
2697  192 * 2,
2698  128 * 2,
2699  140 * 2,
2700  192 * 2,
2701  160 * 2,
2702  174 * 2,
2703  240 * 2,
2704  160 * 2,
2705  175 * 2,
2706  240 * 2,
2707  192 * 2,
2708  208 * 2,
2709  288 * 2,
2710  192 * 2,
2711  209 * 2,
2712  288 * 2,
2713  224 * 2,
2714  243 * 2,
2715  336 * 2,
2716  224 * 2,
2717  244 * 2,
2718  336 * 2,
2719  256 * 2,
2720  278 * 2,
2721  384 * 2,
2722  256 * 2,
2723  279 * 2,
2724  384 * 2,
2725  320 * 2,
2726  348 * 2,
2727  480 * 2,
2728  320 * 2,
2729  349 * 2,
2730  480 * 2,
2731  384 * 2,
2732  417 * 2,
2733  576 * 2,
2734  384 * 2,
2735  418 * 2,
2736  576 * 2,
2737  448 * 2,
2738  487 * 2,
2739  672 * 2,
2740  448 * 2,
2741  488 * 2,
2742  672 * 2,
2743  512 * 2,
2744  557 * 2,
2745  768 * 2,
2746  512 * 2,
2747  558 * 2,
2748  768 * 2,
2749  640 * 2,
2750  696 * 2,
2751  960 * 2,
2752  640 * 2,
2753  697 * 2,
2754  960 * 2,
2755  768 * 2,
2756  835 * 2,
2757  1152 * 2,
2758  768 * 2,
2759  836 * 2,
2760  1152 * 2,
2761  896 * 2,
2762  975 * 2,
2763  1344 * 2,
2764  896 * 2,
2765  976 * 2,
2766  1344 * 2,
2767  1024 * 2,
2768  1114 * 2,
2769  1536 * 2,
2770  1024 * 2,
2771  1115 * 2,
2772  1536 * 2,
2773  1152 * 2,
2774  1253 * 2,
2775  1728 * 2,
2776  1152 * 2,
2777  1254 * 2,
2778  1728 * 2,
2779  1280 * 2,
2780  1393 * 2,
2781  1920 * 2,
2782  1280 * 2,
2783  1394 * 2,
2784  1920 * 2
2785];
2786var AC3_REGISTRATION_DESCRIPTOR = new Uint8Array([5, 4, 65, 67, 45, 51]);
2787var EAC3_REGISTRATION_DESCRIPTOR = new Uint8Array([5, 4, 69, 65, 67, 51]);
2788var EAC3_NUMBLKS_TABLE = [1, 2, 3, 6];
2789var parseEac3SyncFrame = (data) => {
2790  if (data.length < 6) {
2791    return null;
2792  }
2793  if (data[0] !== 11 || data[1] !== 119) {
2794    return null;
2795  }
2796  const bitstream = new Bitstream(data);
2797  bitstream.skipBits(16);
2798  const strmtyp = bitstream.readBits(2);
2799  bitstream.skipBits(3);
2800  if (strmtyp !== 0 && strmtyp !== 2) {
2801    return null;
2802  }
2803  const frmsiz = bitstream.readBits(11);
2804  const fscod = bitstream.readBits(2);
2805  let fscod2 = 0;
2806  let numblkscod;
2807  if (fscod === 3) {
2808    fscod2 = bitstream.readBits(2);
2809    numblkscod = 3;
2810  } else {
2811    numblkscod = bitstream.readBits(2);
2812  }
2813  const acmod = bitstream.readBits(3);
2814  const lfeon = bitstream.readBits(1);
2815  const bsid = bitstream.readBits(5);
2816  if (bsid < 11 || bsid > 16) {
2817    return null;
2818  }
2819  const numblks = EAC3_NUMBLKS_TABLE[numblkscod];
2820  let fs;
2821  if (fscod < 3) {
2822    fs = AC3_SAMPLE_RATES[fscod] / 1e3;
2823  } else {
2824    fs = EAC3_REDUCED_SAMPLE_RATES[fscod2] / 1e3;
2825  }
2826  const dataRate = Math.round((frmsiz + 1) * fs / (numblks * 16));
2827  const bsmod = 0;
2828  const numDepSub = 0;
2829  const chanLoc = 0;
2830  const substream = {
2831    fscod,
2832    fscod2,
2833    bsid,
2834    bsmod,
2835    acmod,
2836    lfeon,
2837    numDepSub,
2838    chanLoc
2839  };
2840  return {
2841    dataRate,
2842    substreams: [substream]
2843  };
2844};
2845