@gyeonghokim/vega 0.0.0

package/dist/assets/media-worker-DqCztg6H.js

@@ -0,0 +1,3363 @@
+function ht(v, l) {
+  return l.forEach(function(_) {
+    _ && typeof _ != "string" && !Array.isArray(_) && Object.keys(_).forEach(function(d) {
+      if (d !== "default" && !(d in v)) {
+        var b = Object.getOwnPropertyDescriptor(_, d);
+        Object.defineProperty(v, d, b.get ? b : {
+          enumerable: !0,
+          get: function() {
+            return _[d];
+          }
+        });
+      }
+    });
+  }), Object.freeze(v);
+}
+var X = {}, tt;
+function lt() {
+  return tt || (tt = 1, (function(v) {
+    var l = /* @__PURE__ */ (function() {
+      var t = /* @__PURE__ */ new Date(), e = 4, r = 3, n = 2, o = 1, a = e, h = {
+        setLogLevel: function(f) {
+          f == this.debug ? a = o : f == this.info ? a = n : f == this.warn ? a = r : (f == this.error, a = e);
+        },
+        debug: function(f, p) {
+          console.debug === void 0 && (console.debug = console.log), o >= a && console.debug("[" + l.getDurationString(/* @__PURE__ */ new Date() - t, 1e3) + "]", "[" + f + "]", p);
+        },
+        log: function(f, p) {
+          this.debug(f.msg);
+        },
+        info: function(f, p) {
+          n >= a && console.info("[" + l.getDurationString(/* @__PURE__ */ new Date() - t, 1e3) + "]", "[" + f + "]", p);
+        },
+        warn: function(f, p) {
+          r >= a && console.warn("[" + l.getDurationString(/* @__PURE__ */ new Date() - t, 1e3) + "]", "[" + f + "]", p);
+        },
+        error: function(f, p) {
+          e >= a && console.error("[" + l.getDurationString(/* @__PURE__ */ new Date() - t, 1e3) + "]", "[" + f + "]", p);
+        }
+      };
+      return h;
+    })();
+    l.getDurationString = function(t, e) {
+      var r;
+      function n(u, c) {
+        for (var g = "" + u, x = g.split("."); x[0].length < c; )
+          x[0] = "0" + x[0];
+        return x.join(".");
+      }
+      t < 0 ? (r = !0, t = -t) : r = !1;
+      var o = e || 1, a = t / o, h = Math.floor(a / 3600);
+      a -= h * 3600;
+      var f = Math.floor(a / 60);
+      a -= f * 60;
+      var p = a * 1e3;
+      return a = Math.floor(a), p -= a * 1e3, p = Math.floor(p), (r ? "-" : "") + h + ":" + n(f, 2) + ":" + n(a, 2) + "." + n(p, 3);
+    }, l.printRanges = function(t) {
+      var e = t.length;
+      if (e > 0) {
+        for (var r = "", n = 0; n < e; n++)
+          n > 0 && (r += ","), r += "[" + l.getDurationString(t.start(n)) + "," + l.getDurationString(t.end(n)) + "]";
+        return r;
+      } else
+        return "(empty)";
+    }, v.Log = l;
+    var _ = function(t) {
+      if (t instanceof ArrayBuffer)
+        this.buffer = t, this.dataview = new DataView(t);
+      else
+        throw "Needs an array buffer";
+      this.position = 0;
+    };
+    _.prototype.getPosition = function() {
+      return this.position;
+    }, _.prototype.getEndPosition = function() {
+      return this.buffer.byteLength;
+    }, _.prototype.getLength = function() {
+      return this.buffer.byteLength;
+    }, _.prototype.seek = function(t) {
+      var e = Math.max(0, Math.min(this.buffer.byteLength, t));
+      return this.position = isNaN(e) || !isFinite(e) ? 0 : e, !0;
+    }, _.prototype.isEos = function() {
+      return this.getPosition() >= this.getEndPosition();
+    }, _.prototype.readAnyInt = function(t, e) {
+      var r = 0;
+      if (this.position + t <= this.buffer.byteLength) {
+        switch (t) {
+          case 1:
+            e ? r = this.dataview.getInt8(this.position) : r = this.dataview.getUint8(this.position);
+            break;
+          case 2:
+            e ? r = this.dataview.getInt16(this.position) : r = this.dataview.getUint16(this.position);
+            break;
+          case 3:
+            if (e)
+              throw "No method for reading signed 24 bits values";
+            r = this.dataview.getUint8(this.position) << 16, r |= this.dataview.getUint8(this.position + 1) << 8, r |= this.dataview.getUint8(this.position + 2);
+            break;
+          case 4:
+            e ? r = this.dataview.getInt32(this.position) : r = this.dataview.getUint32(this.position);
+            break;
+          case 8:
+            if (e)
+              throw "No method for reading signed 64 bits values";
+            r = this.dataview.getUint32(this.position) << 32, r |= this.dataview.getUint32(this.position + 4);
+            break;
+          default:
+            throw "readInt method not implemented for size: " + t;
+        }
+        return this.position += t, r;
+      } else
+        throw "Not enough bytes in buffer";
+    }, _.prototype.readUint8 = function() {
+      return this.readAnyInt(1, !1);
+    }, _.prototype.readUint16 = function() {
+      return this.readAnyInt(2, !1);
+    }, _.prototype.readUint24 = function() {
+      return this.readAnyInt(3, !1);
+    }, _.prototype.readUint32 = function() {
+      return this.readAnyInt(4, !1);
+    }, _.prototype.readUint64 = function() {
+      return this.readAnyInt(8, !1);
+    }, _.prototype.readString = function(t) {
+      if (this.position + t <= this.buffer.byteLength) {
+        for (var e = "", r = 0; r < t; r++)
+          e += String.fromCharCode(this.readUint8());
+        return e;
+      } else
+        throw "Not enough bytes in buffer";
+    }, _.prototype.readCString = function() {
+      for (var t = []; ; ) {
+        var e = this.readUint8();
+        if (e !== 0)
+          t.push(e);
+        else
+          break;
+      }
+      return String.fromCharCode.apply(null, t);
+    }, _.prototype.readInt8 = function() {
+      return this.readAnyInt(1, !0);
+    }, _.prototype.readInt16 = function() {
+      return this.readAnyInt(2, !0);
+    }, _.prototype.readInt32 = function() {
+      return this.readAnyInt(4, !0);
+    }, _.prototype.readInt64 = function() {
+      return this.readAnyInt(8, !1);
+    }, _.prototype.readUint8Array = function(t) {
+      for (var e = new Uint8Array(t), r = 0; r < t; r++)
+        e[r] = this.readUint8();
+      return e;
+    }, _.prototype.readInt16Array = function(t) {
+      for (var e = new Int16Array(t), r = 0; r < t; r++)
+        e[r] = this.readInt16();
+      return e;
+    }, _.prototype.readUint16Array = function(t) {
+      for (var e = new Int16Array(t), r = 0; r < t; r++)
+        e[r] = this.readUint16();
+      return e;
+    }, _.prototype.readUint32Array = function(t) {
+      for (var e = new Uint32Array(t), r = 0; r < t; r++)
+        e[r] = this.readUint32();
+      return e;
+    }, _.prototype.readInt32Array = function(t) {
+      for (var e = new Int32Array(t), r = 0; r < t; r++)
+        e[r] = this.readInt32();
+      return e;
+    }, v.MP4BoxStream = _;
+    var d = function(t, e, r) {
+      this._byteOffset = e || 0, t instanceof ArrayBuffer ? this.buffer = t : typeof t == "object" ? (this.dataView = t, e && (this._byteOffset += e)) : this.buffer = new ArrayBuffer(t || 0), this.position = 0, this.endianness = r ?? d.LITTLE_ENDIAN;
+    };
+    d.prototype = {}, d.prototype.getPosition = function() {
+      return this.position;
+    }, d.prototype._realloc = function(t) {
+      if (this._dynamicSize) {
+        var e = this._byteOffset + this.position + t, r = this._buffer.byteLength;
+        if (e <= r) {
+          e > this._byteLength && (this._byteLength = e);
+          return;
+        }
+        for (r < 1 && (r = 1); e > r; )
+          r *= 2;
+        var n = new ArrayBuffer(r), o = new Uint8Array(this._buffer), a = new Uint8Array(n, 0, o.length);
+        a.set(o), this.buffer = n, this._byteLength = e;
+      }
+    }, d.prototype._trimAlloc = function() {
+      if (this._byteLength != this._buffer.byteLength) {
+        var t = new ArrayBuffer(this._byteLength), e = new Uint8Array(t), r = new Uint8Array(this._buffer, 0, e.length);
+        e.set(r), this.buffer = t;
+      }
+    }, d.BIG_ENDIAN = !1, d.LITTLE_ENDIAN = !0, d.prototype._byteLength = 0, Object.defineProperty(
+      d.prototype,
+      "byteLength",
+      { get: function() {
+        return this._byteLength - this._byteOffset;
+      } }
+    ), Object.defineProperty(
+      d.prototype,
+      "buffer",
+      {
+        get: function() {
+          return this._trimAlloc(), this._buffer;
+        },
+        set: function(t) {
+          this._buffer = t, this._dataView = new DataView(this._buffer, this._byteOffset), this._byteLength = this._buffer.byteLength;
+        }
+      }
+    ), Object.defineProperty(
+      d.prototype,
+      "byteOffset",
+      {
+        get: function() {
+          return this._byteOffset;
+        },
+        set: function(t) {
+          this._byteOffset = t, this._dataView = new DataView(this._buffer, this._byteOffset), this._byteLength = this._buffer.byteLength;
+        }
+      }
+    ), Object.defineProperty(
+      d.prototype,
+      "dataView",
+      {
+        get: function() {
+          return this._dataView;
+        },
+        set: function(t) {
+          this._byteOffset = t.byteOffset, this._buffer = t.buffer, this._dataView = new DataView(this._buffer, this._byteOffset), this._byteLength = this._byteOffset + t.byteLength;
+        }
+      }
+    ), d.prototype.seek = function(t) {
+      var e = Math.max(0, Math.min(this.byteLength, t));
+      this.position = isNaN(e) || !isFinite(e) ? 0 : e;
+    }, d.prototype.isEof = function() {
+      return this.position >= this._byteLength;
+    }, d.prototype.mapUint8Array = function(t) {
+      this._realloc(t * 1);
+      var e = new Uint8Array(this._buffer, this.byteOffset + this.position, t);
+      return this.position += t * 1, e;
+    }, d.prototype.readInt32Array = function(t, e) {
+      t = t ?? this.byteLength - this.position / 4;
+      var r = new Int32Array(t);
+      return d.memcpy(
+        r.buffer,
+        0,
+        this.buffer,
+        this.byteOffset + this.position,
+        t * r.BYTES_PER_ELEMENT
+      ), d.arrayToNative(r, e ?? this.endianness), this.position += r.byteLength, r;
+    }, d.prototype.readInt16Array = function(t, e) {
+      t = t ?? this.byteLength - this.position / 2;
+      var r = new Int16Array(t);
+      return d.memcpy(
+        r.buffer,
+        0,
+        this.buffer,
+        this.byteOffset + this.position,
+        t * r.BYTES_PER_ELEMENT
+      ), d.arrayToNative(r, e ?? this.endianness), this.position += r.byteLength, r;
+    }, d.prototype.readInt8Array = function(t) {
+      t = t ?? this.byteLength - this.position;
+      var e = new Int8Array(t);
+      return d.memcpy(
+        e.buffer,
+        0,
+        this.buffer,
+        this.byteOffset + this.position,
+        t * e.BYTES_PER_ELEMENT
+      ), this.position += e.byteLength, e;
+    }, d.prototype.readUint32Array = function(t, e) {
+      t = t ?? this.byteLength - this.position / 4;
+      var r = new Uint32Array(t);
+      return d.memcpy(
+        r.buffer,
+        0,
+        this.buffer,
+        this.byteOffset + this.position,
+        t * r.BYTES_PER_ELEMENT
+      ), d.arrayToNative(r, e ?? this.endianness), this.position += r.byteLength, r;
+    }, d.prototype.readUint16Array = function(t, e) {
+      t = t ?? this.byteLength - this.position / 2;
+      var r = new Uint16Array(t);
+      return d.memcpy(
+        r.buffer,
+        0,
+        this.buffer,
+        this.byteOffset + this.position,
+        t * r.BYTES_PER_ELEMENT
+      ), d.arrayToNative(r, e ?? this.endianness), this.position += r.byteLength, r;
+    }, d.prototype.readUint8Array = function(t) {
+      t = t ?? this.byteLength - this.position;
+      var e = new Uint8Array(t);
+      return d.memcpy(
+        e.buffer,
+        0,
+        this.buffer,
+        this.byteOffset + this.position,
+        t * e.BYTES_PER_ELEMENT
+      ), this.position += e.byteLength, e;
+    }, d.prototype.readFloat64Array = function(t, e) {
+      t = t ?? this.byteLength - this.position / 8;
+      var r = new Float64Array(t);
+      return d.memcpy(
+        r.buffer,
+        0,
+        this.buffer,
+        this.byteOffset + this.position,
+        t * r.BYTES_PER_ELEMENT
+      ), d.arrayToNative(r, e ?? this.endianness), this.position += r.byteLength, r;
+    }, d.prototype.readFloat32Array = function(t, e) {
+      t = t ?? this.byteLength - this.position / 4;
+      var r = new Float32Array(t);
+      return d.memcpy(
+        r.buffer,
+        0,
+        this.buffer,
+        this.byteOffset + this.position,
+        t * r.BYTES_PER_ELEMENT
+      ), d.arrayToNative(r, e ?? this.endianness), this.position += r.byteLength, r;
+    }, d.prototype.readInt32 = function(t) {
+      var e = this._dataView.getInt32(this.position, t ?? this.endianness);
+      return this.position += 4, e;
+    }, d.prototype.readInt16 = function(t) {
+      var e = this._dataView.getInt16(this.position, t ?? this.endianness);
+      return this.position += 2, e;
+    }, d.prototype.readInt8 = function() {
+      var t = this._dataView.getInt8(this.position);
+      return this.position += 1, t;
+    }, d.prototype.readUint32 = function(t) {
+      var e = this._dataView.getUint32(this.position, t ?? this.endianness);
+      return this.position += 4, e;
+    }, d.prototype.readUint16 = function(t) {
+      var e = this._dataView.getUint16(this.position, t ?? this.endianness);
+      return this.position += 2, e;
+    }, d.prototype.readUint8 = function() {
+      var t = this._dataView.getUint8(this.position);
+      return this.position += 1, t;
+    }, d.prototype.readFloat32 = function(t) {
+      var e = this._dataView.getFloat32(this.position, t ?? this.endianness);
+      return this.position += 4, e;
+    }, d.prototype.readFloat64 = function(t) {
+      var e = this._dataView.getFloat64(this.position, t ?? this.endianness);
+      return this.position += 8, e;
+    }, d.endianness = new Int8Array(new Int16Array([1]).buffer)[0] > 0, d.memcpy = function(t, e, r, n, o) {
+      var a = new Uint8Array(t, e, o), h = new Uint8Array(r, n, o);
+      a.set(h);
+    }, d.arrayToNative = function(t, e) {
+      return e == this.endianness ? t : this.flipArrayEndianness(t);
+    }, d.nativeToEndian = function(t, e) {
+      return this.endianness == e ? t : this.flipArrayEndianness(t);
+    }, d.flipArrayEndianness = function(t) {
+      for (var e = new Uint8Array(t.buffer, t.byteOffset, t.byteLength), r = 0; r < t.byteLength; r += t.BYTES_PER_ELEMENT)
+        for (var n = r + t.BYTES_PER_ELEMENT - 1, o = r; n > o; n--, o++) {
+          var a = e[o];
+          e[o] = e[n], e[n] = a;
+        }
+      return t;
+    }, d.prototype.failurePosition = 0, String.fromCharCodeUint8 = function(t) {
+      for (var e = [], r = 0; r < t.length; r++)
+        e[r] = t[r];
+      return String.fromCharCode.apply(null, e);
+    }, d.prototype.readString = function(t, e) {
+      return e == null || e == "ASCII" ? String.fromCharCodeUint8.apply(null, [this.mapUint8Array(t ?? this.byteLength - this.position)]) : new TextDecoder(e).decode(this.mapUint8Array(t));
+    }, d.prototype.readCString = function(t) {
+      var e = this.byteLength - this.position, r = new Uint8Array(this._buffer, this._byteOffset + this.position), n = e;
+      t != null && (n = Math.min(t, e));
+      for (var o = 0; o < n && r[o] !== 0; o++) ;
+      var a = String.fromCharCodeUint8.apply(null, [this.mapUint8Array(o)]);
+      return t != null ? this.position += n - o : o != e && (this.position += 1), a;
+    };
+    var b = Math.pow(2, 32);
+    d.prototype.readInt64 = function() {
+      return this.readInt32() * b + this.readUint32();
+    }, d.prototype.readUint64 = function() {
+      return this.readUint32() * b + this.readUint32();
+    }, d.prototype.readInt64 = function() {
+      return this.readUint32() * b + this.readUint32();
+    }, d.prototype.readUint24 = function() {
+      return (this.readUint8() << 16) + (this.readUint8() << 8) + this.readUint8();
+    }, v.DataStream = d, d.prototype.save = function(t) {
+      var e = new Blob([this.buffer]);
+      if (window.URL && URL.createObjectURL) {
+        var r = window.URL.createObjectURL(e), n = document.createElement("a");
+        document.body.appendChild(n), n.setAttribute("href", r), n.setAttribute("download", t), n.setAttribute("target", "_self"), n.click(), window.URL.revokeObjectURL(r);
+      } else
+        throw "DataStream.save: Can't create object URL.";
+    }, d.prototype._dynamicSize = !0, Object.defineProperty(
+      d.prototype,
+      "dynamicSize",
+      {
+        get: function() {
+          return this._dynamicSize;
+        },
+        set: function(t) {
+          t || this._trimAlloc(), this._dynamicSize = t;
+        }
+      }
+    ), d.prototype.shift = function(t) {
+      var e = new ArrayBuffer(this._byteLength - t), r = new Uint8Array(e), n = new Uint8Array(this._buffer, t, r.length);
+      r.set(n), this.buffer = e, this.position -= t;
+    }, d.prototype.writeInt32Array = function(t, e) {
+      if (this._realloc(t.length * 4), t instanceof Int32Array && this.byteOffset + this.position % t.BYTES_PER_ELEMENT === 0)
+        d.memcpy(
+          this._buffer,
+          this.byteOffset + this.position,
+          t.buffer,
+          0,
+          t.byteLength
+        ), this.mapInt32Array(t.length, e);
+      else
+        for (var r = 0; r < t.length; r++)
+          this.writeInt32(t[r], e);
+    }, d.prototype.writeInt16Array = function(t, e) {
+      if (this._realloc(t.length * 2), t instanceof Int16Array && this.byteOffset + this.position % t.BYTES_PER_ELEMENT === 0)
+        d.memcpy(
+          this._buffer,
+          this.byteOffset + this.position,
+          t.buffer,
+          0,
+          t.byteLength
+        ), this.mapInt16Array(t.length, e);
+      else
+        for (var r = 0; r < t.length; r++)
+          this.writeInt16(t[r], e);
+    }, d.prototype.writeInt8Array = function(t) {
+      if (this._realloc(t.length * 1), t instanceof Int8Array && this.byteOffset + this.position % t.BYTES_PER_ELEMENT === 0)
+        d.memcpy(
+          this._buffer,
+          this.byteOffset + this.position,
+          t.buffer,
+          0,
+          t.byteLength
+        ), this.mapInt8Array(t.length);
+      else
+        for (var e = 0; e < t.length; e++)
+          this.writeInt8(t[e]);
+    }, d.prototype.writeUint32Array = function(t, e) {
+      if (this._realloc(t.length * 4), t instanceof Uint32Array && this.byteOffset + this.position % t.BYTES_PER_ELEMENT === 0)
+        d.memcpy(
+          this._buffer,
+          this.byteOffset + this.position,
+          t.buffer,
+          0,
+          t.byteLength
+        ), this.mapUint32Array(t.length, e);
+      else
+        for (var r = 0; r < t.length; r++)
+          this.writeUint32(t[r], e);
+    }, d.prototype.writeUint16Array = function(t, e) {
+      if (this._realloc(t.length * 2), t instanceof Uint16Array && this.byteOffset + this.position % t.BYTES_PER_ELEMENT === 0)
+        d.memcpy(
+          this._buffer,
+          this.byteOffset + this.position,
+          t.buffer,
+          0,
+          t.byteLength
+        ), this.mapUint16Array(t.length, e);
+      else
+        for (var r = 0; r < t.length; r++)
+          this.writeUint16(t[r], e);
+    }, d.prototype.writeUint8Array = function(t) {
+      if (this._realloc(t.length * 1), t instanceof Uint8Array && this.byteOffset + this.position % t.BYTES_PER_ELEMENT === 0)
+        d.memcpy(
+          this._buffer,
+          this.byteOffset + this.position,
+          t.buffer,
+          0,
+          t.byteLength
+        ), this.mapUint8Array(t.length);
+      else
+        for (var e = 0; e < t.length; e++)
+          this.writeUint8(t[e]);
+    }, d.prototype.writeFloat64Array = function(t, e) {
+      if (this._realloc(t.length * 8), t instanceof Float64Array && this.byteOffset + this.position % t.BYTES_PER_ELEMENT === 0)
+        d.memcpy(
+          this._buffer,
+          this.byteOffset + this.position,
+          t.buffer,
+          0,
+          t.byteLength
+        ), this.mapFloat64Array(t.length, e);
+      else
+        for (var r = 0; r < t.length; r++)
+          this.writeFloat64(t[r], e);
+    }, d.prototype.writeFloat32Array = function(t, e) {
+      if (this._realloc(t.length * 4), t instanceof Float32Array && this.byteOffset + this.position % t.BYTES_PER_ELEMENT === 0)
+        d.memcpy(
+          this._buffer,
+          this.byteOffset + this.position,
+          t.buffer,
+          0,
+          t.byteLength
+        ), this.mapFloat32Array(t.length, e);
+      else
+        for (var r = 0; r < t.length; r++)
+          this.writeFloat32(t[r], e);
+    }, d.prototype.writeInt32 = function(t, e) {
+      this._realloc(4), this._dataView.setInt32(this.position, t, e ?? this.endianness), this.position += 4;
+    }, d.prototype.writeInt16 = function(t, e) {
+      this._realloc(2), this._dataView.setInt16(this.position, t, e ?? this.endianness), this.position += 2;
+    }, d.prototype.writeInt8 = function(t) {
+      this._realloc(1), this._dataView.setInt8(this.position, t), this.position += 1;
+    }, d.prototype.writeUint32 = function(t, e) {
+      this._realloc(4), this._dataView.setUint32(this.position, t, e ?? this.endianness), this.position += 4;
+    }, d.prototype.writeUint16 = function(t, e) {
+      this._realloc(2), this._dataView.setUint16(this.position, t, e ?? this.endianness), this.position += 2;
+    }, d.prototype.writeUint8 = function(t) {
+      this._realloc(1), this._dataView.setUint8(this.position, t), this.position += 1;
+    }, d.prototype.writeFloat32 = function(t, e) {
+      this._realloc(4), this._dataView.setFloat32(this.position, t, e ?? this.endianness), this.position += 4;
+    }, d.prototype.writeFloat64 = function(t, e) {
+      this._realloc(8), this._dataView.setFloat64(this.position, t, e ?? this.endianness), this.position += 8;
+    }, d.prototype.writeUCS2String = function(t, e, r) {
+      r == null && (r = t.length);
+      for (var n = 0; n < t.length && n < r; n++)
+        this.writeUint16(t.charCodeAt(n), e);
+      for (; n < r; n++)
+        this.writeUint16(0);
+    }, d.prototype.writeString = function(t, e, r) {
+      var n = 0;
+      if (e == null || e == "ASCII")
+        if (r != null) {
+          var o = Math.min(t.length, r);
+          for (n = 0; n < o; n++)
+            this.writeUint8(t.charCodeAt(n));
+          for (; n < r; n++)
+            this.writeUint8(0);
+        } else
+          for (n = 0; n < t.length; n++)
+            this.writeUint8(t.charCodeAt(n));
+      else
+        this.writeUint8Array(new TextEncoder(e).encode(t.substring(0, r)));
+    }, d.prototype.writeCString = function(t, e) {
+      var r = 0;
+      if (e != null) {
+        var n = Math.min(t.length, e);
+        for (r = 0; r < n; r++)
+          this.writeUint8(t.charCodeAt(r));
+        for (; r < e; r++)
+          this.writeUint8(0);
+      } else {
+        for (r = 0; r < t.length; r++)
+          this.writeUint8(t.charCodeAt(r));
+        this.writeUint8(0);
+      }
+    }, d.prototype.writeStruct = function(t, e) {
+      for (var r = 0; r < t.length; r += 2) {
+        var n = t[r + 1];
+        this.writeType(n, e[t[r]], e);
+      }
+    }, d.prototype.writeType = function(t, e, r) {
+      var n;
+      if (typeof t == "function")
+        return t(this, e);
+      if (typeof t == "object" && !(t instanceof Array))
+        return t.set(this, e, r);
+      var o = null, a = "ASCII", h = this.position;
+      switch (typeof t == "string" && /:/.test(t) && (n = t.split(":"), t = n[0], o = parseInt(n[1])), typeof t == "string" && /,/.test(t) && (n = t.split(","), t = n[0], a = parseInt(n[1])), t) {
+        case "uint8":
+          this.writeUint8(e);
+          break;
+        case "int8":
+          this.writeInt8(e);
+          break;
+        case "uint16":
+          this.writeUint16(e, this.endianness);
+          break;
+        case "int16":
+          this.writeInt16(e, this.endianness);
+          break;
+        case "uint32":
+          this.writeUint32(e, this.endianness);
+          break;
+        case "int32":
+          this.writeInt32(e, this.endianness);
+          break;
+        case "float32":
+          this.writeFloat32(e, this.endianness);
+          break;
+        case "float64":
+          this.writeFloat64(e, this.endianness);
+          break;
+        case "uint16be":
+          this.writeUint16(e, d.BIG_ENDIAN);
+          break;
+        case "int16be":
+          this.writeInt16(e, d.BIG_ENDIAN);
+          break;
+        case "uint32be":
+          this.writeUint32(e, d.BIG_ENDIAN);
+          break;
+        case "int32be":
+          this.writeInt32(e, d.BIG_ENDIAN);
+          break;
+        case "float32be":
+          this.writeFloat32(e, d.BIG_ENDIAN);
+          break;
+        case "float64be":
+          this.writeFloat64(e, d.BIG_ENDIAN);
+          break;
+        case "uint16le":
+          this.writeUint16(e, d.LITTLE_ENDIAN);
+          break;
+        case "int16le":
+          this.writeInt16(e, d.LITTLE_ENDIAN);
+          break;
+        case "uint32le":
+          this.writeUint32(e, d.LITTLE_ENDIAN);
+          break;
+        case "int32le":
+          this.writeInt32(e, d.LITTLE_ENDIAN);
+          break;
+        case "float32le":
+          this.writeFloat32(e, d.LITTLE_ENDIAN);
+          break;
+        case "float64le":
+          this.writeFloat64(e, d.LITTLE_ENDIAN);
+          break;
+        case "cstring":
+          this.writeCString(e, o);
+          break;
+        case "string":
+          this.writeString(e, a, o);
+          break;
+        case "u16string":
+          this.writeUCS2String(e, this.endianness, o);
+          break;
+        case "u16stringle":
+          this.writeUCS2String(e, d.LITTLE_ENDIAN, o);
+          break;
+        case "u16stringbe":
+          this.writeUCS2String(e, d.BIG_ENDIAN, o);
+          break;
+        default:
+          if (t.length == 3) {
+            for (var f = t[1], p = 0; p < e.length; p++)
+              this.writeType(f, e[p]);
+            break;
+          } else {
+            this.writeStruct(t, e);
+            break;
+          }
+      }
+      o != null && (this.position = h, this._realloc(o), this.position = h + o);
+    }, d.prototype.writeUint64 = function(t) {
+      var e = Math.floor(t / b);
+      this.writeUint32(e), this.writeUint32(t & 4294967295);
+    }, d.prototype.writeUint24 = function(t) {
+      this.writeUint8((t & 16711680) >> 16), this.writeUint8((t & 65280) >> 8), this.writeUint8(t & 255);
+    }, d.prototype.adjustUint32 = function(t, e) {
+      var r = this.position;
+      this.seek(t), this.writeUint32(e), this.seek(r);
+    }, d.prototype.mapInt32Array = function(t, e) {
+      this._realloc(t * 4);
+      var r = new Int32Array(this._buffer, this.byteOffset + this.position, t);
+      return d.arrayToNative(r, e ?? this.endianness), this.position += t * 4, r;
+    }, d.prototype.mapInt16Array = function(t, e) {
+      this._realloc(t * 2);
+      var r = new Int16Array(this._buffer, this.byteOffset + this.position, t);
+      return d.arrayToNative(r, e ?? this.endianness), this.position += t * 2, r;
+    }, d.prototype.mapInt8Array = function(t) {
+      this._realloc(t * 1);
+      var e = new Int8Array(this._buffer, this.byteOffset + this.position, t);
+      return this.position += t * 1, e;
+    }, d.prototype.mapUint32Array = function(t, e) {
+      this._realloc(t * 4);
+      var r = new Uint32Array(this._buffer, this.byteOffset + this.position, t);
+      return d.arrayToNative(r, e ?? this.endianness), this.position += t * 4, r;
+    }, d.prototype.mapUint16Array = function(t, e) {
+      this._realloc(t * 2);
+      var r = new Uint16Array(this._buffer, this.byteOffset + this.position, t);
+      return d.arrayToNative(r, e ?? this.endianness), this.position += t * 2, r;
+    }, d.prototype.mapFloat64Array = function(t, e) {
+      this._realloc(t * 8);
+      var r = new Float64Array(this._buffer, this.byteOffset + this.position, t);
+      return d.arrayToNative(r, e ?? this.endianness), this.position += t * 8, r;
+    }, d.prototype.mapFloat32Array = function(t, e) {
+      this._realloc(t * 4);
+      var r = new Float32Array(this._buffer, this.byteOffset + this.position, t);
+      return d.arrayToNative(r, e ?? this.endianness), this.position += t * 4, r;
+    };
+    var S = function(t) {
+      this.buffers = [], this.bufferIndex = -1, t && (this.insertBuffer(t), this.bufferIndex = 0);
+    };
+    S.prototype = new d(new ArrayBuffer(), 0, d.BIG_ENDIAN), S.prototype.initialized = function() {
+      var t;
+      return this.bufferIndex > -1 ? !0 : this.buffers.length > 0 ? (t = this.buffers[0], t.fileStart === 0 ? (this.buffer = t, this.bufferIndex = 0, l.debug("MultiBufferStream", "Stream ready for parsing"), !0) : (l.warn("MultiBufferStream", "The first buffer should have a fileStart of 0"), this.logBufferLevel(), !1)) : (l.warn("MultiBufferStream", "No buffer to start parsing from"), this.logBufferLevel(), !1);
+    }, ArrayBuffer.concat = function(t, e) {
+      l.debug("ArrayBuffer", "Trying to create a new buffer of size: " + (t.byteLength + e.byteLength));
+      var r = new Uint8Array(t.byteLength + e.byteLength);
+      return r.set(new Uint8Array(t), 0), r.set(new Uint8Array(e), t.byteLength), r.buffer;
+    }, S.prototype.reduceBuffer = function(t, e, r) {
+      var n;
+      return n = new Uint8Array(r), n.set(new Uint8Array(t, e, r)), n.buffer.fileStart = t.fileStart + e, n.buffer.usedBytes = 0, n.buffer;
+    }, S.prototype.insertBuffer = function(t) {
+      for (var e = !0, r = 0; r < this.buffers.length; r++) {
+        var n = this.buffers[r];
+        if (t.fileStart <= n.fileStart) {
+          if (t.fileStart === n.fileStart)
+            if (t.byteLength > n.byteLength) {
+              this.buffers.splice(r, 1), r--;
+              continue;
+            } else
+              l.warn("MultiBufferStream", "Buffer (fileStart: " + t.fileStart + " - Length: " + t.byteLength + ") already appended, ignoring");
+          else
+            t.fileStart + t.byteLength <= n.fileStart || (t = this.reduceBuffer(t, 0, n.fileStart - t.fileStart)), l.debug("MultiBufferStream", "Appending new buffer (fileStart: " + t.fileStart + " - Length: " + t.byteLength + ")"), this.buffers.splice(r, 0, t), r === 0 && (this.buffer = t);
+          e = !1;
+          break;
+        } else if (t.fileStart < n.fileStart + n.byteLength) {
+          var o = n.fileStart + n.byteLength - t.fileStart, a = t.byteLength - o;
+          if (a > 0)
+            t = this.reduceBuffer(t, o, a);
+          else {
+            e = !1;
+            break;
+          }
+        }
+      }
+      e && (l.debug("MultiBufferStream", "Appending new buffer (fileStart: " + t.fileStart + " - Length: " + t.byteLength + ")"), this.buffers.push(t), r === 0 && (this.buffer = t));
+    }, S.prototype.logBufferLevel = function(t) {
+      var e, r, n, o, a = [], h, f = "";
+      for (n = 0, o = 0, e = 0; e < this.buffers.length; e++)
+        r = this.buffers[e], e === 0 ? (h = {}, a.push(h), h.start = r.fileStart, h.end = r.fileStart + r.byteLength, f += "[" + h.start + "-") : h.end === r.fileStart ? h.end = r.fileStart + r.byteLength : (h = {}, h.start = r.fileStart, f += a[a.length - 1].end - 1 + "], [" + h.start + "-", h.end = r.fileStart + r.byteLength, a.push(h)), n += r.usedBytes, o += r.byteLength;
+      a.length > 0 && (f += h.end - 1 + "]");
+      var p = t ? l.info : l.debug;
+      this.buffers.length === 0 ? p("MultiBufferStream", "No more buffer in memory") : p("MultiBufferStream", "" + this.buffers.length + " stored buffer(s) (" + n + "/" + o + " bytes), continuous ranges: " + f);
+    }, S.prototype.cleanBuffers = function() {
+      var t, e;
+      for (t = 0; t < this.buffers.length; t++)
+        e = this.buffers[t], e.usedBytes === e.byteLength && (l.debug("MultiBufferStream", "Removing buffer #" + t), this.buffers.splice(t, 1), t--);
+    }, S.prototype.mergeNextBuffer = function() {
+      var t;
+      if (this.bufferIndex + 1 < this.buffers.length)
+        if (t = this.buffers[this.bufferIndex + 1], t.fileStart === this.buffer.fileStart + this.buffer.byteLength) {
+          var e = this.buffer.byteLength, r = this.buffer.usedBytes, n = this.buffer.fileStart;
+          return this.buffers[this.bufferIndex] = ArrayBuffer.concat(this.buffer, t), this.buffer = this.buffers[this.bufferIndex], this.buffers.splice(this.bufferIndex + 1, 1), this.buffer.usedBytes = r, this.buffer.fileStart = n, l.debug("ISOFile", "Concatenating buffer for box parsing (length: " + e + "->" + this.buffer.byteLength + ")"), !0;
+        } else
+          return !1;
+      else
+        return !1;
+    }, S.prototype.findPosition = function(t, e, r) {
+      var n, o = null, a = -1;
+      for (t === !0 ? n = 0 : n = this.bufferIndex; n < this.buffers.length && (o = this.buffers[n], o.fileStart <= e); ) {
+        a = n, r && (o.fileStart + o.byteLength <= e ? o.usedBytes = o.byteLength : o.usedBytes = e - o.fileStart, this.logBufferLevel());
+        n++;
+      }
+      return a !== -1 ? (o = this.buffers[a], o.fileStart + o.byteLength >= e ? (l.debug("MultiBufferStream", "Found position in existing buffer #" + a), a) : -1) : -1;
+    }, S.prototype.findEndContiguousBuf = function(t) {
+      var e, r, n, o = t !== void 0 ? t : this.bufferIndex;
+      if (r = this.buffers[o], this.buffers.length > o + 1)
+        for (e = o + 1; e < this.buffers.length && (n = this.buffers[e], n.fileStart === r.fileStart + r.byteLength); e++)
+          r = n;
+      return r.fileStart + r.byteLength;
+    }, S.prototype.getEndFilePositionAfter = function(t) {
+      var e = this.findPosition(!0, t, !1);
+      return e !== -1 ? this.findEndContiguousBuf(e) : t;
+    }, S.prototype.addUsedBytes = function(t) {
+      this.buffer.usedBytes += t, this.logBufferLevel();
+    }, S.prototype.setAllUsedBytes = function() {
+      this.buffer.usedBytes = this.buffer.byteLength, this.logBufferLevel();
+    }, S.prototype.seek = function(t, e, r) {
+      var n;
+      return n = this.findPosition(e, t, r), n !== -1 ? (this.buffer = this.buffers[n], this.bufferIndex = n, this.position = t - this.buffer.fileStart, l.debug("MultiBufferStream", "Repositioning parser at buffer position: " + this.position), !0) : (l.debug("MultiBufferStream", "Position " + t + " not found in buffered data"), !1);
+    }, S.prototype.getPosition = function() {
+      if (this.bufferIndex === -1 || this.buffers[this.bufferIndex] === null)
+        throw "Error accessing position in the MultiBufferStream";
+      return this.buffers[this.bufferIndex].fileStart + this.position;
+    }, S.prototype.getLength = function() {
+      return this.byteLength;
+    }, S.prototype.getEndPosition = function() {
+      if (this.bufferIndex === -1 || this.buffers[this.bufferIndex] === null)
+        throw "Error accessing position in the MultiBufferStream";
+      return this.buffers[this.bufferIndex].fileStart + this.byteLength;
+    }, v.MultiBufferStream = S;
+    var B = function() {
+      var t = 3, e = 4, r = 5, n = 6, o = [];
+      o[t] = "ES_Descriptor", o[e] = "DecoderConfigDescriptor", o[r] = "DecoderSpecificInfo", o[n] = "SLConfigDescriptor", this.getDescriptorName = function(f) {
+        return o[f];
+      };
+      var a = this, h = {};
+      return this.parseOneDescriptor = function(f) {
+        var p = 0, u, c, g;
+        for (u = f.readUint8(), g = f.readUint8(); g & 128; )
+          p = (p << 7) + (g & 127), g = f.readUint8();
+        return p = (p << 7) + (g & 127), l.debug("MPEG4DescriptorParser", "Found " + (o[u] || "Descriptor " + u) + ", size " + p + " at position " + f.getPosition()), o[u] ? c = new h[o[u]](p) : c = new h.Descriptor(p), c.parse(f), c;
+      }, h.Descriptor = function(f, p) {
+        this.tag = f, this.size = p, this.descs = [];
+      }, h.Descriptor.prototype.parse = function(f) {
+        this.data = f.readUint8Array(this.size);
+      }, h.Descriptor.prototype.findDescriptor = function(f) {
+        for (var p = 0; p < this.descs.length; p++)
+          if (this.descs[p].tag == f)
+            return this.descs[p];
+        return null;
+      }, h.Descriptor.prototype.parseRemainingDescriptors = function(f) {
+        for (var p = f.position; f.position < p + this.size; ) {
+          var u = a.parseOneDescriptor(f);
+          this.descs.push(u);
+        }
+      }, h.ES_Descriptor = function(f) {
+        h.Descriptor.call(this, t, f);
+      }, h.ES_Descriptor.prototype = new h.Descriptor(), h.ES_Descriptor.prototype.parse = function(f) {
+        if (this.ES_ID = f.readUint16(), this.flags = f.readUint8(), this.size -= 3, this.flags & 128 ? (this.dependsOn_ES_ID = f.readUint16(), this.size -= 2) : this.dependsOn_ES_ID = 0, this.flags & 64) {
+          var p = f.readUint8();
+          this.URL = f.readString(p), this.size -= p + 1;
+        } else
+          this.URL = "";
+        this.flags & 32 ? (this.OCR_ES_ID = f.readUint16(), this.size -= 2) : this.OCR_ES_ID = 0, this.parseRemainingDescriptors(f);
+      }, h.ES_Descriptor.prototype.getOTI = function(f) {
+        var p = this.findDescriptor(e);
+        return p ? p.oti : 0;
+      }, h.ES_Descriptor.prototype.getAudioConfig = function(f) {
+        var p = this.findDescriptor(e);
+        if (!p) return null;
+        var u = p.findDescriptor(r);
+        if (u && u.data) {
+          var c = (u.data[0] & 248) >> 3;
+          return c === 31 && u.data.length >= 2 && (c = 32 + ((u.data[0] & 7) << 3) + ((u.data[1] & 224) >> 5)), c;
+        } else
+          return null;
+      }, h.DecoderConfigDescriptor = function(f) {
+        h.Descriptor.call(this, e, f);
+      }, h.DecoderConfigDescriptor.prototype = new h.Descriptor(), h.DecoderConfigDescriptor.prototype.parse = function(f) {
+        this.oti = f.readUint8(), this.streamType = f.readUint8(), this.upStream = (this.streamType >> 1 & 1) !== 0, this.streamType = this.streamType >>> 2, this.bufferSize = f.readUint24(), this.maxBitrate = f.readUint32(), this.avgBitrate = f.readUint32(), this.size -= 13, this.parseRemainingDescriptors(f);
+      }, h.DecoderSpecificInfo = function(f) {
+        h.Descriptor.call(this, r, f);
+      }, h.DecoderSpecificInfo.prototype = new h.Descriptor(), h.SLConfigDescriptor = function(f) {
+        h.Descriptor.call(this, n, f);
+      }, h.SLConfigDescriptor.prototype = new h.Descriptor(), this;
+    };
+    v.MPEG4DescriptorParser = B;
+    var s = {
+      ERR_INVALID_DATA: -1,
+      ERR_NOT_ENOUGH_DATA: 0,
+      OK: 1,
+      // Boxes to be created with default parsing
+      BASIC_BOXES: [
+        { type: "mdat", name: "MediaDataBox" },
+        { type: "idat", name: "ItemDataBox" },
+        { type: "free", name: "FreeSpaceBox" },
+        { type: "skip", name: "FreeSpaceBox" },
+        { type: "meco", name: "AdditionalMetadataContainerBox" },
+        { type: "strk", name: "SubTrackBox" }
+      ],
+      FULL_BOXES: [
+        { type: "hmhd", name: "HintMediaHeaderBox" },
+        { type: "nmhd", name: "NullMediaHeaderBox" },
+        { type: "iods", name: "ObjectDescriptorBox" },
+        { type: "xml ", name: "XMLBox" },
+        { type: "bxml", name: "BinaryXMLBox" },
+        { type: "ipro", name: "ItemProtectionBox" },
+        { type: "mere", name: "MetaboxRelationBox" }
+      ],
+      CONTAINER_BOXES: [
+        [{ type: "moov", name: "CompressedMovieBox" }, ["trak", "pssh"]],
+        [{ type: "trak", name: "TrackBox" }],
+        [{ type: "edts", name: "EditBox" }],
+        [{ type: "mdia", name: "MediaBox" }],
+        [{ type: "minf", name: "MediaInformationBox" }],
+        [{ type: "dinf", name: "DataInformationBox" }],
+        [{ type: "stbl", name: "SampleTableBox" }, ["sgpd", "sbgp"]],
+        [{ type: "mvex", name: "MovieExtendsBox" }, ["trex"]],
+        [{ type: "moof", name: "CompressedMovieFragmentBox" }, ["traf"]],
+        [{ type: "traf", name: "TrackFragmentBox" }, ["trun", "sgpd", "sbgp"]],
+        [{ type: "vttc", name: "VTTCueBox" }],
+        [{ type: "tref", name: "TrackReferenceBox" }],
+        [{ type: "iref", name: "ItemReferenceBox" }],
+        [{ type: "mfra", name: "MovieFragmentRandomAccessBox" }, ["tfra"]],
+        [{ type: "meco", name: "AdditionalMetadataContainerBox" }],
+        [{ type: "hnti", name: "trackhintinformation" }],
+        [{ type: "hinf", name: "hintstatisticsbox" }],
+        [{ type: "strk", name: "SubTrackBox" }],
+        [{ type: "strd", name: "SubTrackDefinitionBox" }],
+        [{ type: "sinf", name: "ProtectionSchemeInfoBox" }],
+        [{ type: "rinf", name: "RestrictedSchemeInfoBox" }],
+        [{ type: "schi", name: "SchemeInformationBox" }],
+        [{ type: "trgr", name: "TrackGroupBox" }],
+        [{ type: "udta", name: "UserDataBox" }, ["kind"]],
+        [{ type: "iprp", name: "ItemPropertiesBox" }, ["ipma"]],
+        [{ type: "ipco", name: "ItemPropertyContainerBox" }],
+        [{ type: "grpl", name: "GroupsListBox" }],
+        [{ type: "j2kH", name: "J2KHeaderInfoBox" }],
+        [{ type: "etyp", name: "ExtendedTypeBox" }, ["tyco"]]
+      ],
+      // Boxes effectively created
+      boxCodes: [],
+      fullBoxCodes: [],
+      containerBoxCodes: [],
+      sampleEntryCodes: {},
+      sampleGroupEntryCodes: [],
+      trackGroupTypes: [],
+      UUIDBoxes: {},
+      UUIDs: [],
+      initialize: function() {
+        s.FullBox.prototype = new s.Box(), s.ContainerBox.prototype = new s.Box(), s.SampleEntry.prototype = new s.Box(), s.TrackGroupTypeBox.prototype = new s.FullBox(), s.BASIC_BOXES.forEach(function(t) {
+          s.createBoxCtor(t.type, t.name);
+        }), s.FULL_BOXES.forEach(function(t) {
+          s.createFullBoxCtor(t.type, t.name);
+        }), s.CONTAINER_BOXES.forEach(function(t) {
+          s.createContainerBoxCtor(t[0].type, t[0].name, null, t[1]);
+        });
+      },
+      Box: function(t, e, r, n) {
+        this.type = t, this.box_name = r, this.size = e, this.uuid = n;
+      },
+      FullBox: function(t, e, r, n) {
+        s.Box.call(this, t, e, r, n), this.flags = 0, this.version = 0;
+      },
+      ContainerBox: function(t, e, r, n) {
+        s.Box.call(this, t, e, r, n), this.boxes = [];
+      },
+      SampleEntry: function(t, e, r, n) {
+        s.ContainerBox.call(this, t, e), this.hdr_size = r, this.start = n;
+      },
+      SampleGroupEntry: function(t) {
+        this.grouping_type = t;
+      },
+      TrackGroupTypeBox: function(t, e) {
+        s.FullBox.call(this, t, e);
+      },
+      createBoxCtor: function(t, e, r) {
+        s.boxCodes.push(t), s[t + "Box"] = function(n) {
+          s.Box.call(this, t, n, e);
+        }, s[t + "Box"].prototype = new s.Box(), r && (s[t + "Box"].prototype.parse = r);
+      },
+      createFullBoxCtor: function(t, e, r) {
+        s[t + "Box"] = function(n) {
+          s.FullBox.call(this, t, n, e);
+        }, s[t + "Box"].prototype = new s.FullBox(), s[t + "Box"].prototype.parse = function(n) {
+          this.parseFullHeader(n), r && r.call(this, n);
+        };
+      },
+      addSubBoxArrays: function(t) {
+        if (t) {
+          this.subBoxNames = t;
+          for (var e = t.length, r = 0; r < e; r++)
+            this[t[r] + "s"] = [];
+        }
+      },
+      createContainerBoxCtor: function(t, e, r, n) {
+        s[t + "Box"] = function(o) {
+          s.ContainerBox.call(this, t, o, e), s.addSubBoxArrays.call(this, n);
+        }, s[t + "Box"].prototype = new s.ContainerBox(), r && (s[t + "Box"].prototype.parse = r);
+      },
+      createMediaSampleEntryCtor: function(t, e, r) {
+        s.sampleEntryCodes[t] = [], s[t + "SampleEntry"] = function(n, o) {
+          s.SampleEntry.call(this, n, o), s.addSubBoxArrays.call(this, r);
+        }, s[t + "SampleEntry"].prototype = new s.SampleEntry(), e && (s[t + "SampleEntry"].prototype.parse = e);
+      },
+      createSampleEntryCtor: function(t, e, r, n) {
+        s.sampleEntryCodes[t].push(e), s[e + "SampleEntry"] = function(o) {
+          s[t + "SampleEntry"].call(this, e, o), s.addSubBoxArrays.call(this, n);
+        }, s[e + "SampleEntry"].prototype = new s[t + "SampleEntry"](), r && (s[e + "SampleEntry"].prototype.parse = r);
+      },
+      createEncryptedSampleEntryCtor: function(t, e, r) {
+        s.createSampleEntryCtor.call(this, t, e, r, ["sinf"]);
+      },
+      createSampleGroupCtor: function(t, e) {
+        s[t + "SampleGroupEntry"] = function(r) {
+          s.SampleGroupEntry.call(this, t, r);
+        }, s[t + "SampleGroupEntry"].prototype = new s.SampleGroupEntry(), e && (s[t + "SampleGroupEntry"].prototype.parse = e);
+      },
+      createTrackGroupCtor: function(t, e) {
+        s[t + "TrackGroupTypeBox"] = function(r) {
+          s.TrackGroupTypeBox.call(this, t, r);
+        }, s[t + "TrackGroupTypeBox"].prototype = new s.TrackGroupTypeBox(), e && (s[t + "TrackGroupTypeBox"].prototype.parse = e);
+      },
+      createUUIDBox: function(t, e, r, n, o) {
+        s.UUIDs.push(t), s.UUIDBoxes[t] = function(a) {
+          r ? s.FullBox.call(this, "uuid", a, e, t) : n ? s.ContainerBox.call(this, "uuid", a, e, t) : s.Box.call(this, "uuid", a, e, t);
+        }, s.UUIDBoxes[t].prototype = r ? new s.FullBox() : n ? new s.ContainerBox() : new s.Box(), o && (r ? s.UUIDBoxes[t].prototype.parse = function(a) {
+          this.parseFullHeader(a), o && o.call(this, a);
+        } : s.UUIDBoxes[t].prototype.parse = o);
+      }
+    };
+    s.initialize(), s.TKHD_FLAG_ENABLED = 1, s.TKHD_FLAG_IN_MOVIE = 2, s.TKHD_FLAG_IN_PREVIEW = 4, s.TFHD_FLAG_BASE_DATA_OFFSET = 1, s.TFHD_FLAG_SAMPLE_DESC = 2, s.TFHD_FLAG_SAMPLE_DUR = 8, s.TFHD_FLAG_SAMPLE_SIZE = 16, s.TFHD_FLAG_SAMPLE_FLAGS = 32, s.TFHD_FLAG_DUR_EMPTY = 65536, s.TFHD_FLAG_DEFAULT_BASE_IS_MOOF = 131072, s.TRUN_FLAGS_DATA_OFFSET = 1, s.TRUN_FLAGS_FIRST_FLAG = 4, s.TRUN_FLAGS_DURATION = 256, s.TRUN_FLAGS_SIZE = 512, s.TRUN_FLAGS_FLAGS = 1024, s.TRUN_FLAGS_CTS_OFFSET = 2048, s.Box.prototype.add = function(t) {
+      return this.addBox(new s[t + "Box"]());
+    }, s.Box.prototype.addBox = function(t) {
+      return this.boxes.push(t), this[t.type + "s"] ? this[t.type + "s"].push(t) : this[t.type] = t, t;
+    }, s.Box.prototype.set = function(t, e) {
+      return this[t] = e, this;
+    }, s.Box.prototype.addEntry = function(t, e) {
+      var r = e || "entries";
+      return this[r] || (this[r] = []), this[r].push(t), this;
+    }, v.BoxParser = s, s.parseUUID = function(t) {
+      return s.parseHex16(t);
+    }, s.parseHex16 = function(t) {
+      for (var e = "", r = 0; r < 16; r++) {
+        var n = t.readUint8().toString(16);
+        e += n.length === 1 ? "0" + n : n;
+      }
+      return e;
+    }, s.parseOneBox = function(t, e, r) {
+      var n, o = t.getPosition(), a = 0, h, f;
+      if (t.getEndPosition() - o < 8)
+        return l.debug("BoxParser", "Not enough data in stream to parse the type and size of the box"), { code: s.ERR_NOT_ENOUGH_DATA };
+      if (r && r < 8)
+        return l.debug("BoxParser", "Not enough bytes left in the parent box to parse a new box"), { code: s.ERR_NOT_ENOUGH_DATA };
+      var p = t.readUint32(), u = t.readString(4), c = u;
+      if (l.debug("BoxParser", "Found box of type '" + u + "' and size " + p + " at position " + o), a = 8, u == "uuid") {
+        if (t.getEndPosition() - t.getPosition() < 16 || r - a < 16)
+          return t.seek(o), l.debug("BoxParser", "Not enough bytes left in the parent box to parse a UUID box"), { code: s.ERR_NOT_ENOUGH_DATA };
+        f = s.parseUUID(t), a += 16, c = f;
+      }
+      if (p == 1) {
+        if (t.getEndPosition() - t.getPosition() < 8 || r && r - a < 8)
+          return t.seek(o), l.warn("BoxParser", 'Not enough data in stream to parse the extended size of the "' + u + '" box'), { code: s.ERR_NOT_ENOUGH_DATA };
+        p = t.readUint64(), a += 8;
+      } else if (p === 0) {
+        if (r)
+          p = r;
+        else if (u !== "mdat")
+          return l.error("BoxParser", "Unlimited box size not supported for type: '" + u + "'"), n = new s.Box(u, p), { code: s.OK, box: n, size: n.size };
+      }
+      return p !== 0 && p < a ? (l.error("BoxParser", "Box of type " + u + " has an invalid size " + p + " (too small to be a box)"), { code: s.ERR_NOT_ENOUGH_DATA, type: u, size: p, hdr_size: a, start: o }) : p !== 0 && r && p > r ? (l.error("BoxParser", "Box of type '" + u + "' has a size " + p + " greater than its container size " + r), { code: s.ERR_NOT_ENOUGH_DATA, type: u, size: p, hdr_size: a, start: o }) : p !== 0 && o + p > t.getEndPosition() ? (t.seek(o), l.info("BoxParser", "Not enough data in stream to parse the entire '" + u + "' box"), { code: s.ERR_NOT_ENOUGH_DATA, type: u, size: p, hdr_size: a, start: o }) : e ? { code: s.OK, type: u, size: p, hdr_size: a, start: o } : (s[u + "Box"] ? n = new s[u + "Box"](p) : u !== "uuid" ? (l.warn("BoxParser", "Unknown box type: '" + u + "'"), n = new s.Box(u, p), n.has_unparsed_data = !0) : s.UUIDBoxes[f] ? n = new s.UUIDBoxes[f](p) : (l.warn("BoxParser", "Unknown uuid type: '" + f + "'"), n = new s.Box(u, p), n.uuid = f, n.has_unparsed_data = !0), n.hdr_size = a, n.start = o, n.write === s.Box.prototype.write && n.type !== "mdat" && (l.info("BoxParser", "'" + c + "' box writing not yet implemented, keeping unparsed data in memory for later write"), n.parseDataAndRewind(t)), n.parse(t), h = t.getPosition() - (n.start + n.size), h < 0 ? (l.warn("BoxParser", "Parsing of box '" + c + "' did not read the entire indicated box data size (missing " + -h + " bytes), seeking forward"), t.seek(n.start + n.size)) : h > 0 && (l.error("BoxParser", "Parsing of box '" + c + "' read " + h + " more bytes than the indicated box data size, seeking backwards"), n.size !== 0 && t.seek(n.start + n.size)), { code: s.OK, box: n, size: n.size });
+    }, s.Box.prototype.parse = function(t) {
+      this.type != "mdat" ? this.data = t.readUint8Array(this.size - this.hdr_size) : this.size === 0 ? t.seek(t.getEndPosition()) : t.seek(this.start + this.size);
+    }, s.Box.prototype.parseDataAndRewind = function(t) {
+      this.data = t.readUint8Array(this.size - this.hdr_size), t.position -= this.size - this.hdr_size;
+    }, s.FullBox.prototype.parseDataAndRewind = function(t) {
+      this.parseFullHeader(t), this.data = t.readUint8Array(this.size - this.hdr_size), this.hdr_size -= 4, t.position -= this.size - this.hdr_size;
+    }, s.FullBox.prototype.parseFullHeader = function(t) {
+      this.version = t.readUint8(), this.flags = t.readUint24(), this.hdr_size += 4;
+    }, s.FullBox.prototype.parse = function(t) {
+      this.parseFullHeader(t), this.data = t.readUint8Array(this.size - this.hdr_size);
+    }, s.ContainerBox.prototype.parse = function(t) {
+      for (var e, r; t.getPosition() < this.start + this.size; )
+        if (e = s.parseOneBox(t, !1, this.size - (t.getPosition() - this.start)), e.code === s.OK)
+          if (r = e.box, this.boxes.push(r), this.subBoxNames && this.subBoxNames.indexOf(r.type) != -1)
+            this[this.subBoxNames[this.subBoxNames.indexOf(r.type)] + "s"].push(r);
+          else {
+            var n = r.type !== "uuid" ? r.type : r.uuid;
+            this[n] ? l.warn("Box of type " + n + " already stored in field of this type") : this[n] = r;
+          }
+        else
+          return;
+    }, s.Box.prototype.parseLanguage = function(t) {
+      this.language = t.readUint16();
+      var e = [];
+      e[0] = this.language >> 10 & 31, e[1] = this.language >> 5 & 31, e[2] = this.language & 31, this.languageString = String.fromCharCode(e[0] + 96, e[1] + 96, e[2] + 96);
+    }, s.SAMPLE_ENTRY_TYPE_VISUAL = "Visual", s.SAMPLE_ENTRY_TYPE_AUDIO = "Audio", s.SAMPLE_ENTRY_TYPE_HINT = "Hint", s.SAMPLE_ENTRY_TYPE_METADATA = "Metadata", s.SAMPLE_ENTRY_TYPE_SUBTITLE = "Subtitle", s.SAMPLE_ENTRY_TYPE_SYSTEM = "System", s.SAMPLE_ENTRY_TYPE_TEXT = "Text", s.SampleEntry.prototype.parseHeader = function(t) {
+      t.readUint8Array(6), this.data_reference_index = t.readUint16(), this.hdr_size += 8;
+    }, s.SampleEntry.prototype.parse = function(t) {
+      this.parseHeader(t), this.data = t.readUint8Array(this.size - this.hdr_size);
+    }, s.SampleEntry.prototype.parseDataAndRewind = function(t) {
+      this.parseHeader(t), this.data = t.readUint8Array(this.size - this.hdr_size), this.hdr_size -= 8, t.position -= this.size - this.hdr_size;
+    }, s.SampleEntry.prototype.parseFooter = function(t) {
+      s.ContainerBox.prototype.parse.call(this, t);
+    }, s.createMediaSampleEntryCtor(s.SAMPLE_ENTRY_TYPE_HINT), s.createMediaSampleEntryCtor(s.SAMPLE_ENTRY_TYPE_METADATA), s.createMediaSampleEntryCtor(s.SAMPLE_ENTRY_TYPE_SUBTITLE), s.createMediaSampleEntryCtor(s.SAMPLE_ENTRY_TYPE_SYSTEM), s.createMediaSampleEntryCtor(s.SAMPLE_ENTRY_TYPE_TEXT), s.createMediaSampleEntryCtor(s.SAMPLE_ENTRY_TYPE_VISUAL, function(t) {
+      var e;
+      this.parseHeader(t), t.readUint16(), t.readUint16(), t.readUint32Array(3), this.width = t.readUint16(), this.height = t.readUint16(), this.horizresolution = t.readUint32(), this.vertresolution = t.readUint32(), t.readUint32(), this.frame_count = t.readUint16(), e = Math.min(31, t.readUint8()), this.compressorname = t.readString(e), e < 31 && t.readString(31 - e), this.depth = t.readUint16(), t.readUint16(), this.parseFooter(t);
+    }), s.createMediaSampleEntryCtor(s.SAMPLE_ENTRY_TYPE_AUDIO, function(t) {
+      this.parseHeader(t), t.readUint32Array(2), this.channel_count = t.readUint16(), this.samplesize = t.readUint16(), t.readUint16(), t.readUint16(), this.samplerate = t.readUint32() / 65536, this.parseFooter(t);
+    }), s.createSampleEntryCtor(s.SAMPLE_ENTRY_TYPE_VISUAL, "avc1"), s.createSampleEntryCtor(s.SAMPLE_ENTRY_TYPE_VISUAL, "avc2"), s.createSampleEntryCtor(s.SAMPLE_ENTRY_TYPE_VISUAL, "avc3"), s.createSampleEntryCtor(s.SAMPLE_ENTRY_TYPE_VISUAL, "avc4"), s.createSampleEntryCtor(s.SAMPLE_ENTRY_TYPE_VISUAL, "av01"), s.createSampleEntryCtor(s.SAMPLE_ENTRY_TYPE_VISUAL, "dav1"), s.createSampleEntryCtor(s.SAMPLE_ENTRY_TYPE_VISUAL, "hvc1"), s.createSampleEntryCtor(s.SAMPLE_ENTRY_TYPE_VISUAL, "hev1"), s.createSampleEntryCtor(s.SAMPLE_ENTRY_TYPE_VISUAL, "hvt1"), s.createSampleEntryCtor(s.SAMPLE_ENTRY_TYPE_VISUAL, "lhe1"), s.createSampleEntryCtor(s.SAMPLE_ENTRY_TYPE_VISUAL, "dvh1"), s.createSampleEntryCtor(s.SAMPLE_ENTRY_TYPE_VISUAL, "dvhe"), s.createSampleEntryCtor(s.SAMPLE_ENTRY_TYPE_VISUAL, "vvc1"), s.createSampleEntryCtor(s.SAMPLE_ENTRY_TYPE_VISUAL, "vvi1"), s.createSampleEntryCtor(s.SAMPLE_ENTRY_TYPE_VISUAL, "vvs1"), s.createSampleEntryCtor(s.SAMPLE_ENTRY_TYPE_VISUAL, "vvcN"), s.createSampleEntryCtor(s.SAMPLE_ENTRY_TYPE_VISUAL, "vp08"), s.createSampleEntryCtor(s.SAMPLE_ENTRY_TYPE_VISUAL, "vp09"), s.createSampleEntryCtor(s.SAMPLE_ENTRY_TYPE_VISUAL, "avs3"), s.createSampleEntryCtor(s.SAMPLE_ENTRY_TYPE_VISUAL, "j2ki"), s.createSampleEntryCtor(s.SAMPLE_ENTRY_TYPE_VISUAL, "mjp2"), s.createSampleEntryCtor(s.SAMPLE_ENTRY_TYPE_VISUAL, "mjpg"), s.createSampleEntryCtor(s.SAMPLE_ENTRY_TYPE_VISUAL, "uncv"), s.createSampleEntryCtor(s.SAMPLE_ENTRY_TYPE_AUDIO, "mp4a"), s.createSampleEntryCtor(s.SAMPLE_ENTRY_TYPE_AUDIO, "ac-3"), s.createSampleEntryCtor(s.SAMPLE_ENTRY_TYPE_AUDIO, "ac-4"), s.createSampleEntryCtor(s.SAMPLE_ENTRY_TYPE_AUDIO, "ec-3"), s.createSampleEntryCtor(s.SAMPLE_ENTRY_TYPE_AUDIO, "Opus"), s.createSampleEntryCtor(s.SAMPLE_ENTRY_TYPE_AUDIO, "mha1"), s.createSampleEntryCtor(s.SAMPLE_ENTRY_TYPE_AUDIO, "mha2"), s.createSampleEntryCtor(s.SAMPLE_ENTRY_TYPE_AUDIO, "mhm1"), s.createSampleEntryCtor(s.SAMPLE_ENTRY_TYPE_AUDIO, "mhm2"), s.createSampleEntryCtor(s.SAMPLE_ENTRY_TYPE_AUDIO, "fLaC"), s.createEncryptedSampleEntryCtor(s.SAMPLE_ENTRY_TYPE_VISUAL, "encv"), s.createEncryptedSampleEntryCtor(s.SAMPLE_ENTRY_TYPE_AUDIO, "enca"), s.createEncryptedSampleEntryCtor(s.SAMPLE_ENTRY_TYPE_SUBTITLE, "encu"), s.createEncryptedSampleEntryCtor(s.SAMPLE_ENTRY_TYPE_SYSTEM, "encs"), s.createEncryptedSampleEntryCtor(s.SAMPLE_ENTRY_TYPE_TEXT, "enct"), s.createEncryptedSampleEntryCtor(s.SAMPLE_ENTRY_TYPE_METADATA, "encm"), s.createBoxCtor("a1lx", "AV1LayeredImageIndexingProperty", function(t) {
+      var e = t.readUint8() & 1, r = ((e & 1) + 1) * 16;
+      this.layer_size = [];
+      for (var n = 0; n < 3; n++)
+        r == 16 ? this.layer_size[n] = t.readUint16() : this.layer_size[n] = t.readUint32();
+    }), s.createBoxCtor("a1op", "OperatingPointSelectorProperty", function(t) {
+      this.op_index = t.readUint8();
+    }), s.createFullBoxCtor("auxC", "AuxiliaryTypeProperty", function(t) {
+      this.aux_type = t.readCString();
+      var e = this.size - this.hdr_size - (this.aux_type.length + 1);
+      this.aux_subtype = t.readUint8Array(e);
+    }), s.createBoxCtor("av1C", "AV1CodecConfigurationBox", function(t) {
+      var e = t.readUint8();
+      if ((e >> 7 & 1) !== 1) {
+        l.error("av1C marker problem");
+        return;
+      }
+      if (this.version = e & 127, this.version !== 1) {
+        l.error("av1C version " + this.version + " not supported");
+        return;
+      }
+      if (e = t.readUint8(), this.seq_profile = e >> 5 & 7, this.seq_level_idx_0 = e & 31, e = t.readUint8(), this.seq_tier_0 = e >> 7 & 1, this.high_bitdepth = e >> 6 & 1, this.twelve_bit = e >> 5 & 1, this.monochrome = e >> 4 & 1, this.chroma_subsampling_x = e >> 3 & 1, this.chroma_subsampling_y = e >> 2 & 1, this.chroma_sample_position = e & 3, e = t.readUint8(), this.reserved_1 = e >> 5 & 7, this.reserved_1 !== 0) {
+        l.error("av1C reserved_1 parsing problem");
+        return;
+      }
+      if (this.initial_presentation_delay_present = e >> 4 & 1, this.initial_presentation_delay_present === 1)
+        this.initial_presentation_delay_minus_one = e & 15;
+      else if (this.reserved_2 = e & 15, this.reserved_2 !== 0) {
+        l.error("av1C reserved_2 parsing problem");
+        return;
+      }
+      var r = this.size - this.hdr_size - 4;
+      this.configOBUs = t.readUint8Array(r);
+    });
+    function R(t) {
+      var e = "<table class='inner-table'>";
+      e += "<thead><tr><th>length</th><th>nalu_data</th></tr></thead>", e += "<tbody>";
+      for (var r = 0; r < t.length; r++) {
+        var n = t[r];
+        e += "<tr>", e += "<td>" + n.length + "</td>", e += "<td>", e += n.nalu.reduce(function(o, a) {
+          return o + a.toString(16).padStart(2, "0");
+        }, "0x"), e += "</td></tr>";
+      }
+      return e += "</tbody></table>", e;
+    }
+    s.createBoxCtor("avcC", "AVCConfigurationBox", function(t) {
+      var e, r;
+      for (this.configurationVersion = t.readUint8(), this.AVCProfileIndication = t.readUint8(), this.profile_compatibility = t.readUint8(), this.AVCLevelIndication = t.readUint8(), this.lengthSizeMinusOne = t.readUint8() & 3, this.nb_SPS_nalus = t.readUint8() & 31, r = this.size - this.hdr_size - 6, this.SPS = [], this.SPS.toString = function() {
+        return R(this);
+      }, e = 0; e < this.nb_SPS_nalus; e++)
+        this.SPS[e] = {}, this.SPS[e].length = t.readUint16(), this.SPS[e].nalu = t.readUint8Array(this.SPS[e].length), r -= 2 + this.SPS[e].length;
+      for (this.nb_PPS_nalus = t.readUint8(), r--, this.PPS = [], this.PPS.toString = function() {
+        return R(this);
+      }, e = 0; e < this.nb_PPS_nalus; e++)
+        this.PPS[e] = {}, this.PPS[e].length = t.readUint16(), this.PPS[e].nalu = t.readUint8Array(this.PPS[e].length), r -= 2 + this.PPS[e].length;
+      r > 0 && (this.ext = t.readUint8Array(r));
+    }), s.createBoxCtor("btrt", "BitRateBox", function(t) {
+      this.bufferSizeDB = t.readUint32(), this.maxBitrate = t.readUint32(), this.avgBitrate = t.readUint32();
+    }), s.createFullBoxCtor("ccst", "CodingConstraintsBox", function(t) {
+      var e = t.readUint8();
+      this.all_ref_pics_intra = (e & 128) == 128, this.intra_pred_used = (e & 64) == 64, this.max_ref_per_pic = (e & 63) >> 2, t.readUint24();
+    }), s.createBoxCtor("cdef", "ComponentDefinitionBox", function(t) {
+      var e;
+      for (this.channel_count = t.readUint16(), this.channel_indexes = [], this.channel_types = [], this.channel_associations = [], e = 0; e < this.channel_count; e++)
+        this.channel_indexes.push(t.readUint16()), this.channel_types.push(t.readUint16()), this.channel_associations.push(t.readUint16());
+    }), s.createBoxCtor("clap", "CleanApertureBox", function(t) {
+      this.cleanApertureWidthN = t.readUint32(), this.cleanApertureWidthD = t.readUint32(), this.cleanApertureHeightN = t.readUint32(), this.cleanApertureHeightD = t.readUint32(), this.horizOffN = t.readUint32(), this.horizOffD = t.readUint32(), this.vertOffN = t.readUint32(), this.vertOffD = t.readUint32();
+    }), s.createBoxCtor("clli", "ContentLightLevelBox", function(t) {
+      this.max_content_light_level = t.readUint16(), this.max_pic_average_light_level = t.readUint16();
+    }), s.createFullBoxCtor("cmex", "CameraExtrinsicMatrixProperty", function(t) {
+      this.flags & 1 && (this.pos_x = t.readInt32()), this.flags & 2 && (this.pos_y = t.readInt32()), this.flags & 4 && (this.pos_z = t.readInt32()), this.flags & 8 && (this.version == 0 ? this.flags & 16 ? (this.quat_x = t.readInt32(), this.quat_y = t.readInt32(), this.quat_z = t.readInt32()) : (this.quat_x = t.readInt16(), this.quat_y = t.readInt16(), this.quat_z = t.readInt16()) : this.version == 1), this.flags & 32 && (this.id = t.readUint32());
+    }), s.createFullBoxCtor("cmin", "CameraIntrinsicMatrixProperty", function(t) {
+      this.focal_length_x = t.readInt32(), this.principal_point_x = t.readInt32(), this.principal_point_y = t.readInt32(), this.flags & 1 && (this.focal_length_y = t.readInt32(), this.skew_factor = t.readInt32());
+    }), s.createBoxCtor("cmpd", "ComponentDefinitionBox", function(t) {
+      for (this.component_count = t.readUint32(), this.component_types = [], this.component_type_urls = [], i = 0; i < this.component_count; i++) {
+        var e = t.readUint16();
+        this.component_types.push(e), e >= 32768 && this.component_type_urls.push(t.readCString());
+      }
+    }), s.createFullBoxCtor("co64", "ChunkLargeOffsetBox", function(t) {
+      var e, r;
+      if (e = t.readUint32(), this.chunk_offsets = [], this.version === 0)
+        for (r = 0; r < e; r++)
+          this.chunk_offsets.push(t.readUint64());
+    }), s.createFullBoxCtor("CoLL", "ContentLightLevelBox", function(t) {
+      this.maxCLL = t.readUint16(), this.maxFALL = t.readUint16();
+    }), s.createBoxCtor("colr", "ColourInformationBox", function(t) {
+      if (this.colour_type = t.readString(4), this.colour_type === "nclx") {
+        this.colour_primaries = t.readUint16(), this.transfer_characteristics = t.readUint16(), this.matrix_coefficients = t.readUint16();
+        var e = t.readUint8();
+        this.full_range_flag = e >> 7;
+      } else this.colour_type === "rICC" ? this.ICC_profile = t.readUint8Array(this.size - 4) : this.colour_type === "prof" && (this.ICC_profile = t.readUint8Array(this.size - 4));
+    }), s.createFullBoxCtor("cprt", "CopyrightBox", function(t) {
+      this.parseLanguage(t), this.notice = t.readCString();
+    }), s.createFullBoxCtor("cslg", "CompositionToDecodeBox", function(t) {
+      this.version === 0 && (this.compositionToDTSShift = t.readInt32(), this.leastDecodeToDisplayDelta = t.readInt32(), this.greatestDecodeToDisplayDelta = t.readInt32(), this.compositionStartTime = t.readInt32(), this.compositionEndTime = t.readInt32());
+    }), s.createFullBoxCtor("ctts", "CompositionOffsetBox", function(t) {
+      var e, r;
+      if (e = t.readUint32(), this.sample_counts = [], this.sample_offsets = [], this.version === 0)
+        for (r = 0; r < e; r++) {
+          this.sample_counts.push(t.readUint32());
+          var n = t.readInt32();
+          n < 0 && l.warn("BoxParser", "ctts box uses negative values without using version 1"), this.sample_offsets.push(n);
+        }
+      else if (this.version == 1)
+        for (r = 0; r < e; r++)
+          this.sample_counts.push(t.readUint32()), this.sample_offsets.push(t.readInt32());
+    }), s.createBoxCtor("dac3", "AC3SpecificBox", function(t) {
+      var e = t.readUint8(), r = t.readUint8(), n = t.readUint8();
+      this.fscod = e >> 6, this.bsid = e >> 1 & 31, this.bsmod = (e & 1) << 2 | r >> 6 & 3, this.acmod = r >> 3 & 7, this.lfeon = r >> 2 & 1, this.bit_rate_code = r & 3 | n >> 5 & 7;
+    }), s.createBoxCtor("dec3", "EC3SpecificBox", function(t) {
+      var e = t.readUint16();
+      this.data_rate = e >> 3, this.num_ind_sub = e & 7, this.ind_subs = [];
+      for (var r = 0; r < this.num_ind_sub + 1; r++) {
+        var n = {};
+        this.ind_subs.push(n);
+        var o = t.readUint8(), a = t.readUint8(), h = t.readUint8();
+        n.fscod = o >> 6, n.bsid = o >> 1 & 31, n.bsmod = (o & 1) << 4 | a >> 4 & 15, n.acmod = a >> 1 & 7, n.lfeon = a & 1, n.num_dep_sub = h >> 1 & 15, n.num_dep_sub > 0 && (n.chan_loc = (h & 1) << 8 | t.readUint8());
+      }
+    }), s.createFullBoxCtor("dfLa", "FLACSpecificBox", function(t) {
+      var e = 127, r = 128, n = [], o = [
+        "STREAMINFO",
+        "PADDING",
+        "APPLICATION",
+        "SEEKTABLE",
+        "VORBIS_COMMENT",
+        "CUESHEET",
+        "PICTURE",
+        "RESERVED"
+      ];
+      do {
+        var a = t.readUint8(), h = Math.min(
+          a & e,
+          o.length - 1
+        );
+        if (h ? t.readUint8Array(t.readUint24()) : (t.readUint8Array(13), this.samplerate = t.readUint32() >> 12, t.readUint8Array(20)), n.push(o[h]), a & r)
+          break;
+      } while (!0);
+      this.numMetadataBlocks = n.length + " (" + n.join(", ") + ")";
+    }), s.createBoxCtor("dimm", "hintimmediateBytesSent", function(t) {
+      this.bytessent = t.readUint64();
+    }), s.createBoxCtor("dmax", "hintlongestpacket", function(t) {
+      this.time = t.readUint32();
+    }), s.createBoxCtor("dmed", "hintmediaBytesSent", function(t) {
+      this.bytessent = t.readUint64();
+    }), s.createBoxCtor("dOps", "OpusSpecificBox", function(t) {
+      if (this.Version = t.readUint8(), this.OutputChannelCount = t.readUint8(), this.PreSkip = t.readUint16(), this.InputSampleRate = t.readUint32(), this.OutputGain = t.readInt16(), this.ChannelMappingFamily = t.readUint8(), this.ChannelMappingFamily !== 0) {
+        this.StreamCount = t.readUint8(), this.CoupledCount = t.readUint8(), this.ChannelMapping = [];
+        for (var e = 0; e < this.OutputChannelCount; e++)
+          this.ChannelMapping[e] = t.readUint8();
+      }
+    }), s.createFullBoxCtor("dref", "DataReferenceBox", function(t) {
+      var e, r;
+      this.entries = [];
+      for (var n = t.readUint32(), o = 0; o < n; o++)
+        if (e = s.parseOneBox(t, !1, this.size - (t.getPosition() - this.start)), e.code === s.OK)
+          r = e.box, this.entries.push(r);
+        else
+          return;
+    }), s.createBoxCtor("drep", "hintrepeatedBytesSent", function(t) {
+      this.bytessent = t.readUint64();
+    }), s.createFullBoxCtor("elng", "ExtendedLanguageBox", function(t) {
+      this.extended_language = t.readString(this.size - this.hdr_size);
+    }), s.createFullBoxCtor("elst", "EditListBox", function(t) {
+      this.entries = [];
+      for (var e = t.readUint32(), r = 0; r < e; r++) {
+        var n = {};
+        this.entries.push(n), this.version === 1 ? (n.segment_duration = t.readUint64(), n.media_time = t.readInt64()) : (n.segment_duration = t.readUint32(), n.media_time = t.readInt32()), n.media_rate_integer = t.readInt16(), n.media_rate_fraction = t.readInt16();
+      }
+    }), s.createFullBoxCtor("emsg", "EventMessageBox", function(t) {
+      this.version == 1 ? (this.timescale = t.readUint32(), this.presentation_time = t.readUint64(), this.event_duration = t.readUint32(), this.id = t.readUint32(), this.scheme_id_uri = t.readCString(), this.value = t.readCString()) : (this.scheme_id_uri = t.readCString(), this.value = t.readCString(), this.timescale = t.readUint32(), this.presentation_time_delta = t.readUint32(), this.event_duration = t.readUint32(), this.id = t.readUint32());
+      var e = this.size - this.hdr_size - (16 + (this.scheme_id_uri.length + 1) + (this.value.length + 1));
+      this.version == 1 && (e -= 4), this.message_data = t.readUint8Array(e);
+    }), s.createEntityToGroupCtor = function(t, e) {
+      s[t + "Box"] = function(r) {
+        s.FullBox.call(this, t, r);
+      }, s[t + "Box"].prototype = new s.FullBox(), s[t + "Box"].prototype.parse = function(r) {
+        if (this.parseFullHeader(r), e)
+          e.call(this, r);
+        else
+          for (this.group_id = r.readUint32(), this.num_entities_in_group = r.readUint32(), this.entity_ids = [], i = 0; i < this.num_entities_in_group; i++) {
+            var n = r.readUint32();
+            this.entity_ids.push(n);
+          }
+      };
+    }, s.createEntityToGroupCtor("aebr"), s.createEntityToGroupCtor("afbr"), s.createEntityToGroupCtor("albc"), s.createEntityToGroupCtor("altr"), s.createEntityToGroupCtor("brst"), s.createEntityToGroupCtor("dobr"), s.createEntityToGroupCtor("eqiv"), s.createEntityToGroupCtor("favc"), s.createEntityToGroupCtor("fobr"), s.createEntityToGroupCtor("iaug"), s.createEntityToGroupCtor("pano"), s.createEntityToGroupCtor("slid"), s.createEntityToGroupCtor("ster"), s.createEntityToGroupCtor("tsyn"), s.createEntityToGroupCtor("wbbr"), s.createEntityToGroupCtor("prgr"), s.createEntityToGroupCtor("pymd", function(t) {
+      this.group_id = t.readUint32(), this.num_entities_in_group = t.readUint32(), this.entity_ids = [];
+      for (var e = 0; e < this.num_entities_in_group; e++) {
+        var r = t.readUint32();
+        this.entity_ids.push(r);
+      }
+      for (this.tile_size_x = t.readUint16(), this.tile_size_y = t.readUint16(), this.layer_binning = [], this.tiles_in_layer_column_minus1 = [], this.tiles_in_layer_row_minus1 = [], e = 0; e < this.num_entities_in_group; e++)
+        this.layer_binning[e] = t.readUint16(), this.tiles_in_layer_row_minus1[e] = t.readUint16(), this.tiles_in_layer_column_minus1[e] = t.readUint16();
+    }), s.createFullBoxCtor("esds", "ElementaryStreamDescriptorBox", function(t) {
+      var e = t.readUint8Array(this.size - this.hdr_size);
+      if (typeof B < "u") {
+        var r = new B();
+        this.esd = r.parseOneDescriptor(new d(e.buffer, 0, d.BIG_ENDIAN));
+      }
+    }), s.createBoxCtor("fiel", "FieldHandlingBox", function(t) {
+      this.fieldCount = t.readUint8(), this.fieldOrdering = t.readUint8();
+    }), s.createBoxCtor("frma", "OriginalFormatBox", function(t) {
+      this.data_format = t.readString(4);
+    }), s.createBoxCtor("ftyp", "FileTypeBox", function(t) {
+      var e = this.size - this.hdr_size;
+      this.major_brand = t.readString(4), this.minor_version = t.readUint32(), e -= 8, this.compatible_brands = [];
+      for (var r = 0; e >= 4; )
+        this.compatible_brands[r] = t.readString(4), e -= 4, r++;
+    }), s.createFullBoxCtor("hdlr", "HandlerBox", function(t) {
+      this.version === 0 && (t.readUint32(), this.handler = t.readString(4), t.readUint32Array(3), this.name = t.readString(this.size - this.hdr_size - 20), this.name[this.name.length - 1] === "\0" && (this.name = this.name.slice(0, -1)));
+    }), s.createBoxCtor("hvcC", "HEVCConfigurationBox", function(t) {
+      var e, r, n, o;
+      this.configurationVersion = t.readUint8(), o = t.readUint8(), this.general_profile_space = o >> 6, this.general_tier_flag = (o & 32) >> 5, this.general_profile_idc = o & 31, this.general_profile_compatibility = t.readUint32(), this.general_constraint_indicator = t.readUint8Array(6), this.general_level_idc = t.readUint8(), this.min_spatial_segmentation_idc = t.readUint16() & 4095, this.parallelismType = t.readUint8() & 3, this.chroma_format_idc = t.readUint8() & 3, this.bit_depth_luma_minus8 = t.readUint8() & 7, this.bit_depth_chroma_minus8 = t.readUint8() & 7, this.avgFrameRate = t.readUint16(), o = t.readUint8(), this.constantFrameRate = o >> 6, this.numTemporalLayers = (o & 13) >> 3, this.temporalIdNested = (o & 4) >> 2, this.lengthSizeMinusOne = o & 3, this.nalu_arrays = [], this.nalu_arrays.toString = function() {
+        var u = "<table class='inner-table'>";
+        u += "<thead><tr><th>completeness</th><th>nalu_type</th><th>nalu_data</th></tr></thead>", u += "<tbody>";
+        for (var c = 0; c < this.length; c++) {
+          var g = this[c];
+          u += "<tr>", u += "<td rowspan='" + g.length + "'>" + g.completeness + "</td>", u += "<td rowspan='" + g.length + "'>" + g.nalu_type + "</td>";
+          for (var x = 0; x < g.length; x++) {
+            var m = g[x];
+            x !== 0 && (u += "<tr>"), u += "<td>", u += m.data.reduce(function(E, w) {
+              return E + w.toString(16).padStart(2, "0");
+            }, "0x"), u += "</td></tr>";
+          }
+        }
+        return u += "</tbody></table>", u;
+      };
+      var a = t.readUint8();
+      for (e = 0; e < a; e++) {
+        var h = [];
+        this.nalu_arrays.push(h), o = t.readUint8(), h.completeness = (o & 128) >> 7, h.nalu_type = o & 63;
+        var f = t.readUint16();
+        for (r = 0; r < f; r++) {
+          var p = {};
+          h.push(p), n = t.readUint16(), p.data = t.readUint8Array(n);
+        }
+      }
+    }), s.createFullBoxCtor("iinf", "ItemInfoBox", function(t) {
+      var e;
+      this.version === 0 ? this.entry_count = t.readUint16() : this.entry_count = t.readUint32(), this.item_infos = [];
+      for (var r = 0; r < this.entry_count; r++)
+        if (e = s.parseOneBox(t, !1, this.size - (t.getPosition() - this.start)), e.code === s.OK)
+          e.box.type !== "infe" && l.error("BoxParser", "Expected 'infe' box, got " + e.box.type), this.item_infos[r] = e.box;
+        else
+          return;
+    }), s.createFullBoxCtor("iloc", "ItemLocationBox", function(t) {
+      var e;
+      e = t.readUint8(), this.offset_size = e >> 4 & 15, this.length_size = e & 15, e = t.readUint8(), this.base_offset_size = e >> 4 & 15, this.version === 1 || this.version === 2 ? this.index_size = e & 15 : this.index_size = 0, this.items = [];
+      var r = 0;
+      if (this.version < 2)
+        r = t.readUint16();
+      else if (this.version === 2)
+        r = t.readUint32();
+      else
+        throw "version of iloc box not supported";
+      for (var n = 0; n < r; n++) {
+        var o = {};
+        if (this.items.push(o), this.version < 2)
+          o.item_ID = t.readUint16();
+        else if (this.version === 2)
+          o.item_ID = t.readUint32();
+        else
+          throw "version of iloc box not supported";
+        switch (this.version === 1 || this.version === 2 ? o.construction_method = t.readUint16() & 15 : o.construction_method = 0, o.data_reference_index = t.readUint16(), this.base_offset_size) {
+          case 0:
+            o.base_offset = 0;
+            break;
+          case 4:
+            o.base_offset = t.readUint32();
+            break;
+          case 8:
+            o.base_offset = t.readUint64();
+            break;
+          default:
+            throw "Error reading base offset size";
+        }
+        var a = t.readUint16();
+        o.extents = [];
+        for (var h = 0; h < a; h++) {
+          var f = {};
+          if (o.extents.push(f), this.version === 1 || this.version === 2)
+            switch (this.index_size) {
+              case 0:
+                f.extent_index = 0;
+                break;
+              case 4:
+                f.extent_index = t.readUint32();
+                break;
+              case 8:
+                f.extent_index = t.readUint64();
+                break;
+              default:
+                throw "Error reading extent index";
+            }
+          switch (this.offset_size) {
+            case 0:
+              f.extent_offset = 0;
+              break;
+            case 4:
+              f.extent_offset = t.readUint32();
+              break;
+            case 8:
+              f.extent_offset = t.readUint64();
+              break;
+            default:
+              throw "Error reading extent index";
+          }
+          switch (this.length_size) {
+            case 0:
+              f.extent_length = 0;
+              break;
+            case 4:
+              f.extent_length = t.readUint32();
+              break;
+            case 8:
+              f.extent_length = t.readUint64();
+              break;
+            default:
+              throw "Error reading extent index";
+          }
+        }
+      }
+    }), s.createBoxCtor("imir", "ImageMirror", function(t) {
+      var e = t.readUint8();
+      this.reserved = e >> 7, this.axis = e & 1;
+    }), s.createFullBoxCtor("infe", "ItemInfoEntry", function(t) {
+      if ((this.version === 0 || this.version === 1) && (this.item_ID = t.readUint16(), this.item_protection_index = t.readUint16(), this.item_name = t.readCString(), this.content_type = t.readCString(), this.content_encoding = t.readCString()), this.version === 1) {
+        this.extension_type = t.readString(4), l.warn("BoxParser", "Cannot parse extension type"), t.seek(this.start + this.size);
+        return;
+      }
+      this.version >= 2 && (this.version === 2 ? this.item_ID = t.readUint16() : this.version === 3 && (this.item_ID = t.readUint32()), this.item_protection_index = t.readUint16(), this.item_type = t.readString(4), this.item_name = t.readCString(), this.item_type === "mime" ? (this.content_type = t.readCString(), this.content_encoding = t.readCString()) : this.item_type === "uri " && (this.item_uri_type = t.readCString()));
+    }), s.createFullBoxCtor("ipma", "ItemPropertyAssociationBox", function(t) {
+      var e, r;
+      for (entry_count = t.readUint32(), this.associations = [], e = 0; e < entry_count; e++) {
+        var n = {};
+        this.associations.push(n), this.version < 1 ? n.id = t.readUint16() : n.id = t.readUint32();
+        var o = t.readUint8();
+        for (n.props = [], r = 0; r < o; r++) {
+          var a = t.readUint8(), h = {};
+          n.props.push(h), h.essential = (a & 128) >> 7 === 1, this.flags & 1 ? h.property_index = (a & 127) << 8 | t.readUint8() : h.property_index = a & 127;
+        }
+      }
+    }), s.createFullBoxCtor("iref", "ItemReferenceBox", function(t) {
+      var e, r;
+      for (this.references = []; t.getPosition() < this.start + this.size; )
+        if (e = s.parseOneBox(t, !0, this.size - (t.getPosition() - this.start)), e.code === s.OK)
+          this.version === 0 ? r = new s.SingleItemTypeReferenceBox(e.type, e.size, e.hdr_size, e.start) : r = new s.SingleItemTypeReferenceBoxLarge(e.type, e.size, e.hdr_size, e.start), r.write === s.Box.prototype.write && r.type !== "mdat" && (l.warn("BoxParser", r.type + " box writing not yet implemented, keeping unparsed data in memory for later write"), r.parseDataAndRewind(t)), r.parse(t), this.references.push(r);
+        else
+          return;
+    }), s.createBoxCtor("irot", "ImageRotation", function(t) {
+      this.angle = t.readUint8() & 3;
+    }), s.createFullBoxCtor("ispe", "ImageSpatialExtentsProperty", function(t) {
+      this.image_width = t.readUint32(), this.image_height = t.readUint32();
+    }), s.createFullBoxCtor("kind", "KindBox", function(t) {
+      this.schemeURI = t.readCString(), this.value = t.readCString();
+    }), s.createFullBoxCtor("leva", "LevelAssignmentBox", function(t) {
+      var e = t.readUint8();
+      this.levels = [];
+      for (var r = 0; r < e; r++) {
+        var n = {};
+        this.levels[r] = n, n.track_ID = t.readUint32();
+        var o = t.readUint8();
+        switch (n.padding_flag = o >> 7, n.assignment_type = o & 127, n.assignment_type) {
+          case 0:
+            n.grouping_type = t.readString(4);
+            break;
+          case 1:
+            n.grouping_type = t.readString(4), n.grouping_type_parameter = t.readUint32();
+            break;
+          case 2:
+            break;
+          case 3:
+            break;
+          case 4:
+            n.sub_track_id = t.readUint32();
+            break;
+          default:
+            l.warn("BoxParser", "Unknown leva assignement type");
+        }
+      }
+    }), s.createBoxCtor("lhvC", "LHEVCConfigurationBox", function(t) {
+      var e, r, n;
+      this.configurationVersion = t.readUint8(), this.min_spatial_segmentation_idc = t.readUint16() & 4095, this.parallelismType = t.readUint8() & 3, n = t.readUint8(), this.numTemporalLayers = (n & 13) >> 3, this.temporalIdNested = (n & 4) >> 2, this.lengthSizeMinusOne = n & 3, this.nalu_arrays = [], this.nalu_arrays.toString = function() {
+        var u = "<table class='inner-table'>";
+        u += "<thead><tr><th>completeness</th><th>nalu_type</th><th>nalu_data</th></tr></thead>", u += "<tbody>";
+        for (var c = 0; c < this.length; c++) {
+          var g = this[c];
+          u += "<tr>", u += "<td rowspan='" + g.length + "'>" + g.completeness + "</td>", u += "<td rowspan='" + g.length + "'>" + g.nalu_type + "</td>";
+          for (var x = 0; x < g.length; x++) {
+            var m = g[x];
+            x !== 0 && (u += "<tr>"), u += "<td>", u += m.data.reduce(function(E, w) {
+              return E + w.toString(16).padStart(2, "0");
+            }, "0x"), u += "</td></tr>";
+          }
+        }
+        return u += "</tbody></table>", u;
+      };
+      var o = t.readUint8();
+      for (e = 0; e < o; e++) {
+        var a = [];
+        this.nalu_arrays.push(a), n = t.readUint8(), a.completeness = (n & 128) >> 7, a.nalu_type = n & 63;
+        var h = t.readUint16();
+        for (r = 0; r < h; r++) {
+          var f = {};
+          a.push(f);
+          var p = t.readUint16();
+          f.data = t.readUint8Array(p);
+        }
+      }
+    }), s.createBoxCtor("lsel", "LayerSelectorProperty", function(t) {
+      this.layer_id = t.readUint16();
+    }), s.createBoxCtor("maxr", "hintmaxrate", function(t) {
+      this.period = t.readUint32(), this.bytes = t.readUint32();
+    });
+    function M(t, e) {
+      this.x = t, this.y = e;
+    }
+    M.prototype.toString = function() {
+      return "(" + this.x + "," + this.y + ")";
+    }, s.createBoxCtor("mdcv", "MasteringDisplayColourVolumeBox", function(t) {
+      this.display_primaries = [], this.display_primaries[0] = new M(t.readUint16(), t.readUint16()), this.display_primaries[1] = new M(t.readUint16(), t.readUint16()), this.display_primaries[2] = new M(t.readUint16(), t.readUint16()), this.white_point = new M(t.readUint16(), t.readUint16()), this.max_display_mastering_luminance = t.readUint32(), this.min_display_mastering_luminance = t.readUint32();
+    }), s.createFullBoxCtor("mdhd", "MediaHeaderBox", function(t) {
+      this.version == 1 ? (this.creation_time = t.readUint64(), this.modification_time = t.readUint64(), this.timescale = t.readUint32(), this.duration = t.readUint64()) : (this.creation_time = t.readUint32(), this.modification_time = t.readUint32(), this.timescale = t.readUint32(), this.duration = t.readUint32()), this.parseLanguage(t), t.readUint16();
+    }), s.createFullBoxCtor("mehd", "MovieExtendsHeaderBox", function(t) {
+      this.flags & 1 && (l.warn("BoxParser", "mehd box incorrectly uses flags set to 1, converting version to 1"), this.version = 1), this.version == 1 ? this.fragment_duration = t.readUint64() : this.fragment_duration = t.readUint32();
+    }), s.createFullBoxCtor("meta", "MetaBox", function(t) {
+      this.boxes = [], s.ContainerBox.prototype.parse.call(this, t);
+    }), s.createFullBoxCtor("mfhd", "MovieFragmentHeaderBox", function(t) {
+      this.sequence_number = t.readUint32();
+    }), s.createFullBoxCtor("mfro", "MovieFragmentRandomAccessOffsetBox", function(t) {
+      this._size = t.readUint32();
+    }), s.createFullBoxCtor("mskC", "MaskConfigurationProperty", function(t) {
+      this.bits_per_pixel = t.readUint8();
+    }), s.createFullBoxCtor("mvhd", "MovieHeaderBox", function(t) {
+      this.version == 1 ? (this.creation_time = t.readUint64(), this.modification_time = t.readUint64(), this.timescale = t.readUint32(), this.duration = t.readUint64()) : (this.creation_time = t.readUint32(), this.modification_time = t.readUint32(), this.timescale = t.readUint32(), this.duration = t.readUint32()), this.rate = t.readUint32(), this.volume = t.readUint16() >> 8, t.readUint16(), t.readUint32Array(2), this.matrix = t.readUint32Array(9), t.readUint32Array(6), this.next_track_id = t.readUint32();
+    }), s.createBoxCtor("npck", "hintPacketsSent", function(t) {
+      this.packetssent = t.readUint32();
+    }), s.createBoxCtor("nump", "hintPacketsSent", function(t) {
+      this.packetssent = t.readUint64();
+    }), s.createFullBoxCtor("padb", "PaddingBitsBox", function(t) {
+      var e = t.readUint32();
+      this.padbits = [];
+      for (var r = 0; r < Math.floor((e + 1) / 2); r++)
+        this.padbits = t.readUint8();
+    }), s.createBoxCtor("pasp", "PixelAspectRatioBox", function(t) {
+      this.hSpacing = t.readUint32(), this.vSpacing = t.readUint32();
+    }), s.createBoxCtor("payl", "CuePayloadBox", function(t) {
+      this.text = t.readString(this.size - this.hdr_size);
+    }), s.createBoxCtor("payt", "hintpayloadID", function(t) {
+      this.payloadID = t.readUint32();
+      var e = t.readUint8();
+      this.rtpmap_string = t.readString(e);
+    }), s.createFullBoxCtor("pdin", "ProgressiveDownloadInfoBox", function(t) {
+      var e = (this.size - this.hdr_size) / 8;
+      this.rate = [], this.initial_delay = [];
+      for (var r = 0; r < e; r++)
+        this.rate[r] = t.readUint32(), this.initial_delay[r] = t.readUint32();
+    }), s.createFullBoxCtor("pitm", "PrimaryItemBox", function(t) {
+      this.version === 0 ? this.item_id = t.readUint16() : this.item_id = t.readUint32();
+    }), s.createFullBoxCtor("pixi", "PixelInformationProperty", function(t) {
+      var e;
+      for (this.num_channels = t.readUint8(), this.bits_per_channels = [], e = 0; e < this.num_channels; e++)
+        this.bits_per_channels[e] = t.readUint8();
+    }), s.createBoxCtor("pmax", "hintlargestpacket", function(t) {
+      this.bytes = t.readUint32();
+    }), s.createFullBoxCtor("prdi", "ProgressiveDerivedImageItemInformationProperty", function(t) {
+      if (this.step_count = t.readUint16(), this.item_count = [], this.flags & 2)
+        for (var e = 0; e < this.step_count; e++)
+          this.item_count[e] = t.readUint16();
+    }), s.createFullBoxCtor("prft", "ProducerReferenceTimeBox", function(t) {
+      this.ref_track_id = t.readUint32(), this.ntp_timestamp = t.readUint64(), this.version === 0 ? this.media_time = t.readUint32() : this.media_time = t.readUint64();
+    }), s.createFullBoxCtor("pssh", "ProtectionSystemSpecificHeaderBox", function(t) {
+      if (this.system_id = s.parseHex16(t), this.version > 0) {
+        var e = t.readUint32();
+        this.kid = [];
+        for (var r = 0; r < e; r++)
+          this.kid[r] = s.parseHex16(t);
+      }
+      var n = t.readUint32();
+      n > 0 && (this.data = t.readUint8Array(n));
+    }), s.createFullBoxCtor("clef", "TrackCleanApertureDimensionsBox", function(t) {
+      this.width = t.readUint32(), this.height = t.readUint32();
+    }), s.createFullBoxCtor("enof", "TrackEncodedPixelsDimensionsBox", function(t) {
+      this.width = t.readUint32(), this.height = t.readUint32();
+    }), s.createFullBoxCtor("prof", "TrackProductionApertureDimensionsBox", function(t) {
+      this.width = t.readUint32(), this.height = t.readUint32();
+    }), s.createContainerBoxCtor("tapt", "TrackApertureModeDimensionsBox", null, ["clef", "prof", "enof"]), s.createBoxCtor("rtp ", "rtpmoviehintinformation", function(t) {
+      this.descriptionformat = t.readString(4), this.sdptext = t.readString(this.size - this.hdr_size - 4);
+    }), s.createFullBoxCtor("saio", "SampleAuxiliaryInformationOffsetsBox", function(t) {
+      this.flags & 1 && (this.aux_info_type = t.readString(4), this.aux_info_type_parameter = t.readUint32());
+      var e = t.readUint32();
+      this.offset = [];
+      for (var r = 0; r < e; r++)
+        this.version === 0 ? this.offset[r] = t.readUint32() : this.offset[r] = t.readUint64();
+    }), s.createFullBoxCtor("saiz", "SampleAuxiliaryInformationSizesBox", function(t) {
+      if (this.flags & 1 && (this.aux_info_type = t.readString(4), this.aux_info_type_parameter = t.readUint32()), this.default_sample_info_size = t.readUint8(), this.sample_count = t.readUint32(), this.sample_info_size = [], this.default_sample_info_size === 0)
+        for (var e = 0; e < this.sample_count; e++)
+          this.sample_info_size[e] = t.readUint8();
+    }), s.createSampleEntryCtor(s.SAMPLE_ENTRY_TYPE_METADATA, "mett", function(t) {
+      this.parseHeader(t), this.content_encoding = t.readCString(), this.mime_format = t.readCString(), this.parseFooter(t);
+    }), s.createSampleEntryCtor(s.SAMPLE_ENTRY_TYPE_METADATA, "metx", function(t) {
+      this.parseHeader(t), this.content_encoding = t.readCString(), this.namespace = t.readCString(), this.schema_location = t.readCString(), this.parseFooter(t);
+    }), s.createSampleEntryCtor(s.SAMPLE_ENTRY_TYPE_SUBTITLE, "sbtt", function(t) {
+      this.parseHeader(t), this.content_encoding = t.readCString(), this.mime_format = t.readCString(), this.parseFooter(t);
+    }), s.createSampleEntryCtor(s.SAMPLE_ENTRY_TYPE_SUBTITLE, "stpp", function(t) {
+      this.parseHeader(t), this.namespace = t.readCString(), this.schema_location = t.readCString(), this.auxiliary_mime_types = t.readCString(), this.parseFooter(t);
+    }), s.createSampleEntryCtor(s.SAMPLE_ENTRY_TYPE_SUBTITLE, "stxt", function(t) {
+      this.parseHeader(t), this.content_encoding = t.readCString(), this.mime_format = t.readCString(), this.parseFooter(t);
+    }), s.createSampleEntryCtor(s.SAMPLE_ENTRY_TYPE_SUBTITLE, "tx3g", function(t) {
+      this.parseHeader(t), this.displayFlags = t.readUint32(), this.horizontal_justification = t.readInt8(), this.vertical_justification = t.readInt8(), this.bg_color_rgba = t.readUint8Array(4), this.box_record = t.readInt16Array(4), this.style_record = t.readUint8Array(12), this.parseFooter(t);
+    }), s.createSampleEntryCtor(s.SAMPLE_ENTRY_TYPE_METADATA, "wvtt", function(t) {
+      this.parseHeader(t), this.parseFooter(t);
+    }), s.createSampleGroupCtor("alst", function(t) {
+      var e, r = t.readUint16();
+      for (this.first_output_sample = t.readUint16(), this.sample_offset = [], e = 0; e < r; e++)
+        this.sample_offset[e] = t.readUint32();
+      var n = this.description_length - 4 - 4 * r;
+      for (this.num_output_samples = [], this.num_total_samples = [], e = 0; e < n / 4; e++)
+        this.num_output_samples[e] = t.readUint16(), this.num_total_samples[e] = t.readUint16();
+    }), s.createSampleGroupCtor("avll", function(t) {
+      this.layerNumber = t.readUint8(), this.accurateStatisticsFlag = t.readUint8(), this.avgBitRate = t.readUint16(), this.avgFrameRate = t.readUint16();
+    }), s.createSampleGroupCtor("avss", function(t) {
+      this.subSequenceIdentifier = t.readUint16(), this.layerNumber = t.readUint8();
+      var e = t.readUint8();
+      this.durationFlag = e >> 7, this.avgRateFlag = e >> 6 & 1, this.durationFlag && (this.duration = t.readUint32()), this.avgRateFlag && (this.accurateStatisticsFlag = t.readUint8(), this.avgBitRate = t.readUint16(), this.avgFrameRate = t.readUint16()), this.dependency = [];
+      for (var r = t.readUint8(), n = 0; n < r; n++) {
+        var o = {};
+        this.dependency.push(o), o.subSeqDirectionFlag = t.readUint8(), o.layerNumber = t.readUint8(), o.subSequenceIdentifier = t.readUint16();
+      }
+    }), s.createSampleGroupCtor("dtrt", function(t) {
+      l.warn("BoxParser", "Sample Group type: " + this.grouping_type + " not fully parsed");
+    }), s.createSampleGroupCtor("mvif", function(t) {
+      l.warn("BoxParser", "Sample Group type: " + this.grouping_type + " not fully parsed");
+    }), s.createSampleGroupCtor("prol", function(t) {
+      this.roll_distance = t.readInt16();
+    }), s.createSampleGroupCtor("rap ", function(t) {
+      var e = t.readUint8();
+      this.num_leading_samples_known = e >> 7, this.num_leading_samples = e & 127;
+    }), s.createSampleGroupCtor("rash", function(t) {
+      if (this.operation_point_count = t.readUint16(), this.description_length !== 2 + (this.operation_point_count === 1 ? 2 : this.operation_point_count * 6) + 9)
+        l.warn("BoxParser", "Mismatch in " + this.grouping_type + " sample group length"), this.data = t.readUint8Array(this.description_length - 2);
+      else {
+        if (this.operation_point_count === 1)
+          this.target_rate_share = t.readUint16();
+        else {
+          this.target_rate_share = [], this.available_bitrate = [];
+          for (var e = 0; e < this.operation_point_count; e++)
+            this.available_bitrate[e] = t.readUint32(), this.target_rate_share[e] = t.readUint16();
+        }
+        this.maximum_bitrate = t.readUint32(), this.minimum_bitrate = t.readUint32(), this.discard_priority = t.readUint8();
+      }
+    }), s.createSampleGroupCtor("roll", function(t) {
+      this.roll_distance = t.readInt16();
+    }), s.SampleGroupEntry.prototype.parse = function(t) {
+      l.warn("BoxParser", "Unknown Sample Group type: " + this.grouping_type), this.data = t.readUint8Array(this.description_length);
+    }, s.createSampleGroupCtor("scif", function(t) {
+      l.warn("BoxParser", "Sample Group type: " + this.grouping_type + " not fully parsed");
+    }), s.createSampleGroupCtor("scnm", function(t) {
+      l.warn("BoxParser", "Sample Group type: " + this.grouping_type + " not fully parsed");
+    }), s.createSampleGroupCtor("seig", function(t) {
+      this.reserved = t.readUint8();
+      var e = t.readUint8();
+      this.crypt_byte_block = e >> 4, this.skip_byte_block = e & 15, this.isProtected = t.readUint8(), this.Per_Sample_IV_Size = t.readUint8(), this.KID = s.parseHex16(t), this.constant_IV_size = 0, this.constant_IV = 0, this.isProtected === 1 && this.Per_Sample_IV_Size === 0 && (this.constant_IV_size = t.readUint8(), this.constant_IV = t.readUint8Array(this.constant_IV_size));
+    }), s.createSampleGroupCtor("stsa", function(t) {
+      l.warn("BoxParser", "Sample Group type: " + this.grouping_type + " not fully parsed");
+    }), s.createSampleGroupCtor("sync", function(t) {
+      var e = t.readUint8();
+      this.NAL_unit_type = e & 63;
+    }), s.createSampleGroupCtor("tele", function(t) {
+      var e = t.readUint8();
+      this.level_independently_decodable = e >> 7;
+    }), s.createSampleGroupCtor("tsas", function(t) {
+      l.warn("BoxParser", "Sample Group type: " + this.grouping_type + " not fully parsed");
+    }), s.createSampleGroupCtor("tscl", function(t) {
+      l.warn("BoxParser", "Sample Group type: " + this.grouping_type + " not fully parsed");
+    }), s.createSampleGroupCtor("vipr", function(t) {
+      l.warn("BoxParser", "Sample Group type: " + this.grouping_type + " not fully parsed");
+    }), s.createFullBoxCtor("sbgp", "SampleToGroupBox", function(t) {
+      this.grouping_type = t.readString(4), this.version === 1 ? this.grouping_type_parameter = t.readUint32() : this.grouping_type_parameter = 0, this.entries = [];
+      for (var e = t.readUint32(), r = 0; r < e; r++) {
+        var n = {};
+        this.entries.push(n), n.sample_count = t.readInt32(), n.group_description_index = t.readInt32();
+      }
+    });
+    function J(t, e) {
+      this.bad_pixel_row = t, this.bad_pixel_column = e;
+    }
+    J.prototype.toString = function() {
+      return "[row: " + this.bad_pixel_row + ", column: " + this.bad_pixel_column + "]";
+    }, s.createFullBoxCtor("sbpm", "SensorBadPixelsMapBox", function(t) {
+      var e;
+      for (this.component_count = t.readUint16(), this.component_index = [], e = 0; e < this.component_count; e++)
+        this.component_index.push(t.readUint16());
+      var r = t.readUint8();
+      for (this.correction_applied = (r & 128) == 128, this.num_bad_rows = t.readUint32(), this.num_bad_cols = t.readUint32(), this.num_bad_pixels = t.readUint32(), this.bad_rows = [], this.bad_columns = [], this.bad_pixels = [], e = 0; e < this.num_bad_rows; e++)
+        this.bad_rows.push(t.readUint32());
+      for (e = 0; e < this.num_bad_cols; e++)
+        this.bad_columns.push(t.readUint32());
+      for (e = 0; e < this.num_bad_pixels; e++) {
+        var n = t.readUint32(), o = t.readUint32();
+        this.bad_pixels.push(new J(n, o));
+      }
+    }), s.createFullBoxCtor("schm", "SchemeTypeBox", function(t) {
+      this.scheme_type = t.readString(4), this.scheme_version = t.readUint32(), this.flags & 1 && (this.scheme_uri = t.readString(this.size - this.hdr_size - 8));
+    }), s.createBoxCtor("sdp ", "rtptracksdphintinformation", function(t) {
+      this.sdptext = t.readString(this.size - this.hdr_size);
+    }), s.createFullBoxCtor("sdtp", "SampleDependencyTypeBox", function(t) {
+      var e, r = this.size - this.hdr_size;
+      this.is_leading = [], this.sample_depends_on = [], this.sample_is_depended_on = [], this.sample_has_redundancy = [];
+      for (var n = 0; n < r; n++)
+        e = t.readUint8(), this.is_leading[n] = e >> 6, this.sample_depends_on[n] = e >> 4 & 3, this.sample_is_depended_on[n] = e >> 2 & 3, this.sample_has_redundancy[n] = e & 3;
+    }), s.createFullBoxCtor(
+      "senc",
+      "SampleEncryptionBox"
+      /*, function(stream) {
+      	this.parseFullHeader(stream);
+      	var sample_count = stream.readUint32();
+      	this.samples = [];
+      	for (var i = 0; i < sample_count; i++) {
+      		var sample = {};
+      		// tenc.default_Per_Sample_IV_Size or seig.Per_Sample_IV_Size
+      		sample.InitializationVector = this.readUint8Array(Per_Sample_IV_Size*8);
+      		if (this.flags & 0x2) {
+      			sample.subsamples = [];
+      			subsample_count = stream.readUint16();
+      			for (var j = 0; j < subsample_count; j++) {
+      				var subsample = {};
+      				subsample.BytesOfClearData = stream.readUint16();
+      				subsample.BytesOfProtectedData = stream.readUint32();
+      				sample.subsamples.push(subsample);
+      			}
+      		}
+      		// TODO
+      		this.samples.push(sample);
+      	}
+      }*/
+    ), s.createFullBoxCtor("sgpd", "SampleGroupDescriptionBox", function(t) {
+      this.grouping_type = t.readString(4), l.debug("BoxParser", "Found Sample Groups of type " + this.grouping_type), this.version === 1 ? this.default_length = t.readUint32() : this.default_length = 0, this.version >= 2 && (this.default_group_description_index = t.readUint32()), this.entries = [];
+      for (var e = t.readUint32(), r = 0; r < e; r++) {
+        var n;
+        s[this.grouping_type + "SampleGroupEntry"] ? n = new s[this.grouping_type + "SampleGroupEntry"](this.grouping_type) : n = new s.SampleGroupEntry(this.grouping_type), this.entries.push(n), this.version === 1 ? this.default_length === 0 ? n.description_length = t.readUint32() : n.description_length = this.default_length : n.description_length = this.default_length, n.write === s.SampleGroupEntry.prototype.write && (l.info("BoxParser", "SampleGroup for type " + this.grouping_type + " writing not yet implemented, keeping unparsed data in memory for later write"), n.data = t.readUint8Array(n.description_length), t.position -= n.description_length), n.parse(t);
+      }
+    }), s.createFullBoxCtor("sidx", "CompressedSegmentIndexBox", function(t) {
+      this.reference_ID = t.readUint32(), this.timescale = t.readUint32(), this.version === 0 ? (this.earliest_presentation_time = t.readUint32(), this.first_offset = t.readUint32()) : (this.earliest_presentation_time = t.readUint64(), this.first_offset = t.readUint64()), t.readUint16(), this.references = [];
+      for (var e = t.readUint16(), r = 0; r < e; r++) {
+        var n = {};
+        this.references.push(n);
+        var o = t.readUint32();
+        n.reference_type = o >> 31 & 1, n.referenced_size = o & 2147483647, n.subsegment_duration = t.readUint32(), o = t.readUint32(), n.starts_with_SAP = o >> 31 & 1, n.SAP_type = o >> 28 & 7, n.SAP_delta_time = o & 268435455;
+      }
+    }), s.SingleItemTypeReferenceBox = function(t, e, r, n) {
+      s.Box.call(this, t, e), this.hdr_size = r, this.start = n;
+    }, s.SingleItemTypeReferenceBox.prototype = new s.Box(), s.SingleItemTypeReferenceBox.prototype.parse = function(t) {
+      this.from_item_ID = t.readUint16();
+      var e = t.readUint16();
+      this.references = [];
+      for (var r = 0; r < e; r++)
+        this.references[r] = {}, this.references[r].to_item_ID = t.readUint16();
+    }, s.SingleItemTypeReferenceBoxLarge = function(t, e, r, n) {
+      s.Box.call(this, t, e), this.hdr_size = r, this.start = n;
+    }, s.SingleItemTypeReferenceBoxLarge.prototype = new s.Box(), s.SingleItemTypeReferenceBoxLarge.prototype.parse = function(t) {
+      this.from_item_ID = t.readUint32();
+      var e = t.readUint16();
+      this.references = [];
+      for (var r = 0; r < e; r++)
+        this.references[r] = {}, this.references[r].to_item_ID = t.readUint32();
+    }, s.createFullBoxCtor("SmDm", "SMPTE2086MasteringDisplayMetadataBox", function(t) {
+      this.primaryRChromaticity_x = t.readUint16(), this.primaryRChromaticity_y = t.readUint16(), this.primaryGChromaticity_x = t.readUint16(), this.primaryGChromaticity_y = t.readUint16(), this.primaryBChromaticity_x = t.readUint16(), this.primaryBChromaticity_y = t.readUint16(), this.whitePointChromaticity_x = t.readUint16(), this.whitePointChromaticity_y = t.readUint16(), this.luminanceMax = t.readUint32(), this.luminanceMin = t.readUint32();
+    }), s.createFullBoxCtor("smhd", "SoundMediaHeaderBox", function(t) {
+      this.balance = t.readUint16(), t.readUint16();
+    }), s.createFullBoxCtor("ssix", "CompressedSubsegmentIndexBox", function(t) {
+      this.subsegments = [];
+      for (var e = t.readUint32(), r = 0; r < e; r++) {
+        var n = {};
+        this.subsegments.push(n), n.ranges = [];
+        for (var o = t.readUint32(), a = 0; a < o; a++) {
+          var h = {};
+          n.ranges.push(h), h.level = t.readUint8(), h.range_size = t.readUint24();
+        }
+      }
+    }), s.createFullBoxCtor("stco", "ChunkOffsetBox", function(t) {
+      var e;
+      if (e = t.readUint32(), this.chunk_offsets = [], this.version === 0)
+        for (var r = 0; r < e; r++)
+          this.chunk_offsets.push(t.readUint32());
+    }), s.createFullBoxCtor("stdp", "DegradationPriorityBox", function(t) {
+      var e = (this.size - this.hdr_size) / 2;
+      this.priority = [];
+      for (var r = 0; r < e; r++)
+        this.priority[r] = t.readUint16();
+    }), s.createFullBoxCtor("sthd", "SubtitleMediaHeaderBox"), s.createFullBoxCtor("stri", "SubTrackInformationBox", function(t) {
+      this.switch_group = t.readUint16(), this.alternate_group = t.readUint16(), this.sub_track_id = t.readUint32();
+      var e = (this.size - this.hdr_size - 8) / 4;
+      this.attribute_list = [];
+      for (var r = 0; r < e; r++)
+        this.attribute_list[r] = t.readUint32();
+    }), s.createFullBoxCtor("stsc", "SampleToChunkBox", function(t) {
+      var e, r;
+      if (e = t.readUint32(), this.first_chunk = [], this.samples_per_chunk = [], this.sample_description_index = [], this.version === 0)
+        for (r = 0; r < e; r++)
+          this.first_chunk.push(t.readUint32()), this.samples_per_chunk.push(t.readUint32()), this.sample_description_index.push(t.readUint32());
+    }), s.createFullBoxCtor("stsd", "SampleDescriptionBox", function(t) {
+      var e, r, n, o;
+      for (this.entries = [], n = t.readUint32(), e = 1; e <= n; e++)
+        if (r = s.parseOneBox(t, !0, this.size - (t.getPosition() - this.start)), r.code === s.OK)
+          s[r.type + "SampleEntry"] ? (o = new s[r.type + "SampleEntry"](r.size), o.hdr_size = r.hdr_size, o.start = r.start) : (l.warn("BoxParser", "Unknown sample entry type: " + r.type), o = new s.SampleEntry(r.type, r.size, r.hdr_size, r.start)), o.write === s.SampleEntry.prototype.write && (l.info("BoxParser", "SampleEntry " + o.type + " box writing not yet implemented, keeping unparsed data in memory for later write"), o.parseDataAndRewind(t)), o.parse(t), this.entries.push(o);
+        else
+          return;
+    }), s.createFullBoxCtor("stsg", "SubTrackSampleGroupBox", function(t) {
+      this.grouping_type = t.readUint32();
+      var e = t.readUint16();
+      this.group_description_index = [];
+      for (var r = 0; r < e; r++)
+        this.group_description_index[r] = t.readUint32();
+    }), s.createFullBoxCtor("stsh", "ShadowSyncSampleBox", function(t) {
+      var e, r;
+      if (e = t.readUint32(), this.shadowed_sample_numbers = [], this.sync_sample_numbers = [], this.version === 0)
+        for (r = 0; r < e; r++)
+          this.shadowed_sample_numbers.push(t.readUint32()), this.sync_sample_numbers.push(t.readUint32());
+    }), s.createFullBoxCtor("stss", "SyncSampleBox", function(t) {
+      var e, r;
+      if (r = t.readUint32(), this.version === 0)
+        for (this.sample_numbers = [], e = 0; e < r; e++)
+          this.sample_numbers.push(t.readUint32());
+    }), s.createFullBoxCtor("stsz", "SampleSizeBox", function(t) {
+      var e;
+      if (this.sample_sizes = [], this.version === 0)
+        for (this.sample_size = t.readUint32(), this.sample_count = t.readUint32(), e = 0; e < this.sample_count; e++)
+          this.sample_size === 0 ? this.sample_sizes.push(t.readUint32()) : this.sample_sizes[e] = this.sample_size;
+    }), s.createFullBoxCtor("stts", "TimeToSampleBox", function(t) {
+      var e, r, n;
+      if (e = t.readUint32(), this.sample_counts = [], this.sample_deltas = [], this.version === 0)
+        for (r = 0; r < e; r++)
+          this.sample_counts.push(t.readUint32()), n = t.readInt32(), n < 0 && (l.warn("BoxParser", "File uses negative stts sample delta, using value 1 instead, sync may be lost!"), n = 1), this.sample_deltas.push(n);
+    }), s.createFullBoxCtor("stvi", "StereoVideoBox", function(t) {
+      var e = t.readUint32();
+      this.single_view_allowed = e & 3, this.stereo_scheme = t.readUint32();
+      var r = t.readUint32();
+      this.stereo_indication_type = t.readString(r);
+      var n, o;
+      for (this.boxes = []; t.getPosition() < this.start + this.size; )
+        if (n = s.parseOneBox(t, !1, this.size - (t.getPosition() - this.start)), n.code === s.OK)
+          o = n.box, this.boxes.push(o), this[o.type] = o;
+        else
+          return;
+    }), s.createBoxCtor("styp", "SegmentTypeBox", function(t) {
+      s.ftypBox.prototype.parse.call(this, t);
+    }), s.createFullBoxCtor("stz2", "CompactSampleSizeBox", function(t) {
+      var e, r;
+      if (this.sample_sizes = [], this.version === 0)
+        if (this.reserved = t.readUint24(), this.field_size = t.readUint8(), r = t.readUint32(), this.field_size === 4)
+          for (e = 0; e < r; e += 2) {
+            var n = t.readUint8();
+            this.sample_sizes[e] = n >> 4 & 15, this.sample_sizes[e + 1] = n & 15;
+          }
+        else if (this.field_size === 8)
+          for (e = 0; e < r; e++)
+            this.sample_sizes[e] = t.readUint8();
+        else if (this.field_size === 16)
+          for (e = 0; e < r; e++)
+            this.sample_sizes[e] = t.readUint16();
+        else
+          l.error("BoxParser", "Error in length field in stz2 box");
+    }), s.createFullBoxCtor("subs", "SubSampleInformationBox", function(t) {
+      var e, r, n, o;
+      for (n = t.readUint32(), this.entries = [], e = 0; e < n; e++) {
+        var a = {};
+        if (this.entries[e] = a, a.sample_delta = t.readUint32(), a.subsamples = [], o = t.readUint16(), o > 0)
+          for (r = 0; r < o; r++) {
+            var h = {};
+            a.subsamples.push(h), this.version == 1 ? h.size = t.readUint32() : h.size = t.readUint16(), h.priority = t.readUint8(), h.discardable = t.readUint8(), h.codec_specific_parameters = t.readUint32();
+          }
+      }
+    }), s.createFullBoxCtor("tenc", "TrackEncryptionBox", function(t) {
+      if (t.readUint8(), this.version === 0)
+        t.readUint8();
+      else {
+        var e = t.readUint8();
+        this.default_crypt_byte_block = e >> 4 & 15, this.default_skip_byte_block = e & 15;
+      }
+      this.default_isProtected = t.readUint8(), this.default_Per_Sample_IV_Size = t.readUint8(), this.default_KID = s.parseHex16(t), this.default_isProtected === 1 && this.default_Per_Sample_IV_Size === 0 && (this.default_constant_IV_size = t.readUint8(), this.default_constant_IV = t.readUint8Array(this.default_constant_IV_size));
+    }), s.createFullBoxCtor("tfdt", "TrackFragmentBaseMediaDecodeTimeBox", function(t) {
+      this.version == 1 ? this.baseMediaDecodeTime = t.readUint64() : this.baseMediaDecodeTime = t.readUint32();
+    }), s.createFullBoxCtor("tfhd", "TrackFragmentHeaderBox", function(t) {
+      var e = 0;
+      this.track_id = t.readUint32(), this.size - this.hdr_size > e && this.flags & s.TFHD_FLAG_BASE_DATA_OFFSET ? (this.base_data_offset = t.readUint64(), e += 8) : this.base_data_offset = 0, this.size - this.hdr_size > e && this.flags & s.TFHD_FLAG_SAMPLE_DESC ? (this.default_sample_description_index = t.readUint32(), e += 4) : this.default_sample_description_index = 0, this.size - this.hdr_size > e && this.flags & s.TFHD_FLAG_SAMPLE_DUR ? (this.default_sample_duration = t.readUint32(), e += 4) : this.default_sample_duration = 0, this.size - this.hdr_size > e && this.flags & s.TFHD_FLAG_SAMPLE_SIZE ? (this.default_sample_size = t.readUint32(), e += 4) : this.default_sample_size = 0, this.size - this.hdr_size > e && this.flags & s.TFHD_FLAG_SAMPLE_FLAGS ? (this.default_sample_flags = t.readUint32(), e += 4) : this.default_sample_flags = 0;
+    }), s.createFullBoxCtor("tfra", "TrackFragmentRandomAccessBox", function(t) {
+      this.track_ID = t.readUint32(), t.readUint24();
+      var e = t.readUint8();
+      this.length_size_of_traf_num = e >> 4 & 3, this.length_size_of_trun_num = e >> 2 & 3, this.length_size_of_sample_num = e & 3, this.entries = [];
+      for (var r = t.readUint32(), n = 0; n < r; n++)
+        this.version === 1 ? (this.time = t.readUint64(), this.moof_offset = t.readUint64()) : (this.time = t.readUint32(), this.moof_offset = t.readUint32()), this.traf_number = t["readUint" + 8 * (this.length_size_of_traf_num + 1)](), this.trun_number = t["readUint" + 8 * (this.length_size_of_trun_num + 1)](), this.sample_number = t["readUint" + 8 * (this.length_size_of_sample_num + 1)]();
+    }), s.createFullBoxCtor("tkhd", "TrackHeaderBox", function(t) {
+      this.version == 1 ? (this.creation_time = t.readUint64(), this.modification_time = t.readUint64(), this.track_id = t.readUint32(), t.readUint32(), this.duration = t.readUint64()) : (this.creation_time = t.readUint32(), this.modification_time = t.readUint32(), this.track_id = t.readUint32(), t.readUint32(), this.duration = t.readUint32()), t.readUint32Array(2), this.layer = t.readInt16(), this.alternate_group = t.readInt16(), this.volume = t.readInt16() >> 8, t.readUint16(), this.matrix = t.readInt32Array(9), this.width = t.readUint32(), this.height = t.readUint32();
+    }), s.createBoxCtor("tmax", "hintmaxrelativetime", function(t) {
+      this.time = t.readUint32();
+    }), s.createBoxCtor("tmin", "hintminrelativetime", function(t) {
+      this.time = t.readUint32();
+    }), s.createBoxCtor("totl", "hintBytesSent", function(t) {
+      this.bytessent = t.readUint32();
+    }), s.createBoxCtor("tpay", "hintBytesSent", function(t) {
+      this.bytessent = t.readUint32();
+    }), s.createBoxCtor("tpyl", "hintBytesSent", function(t) {
+      this.bytessent = t.readUint64();
+    }), s.TrackGroupTypeBox.prototype.parse = function(t) {
+      this.parseFullHeader(t), this.track_group_id = t.readUint32();
+    }, s.createTrackGroupCtor("msrc"), s.TrackReferenceTypeBox = function(t, e, r, n) {
+      s.Box.call(this, t, e), this.hdr_size = r, this.start = n;
+    }, s.TrackReferenceTypeBox.prototype = new s.Box(), s.TrackReferenceTypeBox.prototype.parse = function(t) {
+      this.track_ids = t.readUint32Array((this.size - this.hdr_size) / 4);
+    }, s.trefBox.prototype.parse = function(t) {
+      for (var e, r; t.getPosition() < this.start + this.size; )
+        if (e = s.parseOneBox(t, !0, this.size - (t.getPosition() - this.start)), e.code === s.OK)
+          r = new s.TrackReferenceTypeBox(e.type, e.size, e.hdr_size, e.start), r.write === s.Box.prototype.write && r.type !== "mdat" && (l.info("BoxParser", "TrackReference " + r.type + " box writing not yet implemented, keeping unparsed data in memory for later write"), r.parseDataAndRewind(t)), r.parse(t), this.boxes.push(r);
+        else
+          return;
+    }, s.createFullBoxCtor("trep", "TrackExtensionPropertiesBox", function(t) {
+      for (this.track_ID = t.readUint32(), this.boxes = []; t.getPosition() < this.start + this.size; )
+        if (ret = s.parseOneBox(t, !1, this.size - (t.getPosition() - this.start)), ret.code === s.OK)
+          box = ret.box, this.boxes.push(box);
+        else
+          return;
+    }), s.createFullBoxCtor("trex", "TrackExtendsBox", function(t) {
+      this.track_id = t.readUint32(), this.default_sample_description_index = t.readUint32(), this.default_sample_duration = t.readUint32(), this.default_sample_size = t.readUint32(), this.default_sample_flags = t.readUint32();
+    }), s.createBoxCtor("trpy", "hintBytesSent", function(t) {
+      this.bytessent = t.readUint64();
+    }), s.createFullBoxCtor("trun", "TrackRunBox", function(t) {
+      var e = 0;
+      if (this.sample_count = t.readUint32(), e += 4, this.size - this.hdr_size > e && this.flags & s.TRUN_FLAGS_DATA_OFFSET ? (this.data_offset = t.readInt32(), e += 4) : this.data_offset = 0, this.size - this.hdr_size > e && this.flags & s.TRUN_FLAGS_FIRST_FLAG ? (this.first_sample_flags = t.readUint32(), e += 4) : this.first_sample_flags = 0, this.sample_duration = [], this.sample_size = [], this.sample_flags = [], this.sample_composition_time_offset = [], this.size - this.hdr_size > e)
+        for (var r = 0; r < this.sample_count; r++)
+          this.flags & s.TRUN_FLAGS_DURATION && (this.sample_duration[r] = t.readUint32()), this.flags & s.TRUN_FLAGS_SIZE && (this.sample_size[r] = t.readUint32()), this.flags & s.TRUN_FLAGS_FLAGS && (this.sample_flags[r] = t.readUint32()), this.flags & s.TRUN_FLAGS_CTS_OFFSET && (this.version === 0 ? this.sample_composition_time_offset[r] = t.readUint32() : this.sample_composition_time_offset[r] = t.readInt32());
+    }), s.createFullBoxCtor("tsel", "TrackSelectionBox", function(t) {
+      this.switch_group = t.readUint32();
+      var e = (this.size - this.hdr_size - 4) / 4;
+      this.attribute_list = [];
+      for (var r = 0; r < e; r++)
+        this.attribute_list[r] = t.readUint32();
+    }), s.createFullBoxCtor("txtC", "TextConfigBox", function(t) {
+      this.config = t.readCString();
+    }), s.createBoxCtor("tyco", "TypeCombinationBox", function(t) {
+      var e = (this.size - this.hdr_size) / 4;
+      this.compatible_brands = [];
+      for (var r = 0; r < e; r++)
+        this.compatible_brands[r] = t.readString(4);
+    }), s.createFullBoxCtor("udes", "UserDescriptionProperty", function(t) {
+      this.lang = t.readCString(), this.name = t.readCString(), this.description = t.readCString(), this.tags = t.readCString();
+    }), s.createFullBoxCtor("uncC", "UncompressedFrameConfigBox", function(t) {
+      var e;
+      if (this.profile = t.readString(4), this.version != 1) {
+        if (this.version == 0) {
+          for (this.component_count = t.readUint32(), this.component_index = [], this.component_bit_depth_minus_one = [], this.component_format = [], this.component_align_size = [], e = 0; e < this.component_count; e++)
+            this.component_index.push(t.readUint16()), this.component_bit_depth_minus_one.push(t.readUint8()), this.component_format.push(t.readUint8()), this.component_align_size.push(t.readUint8());
+          this.sampling_type = t.readUint8(), this.interleave_type = t.readUint8(), this.block_size = t.readUint8();
+          var r = t.readUint8();
+          this.component_little_endian = r >> 7 & 1, this.block_pad_lsb = r >> 6 & 1, this.block_little_endian = r >> 5 & 1, this.block_reversed = r >> 4 & 1, this.pad_unknown = r >> 3 & 1, this.pixel_size = t.readUint32(), this.row_align_size = t.readUint32(), this.tile_align_size = t.readUint32(), this.num_tile_cols_minus_one = t.readUint32(), this.num_tile_rows_minus_one = t.readUint32();
+        }
+      }
+    }), s.createFullBoxCtor("url ", "DataEntryUrlBox", function(t) {
+      this.flags !== 1 && (this.location = t.readCString());
+    }), s.createFullBoxCtor("urn ", "DataEntryUrnBox", function(t) {
+      this.name = t.readCString(), this.size - this.hdr_size - this.name.length - 1 > 0 && (this.location = t.readCString());
+    }), s.createUUIDBox("a5d40b30e81411ddba2f0800200c9a66", "LiveServerManifestBox", !0, !1, function(t) {
+      this.LiveServerManifest = t.readString(this.size - this.hdr_size).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+    }), s.createUUIDBox("d08a4f1810f34a82b6c832d8aba183d3", "PiffProtectionSystemSpecificHeaderBox", !0, !1, function(t) {
+      this.system_id = s.parseHex16(t);
+      var e = t.readUint32();
+      e > 0 && (this.data = t.readUint8Array(e));
+    }), s.createUUIDBox(
+      "a2394f525a9b4f14a2446c427c648df4",
+      "PiffSampleEncryptionBox",
+      !0,
+      !1
+      /*, function(stream) {
+      	if (this.flags & 0x1) {
+      		this.AlgorithmID = stream.readUint24();
+      		this.IV_size = stream.readUint8();
+      		this.KID = BoxParser.parseHex16(stream);
+      	}
+      	var sample_count = stream.readUint32();
+      	this.samples = [];
+      	for (var i = 0; i < sample_count; i++) {
+      		var sample = {};
+      		sample.InitializationVector = this.readUint8Array(this.IV_size*8);
+      		if (this.flags & 0x2) {
+      			sample.subsamples = [];
+      			sample.NumberOfEntries = stream.readUint16();
+      			for (var j = 0; j < sample.NumberOfEntries; j++) {
+      				var subsample = {};
+      				subsample.BytesOfClearData = stream.readUint16();
+      				subsample.BytesOfProtectedData = stream.readUint32();
+      				sample.subsamples.push(subsample);
+      			}
+      		}
+      		this.samples.push(sample);
+      	}
+      }*/
+    ), s.createUUIDBox("8974dbce7be74c5184f97148f9882554", "PiffTrackEncryptionBox", !0, !1, function(t) {
+      this.default_AlgorithmID = t.readUint24(), this.default_IV_size = t.readUint8(), this.default_KID = s.parseHex16(t);
+    }), s.createUUIDBox("d4807ef2ca3946958e5426cb9e46a79f", "TfrfBox", !0, !1, function(t) {
+      this.fragment_count = t.readUint8(), this.entries = [];
+      for (var e = 0; e < this.fragment_count; e++) {
+        var r = {}, n = 0, o = 0;
+        this.version === 1 ? (n = t.readUint64(), o = t.readUint64()) : (n = t.readUint32(), o = t.readUint32()), r.absolute_time = n, r.absolute_duration = o, this.entries.push(r);
+      }
+    }), s.createUUIDBox("6d1d9b0542d544e680e2141daff757b2", "TfxdBox", !0, !1, function(t) {
+      this.version === 1 ? (this.absolute_time = t.readUint64(), this.duration = t.readUint64()) : (this.absolute_time = t.readUint32(), this.duration = t.readUint32());
+    }), s.createFullBoxCtor("vmhd", "VideoMediaHeaderBox", function(t) {
+      this.graphicsmode = t.readUint16(), this.opcolor = t.readUint16Array(3);
+    }), s.createFullBoxCtor("vpcC", "VPCodecConfigurationRecord", function(t) {
+      var e;
+      this.version === 1 ? (this.profile = t.readUint8(), this.level = t.readUint8(), e = t.readUint8(), this.bitDepth = e >> 4, this.chromaSubsampling = e >> 1 & 7, this.videoFullRangeFlag = e & 1, this.colourPrimaries = t.readUint8(), this.transferCharacteristics = t.readUint8(), this.matrixCoefficients = t.readUint8(), this.codecIntializationDataSize = t.readUint16(), this.codecIntializationData = t.readUint8Array(this.codecIntializationDataSize)) : (this.profile = t.readUint8(), this.level = t.readUint8(), e = t.readUint8(), this.bitDepth = e >> 4 & 15, this.colorSpace = e & 15, e = t.readUint8(), this.chromaSubsampling = e >> 4 & 15, this.transferFunction = e >> 1 & 7, this.videoFullRangeFlag = e & 1, this.codecIntializationDataSize = t.readUint16(), this.codecIntializationData = t.readUint8Array(this.codecIntializationDataSize));
+    }), s.createBoxCtor("vttC", "WebVTTConfigurationBox", function(t) {
+      this.text = t.readString(this.size - this.hdr_size);
+    }), s.createFullBoxCtor("vvcC", "VvcConfigurationBox", function(t) {
+      var e, r, n = {
+        held_bits: void 0,
+        num_held_bits: 0,
+        stream_read_1_bytes: function(m) {
+          this.held_bits = m.readUint8(), this.num_held_bits = 8;
+        },
+        stream_read_2_bytes: function(m) {
+          this.held_bits = m.readUint16(), this.num_held_bits = 16;
+        },
+        extract_bits: function(m) {
+          var E = this.held_bits >> this.num_held_bits - m & (1 << m) - 1;
+          return this.num_held_bits -= m, E;
+        }
+      };
+      if (n.stream_read_1_bytes(t), n.extract_bits(5), this.lengthSizeMinusOne = n.extract_bits(2), this.ptl_present_flag = n.extract_bits(1), this.ptl_present_flag) {
+        n.stream_read_2_bytes(t), this.ols_idx = n.extract_bits(9), this.num_sublayers = n.extract_bits(3), this.constant_frame_rate = n.extract_bits(2), this.chroma_format_idc = n.extract_bits(2), n.stream_read_1_bytes(t), this.bit_depth_minus8 = n.extract_bits(3), n.extract_bits(5);
+        {
+          if (n.stream_read_2_bytes(t), n.extract_bits(2), this.num_bytes_constraint_info = n.extract_bits(6), this.general_profile_idc = n.extract_bits(7), this.general_tier_flag = n.extract_bits(1), this.general_level_idc = t.readUint8(), n.stream_read_1_bytes(t), this.ptl_frame_only_constraint_flag = n.extract_bits(1), this.ptl_multilayer_enabled_flag = n.extract_bits(1), this.general_constraint_info = new Uint8Array(this.num_bytes_constraint_info), this.num_bytes_constraint_info) {
+            for (e = 0; e < this.num_bytes_constraint_info - 1; e++) {
+              var o = n.extract_bits(6);
+              n.stream_read_1_bytes(t);
+              var a = n.extract_bits(2);
+              this.general_constraint_info[e] = o << 2 | a;
+            }
+            this.general_constraint_info[this.num_bytes_constraint_info - 1] = n.extract_bits(6);
+          } else
+            n.extract_bits(6);
+          if (this.num_sublayers > 1) {
+            for (n.stream_read_1_bytes(t), this.ptl_sublayer_present_mask = 0, r = this.num_sublayers - 2; r >= 0; --r) {
+              var h = n.extract_bits(1);
+              this.ptl_sublayer_present_mask |= h << r;
+            }
+            for (r = this.num_sublayers; r <= 8 && this.num_sublayers > 1; ++r)
+              n.extract_bits(1);
+            for (this.sublayer_level_idc = [], r = this.num_sublayers - 2; r >= 0; --r)
+              this.ptl_sublayer_present_mask & 1 << r && (this.sublayer_level_idc[r] = t.readUint8());
+          }
+          if (this.ptl_num_sub_profiles = t.readUint8(), this.general_sub_profile_idc = [], this.ptl_num_sub_profiles)
+            for (e = 0; e < this.ptl_num_sub_profiles; e++)
+              this.general_sub_profile_idc.push(t.readUint32());
+        }
+        this.max_picture_width = t.readUint16(), this.max_picture_height = t.readUint16(), this.avg_frame_rate = t.readUint16();
+      }
+      var f = 12, p = 13;
+      this.nalu_arrays = [];
+      var u = t.readUint8();
+      for (e = 0; e < u; e++) {
+        var c = [];
+        this.nalu_arrays.push(c), n.stream_read_1_bytes(t), c.completeness = n.extract_bits(1), n.extract_bits(2), c.nalu_type = n.extract_bits(5);
+        var g = 1;
+        for (c.nalu_type != p && c.nalu_type != f && (g = t.readUint16()), r = 0; r < g; r++) {
+          var x = t.readUint16();
+          c.push({
+            data: t.readUint8Array(x),
+            length: x
+          });
+        }
+      }
+    }), s.createFullBoxCtor("vvnC", "VvcNALUConfigBox", function(t) {
+      var e = strm.readUint8();
+      this.lengthSizeMinusOne = e & 3;
+    }), s.SampleEntry.prototype.isVideo = function() {
+      return !1;
+    }, s.SampleEntry.prototype.isAudio = function() {
+      return !1;
+    }, s.SampleEntry.prototype.isSubtitle = function() {
+      return !1;
+    }, s.SampleEntry.prototype.isMetadata = function() {
+      return !1;
+    }, s.SampleEntry.prototype.isHint = function() {
+      return !1;
+    }, s.SampleEntry.prototype.getCodec = function() {
+      return this.type.replace(".", "");
+    }, s.SampleEntry.prototype.getWidth = function() {
+      return "";
+    }, s.SampleEntry.prototype.getHeight = function() {
+      return "";
+    }, s.SampleEntry.prototype.getChannelCount = function() {
+      return "";
+    }, s.SampleEntry.prototype.getSampleRate = function() {
+      return "";
+    }, s.SampleEntry.prototype.getSampleSize = function() {
+      return "";
+    }, s.VisualSampleEntry.prototype.isVideo = function() {
+      return !0;
+    }, s.VisualSampleEntry.prototype.getWidth = function() {
+      return this.width;
+    }, s.VisualSampleEntry.prototype.getHeight = function() {
+      return this.height;
+    }, s.AudioSampleEntry.prototype.isAudio = function() {
+      return !0;
+    }, s.AudioSampleEntry.prototype.getChannelCount = function() {
+      return this.channel_count;
+    }, s.AudioSampleEntry.prototype.getSampleRate = function() {
+      return this.samplerate;
+    }, s.AudioSampleEntry.prototype.getSampleSize = function() {
+      return this.samplesize;
+    }, s.SubtitleSampleEntry.prototype.isSubtitle = function() {
+      return !0;
+    }, s.MetadataSampleEntry.prototype.isMetadata = function() {
+      return !0;
+    }, s.decimalToHex = function(t, e) {
+      var r = Number(t).toString(16);
+      for (e = typeof e > "u" || e === null ? e = 2 : e; r.length < e; )
+        r = "0" + r;
+      return r;
+    }, s.avc1SampleEntry.prototype.getCodec = s.avc2SampleEntry.prototype.getCodec = s.avc3SampleEntry.prototype.getCodec = s.avc4SampleEntry.prototype.getCodec = function() {
+      var t = s.SampleEntry.prototype.getCodec.call(this);
+      return this.avcC ? t + "." + s.decimalToHex(this.avcC.AVCProfileIndication) + s.decimalToHex(this.avcC.profile_compatibility) + s.decimalToHex(this.avcC.AVCLevelIndication) : t;
+    }, s.hev1SampleEntry.prototype.getCodec = s.hvc1SampleEntry.prototype.getCodec = function() {
+      var t, e = s.SampleEntry.prototype.getCodec.call(this);
+      if (this.hvcC) {
+        switch (e += ".", this.hvcC.general_profile_space) {
+          case 0:
+            e += "";
+            break;
+          case 1:
+            e += "A";
+            break;
+          case 2:
+            e += "B";
+            break;
+          case 3:
+            e += "C";
+            break;
+        }
+        e += this.hvcC.general_profile_idc, e += ".";
+        var r = this.hvcC.general_profile_compatibility, n = 0;
+        for (t = 0; t < 32 && (n |= r & 1, t != 31); t++)
+          n <<= 1, r >>= 1;
+        e += s.decimalToHex(n, 0), e += ".", this.hvcC.general_tier_flag === 0 ? e += "L" : e += "H", e += this.hvcC.general_level_idc;
+        var o = !1, a = "";
+        for (t = 5; t >= 0; t--)
+          (this.hvcC.general_constraint_indicator[t] || o) && (a = "." + s.decimalToHex(this.hvcC.general_constraint_indicator[t], 0) + a, o = !0);
+        e += a;
+      }
+      return e;
+    }, s.vvc1SampleEntry.prototype.getCodec = s.vvi1SampleEntry.prototype.getCodec = function() {
+      var t, e = s.SampleEntry.prototype.getCodec.call(this);
+      if (this.vvcC) {
+        e += "." + this.vvcC.general_profile_idc, this.vvcC.general_tier_flag ? e += ".H" : e += ".L", e += this.vvcC.general_level_idc;
+        var r = "";
+        if (this.vvcC.general_constraint_info) {
+          var n = [], o = 0;
+          o |= this.vvcC.ptl_frame_only_constraint << 7, o |= this.vvcC.ptl_multilayer_enabled << 6;
+          var a;
+          for (t = 0; t < this.vvcC.general_constraint_info.length; ++t)
+            o |= this.vvcC.general_constraint_info[t] >> 2 & 63, n.push(o), o && (a = t), o = this.vvcC.general_constraint_info[t] >> 2 & 3;
+          if (a === void 0)
+            r = ".CA";
+          else {
+            r = ".C";
+            var h = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567", f = 0, p = 0;
+            for (t = 0; t <= a; ++t)
+              for (f = f << 8 | n[t], p += 8; p >= 5; ) {
+                var u = f >> p - 5 & 31;
+                r += h[u], p -= 5, f &= (1 << p) - 1;
+              }
+            p && (f <<= 5 - p, r += h[f & 31]);
+          }
+        }
+        e += r;
+      }
+      return e;
+    }, s.mp4aSampleEntry.prototype.getCodec = function() {
+      var t = s.SampleEntry.prototype.getCodec.call(this);
+      if (this.esds && this.esds.esd) {
+        var e = this.esds.esd.getOTI(), r = this.esds.esd.getAudioConfig();
+        return t + "." + s.decimalToHex(e) + (r ? "." + r : "");
+      } else
+        return t;
+    }, s.stxtSampleEntry.prototype.getCodec = function() {
+      var t = s.SampleEntry.prototype.getCodec.call(this);
+      return this.mime_format ? t + "." + this.mime_format : t;
+    }, s.vp08SampleEntry.prototype.getCodec = s.vp09SampleEntry.prototype.getCodec = function() {
+      var t = s.SampleEntry.prototype.getCodec.call(this), e = this.vpcC.level;
+      e == 0 && (e = "00");
+      var r = this.vpcC.bitDepth;
+      return r == 8 && (r = "08"), t + ".0" + this.vpcC.profile + "." + e + "." + r;
+    }, s.av01SampleEntry.prototype.getCodec = function() {
+      var t = s.SampleEntry.prototype.getCodec.call(this), e = this.av1C.seq_level_idx_0;
+      e < 10 && (e = "0" + e);
+      var r;
+      return this.av1C.seq_profile === 2 && this.av1C.high_bitdepth === 1 ? r = this.av1C.twelve_bit === 1 ? "12" : "10" : this.av1C.seq_profile <= 2 && (r = this.av1C.high_bitdepth === 1 ? "10" : "08"), t + "." + this.av1C.seq_profile + "." + e + (this.av1C.seq_tier_0 ? "H" : "M") + "." + r;
+    }, s.Box.prototype.writeHeader = function(t, e) {
+      this.size += 8, this.size > b && (this.size += 8), this.type === "uuid" && (this.size += 16), l.debug("BoxWriter", "Writing box " + this.type + " of size: " + this.size + " at position " + t.getPosition() + (e || "")), this.size > b ? t.writeUint32(1) : (this.sizePosition = t.getPosition(), t.writeUint32(this.size)), t.writeString(this.type, null, 4), this.type === "uuid" && t.writeUint8Array(this.uuid), this.size > b && t.writeUint64(this.size);
+    }, s.FullBox.prototype.writeHeader = function(t) {
+      this.size += 4, s.Box.prototype.writeHeader.call(this, t, " v=" + this.version + " f=" + this.flags), t.writeUint8(this.version), t.writeUint24(this.flags);
+    }, s.Box.prototype.write = function(t) {
+      this.type === "mdat" ? this.data && (this.size = this.data.length, this.writeHeader(t), t.writeUint8Array(this.data)) : (this.size = this.data ? this.data.length : 0, this.writeHeader(t), this.data && t.writeUint8Array(this.data));
+    }, s.ContainerBox.prototype.write = function(t) {
+      this.size = 0, this.writeHeader(t);
+      for (var e = 0; e < this.boxes.length; e++)
+        this.boxes[e] && (this.boxes[e].write(t), this.size += this.boxes[e].size);
+      l.debug("BoxWriter", "Adjusting box " + this.type + " with new size " + this.size), t.adjustUint32(this.sizePosition, this.size);
+    }, s.TrackReferenceTypeBox.prototype.write = function(t) {
+      this.size = this.track_ids.length * 4, this.writeHeader(t), t.writeUint32Array(this.track_ids);
+    }, s.avcCBox.prototype.write = function(t) {
+      var e;
+      for (this.size = 7, e = 0; e < this.SPS.length; e++)
+        this.size += 2 + this.SPS[e].length;
+      for (e = 0; e < this.PPS.length; e++)
+        this.size += 2 + this.PPS[e].length;
+      for (this.ext && (this.size += this.ext.length), this.writeHeader(t), t.writeUint8(this.configurationVersion), t.writeUint8(this.AVCProfileIndication), t.writeUint8(this.profile_compatibility), t.writeUint8(this.AVCLevelIndication), t.writeUint8(this.lengthSizeMinusOne + 252), t.writeUint8(this.SPS.length + 224), e = 0; e < this.SPS.length; e++)
+        t.writeUint16(this.SPS[e].length), t.writeUint8Array(this.SPS[e].nalu);
+      for (t.writeUint8(this.PPS.length), e = 0; e < this.PPS.length; e++)
+        t.writeUint16(this.PPS[e].length), t.writeUint8Array(this.PPS[e].nalu);
+      this.ext && t.writeUint8Array(this.ext);
+    }, s.co64Box.prototype.write = function(t) {
+      var e;
+      for (this.version = 0, this.flags = 0, this.size = 4 + 8 * this.chunk_offsets.length, this.writeHeader(t), t.writeUint32(this.chunk_offsets.length), e = 0; e < this.chunk_offsets.length; e++)
+        t.writeUint64(this.chunk_offsets[e]);
+    }, s.cslgBox.prototype.write = function(t) {
+      this.version = 0, this.flags = 0, this.size = 20, this.writeHeader(t), t.writeInt32(this.compositionToDTSShift), t.writeInt32(this.leastDecodeToDisplayDelta), t.writeInt32(this.greatestDecodeToDisplayDelta), t.writeInt32(this.compositionStartTime), t.writeInt32(this.compositionEndTime);
+    }, s.cttsBox.prototype.write = function(t) {
+      var e;
+      for (this.version = 0, this.flags = 0, this.size = 4 + 8 * this.sample_counts.length, this.writeHeader(t), t.writeUint32(this.sample_counts.length), e = 0; e < this.sample_counts.length; e++)
+        t.writeUint32(this.sample_counts[e]), this.version === 1 ? t.writeInt32(this.sample_offsets[e]) : t.writeUint32(this.sample_offsets[e]);
+    }, s.drefBox.prototype.write = function(t) {
+      this.version = 0, this.flags = 0, this.size = 4, this.writeHeader(t), t.writeUint32(this.entries.length);
+      for (var e = 0; e < this.entries.length; e++)
+        this.entries[e].write(t), this.size += this.entries[e].size;
+      l.debug("BoxWriter", "Adjusting box " + this.type + " with new size " + this.size), t.adjustUint32(this.sizePosition, this.size);
+    }, s.elngBox.prototype.write = function(t) {
+      this.version = 0, this.flags = 0, this.size = this.extended_language.length, this.writeHeader(t), t.writeString(this.extended_language);
+    }, s.elstBox.prototype.write = function(t) {
+      this.version = 0, this.flags = 0, this.size = 4 + 12 * this.entries.length, this.writeHeader(t), t.writeUint32(this.entries.length);
+      for (var e = 0; e < this.entries.length; e++) {
+        var r = this.entries[e];
+        t.writeUint32(r.segment_duration), t.writeInt32(r.media_time), t.writeInt16(r.media_rate_integer), t.writeInt16(r.media_rate_fraction);
+      }
+    }, s.emsgBox.prototype.write = function(t) {
+      this.version = 0, this.flags = 0, this.size = 16 + this.message_data.length + (this.scheme_id_uri.length + 1) + (this.value.length + 1), this.writeHeader(t), t.writeCString(this.scheme_id_uri), t.writeCString(this.value), t.writeUint32(this.timescale), t.writeUint32(this.presentation_time_delta), t.writeUint32(this.event_duration), t.writeUint32(this.id), t.writeUint8Array(this.message_data);
+    }, s.ftypBox.prototype.write = function(t) {
+      this.size = 8 + 4 * this.compatible_brands.length, this.writeHeader(t), t.writeString(this.major_brand, null, 4), t.writeUint32(this.minor_version);
+      for (var e = 0; e < this.compatible_brands.length; e++)
+        t.writeString(this.compatible_brands[e], null, 4);
+    }, s.hdlrBox.prototype.write = function(t) {
+      this.size = 20 + this.name.length + 1, this.version = 0, this.flags = 0, this.writeHeader(t), t.writeUint32(0), t.writeString(this.handler, null, 4), t.writeUint32(0), t.writeUint32(0), t.writeUint32(0), t.writeCString(this.name);
+    }, s.hvcCBox.prototype.write = function(t) {
+      var e, r;
+      for (this.size = 23, e = 0; e < this.nalu_arrays.length; e++)
+        for (this.size += 3, r = 0; r < this.nalu_arrays[e].length; r++)
+          this.size += 2 + this.nalu_arrays[e][r].data.length;
+      for (this.writeHeader(t), t.writeUint8(this.configurationVersion), t.writeUint8((this.general_profile_space << 6) + (this.general_tier_flag << 5) + this.general_profile_idc), t.writeUint32(this.general_profile_compatibility), t.writeUint8Array(this.general_constraint_indicator), t.writeUint8(this.general_level_idc), t.writeUint16(this.min_spatial_segmentation_idc + (15 << 24)), t.writeUint8(this.parallelismType + 252), t.writeUint8(this.chroma_format_idc + 252), t.writeUint8(this.bit_depth_luma_minus8 + 248), t.writeUint8(this.bit_depth_chroma_minus8 + 248), t.writeUint16(this.avgFrameRate), t.writeUint8((this.constantFrameRate << 6) + (this.numTemporalLayers << 3) + (this.temporalIdNested << 2) + this.lengthSizeMinusOne), t.writeUint8(this.nalu_arrays.length), e = 0; e < this.nalu_arrays.length; e++)
+        for (t.writeUint8((this.nalu_arrays[e].completeness << 7) + this.nalu_arrays[e].nalu_type), t.writeUint16(this.nalu_arrays[e].length), r = 0; r < this.nalu_arrays[e].length; r++)
+          t.writeUint16(this.nalu_arrays[e][r].data.length), t.writeUint8Array(this.nalu_arrays[e][r].data);
+    }, s.kindBox.prototype.write = function(t) {
+      this.version = 0, this.flags = 0, this.size = this.schemeURI.length + 1 + (this.value.length + 1), this.writeHeader(t), t.writeCString(this.schemeURI), t.writeCString(this.value);
+    }, s.mdhdBox.prototype.write = function(t) {
+      this.size = 20, this.flags = 0, this.version = 0, this.writeHeader(t), t.writeUint32(this.creation_time), t.writeUint32(this.modification_time), t.writeUint32(this.timescale), t.writeUint32(this.duration), t.writeUint16(this.language), t.writeUint16(0);
+    }, s.mehdBox.prototype.write = function(t) {
+      this.version = 0, this.flags = 0, this.size = 4, this.writeHeader(t), t.writeUint32(this.fragment_duration);
+    }, s.mfhdBox.prototype.write = function(t) {
+      this.version = 0, this.flags = 0, this.size = 4, this.writeHeader(t), t.writeUint32(this.sequence_number);
+    }, s.mvhdBox.prototype.write = function(t) {
+      this.version = 0, this.flags = 0, this.size = 96, this.writeHeader(t), t.writeUint32(this.creation_time), t.writeUint32(this.modification_time), t.writeUint32(this.timescale), t.writeUint32(this.duration), t.writeUint32(this.rate), t.writeUint16(this.volume << 8), t.writeUint16(0), t.writeUint32(0), t.writeUint32(0), t.writeUint32Array(this.matrix), t.writeUint32(0), t.writeUint32(0), t.writeUint32(0), t.writeUint32(0), t.writeUint32(0), t.writeUint32(0), t.writeUint32(this.next_track_id);
+    }, s.SampleEntry.prototype.writeHeader = function(t) {
+      this.size = 8, s.Box.prototype.writeHeader.call(this, t), t.writeUint8(0), t.writeUint8(0), t.writeUint8(0), t.writeUint8(0), t.writeUint8(0), t.writeUint8(0), t.writeUint16(this.data_reference_index);
+    }, s.SampleEntry.prototype.writeFooter = function(t) {
+      for (var e = 0; e < this.boxes.length; e++)
+        this.boxes[e].write(t), this.size += this.boxes[e].size;
+      l.debug("BoxWriter", "Adjusting box " + this.type + " with new size " + this.size), t.adjustUint32(this.sizePosition, this.size);
+    }, s.SampleEntry.prototype.write = function(t) {
+      this.writeHeader(t), t.writeUint8Array(this.data), this.size += this.data.length, l.debug("BoxWriter", "Adjusting box " + this.type + " with new size " + this.size), t.adjustUint32(this.sizePosition, this.size);
+    }, s.VisualSampleEntry.prototype.write = function(t) {
+      this.writeHeader(t), this.size += 70, t.writeUint16(0), t.writeUint16(0), t.writeUint32(0), t.writeUint32(0), t.writeUint32(0), t.writeUint16(this.width), t.writeUint16(this.height), t.writeUint32(this.horizresolution), t.writeUint32(this.vertresolution), t.writeUint32(0), t.writeUint16(this.frame_count), t.writeUint8(Math.min(31, this.compressorname.length)), t.writeString(this.compressorname, null, 31), t.writeUint16(this.depth), t.writeInt16(-1), this.writeFooter(t);
+    }, s.AudioSampleEntry.prototype.write = function(t) {
+      this.writeHeader(t), this.size += 20, t.writeUint32(0), t.writeUint32(0), t.writeUint16(this.channel_count), t.writeUint16(this.samplesize), t.writeUint16(0), t.writeUint16(0), t.writeUint32(this.samplerate << 16), this.writeFooter(t);
+    }, s.stppSampleEntry.prototype.write = function(t) {
+      this.writeHeader(t), this.size += this.namespace.length + 1 + this.schema_location.length + 1 + this.auxiliary_mime_types.length + 1, t.writeCString(this.namespace), t.writeCString(this.schema_location), t.writeCString(this.auxiliary_mime_types), this.writeFooter(t);
+    }, s.SampleGroupEntry.prototype.write = function(t) {
+      t.writeUint8Array(this.data);
+    }, s.sbgpBox.prototype.write = function(t) {
+      this.version = 1, this.flags = 0, this.size = 12 + 8 * this.entries.length, this.writeHeader(t), t.writeString(this.grouping_type, null, 4), t.writeUint32(this.grouping_type_parameter), t.writeUint32(this.entries.length);
+      for (var e = 0; e < this.entries.length; e++) {
+        var r = this.entries[e];
+        t.writeInt32(r.sample_count), t.writeInt32(r.group_description_index);
+      }
+    }, s.sgpdBox.prototype.write = function(t) {
+      var e, r;
+      for (this.flags = 0, this.size = 12, e = 0; e < this.entries.length; e++)
+        r = this.entries[e], this.version === 1 && (this.default_length === 0 && (this.size += 4), this.size += r.data.length);
+      for (this.writeHeader(t), t.writeString(this.grouping_type, null, 4), this.version === 1 && t.writeUint32(this.default_length), this.version >= 2 && t.writeUint32(this.default_sample_description_index), t.writeUint32(this.entries.length), e = 0; e < this.entries.length; e++)
+        r = this.entries[e], this.version === 1 && this.default_length === 0 && t.writeUint32(r.description_length), r.write(t);
+    }, s.sidxBox.prototype.write = function(t) {
+      this.version = 0, this.flags = 0, this.size = 20 + 12 * this.references.length, this.writeHeader(t), t.writeUint32(this.reference_ID), t.writeUint32(this.timescale), t.writeUint32(this.earliest_presentation_time), t.writeUint32(this.first_offset), t.writeUint16(0), t.writeUint16(this.references.length);
+      for (var e = 0; e < this.references.length; e++) {
+        var r = this.references[e];
+        t.writeUint32(r.reference_type << 31 | r.referenced_size), t.writeUint32(r.subsegment_duration), t.writeUint32(r.starts_with_SAP << 31 | r.SAP_type << 28 | r.SAP_delta_time);
+      }
+    }, s.smhdBox.prototype.write = function(t) {
+      this.version = 0, this.flags = 1, this.size = 4, this.writeHeader(t), t.writeUint16(this.balance), t.writeUint16(0);
+    }, s.stcoBox.prototype.write = function(t) {
+      this.version = 0, this.flags = 0, this.size = 4 + 4 * this.chunk_offsets.length, this.writeHeader(t), t.writeUint32(this.chunk_offsets.length), t.writeUint32Array(this.chunk_offsets);
+    }, s.stscBox.prototype.write = function(t) {
+      var e;
+      for (this.version = 0, this.flags = 0, this.size = 4 + 12 * this.first_chunk.length, this.writeHeader(t), t.writeUint32(this.first_chunk.length), e = 0; e < this.first_chunk.length; e++)
+        t.writeUint32(this.first_chunk[e]), t.writeUint32(this.samples_per_chunk[e]), t.writeUint32(this.sample_description_index[e]);
+    }, s.stsdBox.prototype.write = function(t) {
+      var e;
+      for (this.version = 0, this.flags = 0, this.size = 0, this.writeHeader(t), t.writeUint32(this.entries.length), this.size += 4, e = 0; e < this.entries.length; e++)
+        this.entries[e].write(t), this.size += this.entries[e].size;
+      l.debug("BoxWriter", "Adjusting box " + this.type + " with new size " + this.size), t.adjustUint32(this.sizePosition, this.size);
+    }, s.stshBox.prototype.write = function(t) {
+      var e;
+      for (this.version = 0, this.flags = 0, this.size = 4 + 8 * this.shadowed_sample_numbers.length, this.writeHeader(t), t.writeUint32(this.shadowed_sample_numbers.length), e = 0; e < this.shadowed_sample_numbers.length; e++)
+        t.writeUint32(this.shadowed_sample_numbers[e]), t.writeUint32(this.sync_sample_numbers[e]);
+    }, s.stssBox.prototype.write = function(t) {
+      this.version = 0, this.flags = 0, this.size = 4 + 4 * this.sample_numbers.length, this.writeHeader(t), t.writeUint32(this.sample_numbers.length), t.writeUint32Array(this.sample_numbers);
+    }, s.stszBox.prototype.write = function(t) {
+      var e, r = !0;
+      if (this.version = 0, this.flags = 0, this.sample_sizes.length > 0)
+        for (e = 0; e + 1 < this.sample_sizes.length; )
+          if (this.sample_sizes[e + 1] !== this.sample_sizes[0]) {
+            r = !1;
+            break;
+          } else
+            e++;
+      else
+        r = !1;
+      this.size = 8, r || (this.size += 4 * this.sample_sizes.length), this.writeHeader(t), r ? t.writeUint32(this.sample_sizes[0]) : t.writeUint32(0), t.writeUint32(this.sample_sizes.length), r || t.writeUint32Array(this.sample_sizes);
+    }, s.sttsBox.prototype.write = function(t) {
+      var e;
+      for (this.version = 0, this.flags = 0, this.size = 4 + 8 * this.sample_counts.length, this.writeHeader(t), t.writeUint32(this.sample_counts.length), e = 0; e < this.sample_counts.length; e++)
+        t.writeUint32(this.sample_counts[e]), t.writeUint32(this.sample_deltas[e]);
+    }, s.tfdtBox.prototype.write = function(t) {
+      var e = Math.pow(2, 32) - 1;
+      this.version = this.baseMediaDecodeTime > e ? 1 : 0, this.flags = 0, this.size = 4, this.version === 1 && (this.size += 4), this.writeHeader(t), this.version === 1 ? t.writeUint64(this.baseMediaDecodeTime) : t.writeUint32(this.baseMediaDecodeTime);
+    }, s.tfhdBox.prototype.write = function(t) {
+      this.version = 0, this.size = 4, this.flags & s.TFHD_FLAG_BASE_DATA_OFFSET && (this.size += 8), this.flags & s.TFHD_FLAG_SAMPLE_DESC && (this.size += 4), this.flags & s.TFHD_FLAG_SAMPLE_DUR && (this.size += 4), this.flags & s.TFHD_FLAG_SAMPLE_SIZE && (this.size += 4), this.flags & s.TFHD_FLAG_SAMPLE_FLAGS && (this.size += 4), this.writeHeader(t), t.writeUint32(this.track_id), this.flags & s.TFHD_FLAG_BASE_DATA_OFFSET && t.writeUint64(this.base_data_offset), this.flags & s.TFHD_FLAG_SAMPLE_DESC && t.writeUint32(this.default_sample_description_index), this.flags & s.TFHD_FLAG_SAMPLE_DUR && t.writeUint32(this.default_sample_duration), this.flags & s.TFHD_FLAG_SAMPLE_SIZE && t.writeUint32(this.default_sample_size), this.flags & s.TFHD_FLAG_SAMPLE_FLAGS && t.writeUint32(this.default_sample_flags);
+    }, s.tkhdBox.prototype.write = function(t) {
+      this.version = 0, this.size = 80, this.writeHeader(t), t.writeUint32(this.creation_time), t.writeUint32(this.modification_time), t.writeUint32(this.track_id), t.writeUint32(0), t.writeUint32(this.duration), t.writeUint32(0), t.writeUint32(0), t.writeInt16(this.layer), t.writeInt16(this.alternate_group), t.writeInt16(this.volume << 8), t.writeUint16(0), t.writeInt32Array(this.matrix), t.writeUint32(this.width), t.writeUint32(this.height);
+    }, s.trexBox.prototype.write = function(t) {
+      this.version = 0, this.flags = 0, this.size = 20, this.writeHeader(t), t.writeUint32(this.track_id), t.writeUint32(this.default_sample_description_index), t.writeUint32(this.default_sample_duration), t.writeUint32(this.default_sample_size), t.writeUint32(this.default_sample_flags);
+    }, s.trunBox.prototype.write = function(t) {
+      this.version = 0, this.size = 4, this.flags & s.TRUN_FLAGS_DATA_OFFSET && (this.size += 4), this.flags & s.TRUN_FLAGS_FIRST_FLAG && (this.size += 4), this.flags & s.TRUN_FLAGS_DURATION && (this.size += 4 * this.sample_duration.length), this.flags & s.TRUN_FLAGS_SIZE && (this.size += 4 * this.sample_size.length), this.flags & s.TRUN_FLAGS_FLAGS && (this.size += 4 * this.sample_flags.length), this.flags & s.TRUN_FLAGS_CTS_OFFSET && (this.size += 4 * this.sample_composition_time_offset.length), this.writeHeader(t), t.writeUint32(this.sample_count), this.flags & s.TRUN_FLAGS_DATA_OFFSET && (this.data_offset_position = t.getPosition(), t.writeInt32(this.data_offset)), this.flags & s.TRUN_FLAGS_FIRST_FLAG && t.writeUint32(this.first_sample_flags);
+      for (var e = 0; e < this.sample_count; e++)
+        this.flags & s.TRUN_FLAGS_DURATION && t.writeUint32(this.sample_duration[e]), this.flags & s.TRUN_FLAGS_SIZE && t.writeUint32(this.sample_size[e]), this.flags & s.TRUN_FLAGS_FLAGS && t.writeUint32(this.sample_flags[e]), this.flags & s.TRUN_FLAGS_CTS_OFFSET && (this.version === 0 ? t.writeUint32(this.sample_composition_time_offset[e]) : t.writeInt32(this.sample_composition_time_offset[e]));
+    }, s["url Box"].prototype.write = function(t) {
+      this.version = 0, this.location ? (this.flags = 0, this.size = this.location.length + 1) : (this.flags = 1, this.size = 0), this.writeHeader(t), this.location && t.writeCString(this.location);
+    }, s["urn Box"].prototype.write = function(t) {
+      this.version = 0, this.flags = 0, this.size = this.name.length + 1 + (this.location ? this.location.length + 1 : 0), this.writeHeader(t), t.writeCString(this.name), this.location && t.writeCString(this.location);
+    }, s.vmhdBox.prototype.write = function(t) {
+      this.version = 0, this.flags = 1, this.size = 8, this.writeHeader(t), t.writeUint16(this.graphicsmode), t.writeUint16Array(this.opcolor);
+    }, s.cttsBox.prototype.unpack = function(t) {
+      var e, r, n;
+      for (n = 0, e = 0; e < this.sample_counts.length; e++)
+        for (r = 0; r < this.sample_counts[e]; r++)
+          t[n].pts = t[n].dts + this.sample_offsets[e], n++;
+    }, s.sttsBox.prototype.unpack = function(t) {
+      var e, r, n;
+      for (n = 0, e = 0; e < this.sample_counts.length; e++)
+        for (r = 0; r < this.sample_counts[e]; r++)
+          n === 0 ? t[n].dts = 0 : t[n].dts = t[n - 1].dts + this.sample_deltas[e], n++;
+    }, s.stcoBox.prototype.unpack = function(t) {
+      var e;
+      for (e = 0; e < this.chunk_offsets.length; e++)
+        t[e].offset = this.chunk_offsets[e];
+    }, s.stscBox.prototype.unpack = function(t) {
+      var e, r, n, o, a;
+      for (o = 0, a = 0, e = 0; e < this.first_chunk.length; e++)
+        for (r = 0; r < (e + 1 < this.first_chunk.length ? this.first_chunk[e + 1] : 1 / 0); r++)
+          for (a++, n = 0; n < this.samples_per_chunk[e]; n++) {
+            if (t[o])
+              t[o].description_index = this.sample_description_index[e], t[o].chunk_index = a;
+            else
+              return;
+            o++;
+          }
+    }, s.stszBox.prototype.unpack = function(t) {
+      var e;
+      for (e = 0; e < this.sample_sizes.length; e++)
+        t[e].size = this.sample_sizes[e];
+    }, s.DIFF_BOXES_PROP_NAMES = [
+      "boxes",
+      "entries",
+      "references",
+      "subsamples",
+      "items",
+      "item_infos",
+      "extents",
+      "associations",
+      "subsegments",
+      "ranges",
+      "seekLists",
+      "seekPoints",
+      "esd",
+      "levels"
+    ], s.DIFF_PRIMITIVE_ARRAY_PROP_NAMES = [
+      "compatible_brands",
+      "matrix",
+      "opcolor",
+      "sample_counts",
+      "sample_deltas",
+      "first_chunk",
+      "samples_per_chunk",
+      "sample_sizes",
+      "chunk_offsets",
+      "sample_offsets",
+      "sample_description_index",
+      "sample_duration"
+    ], s.boxEqualFields = function(t, e) {
+      if (t && !e) return !1;
+      var r;
+      for (r in t)
+        if (!(s.DIFF_BOXES_PROP_NAMES.indexOf(r) > -1)) {
+          if (t[r] instanceof s.Box || e[r] instanceof s.Box)
+            continue;
+          if (typeof t[r] > "u" || typeof e[r] > "u")
+            continue;
+          if (typeof t[r] == "function" || typeof e[r] == "function")
+            continue;
+          if (t.subBoxNames && t.subBoxNames.indexOf(r.slice(0, 4)) > -1 || e.subBoxNames && e.subBoxNames.indexOf(r.slice(0, 4)) > -1)
+            continue;
+          if (r === "data" || r === "start" || r === "size" || r === "creation_time" || r === "modification_time")
+            continue;
+          if (s.DIFF_PRIMITIVE_ARRAY_PROP_NAMES.indexOf(r) > -1)
+            continue;
+          if (t[r] !== e[r])
+            return !1;
+        }
+      return !0;
+    }, s.boxEqual = function(t, e) {
+      if (!s.boxEqualFields(t, e))
+        return !1;
+      for (var r = 0; r < s.DIFF_BOXES_PROP_NAMES.length; r++) {
+        var n = s.DIFF_BOXES_PROP_NAMES[r];
+        if (t[n] && e[n] && !s.boxEqual(t[n], e[n]))
+          return !1;
+      }
+      return !0;
+    };
+    var j = function() {
+    };
+    j.prototype.parseSample = function(t) {
+      var e, r, n = new _(t.buffer);
+      for (e = []; !n.isEos(); )
+        r = s.parseOneBox(n, !1), r.code === s.OK && r.box.type === "vttc" && e.push(r.box);
+      return e;
+    }, j.prototype.getText = function(t, e, r) {
+      function n(u, c, g) {
+        return g = g || "0", u = u + "", u.length >= c ? u : new Array(c - u.length + 1).join(g) + u;
+      }
+      function o(u) {
+        var c = Math.floor(u / 3600), g = Math.floor((u - c * 3600) / 60), x = Math.floor(u - c * 3600 - g * 60), m = Math.floor((u - c * 3600 - g * 60 - x) * 1e3);
+        return "" + n(c, 2) + ":" + n(g, 2) + ":" + n(x, 2) + "." + n(m, 3);
+      }
+      for (var a = this.parseSample(r), h = "", f = 0; f < a.length; f++) {
+        var p = a[f];
+        h += o(t) + " --> " + o(e) + `\r
+`, h += p.payl.text;
+      }
+      return h;
+    };
+    var Q = function() {
+    };
+    Q.prototype.parseSample = function(t) {
+      var e = {}, r;
+      e.resources = [];
+      var n = new _(t.data.buffer);
+      if (!t.subsamples || t.subsamples.length === 0)
+        e.documentString = n.readString(t.data.length);
+      else if (e.documentString = n.readString(t.subsamples[0].size), t.subsamples.length > 1)
+        for (r = 1; r < t.subsamples.length; r++)
+          e.resources[r] = n.readUint8Array(t.subsamples[r].size);
+      return typeof DOMParser < "u" && (e.document = new DOMParser().parseFromString(e.documentString, "application/xml")), e;
+    };
+    var q = function() {
+    };
+    q.prototype.parseSample = function(t) {
+      var e, r = new _(t.data.buffer);
+      return e = r.readString(t.data.length), e;
+    }, q.prototype.parseConfig = function(t) {
+      var e, r = new _(t.buffer);
+      return r.readUint32(), e = r.readCString(), e;
+    }, v.VTTin4Parser = j, v.XMLSubtitlein4Parser = Q, v.Textin4Parser = q;
+    var y = function(t) {
+      this.stream = t || new S(), this.boxes = [], this.mdats = [], this.moofs = [], this.isProgressive = !1, this.moovStartFound = !1, this.onMoovStart = null, this.moovStartSent = !1, this.onReady = null, this.readySent = !1, this.onSegment = null, this.onSamples = null, this.onError = null, this.sampleListBuilt = !1, this.fragmentedTracks = [], this.extractedTracks = [], this.isFragmentationInitialized = !1, this.sampleProcessingStarted = !1, this.nextMoofNumber = 0, this.itemListBuilt = !1, this.items = [], this.entity_groups = [], this.onSidx = null, this.sidxSent = !1;
+    };
+    y.prototype.setSegmentOptions = function(t, e, r) {
+      var n = this.getTrackById(t);
+      if (n) {
+        var o = {};
+        this.fragmentedTracks.push(o), o.id = t, o.user = e, o.trak = n, n.nextSample = 0, o.segmentStream = null, o.nb_samples = 1e3, o.rapAlignement = !0, r && (r.nbSamples && (o.nb_samples = r.nbSamples), r.rapAlignement && (o.rapAlignement = r.rapAlignement));
+      }
+    }, y.prototype.unsetSegmentOptions = function(t) {
+      for (var e = -1, r = 0; r < this.fragmentedTracks.length; r++) {
+        var n = this.fragmentedTracks[r];
+        n.id == t && (e = r);
+      }
+      e > -1 && this.fragmentedTracks.splice(e, 1);
+    }, y.prototype.setExtractionOptions = function(t, e, r) {
+      var n = this.getTrackById(t);
+      if (n) {
+        var o = {};
+        this.extractedTracks.push(o), o.id = t, o.user = e, o.trak = n, n.nextSample = 0, o.nb_samples = 1e3, o.samples = [], r && r.nbSamples && (o.nb_samples = r.nbSamples);
+      }
+    }, y.prototype.unsetExtractionOptions = function(t) {
+      for (var e = -1, r = 0; r < this.extractedTracks.length; r++) {
+        var n = this.extractedTracks[r];
+        n.id == t && (e = r);
+      }
+      e > -1 && this.extractedTracks.splice(e, 1);
+    }, y.prototype.parse = function() {
+      var t, e, r = !1;
+      if (!(this.restoreParsePosition && !this.restoreParsePosition()))
+        for (; ; )
+          if (this.hasIncompleteMdat && this.hasIncompleteMdat()) {
+            if (this.processIncompleteMdat())
+              continue;
+            return;
+          } else if (this.saveParsePosition && this.saveParsePosition(), t = s.parseOneBox(this.stream, r), t.code === s.ERR_NOT_ENOUGH_DATA)
+            if (this.processIncompleteBox) {
+              if (this.processIncompleteBox(t))
+                continue;
+              return;
+            } else
+              return;
+          else {
+            var n;
+            switch (e = t.box, n = e.type !== "uuid" ? e.type : e.uuid, this.boxes.push(e), n) {
+              case "mdat":
+                this.mdats.push(e);
+                break;
+              case "moof":
+                this.moofs.push(e);
+                break;
+              case "moov":
+                this.moovStartFound = !0, this.mdats.length === 0 && (this.isProgressive = !0);
+              /* no break */
+              /* falls through */
+              default:
+                this[n] !== void 0 && l.warn("ISOFile", "Duplicate Box of type: " + n + ", overriding previous occurrence"), this[n] = e;
+                break;
+            }
+            this.updateUsedBytes && this.updateUsedBytes(e, t);
+          }
+    }, y.prototype.checkBuffer = function(t) {
+      if (t == null)
+        throw "Buffer must be defined and non empty";
+      if (t.fileStart === void 0)
+        throw "Buffer must have a fileStart property";
+      return t.byteLength === 0 ? (l.warn("ISOFile", "Ignoring empty buffer (fileStart: " + t.fileStart + ")"), this.stream.logBufferLevel(), !1) : (l.info("ISOFile", "Processing buffer (fileStart: " + t.fileStart + ")"), t.usedBytes = 0, this.stream.insertBuffer(t), this.stream.logBufferLevel(), this.stream.initialized() ? !0 : (l.warn("ISOFile", "Not ready to start parsing"), !1));
+    }, y.prototype.appendBuffer = function(t, e) {
+      var r;
+      if (this.checkBuffer(t))
+        return this.parse(), this.moovStartFound && !this.moovStartSent && (this.moovStartSent = !0, this.onMoovStart && this.onMoovStart()), this.moov ? (this.sampleListBuilt || (this.buildSampleLists(), this.sampleListBuilt = !0), this.updateSampleLists(), this.onReady && !this.readySent && (this.readySent = !0, this.onReady(this.getInfo())), this.processSamples(e), this.nextSeekPosition ? (r = this.nextSeekPosition, this.nextSeekPosition = void 0) : r = this.nextParsePosition, this.stream.getEndFilePositionAfter && (r = this.stream.getEndFilePositionAfter(r))) : this.nextParsePosition ? r = this.nextParsePosition : r = 0, this.sidx && this.onSidx && !this.sidxSent && (this.onSidx(this.sidx), this.sidxSent = !0), this.meta && (this.flattenItemInfo && !this.itemListBuilt && (this.flattenItemInfo(), this.itemListBuilt = !0), this.processItems && this.processItems(this.onItem)), this.stream.cleanBuffers && (l.info("ISOFile", "Done processing buffer (fileStart: " + t.fileStart + ") - next buffer to fetch should have a fileStart position of " + r), this.stream.logBufferLevel(), this.stream.cleanBuffers(), this.stream.logBufferLevel(!0), l.info("ISOFile", "Sample data size in memory: " + this.getAllocatedSampleDataSize())), r;
+    }, y.prototype.getInfo = function() {
+      var t, e, r = {}, n, o, a, h, f = (/* @__PURE__ */ new Date("1904-01-01T00:00:00Z")).getTime();
+      if (this.moov)
+        for (r.hasMoov = !0, r.duration = this.moov.mvhd.duration, r.timescale = this.moov.mvhd.timescale, r.isFragmented = this.moov.mvex != null, r.isFragmented && this.moov.mvex.mehd && (r.fragment_duration = this.moov.mvex.mehd.fragment_duration), r.isProgressive = this.isProgressive, r.hasIOD = this.moov.iods != null, r.brands = [], r.brands.push(this.ftyp.major_brand), r.brands = r.brands.concat(this.ftyp.compatible_brands), r.created = new Date(f + this.moov.mvhd.creation_time * 1e3), r.modified = new Date(f + this.moov.mvhd.modification_time * 1e3), r.tracks = [], r.audioTracks = [], r.videoTracks = [], r.subtitleTracks = [], r.metadataTracks = [], r.hintTracks = [], r.otherTracks = [], t = 0; t < this.moov.traks.length; t++) {
+          if (n = this.moov.traks[t], h = n.mdia.minf.stbl.stsd.entries[0], o = {}, r.tracks.push(o), o.id = n.tkhd.track_id, o.name = n.mdia.hdlr.name, o.references = [], n.tref)
+            for (e = 0; e < n.tref.boxes.length; e++)
+              a = {}, o.references.push(a), a.type = n.tref.boxes[e].type, a.track_ids = n.tref.boxes[e].track_ids;
+          n.edts && (o.edits = n.edts.elst.entries), o.created = new Date(f + n.tkhd.creation_time * 1e3), o.modified = new Date(f + n.tkhd.modification_time * 1e3), o.movie_duration = n.tkhd.duration, o.movie_timescale = r.timescale, o.layer = n.tkhd.layer, o.alternate_group = n.tkhd.alternate_group, o.volume = n.tkhd.volume, o.matrix = n.tkhd.matrix, o.track_width = n.tkhd.width / 65536, o.track_height = n.tkhd.height / 65536, o.timescale = n.mdia.mdhd.timescale, o.cts_shift = n.mdia.minf.stbl.cslg, o.duration = n.mdia.mdhd.duration, o.samples_duration = n.samples_duration, o.codec = h.getCodec(), o.kind = n.udta && n.udta.kinds.length ? n.udta.kinds[0] : { schemeURI: "", value: "" }, o.language = n.mdia.elng ? n.mdia.elng.extended_language : n.mdia.mdhd.languageString, o.nb_samples = n.samples.length, o.size = n.samples_size, o.bitrate = o.size * 8 * o.timescale / o.samples_duration, h.isAudio() ? (o.type = "audio", r.audioTracks.push(o), o.audio = {}, o.audio.sample_rate = h.getSampleRate(), o.audio.channel_count = h.getChannelCount(), o.audio.sample_size = h.getSampleSize()) : h.isVideo() ? (o.type = "video", r.videoTracks.push(o), o.video = {}, o.video.width = h.getWidth(), o.video.height = h.getHeight()) : h.isSubtitle() ? (o.type = "subtitles", r.subtitleTracks.push(o)) : h.isHint() ? (o.type = "metadata", r.hintTracks.push(o)) : h.isMetadata() ? (o.type = "metadata", r.metadataTracks.push(o)) : (o.type = "metadata", r.otherTracks.push(o));
+        }
+      else
+        r.hasMoov = !1;
+      if (r.mime = "", r.hasMoov && r.tracks) {
+        for (r.videoTracks && r.videoTracks.length > 0 ? r.mime += 'video/mp4; codecs="' : r.audioTracks && r.audioTracks.length > 0 ? r.mime += 'audio/mp4; codecs="' : r.mime += 'application/mp4; codecs="', t = 0; t < r.tracks.length; t++)
+          t !== 0 && (r.mime += ","), r.mime += r.tracks[t].codec;
+        r.mime += '"; profiles="', r.mime += this.ftyp.compatible_brands.join(), r.mime += '"';
+      }
+      return r;
+    }, y.prototype.setNextSeekPositionFromSample = function(t) {
+      t && (this.nextSeekPosition ? this.nextSeekPosition = Math.min(t.offset + t.alreadyRead, this.nextSeekPosition) : this.nextSeekPosition = t.offset + t.alreadyRead);
+    }, y.prototype.processSamples = function(t) {
+      var e, r;
+      if (this.sampleProcessingStarted) {
+        if (this.isFragmentationInitialized && this.onSegment !== null)
+          for (e = 0; e < this.fragmentedTracks.length; e++) {
+            var n = this.fragmentedTracks[e];
+            for (r = n.trak; r.nextSample < r.samples.length && this.sampleProcessingStarted; ) {
+              l.debug("ISOFile", "Creating media fragment on track #" + n.id + " for sample " + r.nextSample);
+              var o = this.createFragment(n.id, r.nextSample, n.segmentStream);
+              if (o)
+                n.segmentStream = o, r.nextSample++;
+              else
+                break;
+              if ((r.nextSample % n.nb_samples === 0 || t || r.nextSample >= r.samples.length) && (l.info("ISOFile", "Sending fragmented data on track #" + n.id + " for samples [" + Math.max(0, r.nextSample - n.nb_samples) + "," + (r.nextSample - 1) + "]"), l.info("ISOFile", "Sample data size in memory: " + this.getAllocatedSampleDataSize()), this.onSegment && this.onSegment(n.id, n.user, n.segmentStream.buffer, r.nextSample, t || r.nextSample >= r.samples.length), n.segmentStream = null, n !== this.fragmentedTracks[e]))
+                break;
+            }
+          }
+        if (this.onSamples !== null)
+          for (e = 0; e < this.extractedTracks.length; e++) {
+            var a = this.extractedTracks[e];
+            for (r = a.trak; r.nextSample < r.samples.length && this.sampleProcessingStarted; ) {
+              l.debug("ISOFile", "Exporting on track #" + a.id + " sample #" + r.nextSample);
+              var h = this.getSample(r, r.nextSample);
+              if (h)
+                r.nextSample++, a.samples.push(h);
+              else {
+                this.setNextSeekPositionFromSample(r.samples[r.nextSample]);
+                break;
+              }
+              if ((r.nextSample % a.nb_samples === 0 || r.nextSample >= r.samples.length) && (l.debug("ISOFile", "Sending samples on track #" + a.id + " for sample " + r.nextSample), this.onSamples && this.onSamples(a.id, a.user, a.samples), a.samples = [], a !== this.extractedTracks[e]))
+                break;
+            }
+          }
+      }
+    }, y.prototype.getBox = function(t) {
+      var e = this.getBoxes(t, !0);
+      return e.length ? e[0] : null;
+    }, y.prototype.getBoxes = function(t, e) {
+      var r = [];
+      return y._sweep.call(this, t, r, e), r;
+    }, y._sweep = function(t, e, r) {
+      this.type && this.type == t && e.push(this);
+      for (var n in this.boxes) {
+        if (e.length && r) return;
+        y._sweep.call(this.boxes[n], t, e, r);
+      }
+    }, y.prototype.getTrackSamplesInfo = function(t) {
+      var e = this.getTrackById(t);
+      if (e)
+        return e.samples;
+    }, y.prototype.getTrackSample = function(t, e) {
+      var r = this.getTrackById(t), n = this.getSample(r, e);
+      return n;
+    }, y.prototype.releaseUsedSamples = function(t, e) {
+      var r = 0, n = this.getTrackById(t);
+      n.lastValidSample || (n.lastValidSample = 0);
+      for (var o = n.lastValidSample; o < e; o++)
+        r += this.releaseSample(n, o);
+      l.info("ISOFile", "Track #" + t + " released samples up to " + e + " (released size: " + r + ", remaining: " + this.samplesDataSize + ")"), n.lastValidSample = e;
+    }, y.prototype.start = function() {
+      this.sampleProcessingStarted = !0, this.processSamples(!1);
+    }, y.prototype.stop = function() {
+      this.sampleProcessingStarted = !1;
+    }, y.prototype.flush = function() {
+      l.info("ISOFile", "Flushing remaining samples"), this.updateSampleLists(), this.processSamples(!0), this.stream.cleanBuffers(), this.stream.logBufferLevel(!0);
+    }, y.prototype.seekTrack = function(t, e, r) {
+      var n, o, a = 1 / 0, h = 0, f = 0, p;
+      if (r.samples.length === 0)
+        return l.info("ISOFile", "No sample in track, cannot seek! Using time " + l.getDurationString(0, 1) + " and offset: 0"), { offset: 0, time: 0 };
+      for (n = 0; n < r.samples.length; n++) {
+        if (o = r.samples[n], n === 0)
+          f = 0, p = o.timescale;
+        else if (o.cts > t * o.timescale) {
+          f = n - 1;
+          break;
+        }
+        e && o.is_sync && (h = n);
+      }
+      for (e && (f = h), t = r.samples[f].cts, r.nextSample = f; r.samples[f].alreadyRead === r.samples[f].size && r.samples[f + 1]; )
+        f++;
+      return a = r.samples[f].offset + r.samples[f].alreadyRead, l.info("ISOFile", "Seeking to " + (e ? "RAP" : "") + " sample #" + r.nextSample + " on track " + r.tkhd.track_id + ", time " + l.getDurationString(t, p) + " and offset: " + a), { offset: a, time: t / p };
+    }, y.prototype.getTrackDuration = function(t) {
+      var e;
+      return t.samples ? (e = t.samples[t.samples.length - 1], (e.cts + e.duration) / e.timescale) : 1 / 0;
+    }, y.prototype.seek = function(t, e) {
+      var r = this.moov, n, o, a, h = { offset: 1 / 0, time: 1 / 0 };
+      if (this.moov) {
+        for (a = 0; a < r.traks.length; a++)
+          n = r.traks[a], !(t > this.getTrackDuration(n)) && (o = this.seekTrack(t, e, n), o.offset < h.offset && (h.offset = o.offset), o.time < h.time && (h.time = o.time));
+        return l.info("ISOFile", "Seeking at time " + l.getDurationString(h.time, 1) + " needs a buffer with a fileStart position of " + h.offset), h.offset === 1 / 0 ? h = { offset: this.nextParsePosition, time: 0 } : h.offset = this.stream.getEndFilePositionAfter(h.offset), l.info("ISOFile", "Adjusted seek position (after checking data already in buffer): " + h.offset), h;
+      } else
+        throw "Cannot seek: moov not received!";
+    }, y.prototype.equal = function(t) {
+      for (var e = 0; e < this.boxes.length && e < t.boxes.length; ) {
+        var r = this.boxes[e], n = t.boxes[e];
+        if (!s.boxEqual(r, n))
+          return !1;
+        e++;
+      }
+      return !0;
+    }, v.ISOFile = y, y.prototype.lastBoxStartPosition = 0, y.prototype.parsingMdat = null, y.prototype.nextParsePosition = 0, y.prototype.discardMdatData = !1, y.prototype.processIncompleteBox = function(t) {
+      var e, r, n;
+      return t.type === "mdat" ? (e = new s[t.type + "Box"](t.size), this.parsingMdat = e, this.boxes.push(e), this.mdats.push(e), e.start = t.start, e.hdr_size = t.hdr_size, this.stream.addUsedBytes(e.hdr_size), this.lastBoxStartPosition = e.start + e.size, n = this.stream.seek(e.start + e.size, !1, this.discardMdatData), n ? (this.parsingMdat = null, !0) : (this.moovStartFound ? this.nextParsePosition = this.stream.findEndContiguousBuf() : this.nextParsePosition = e.start + e.size, !1)) : (t.type === "moov" && (this.moovStartFound = !0, this.mdats.length === 0 && (this.isProgressive = !0)), r = this.stream.mergeNextBuffer ? this.stream.mergeNextBuffer() : !1, r ? (this.nextParsePosition = this.stream.getEndPosition(), !0) : (t.type ? this.moovStartFound ? this.nextParsePosition = this.stream.getEndPosition() : this.nextParsePosition = this.stream.getPosition() + t.size : this.nextParsePosition = this.stream.getEndPosition(), !1));
+    }, y.prototype.hasIncompleteMdat = function() {
+      return this.parsingMdat !== null;
+    }, y.prototype.processIncompleteMdat = function() {
+      var t, e;
+      return t = this.parsingMdat, e = this.stream.seek(t.start + t.size, !1, this.discardMdatData), e ? (l.debug("ISOFile", "Found 'mdat' end in buffered data"), this.parsingMdat = null, !0) : (this.nextParsePosition = this.stream.findEndContiguousBuf(), !1);
+    }, y.prototype.restoreParsePosition = function() {
+      return this.stream.seek(this.lastBoxStartPosition, !0, this.discardMdatData);
+    }, y.prototype.saveParsePosition = function() {
+      this.lastBoxStartPosition = this.stream.getPosition();
+    }, y.prototype.updateUsedBytes = function(t, e) {
+      this.stream.addUsedBytes && (t.type === "mdat" ? (this.stream.addUsedBytes(t.hdr_size), this.discardMdatData && this.stream.addUsedBytes(t.size - t.hdr_size)) : this.stream.addUsedBytes(t.size));
+    }, y.prototype.add = s.Box.prototype.add, y.prototype.addBox = s.Box.prototype.addBox, y.prototype.init = function(t) {
+      var e = t || {};
+      this.add("ftyp").set("major_brand", e.brands && e.brands[0] || "iso4").set("minor_version", 0).set("compatible_brands", e.brands || ["iso4"]);
+      var r = this.add("moov");
+      return r.add("mvhd").set("timescale", e.timescale || 600).set("rate", e.rate || 65536).set("creation_time", 0).set("modification_time", 0).set("duration", e.duration || 0).set("volume", e.width ? 0 : 256).set("matrix", [65536, 0, 0, 0, 65536, 0, 0, 0, 1073741824]).set("next_track_id", 1), r.add("mvex"), this;
+    }, y.prototype.addTrack = function(t) {
+      this.moov || this.init(t);
+      var e = t || {};
+      e.width = e.width || 320, e.height = e.height || 320, e.id = e.id || this.moov.mvhd.next_track_id, e.type = e.type || "avc1";
+      var r = this.moov.add("trak");
+      this.moov.mvhd.next_track_id = e.id + 1, r.add("tkhd").set("flags", s.TKHD_FLAG_ENABLED | s.TKHD_FLAG_IN_MOVIE | s.TKHD_FLAG_IN_PREVIEW).set("creation_time", 0).set("modification_time", 0).set("track_id", e.id).set("duration", e.duration || 0).set("layer", e.layer || 0).set("alternate_group", 0).set("volume", 1).set("matrix", [65536, 0, 0, 0, 65536, 0, 0, 0, 1073741824]).set("width", e.width << 16).set("height", e.height << 16);
+      var n = r.add("mdia");
+      n.add("mdhd").set("creation_time", 0).set("modification_time", 0).set("timescale", e.timescale || 1).set("duration", e.media_duration || 0).set("language", e.language || "und"), n.add("hdlr").set("handler", e.hdlr || "vide").set("name", e.name || "Track created with MP4Box.js"), n.add("elng").set("extended_language", e.language || "fr-FR");
+      var o = n.add("minf");
+      if (s[e.type + "SampleEntry"] !== void 0) {
+        var a = new s[e.type + "SampleEntry"]();
+        a.data_reference_index = 1;
+        var h = "";
+        for (var f in s.sampleEntryCodes)
+          for (var p = s.sampleEntryCodes[f], u = 0; u < p.length; u++)
+            if (p.indexOf(e.type) > -1) {
+              h = f;
+              break;
+            }
+        switch (h) {
+          case "Visual":
+            if (o.add("vmhd").set("graphicsmode", 0).set("opcolor", [0, 0, 0]), a.set("width", e.width).set("height", e.height).set("horizresolution", 72 << 16).set("vertresolution", 72 << 16).set("frame_count", 1).set("compressorname", e.type + " Compressor").set("depth", 24), e.avcDecoderConfigRecord) {
+              var c = new s.avcCBox();
+              c.parse(new _(e.avcDecoderConfigRecord)), a.addBox(c);
+            } else if (e.hevcDecoderConfigRecord) {
+              var g = new s.hvcCBox();
+              g.parse(new _(e.hevcDecoderConfigRecord)), a.addBox(g);
+            }
+            break;
+          case "Audio":
+            o.add("smhd").set("balance", e.balance || 0), a.set("channel_count", e.channel_count || 2).set("samplesize", e.samplesize || 16).set("samplerate", e.samplerate || 65536);
+            break;
+          case "Hint":
+            o.add("hmhd");
+            break;
+          case "Subtitle":
+            o.add("sthd"), e.type === "stpp" && a.set("namespace", e.namespace || "nonamespace").set("schema_location", e.schema_location || "").set("auxiliary_mime_types", e.auxiliary_mime_types || "");
+            break;
+          case "Metadata":
+            o.add("nmhd");
+            break;
+          case "System":
+            o.add("nmhd");
+            break;
+          default:
+            o.add("nmhd");
+            break;
+        }
+        e.description && a.addBox(e.description), e.description_boxes && e.description_boxes.forEach(function(m) {
+          a.addBox(m);
+        }), o.add("dinf").add("dref").addEntry(new s["url Box"]().set("flags", 1));
+        var x = o.add("stbl");
+        return x.add("stsd").addEntry(a), x.add("stts").set("sample_counts", []).set("sample_deltas", []), x.add("stsc").set("first_chunk", []).set("samples_per_chunk", []).set("sample_description_index", []), x.add("stco").set("chunk_offsets", []), x.add("stsz").set("sample_sizes", []), this.moov.mvex.add("trex").set("track_id", e.id).set("default_sample_description_index", e.default_sample_description_index || 1).set("default_sample_duration", e.default_sample_duration || 0).set("default_sample_size", e.default_sample_size || 0).set("default_sample_flags", e.default_sample_flags || 0), this.buildTrakSampleLists(r), e.id;
+      }
+    }, s.Box.prototype.computeSize = function(t) {
+      var e = t || new d();
+      e.endianness = d.BIG_ENDIAN, this.write(e);
+    }, y.prototype.addSample = function(t, e, r) {
+      var n = r || {}, o = {}, a = this.getTrackById(t);
+      if (a !== null) {
+        o.number = a.samples.length, o.track_id = a.tkhd.track_id, o.timescale = a.mdia.mdhd.timescale, o.description_index = n.sample_description_index ? n.sample_description_index - 1 : 0, o.description = a.mdia.minf.stbl.stsd.entries[o.description_index], o.data = e, o.size = e.byteLength, o.alreadyRead = o.size, o.duration = n.duration || 1, o.cts = n.cts || 0, o.dts = n.dts || 0, o.is_sync = n.is_sync || !1, o.is_leading = n.is_leading || 0, o.depends_on = n.depends_on || 0, o.is_depended_on = n.is_depended_on || 0, o.has_redundancy = n.has_redundancy || 0, o.degradation_priority = n.degradation_priority || 0, o.offset = 0, o.subsamples = n.subsamples, a.samples.push(o), a.samples_size += o.size, a.samples_duration += o.duration, a.first_dts === void 0 && (a.first_dts = n.dts), this.processSamples();
+        var h = this.createSingleSampleMoof(o);
+        return this.addBox(h), h.computeSize(), h.trafs[0].truns[0].data_offset = h.size + 8, this.add("mdat").data = new Uint8Array(e), o;
+      }
+    }, y.prototype.createSingleSampleMoof = function(t) {
+      var e = 0;
+      t.is_sync ? e = 1 << 25 : e = 65536;
+      var r = new s.moofBox();
+      r.add("mfhd").set("sequence_number", this.nextMoofNumber), this.nextMoofNumber++;
+      var n = r.add("traf"), o = this.getTrackById(t.track_id);
+      return n.add("tfhd").set("track_id", t.track_id).set("flags", s.TFHD_FLAG_DEFAULT_BASE_IS_MOOF), n.add("tfdt").set("baseMediaDecodeTime", t.dts - (o.first_dts || 0)), n.add("trun").set("flags", s.TRUN_FLAGS_DATA_OFFSET | s.TRUN_FLAGS_DURATION | s.TRUN_FLAGS_SIZE | s.TRUN_FLAGS_FLAGS | s.TRUN_FLAGS_CTS_OFFSET).set("data_offset", 0).set("first_sample_flags", 0).set("sample_count", 1).set("sample_duration", [t.duration]).set("sample_size", [t.size]).set("sample_flags", [e]).set("sample_composition_time_offset", [t.cts - t.dts]), r;
+    }, y.prototype.lastMoofIndex = 0, y.prototype.samplesDataSize = 0, y.prototype.resetTables = function() {
+      var t, e, r, n, o, a, h, f;
+      for (this.initial_duration = this.moov.mvhd.duration, this.moov.mvhd.duration = 0, t = 0; t < this.moov.traks.length; t++) {
+        e = this.moov.traks[t], e.tkhd.duration = 0, e.mdia.mdhd.duration = 0, r = e.mdia.minf.stbl.stco || e.mdia.minf.stbl.co64, r.chunk_offsets = [], n = e.mdia.minf.stbl.stsc, n.first_chunk = [], n.samples_per_chunk = [], n.sample_description_index = [], o = e.mdia.minf.stbl.stsz || e.mdia.minf.stbl.stz2, o.sample_sizes = [], a = e.mdia.minf.stbl.stts, a.sample_counts = [], a.sample_deltas = [], h = e.mdia.minf.stbl.ctts, h && (h.sample_counts = [], h.sample_offsets = []), f = e.mdia.minf.stbl.stss;
+        var p = e.mdia.minf.stbl.boxes.indexOf(f);
+        p != -1 && (e.mdia.minf.stbl.boxes[p] = null);
+      }
+    }, y.initSampleGroups = function(t, e, r, n, o) {
+      var a, h, f, p;
+      function u(c, g, x) {
+        this.grouping_type = c, this.grouping_type_parameter = g, this.sbgp = x, this.last_sample_in_run = -1, this.entry_index = -1;
+      }
+      for (e && (e.sample_groups_info = []), t.sample_groups_info || (t.sample_groups_info = []), h = 0; h < r.length; h++) {
+        for (p = r[h].grouping_type + "/" + r[h].grouping_type_parameter, f = new u(r[h].grouping_type, r[h].grouping_type_parameter, r[h]), e && (e.sample_groups_info[p] = f), t.sample_groups_info[p] || (t.sample_groups_info[p] = f), a = 0; a < n.length; a++)
+          n[a].grouping_type === r[h].grouping_type && (f.description = n[a], f.description.used = !0);
+        if (o)
+          for (a = 0; a < o.length; a++)
+            o[a].grouping_type === r[h].grouping_type && (f.fragment_description = o[a], f.fragment_description.used = !0, f.is_fragment = !0);
+      }
+      if (e) {
+        if (o)
+          for (h = 0; h < o.length; h++)
+            !o[h].used && o[h].version >= 2 && (p = o[h].grouping_type + "/0", f = new u(o[h].grouping_type, 0), f.is_fragment = !0, e.sample_groups_info[p] || (e.sample_groups_info[p] = f));
+      } else
+        for (h = 0; h < n.length; h++)
+          !n[h].used && n[h].version >= 2 && (p = n[h].grouping_type + "/0", f = new u(n[h].grouping_type, 0), t.sample_groups_info[p] || (t.sample_groups_info[p] = f));
+    }, y.setSampleGroupProperties = function(t, e, r, n) {
+      var o, a;
+      e.sample_groups = [];
+      for (o in n)
+        if (e.sample_groups[o] = {}, e.sample_groups[o].grouping_type = n[o].grouping_type, e.sample_groups[o].grouping_type_parameter = n[o].grouping_type_parameter, r >= n[o].last_sample_in_run && (n[o].last_sample_in_run < 0 && (n[o].last_sample_in_run = 0), n[o].entry_index++, n[o].entry_index <= n[o].sbgp.entries.length - 1 && (n[o].last_sample_in_run += n[o].sbgp.entries[n[o].entry_index].sample_count)), n[o].entry_index <= n[o].sbgp.entries.length - 1 ? e.sample_groups[o].group_description_index = n[o].sbgp.entries[n[o].entry_index].group_description_index : e.sample_groups[o].group_description_index = -1, e.sample_groups[o].group_description_index !== 0) {
+          var h;
+          n[o].fragment_description ? h = n[o].fragment_description : h = n[o].description, e.sample_groups[o].group_description_index > 0 ? (e.sample_groups[o].group_description_index > 65535 ? a = (e.sample_groups[o].group_description_index >> 16) - 1 : a = e.sample_groups[o].group_description_index - 1, h && a >= 0 && (e.sample_groups[o].description = h.entries[a])) : h && h.version >= 2 && h.default_group_description_index > 0 && (e.sample_groups[o].description = h.entries[h.default_group_description_index - 1]);
+        }
+    }, y.process_sdtp = function(t, e, r) {
+      e && (t ? (e.is_leading = t.is_leading[r], e.depends_on = t.sample_depends_on[r], e.is_depended_on = t.sample_is_depended_on[r], e.has_redundancy = t.sample_has_redundancy[r]) : (e.is_leading = 0, e.depends_on = 0, e.is_depended_on = 0, e.has_redundancy = 0));
+    }, y.prototype.buildSampleLists = function() {
+      var t, e;
+      for (t = 0; t < this.moov.traks.length; t++)
+        e = this.moov.traks[t], this.buildTrakSampleLists(e);
+    }, y.prototype.buildTrakSampleLists = function(t) {
+      var e, r, n, o, a, h, f, p, u, c, g, x, m, E, w, k, N, P, I, F, Y, K, z, O;
+      if (t.samples = [], t.samples_duration = 0, t.samples_size = 0, r = t.mdia.minf.stbl.stco || t.mdia.minf.stbl.co64, n = t.mdia.minf.stbl.stsc, o = t.mdia.minf.stbl.stsz || t.mdia.minf.stbl.stz2, a = t.mdia.minf.stbl.stts, h = t.mdia.minf.stbl.ctts, f = t.mdia.minf.stbl.stss, p = t.mdia.minf.stbl.stsd, u = t.mdia.minf.stbl.subs, x = t.mdia.minf.stbl.stdp, c = t.mdia.minf.stbl.sbgps, g = t.mdia.minf.stbl.sgpds, P = -1, I = -1, F = -1, Y = -1, K = 0, z = 0, O = 0, y.initSampleGroups(t, null, c, g), !(typeof o > "u")) {
+        for (e = 0; e < o.sample_sizes.length; e++) {
+          var U = {};
+          U.number = e, U.track_id = t.tkhd.track_id, U.timescale = t.mdia.mdhd.timescale, U.alreadyRead = 0, t.samples[e] = U, U.size = o.sample_sizes[e], t.samples_size += U.size, e === 0 ? (E = 1, m = 0, U.chunk_index = E, U.chunk_run_index = m, N = n.samples_per_chunk[m], k = 0, m + 1 < n.first_chunk.length ? w = n.first_chunk[m + 1] - 1 : w = 1 / 0) : e < N ? (U.chunk_index = E, U.chunk_run_index = m) : (E++, U.chunk_index = E, k = 0, E <= w || (m++, m + 1 < n.first_chunk.length ? w = n.first_chunk[m + 1] - 1 : w = 1 / 0), U.chunk_run_index = m, N += n.samples_per_chunk[m]), U.description_index = n.sample_description_index[U.chunk_run_index] - 1, U.description = p.entries[U.description_index], U.offset = r.chunk_offsets[U.chunk_index - 1] + k, k += U.size, e > P && (I++, P < 0 && (P = 0), P += a.sample_counts[I]), e > 0 ? (t.samples[e - 1].duration = a.sample_deltas[I], t.samples_duration += t.samples[e - 1].duration, U.dts = t.samples[e - 1].dts + t.samples[e - 1].duration) : U.dts = 0, h ? (e >= F && (Y++, F < 0 && (F = 0), F += h.sample_counts[Y]), U.cts = t.samples[e].dts + h.sample_offsets[Y]) : U.cts = U.dts, f ? (e == f.sample_numbers[K] - 1 ? (U.is_sync = !0, K++) : (U.is_sync = !1, U.degradation_priority = 0), u && u.entries[z].sample_delta + O == e + 1 && (U.subsamples = u.entries[z].subsamples, O += u.entries[z].sample_delta, z++)) : U.is_sync = !0, y.process_sdtp(t.mdia.minf.stbl.sdtp, U, U.number), x ? U.degradation_priority = x.priority[e] : U.degradation_priority = 0, u && u.entries[z].sample_delta + O == e && (U.subsamples = u.entries[z].subsamples, O += u.entries[z].sample_delta), (c.length > 0 || g.length > 0) && y.setSampleGroupProperties(t, U, e, t.sample_groups_info);
+        }
+        e > 0 && (t.samples[e - 1].duration = Math.max(t.mdia.mdhd.duration - t.samples[e - 1].dts, 0), t.samples_duration += t.samples[e - 1].duration);
+      }
+    }, y.prototype.updateSampleLists = function() {
+      var t, e, r, n, o, a, h, f, p, u, c, g, x, m, E;
+      if (this.moov !== void 0) {
+        for (; this.lastMoofIndex < this.moofs.length; )
+          if (p = this.moofs[this.lastMoofIndex], this.lastMoofIndex++, p.type == "moof")
+            for (u = p, t = 0; t < u.trafs.length; t++) {
+              for (c = u.trafs[t], g = this.getTrackById(c.tfhd.track_id), x = this.getTrexById(c.tfhd.track_id), c.tfhd.flags & s.TFHD_FLAG_SAMPLE_DESC ? n = c.tfhd.default_sample_description_index : n = x ? x.default_sample_description_index : 1, c.tfhd.flags & s.TFHD_FLAG_SAMPLE_DUR ? o = c.tfhd.default_sample_duration : o = x ? x.default_sample_duration : 0, c.tfhd.flags & s.TFHD_FLAG_SAMPLE_SIZE ? a = c.tfhd.default_sample_size : a = x ? x.default_sample_size : 0, c.tfhd.flags & s.TFHD_FLAG_SAMPLE_FLAGS ? h = c.tfhd.default_sample_flags : h = x ? x.default_sample_flags : 0, c.sample_number = 0, c.sbgps.length > 0 && y.initSampleGroups(g, c, c.sbgps, g.mdia.minf.stbl.sgpds, c.sgpds), e = 0; e < c.truns.length; e++) {
+                var w = c.truns[e];
+                for (r = 0; r < w.sample_count; r++) {
+                  m = {}, m.moof_number = this.lastMoofIndex, m.number_in_traf = c.sample_number, c.sample_number++, m.number = g.samples.length, c.first_sample_index = g.samples.length, g.samples.push(m), m.track_id = g.tkhd.track_id, m.timescale = g.mdia.mdhd.timescale, m.description_index = n - 1, m.description = g.mdia.minf.stbl.stsd.entries[m.description_index], m.size = a, w.flags & s.TRUN_FLAGS_SIZE && (m.size = w.sample_size[r]), g.samples_size += m.size, m.duration = o, w.flags & s.TRUN_FLAGS_DURATION && (m.duration = w.sample_duration[r]), g.samples_duration += m.duration, g.first_traf_merged || r > 0 ? m.dts = g.samples[g.samples.length - 2].dts + g.samples[g.samples.length - 2].duration : (c.tfdt ? m.dts = c.tfdt.baseMediaDecodeTime : m.dts = 0, g.first_traf_merged = !0), m.cts = m.dts, w.flags & s.TRUN_FLAGS_CTS_OFFSET && (m.cts = m.dts + w.sample_composition_time_offset[r]), E = h, w.flags & s.TRUN_FLAGS_FLAGS ? E = w.sample_flags[r] : r === 0 && w.flags & s.TRUN_FLAGS_FIRST_FLAG && (E = w.first_sample_flags), m.is_sync = !(E >> 16 & 1), m.is_leading = E >> 26 & 3, m.depends_on = E >> 24 & 3, m.is_depended_on = E >> 22 & 3, m.has_redundancy = E >> 20 & 3, m.degradation_priority = E & 65535;
+                  var k = !!(c.tfhd.flags & s.TFHD_FLAG_BASE_DATA_OFFSET), N = !!(c.tfhd.flags & s.TFHD_FLAG_DEFAULT_BASE_IS_MOOF), P = !!(w.flags & s.TRUN_FLAGS_DATA_OFFSET), I = 0;
+                  k ? I = c.tfhd.base_data_offset : N || e === 0 ? I = u.start : I = f, e === 0 && r === 0 ? P ? m.offset = I + w.data_offset : m.offset = I : m.offset = f, f = m.offset + m.size, (c.sbgps.length > 0 || c.sgpds.length > 0 || g.mdia.minf.stbl.sbgps.length > 0 || g.mdia.minf.stbl.sgpds.length > 0) && y.setSampleGroupProperties(g, m, m.number_in_traf, c.sample_groups_info);
+                }
+              }
+              if (c.subs) {
+                g.has_fragment_subsamples = !0;
+                var F = c.first_sample_index;
+                for (e = 0; e < c.subs.entries.length; e++)
+                  F += c.subs.entries[e].sample_delta, m = g.samples[F - 1], m.subsamples = c.subs.entries[e].subsamples;
+              }
+            }
+      }
+    }, y.prototype.getSample = function(t, e) {
+      var r, n = t.samples[e];
+      if (!this.moov)
+        return null;
+      if (!n.data)
+        n.data = new Uint8Array(n.size), n.alreadyRead = 0, this.samplesDataSize += n.size, l.debug("ISOFile", "Allocating sample #" + e + " on track #" + t.tkhd.track_id + " of size " + n.size + " (total: " + this.samplesDataSize + ")");
+      else if (n.alreadyRead == n.size)
+        return n;
+      for (; ; ) {
+        var o = this.stream.findPosition(!0, n.offset + n.alreadyRead, !1);
+        if (o > -1) {
+          r = this.stream.buffers[o];
+          var a = r.byteLength - (n.offset + n.alreadyRead - r.fileStart);
+          if (n.size - n.alreadyRead <= a)
+            return l.debug("ISOFile", "Getting sample #" + e + " data (alreadyRead: " + n.alreadyRead + " offset: " + (n.offset + n.alreadyRead - r.fileStart) + " read size: " + (n.size - n.alreadyRead) + " full size: " + n.size + ")"), d.memcpy(
+              n.data.buffer,
+              n.alreadyRead,
+              r,
+              n.offset + n.alreadyRead - r.fileStart,
+              n.size - n.alreadyRead
+            ), r.usedBytes += n.size - n.alreadyRead, this.stream.logBufferLevel(), n.alreadyRead = n.size, n;
+          if (a === 0) return null;
+          l.debug("ISOFile", "Getting sample #" + e + " partial data (alreadyRead: " + n.alreadyRead + " offset: " + (n.offset + n.alreadyRead - r.fileStart) + " read size: " + a + " full size: " + n.size + ")"), d.memcpy(
+            n.data.buffer,
+            n.alreadyRead,
+            r,
+            n.offset + n.alreadyRead - r.fileStart,
+            a
+          ), n.alreadyRead += a, r.usedBytes += a, this.stream.logBufferLevel();
+        } else
+          return null;
+      }
+    }, y.prototype.releaseSample = function(t, e) {
+      var r = t.samples[e];
+      return r.data ? (this.samplesDataSize -= r.size, r.data = null, r.alreadyRead = 0, r.size) : 0;
+    }, y.prototype.getAllocatedSampleDataSize = function() {
+      return this.samplesDataSize;
+    }, y.prototype.getCodecs = function() {
+      var t, e = "";
+      for (t = 0; t < this.moov.traks.length; t++) {
+        var r = this.moov.traks[t];
+        t > 0 && (e += ","), e += r.mdia.minf.stbl.stsd.entries[0].getCodec();
+      }
+      return e;
+    }, y.prototype.getTrexById = function(t) {
+      var e;
+      if (!this.moov || !this.moov.mvex) return null;
+      for (e = 0; e < this.moov.mvex.trexs.length; e++) {
+        var r = this.moov.mvex.trexs[e];
+        if (r.track_id == t) return r;
+      }
+      return null;
+    }, y.prototype.getTrackById = function(t) {
+      if (this.moov === void 0)
+        return null;
+      for (var e = 0; e < this.moov.traks.length; e++) {
+        var r = this.moov.traks[e];
+        if (r.tkhd.track_id == t) return r;
+      }
+      return null;
+    }, y.prototype.itemsDataSize = 0, y.prototype.flattenItemInfo = function() {
+      var t = this.items, e = this.entity_groups, r, n, o, a = this.meta;
+      if (a != null && a.hdlr !== void 0 && a.iinf !== void 0) {
+        for (r = 0; r < a.iinf.item_infos.length; r++)
+          o = {}, o.id = a.iinf.item_infos[r].item_ID, t[o.id] = o, o.ref_to = [], o.name = a.iinf.item_infos[r].item_name, a.iinf.item_infos[r].protection_index > 0 && (o.protection = a.ipro.protections[a.iinf.item_infos[r].protection_index - 1]), a.iinf.item_infos[r].item_type ? o.type = a.iinf.item_infos[r].item_type : o.type = "mime", o.content_type = a.iinf.item_infos[r].content_type, o.content_encoding = a.iinf.item_infos[r].content_encoding, o.item_uri_type = a.iinf.item_infos[r].item_uri_type;
+        if (a.grpl)
+          for (r = 0; r < a.grpl.boxes.length; r++)
+            entity_group = {}, entity_group.id = a.grpl.boxes[r].group_id, entity_group.entity_ids = a.grpl.boxes[r].entity_ids, entity_group.type = a.grpl.boxes[r].type, e[entity_group.id] = entity_group;
+        if (a.iloc)
+          for (r = 0; r < a.iloc.items.length; r++) {
+            var h = a.iloc.items[r];
+            switch (o = t[h.item_ID], h.data_reference_index !== 0 && (l.warn("Item storage with reference to other files: not supported"), o.source = a.dinf.boxes[h.data_reference_index - 1]), h.construction_method) {
+              case 0:
+                break;
+              case 1:
+                break;
+              case 2:
+                l.warn("Item storage with construction_method : not supported");
+                break;
+            }
+            for (o.extents = [], o.size = 0, n = 0; n < h.extents.length; n++)
+              o.extents[n] = {}, o.extents[n].offset = h.extents[n].extent_offset + h.base_offset, h.construction_method == 1 && (o.extents[n].offset += a.idat.start + a.idat.hdr_size), o.extents[n].length = h.extents[n].extent_length, o.extents[n].alreadyRead = 0, o.size += o.extents[n].length;
+          }
+        if (a.pitm && (t[a.pitm.item_id].primary = !0), a.iref)
+          for (r = 0; r < a.iref.references.length; r++) {
+            var f = a.iref.references[r];
+            for (n = 0; n < f.references.length; n++)
+              t[f.from_item_ID].ref_to.push({ type: f.type, id: f.references[n] });
+          }
+        if (a.iprp)
+          for (var p = 0; p < a.iprp.ipmas.length; p++) {
+            var u = a.iprp.ipmas[p];
+            for (r = 0; r < u.associations.length; r++) {
+              var c = u.associations[r];
+              if (o = t[c.id], o || (o = e[c.id]), o)
+                for (o.properties === void 0 && (o.properties = {}, o.properties.boxes = []), n = 0; n < c.props.length; n++) {
+                  var g = c.props[n];
+                  if (g.property_index > 0 && g.property_index - 1 < a.iprp.ipco.boxes.length) {
+                    var x = a.iprp.ipco.boxes[g.property_index - 1];
+                    o.properties[x.type] = x, o.properties.boxes.push(x);
+                  }
+                }
+            }
+          }
+      }
+    }, y.prototype.getItem = function(t) {
+      var e, r;
+      if (!this.meta)
+        return null;
+      if (r = this.items[t], !r.data && r.size)
+        r.data = new Uint8Array(r.size), r.alreadyRead = 0, this.itemsDataSize += r.size, l.debug("ISOFile", "Allocating item #" + t + " of size " + r.size + " (total: " + this.itemsDataSize + ")");
+      else if (r.alreadyRead === r.size)
+        return r;
+      for (var n = 0; n < r.extents.length; n++) {
+        var o = r.extents[n];
+        if (o.alreadyRead !== o.length) {
+          var a = this.stream.findPosition(!0, o.offset + o.alreadyRead, !1);
+          if (a > -1) {
+            e = this.stream.buffers[a];
+            var h = e.byteLength - (o.offset + o.alreadyRead - e.fileStart);
+            if (o.length - o.alreadyRead <= h)
+              l.debug("ISOFile", "Getting item #" + t + " extent #" + n + " data (alreadyRead: " + o.alreadyRead + " offset: " + (o.offset + o.alreadyRead - e.fileStart) + " read size: " + (o.length - o.alreadyRead) + " full extent size: " + o.length + " full item size: " + r.size + ")"), d.memcpy(
+                r.data.buffer,
+                r.alreadyRead,
+                e,
+                o.offset + o.alreadyRead - e.fileStart,
+                o.length - o.alreadyRead
+              ), e.usedBytes += o.length - o.alreadyRead, this.stream.logBufferLevel(), r.alreadyRead += o.length - o.alreadyRead, o.alreadyRead = o.length;
+            else
+              return l.debug("ISOFile", "Getting item #" + t + " extent #" + n + " partial data (alreadyRead: " + o.alreadyRead + " offset: " + (o.offset + o.alreadyRead - e.fileStart) + " read size: " + h + " full extent size: " + o.length + " full item size: " + r.size + ")"), d.memcpy(
+                r.data.buffer,
+                r.alreadyRead,
+                e,
+                o.offset + o.alreadyRead - e.fileStart,
+                h
+              ), o.alreadyRead += h, r.alreadyRead += h, e.usedBytes += h, this.stream.logBufferLevel(), null;
+          } else
+            return null;
+        }
+      }
+      return r.alreadyRead === r.size ? r : null;
+    }, y.prototype.releaseItem = function(t) {
+      var e = this.items[t];
+      if (e.data) {
+        this.itemsDataSize -= e.size, e.data = null, e.alreadyRead = 0;
+        for (var r = 0; r < e.extents.length; r++) {
+          var n = e.extents[r];
+          n.alreadyRead = 0;
+        }
+        return e.size;
+      } else
+        return 0;
+    }, y.prototype.processItems = function(t) {
+      for (var e in this.items) {
+        var r = this.items[e];
+        this.getItem(r.id), t && !r.sent && (t(r), r.sent = !0, r.data = null);
+      }
+    }, y.prototype.hasItem = function(t) {
+      for (var e in this.items) {
+        var r = this.items[e];
+        if (r.name === t)
+          return r.id;
+      }
+      return -1;
+    }, y.prototype.getMetaHandler = function() {
+      return this.meta ? this.meta.hdlr.handler : null;
+    }, y.prototype.getPrimaryItem = function() {
+      return !this.meta || !this.meta.pitm ? null : this.getItem(this.meta.pitm.item_id);
+    }, y.prototype.itemToFragmentedTrackFile = function(t) {
+      var e = t || {}, r = null;
+      if (e.itemId ? r = this.getItem(e.itemId) : r = this.getPrimaryItem(), r == null) return null;
+      var n = new y();
+      n.discardMdatData = !1;
+      var o = { type: r.type, description_boxes: r.properties.boxes };
+      r.properties.ispe && (o.width = r.properties.ispe.image_width, o.height = r.properties.ispe.image_height);
+      var a = n.addTrack(o);
+      return a ? (n.addSample(a, r.data), n) : null;
+    }, y.prototype.write = function(t) {
+      for (var e = 0; e < this.boxes.length; e++)
+        this.boxes[e].write(t);
+    }, y.prototype.createFragment = function(t, e, r) {
+      var n = this.getTrackById(t), o = this.getSample(n, e);
+      if (o == null)
+        return this.setNextSeekPositionFromSample(n.samples[e]), null;
+      var a = r || new d();
+      a.endianness = d.BIG_ENDIAN;
+      var h = this.createSingleSampleMoof(o);
+      h.write(a), h.trafs[0].truns[0].data_offset = h.size + 8, l.debug("MP4Box", "Adjusting data_offset with new value " + h.trafs[0].truns[0].data_offset), a.adjustUint32(h.trafs[0].truns[0].data_offset_position, h.trafs[0].truns[0].data_offset);
+      var f = new s.mdatBox();
+      return f.data = o.data, f.write(a), a;
+    }, y.writeInitializationSegment = function(t, e, r, n) {
+      var o;
+      l.debug("ISOFile", "Generating initialization segment");
+      var a = new d();
+      a.endianness = d.BIG_ENDIAN, t.write(a);
+      var h = e.add("mvex");
+      for (r && h.add("mehd").set("fragment_duration", r), o = 0; o < e.traks.length; o++)
+        h.add("trex").set("track_id", e.traks[o].tkhd.track_id).set("default_sample_description_index", 1).set("default_sample_duration", n).set("default_sample_size", 0).set("default_sample_flags", 65536);
+      return e.write(a), a.buffer;
+    }, y.prototype.save = function(t) {
+      var e = new d();
+      e.endianness = d.BIG_ENDIAN, this.write(e), e.save(t);
+    }, y.prototype.getBuffer = function() {
+      var t = new d();
+      return t.endianness = d.BIG_ENDIAN, this.write(t), t.buffer;
+    }, y.prototype.initializeSegmentation = function() {
+      var t, e, r, n;
+      for (this.onSegment === null && l.warn("MP4Box", "No segmentation callback set!"), this.isFragmentationInitialized || (this.isFragmentationInitialized = !0, this.nextMoofNumber = 0, this.resetTables()), e = [], t = 0; t < this.fragmentedTracks.length; t++) {
+        var o = new s.moovBox();
+        o.mvhd = this.moov.mvhd, o.boxes.push(o.mvhd), r = this.getTrackById(this.fragmentedTracks[t].id), o.boxes.push(r), o.traks.push(r), n = {}, n.id = r.tkhd.track_id, n.user = this.fragmentedTracks[t].user, n.buffer = y.writeInitializationSegment(this.ftyp, o, this.moov.mvex && this.moov.mvex.mehd ? this.moov.mvex.mehd.fragment_duration : void 0, this.moov.traks[t].samples.length > 0 ? this.moov.traks[t].samples[0].duration : 0), e.push(n);
+      }
+      return e;
+    }, s.Box.prototype.printHeader = function(t) {
+      this.size += 8, this.size > b && (this.size += 8), this.type === "uuid" && (this.size += 16), t.log(t.indent + "size:" + this.size), t.log(t.indent + "type:" + this.type);
+    }, s.FullBox.prototype.printHeader = function(t) {
+      this.size += 4, s.Box.prototype.printHeader.call(this, t), t.log(t.indent + "version:" + this.version), t.log(t.indent + "flags:" + this.flags);
+    }, s.Box.prototype.print = function(t) {
+      this.printHeader(t);
+    }, s.ContainerBox.prototype.print = function(t) {
+      this.printHeader(t);
+      for (var e = 0; e < this.boxes.length; e++)
+        if (this.boxes[e]) {
+          var r = t.indent;
+          t.indent += " ", this.boxes[e].print(t), t.indent = r;
+        }
+    }, y.prototype.print = function(t) {
+      t.indent = "";
+      for (var e = 0; e < this.boxes.length; e++)
+        this.boxes[e] && this.boxes[e].print(t);
+    }, s.mvhdBox.prototype.print = function(t) {
+      s.FullBox.prototype.printHeader.call(this, t), t.log(t.indent + "creation_time: " + this.creation_time), t.log(t.indent + "modification_time: " + this.modification_time), t.log(t.indent + "timescale: " + this.timescale), t.log(t.indent + "duration: " + this.duration), t.log(t.indent + "rate: " + this.rate), t.log(t.indent + "volume: " + (this.volume >> 8)), t.log(t.indent + "matrix: " + this.matrix.join(", ")), t.log(t.indent + "next_track_id: " + this.next_track_id);
+    }, s.tkhdBox.prototype.print = function(t) {
+      s.FullBox.prototype.printHeader.call(this, t), t.log(t.indent + "creation_time: " + this.creation_time), t.log(t.indent + "modification_time: " + this.modification_time), t.log(t.indent + "track_id: " + this.track_id), t.log(t.indent + "duration: " + this.duration), t.log(t.indent + "volume: " + (this.volume >> 8)), t.log(t.indent + "matrix: " + this.matrix.join(", ")), t.log(t.indent + "layer: " + this.layer), t.log(t.indent + "alternate_group: " + this.alternate_group), t.log(t.indent + "width: " + this.width), t.log(t.indent + "height: " + this.height);
+    };
+    var $ = {};
+    $.createFile = function(t, e) {
+      var r = t !== void 0 ? t : !0, n = new y(e);
+      return n.discardMdatData = !r, n;
+    }, v.createFile = $.createFile;
+  })(X)), X;
+}
+var dt = lt(), ft = /* @__PURE__ */ ht({
+  __proto__: null
+}, [dt]);
+const W = ft;
+typeof globalThis < "u" && W.DataStream && (globalThis.DataStream = W.DataStream);
+const pt = W.createFile;
+let D = !1, st = 0, nt = 0, T = null, V = 0, A = null, L = null;
+const C = [], et = [], it = 3;
+function H(v) {
+  self.postMessage(v);
+}
+function ot(v, l) {
+  H({ type: "error", message: v, code: l });
+}
+function rt(v, l) {
+  st = v, nt = l - performance.timeOrigin;
+}
+function ut() {
+  const v = performance.now() - nt;
+  return (st * 1e3 + v) * 1e3;
+}
+const ct = 5e3, G = class G {
+  constructor() {
+    this.info = null, this.infoResolver = null, this.errorResolver = null, this.loadError = null, this.videoTrack = null, this.audioTrack = null, this.videoSamples = [], this.audioSamples = [], this.videoSampleResolver = null, this.audioSampleResolver = null, this.file = pt(), this.file.onError = (l) => {
+      this.loadError = new Error(l || "Invalid or unsupported media"), this.errorResolver && (this.errorResolver(this.loadError), this.errorResolver = null), this.infoResolver = null;
+    }, this.file.onReady = this.onReady.bind(this), this.file.onSamples = this.onSamples.bind(this);
+  }
+  async loadFromUrl(l) {
+    this.loadError = null, this.info = null;
+    const _ = await fetch(l, {
+      headers: { Range: `bytes=0-${G.STREAM_CHUNK_SIZE - 1}` }
+    });
+    if (_.status === 200 && !_.headers.has("Content-Range")) {
+      await this.loadFromBuffer(await _.arrayBuffer());
+      return;
+    }
+    if (_.status !== 200 && _.status !== 206)
+      throw new Error(`Fetch failed: ${_.status}`);
+    let d = 0;
+    const b = G.STREAM_CHUNK_SIZE;
+    for (; ; ) {
+      const S = d === 0 ? _ : await fetch(l, {
+        headers: { Range: `bytes=${d}-${d + b - 1}` }
+      });
+      if (S.status !== 200 && S.status !== 206)
+        throw new Error(`Fetch failed: ${S.status}`);
+      const B = await S.arrayBuffer();
+      if (B.byteLength === 0) {
+        this.file.flush();
+        break;
+      }
+      const s = B;
+      s.fileStart = d;
+      const R = this.file.appendBuffer(s);
+      if (d = typeof R == "number" ? R : d + B.byteLength, B.byteLength < b) {
+        this.file.flush();
+        break;
+      }
+    }
+  }
+  async loadFromBuffer(l) {
+    this.loadError = null, this.info = null;
+    const _ = l;
+    _.fileStart = 0, this.file.appendBuffer(_), this.file.flush();
+  }
+  onReady(l) {
+    this.info = l, this.videoTrack = l.videoTracks[0], this.audioTrack = l.audioTracks[0], this.videoTrack && this.file.setExtractionOptions(this.videoTrack.id, null, { nbSamples: 50 }), this.audioTrack && this.file.setExtractionOptions(this.audioTrack.id, null, { nbSamples: 50 }), this.file.start(), this.infoResolver && (this.infoResolver(l), this.infoResolver = null);
+  }
+  onSamples(l, _, d) {
+    if (this.videoTrack && l === this.videoTrack.id) {
+      if (this.videoSamples.push(...d), this.videoSampleResolver && this.videoSamples.length > 0) {
+        const b = this.videoSamples.shift();
+        b !== void 0 && this.videoSampleResolver(b), this.videoSampleResolver = null;
+      }
+    } else if (this.audioTrack && l === this.audioTrack.id && (this.audioSamples.push(...d), this.audioSampleResolver && this.audioSamples.length > 0)) {
+      const b = this.audioSamples.shift();
+      b !== void 0 && this.audioSampleResolver(b), this.audioSampleResolver = null;
+    }
+  }
+  async getInfo() {
+    if (this.info) return this.info;
+    if (this.loadError) return Promise.reject(this.loadError);
+    const l = new Promise((d, b) => {
+      setTimeout(
+        () => b(new Error("Invalid or unsupported media")),
+        ct
+      );
+    }), _ = new Promise((d, b) => {
+      this.infoResolver = d, this.errorResolver = b;
+    });
+    return Promise.race([_, l]);
+  }
+  getVideoDecoderConfig() {
+    if (!this.videoTrack) return null;
+    const l = this.videoTrack.codec.startsWith("vp08") ? "vp8" : this.videoTrack.codec, _ = this.getVideoDescription();
+    return {
+      codec: l,
+      codedWidth: this.videoTrack.video.width,
+      codedHeight: this.videoTrack.video.height,
+      ..._ && { description: _ }
+    };
+  }
+  getAudioDecoderConfig() {
+    if (!this.audioTrack) return null;
+    const l = this.getAudioDescription();
+    return {
+      codec: this.audioTrack.codec,
+      sampleRate: this.audioTrack.audio.sample_rate,
+      numberOfChannels: this.audioTrack.audio.channel_count,
+      ...l && { description: l }
+    };
+  }
+  getVideoDescription() {
+    if (!this.videoTrack) return;
+    const l = this.file.getTrackById(this.videoTrack.id);
+    if (l)
+      for (const _ of l.mdia.minf.stbl.stsd.entries) {
+        const d = _.avcC || _.hvcC || _.vpcC || _.av1C;
+        if (d) {
+          const b = new DataStream(void 0, 0, DataStream.BIG_ENDIAN);
+          return d.write(b), b.buffer.slice(8);
+        }
+      }
+  }
+  getAudioDescription() {
+    if (!this.audioTrack) return;
+    const l = this.file.getTrackById(this.audioTrack.id);
+    if (!l) return;
+    const _ = l.mdia.minf.stbl.stsd.entries[0];
+    if (_?.esds?.esd?.descs?.[0]?.descs?.[0]?.data) {
+      const d = _.esds.esd.descs[0].descs[0].data;
+      return d.buffer.slice(d.byteOffset, d.byteOffset + d.byteLength);
+    }
+  }
+  startVideoExtraction() {
+    this.videoTrack && this.file.start();
+  }
+  startAudioExtraction() {
+    this.audioTrack && this.file.start();
+  }
+  async getNextVideoSample() {
+    return this.videoSamples.length > 0 ? this.videoSamples.shift() ?? null : this.videoTrack ? new Promise((l) => {
+      this.videoSampleResolver = l, this.file.start();
+    }) : null;
+  }
+  async getNextAudioSample() {
+    return this.audioSamples.length > 0 ? this.audioSamples.shift() ?? null : this.audioTrack ? new Promise((l) => {
+      this.audioSampleResolver = l, this.file.start();
+    }) : null;
+  }
+  /** Reset extraction position so next getNextVideoSample() returns from given time (e.g. after seek). */
+  seek(l) {
+    this.file.seek(l, !0);
+  }
+  getMediaInfo() {
+    const l = this.info;
+    if (!l) throw new Error("Demuxer not initialized");
+    const _ = {
+      duration: l.duration / l.timescale,
+      isFragmented: l.isFragmented,
+      brands: l.brands
+    };
+    if (this.videoTrack) {
+      const d = this.videoTrack.nb_samples / (this.videoTrack.duration / this.videoTrack.timescale);
+      _.videoTrack = {
+        codec: this.videoTrack.codec,
+        width: this.videoTrack.video.width,
+        height: this.videoTrack.video.height,
+        frameRate: d,
+        bitrate: this.videoTrack.bitrate
+      };
+    }
+    return this.audioTrack && (_.audioTrack = {
+      codec: this.audioTrack.codec,
+      sampleRate: this.audioTrack.audio.sample_rate,
+      channelCount: this.audioTrack.audio.channel_count,
+      bitrate: this.audioTrack.bitrate
+    }), _;
+  }
+  hasVideoTrack() {
+    return this.videoTrack !== null;
+  }
+  hasAudioTrack() {
+    return this.audioTrack !== null;
+  }
+};
+G.STREAM_CHUNK_SIZE = 256 * 1024;
+let Z = G;
+class _t {
+  constructor(l) {
+    this.fillInProgress = !1, this.getNextSample = l, this.decoder = new VideoDecoder({
+      output: (_) => {
+        C.push(_);
+      },
+      error: (_) => {
+        console.error("[VideoDecoder]", _), ot(`Video decode error: ${_.message}`, "DECODE_ERROR");
+      }
+    });
+  }
+  async configure(l) {
+    if (!(await VideoDecoder.isConfigSupported(l)).supported)
+      throw new Error(`Video codec not supported: ${l.codec}`);
+    this.decoder.configure(l);
+  }
+  async fillBuffer() {
+    if (!this.fillInProgress) {
+      this.fillInProgress = !0;
+      try {
+        for (; C.length < it && this.decoder.decodeQueueSize < it; ) {
+          const l = await this.getNextSample();
+          if (!l) break;
+          const _ = new EncodedVideoChunk({
+            type: l.is_sync ? "key" : "delta",
+            timestamp: l.cts * 1e6 / l.timescale,
+            duration: l.duration * 1e6 / l.timescale,
+            data: l.data
+          });
+          this.decoder.decode(_);
+        }
+      } catch (l) {
+        console.error("[VideoDecoder] Fill error:", l);
+      }
+      this.fillInProgress = !1;
+    }
+  }
+  async flush() {
+    this.decoder.state === "configured" && await this.decoder.flush();
+  }
+  close() {
+    this.decoder.state !== "closed" && this.decoder.close();
+  }
+}
+function at() {
+  if (!D) return;
+  const v = ut(), l = v / 1e6;
+  if (V > 0 && l >= V - 1e-3) {
+    D = !1, T !== null && (cancelAnimationFrame(T), T = null), H({ type: "ended" });
+    return;
+  }
+  let _ = null, d = -1, b = Number.MAX_VALUE;
+  for (let S = 0; S < C.length; S++) {
+    const B = Math.abs(v - C[S].timestamp);
+    B < b && (b = B, d = S);
+  }
+  if (d >= 0) {
+    for (let S = 0; S < d; S++)
+      C[S].close();
+    C.splice(0, d), _ = C.shift() || null;
+  }
+  if (_) {
+    const S = {
+      type: "frame-ready",
+      frame: _,
+      timestamp: _.timestamp
+    };
+    H(S);
+  }
+  L?.fillBuffer(), T = requestAnimationFrame(at);
+}
+async function yt(v) {
+  switch (v.command) {
+    case "initialize": {
+      try {
+        if (A = new Z(), typeof v.source == "string" ? await A.loadFromUrl(v.source) : await A.loadFromBuffer(v.source), await A.getInfo(), A.hasVideoTrack()) {
+          const S = A.getVideoDecoderConfig();
+          if (S) {
+            const B = A;
+            L = new _t(
+              () => B ? B.getNextVideoSample() : Promise.resolve(null)
+            ), await L.configure(S), A.startVideoExtraction(), await L.fillBuffer();
+          }
+        }
+        let l = null, _;
+        A.hasAudioTrack() && (l = A.getAudioDecoderConfig(), l && A.startAudioExtraction());
+        const d = A.getMediaInfo();
+        V = d.duration;
+        const b = {
+          type: "initialize-done",
+          mediaInfo: d,
+          sampleRate: l?.sampleRate,
+          channelCount: l?.numberOfChannels,
+          sharedArrayBuffer: _
+        };
+        H(b);
+      } catch (l) {
+        ot(l.message, "LOAD_ERROR");
+      }
+      break;
+    }
+    case "play": {
+      D = !0, rt(v.mediaTimeSecs, v.mediaTimeCapturedAtHighResTimestamp), T = requestAnimationFrame(at);
+      break;
+    }
+    case "pause": {
+      D = !1, T !== null && (cancelAnimationFrame(T), T = null);
+      break;
+    }
+    case "update-media-time": {
+      rt(v.mediaTimeSecs, v.mediaTimeCapturedAtHighResTimestamp);
+      break;
+    }
+    case "seek": {
+      A && A.seek(v.time);
+      for (const l of C)
+        l.close();
+      C.length = 0;
+      for (const l of et)
+        l.close();
+      et.length = 0, await L?.flush(), await L?.fillBuffer(), H({ type: "seek-done", time: v.time });
+      break;
+    }
+    case "stop": {
+      D = !1, T !== null && (cancelAnimationFrame(T), T = null);
+      for (const l of C)
+        l.close();
+      C.length = 0;
+      break;
+    }
+    case "destroy": {
+      D = !1, V = 0, T !== null && cancelAnimationFrame(T);
+      for (const l of C)
+        l.close();
+      C.length = 0, L?.close();
+      break;
+    }
+  }
+}
+self.addEventListener("message", async (v) => {
+  await yt(v.data);
+});
+//# sourceMappingURL=media-worker-DqCztg6H.js.map