@dolbylaboratories/alps 2.0.0

package/dist/alps.bundle.js

@@ -0,0 +1,4929 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+// node_modules/codem-isoboxer/dist/iso_boxer.js
+var require_iso_boxer = __commonJS({
+  "node_modules/codem-isoboxer/dist/iso_boxer.js"(exports) {
+    var ISOBoxer2 = {};
+    ISOBoxer2.parseBuffer = function(arrayBuffer) {
+      return new ISOFile(arrayBuffer).parse();
+    };
+    ISOBoxer2.addBoxProcessor = function(type, parser) {
+      if (typeof type !== "string" || typeof parser !== "function") {
+        return;
+      }
+      ISOBox.prototype._boxProcessors[type] = parser;
+    };
+    ISOBoxer2.createFile = function() {
+      return new ISOFile();
+    };
+    ISOBoxer2.createBox = function(type, parent, pos) {
+      var newBox = ISOBox.create(type);
+      if (parent) {
+        parent.append(newBox, pos);
+      }
+      return newBox;
+    };
+    ISOBoxer2.createFullBox = function(type, parent, pos) {
+      var newBox = ISOBoxer2.createBox(type, parent, pos);
+      newBox.version = 0;
+      newBox.flags = 0;
+      return newBox;
+    };
+    ISOBoxer2.Utils = {};
+    ISOBoxer2.Utils.dataViewToString = function(dataView, encoding) {
+      var impliedEncoding = encoding || "utf-8";
+      if (typeof TextDecoder !== "undefined") {
+        return new TextDecoder(impliedEncoding).decode(dataView);
+      }
+      var a = [];
+      var i = 0;
+      if (impliedEncoding === "utf-8") {
+        while (i < dataView.byteLength) {
+          var c = dataView.getUint8(i++);
+          if (c < 128) {
+          } else if (c < 224) {
+            c = (c & 31) << 6;
+            c |= dataView.getUint8(i++) & 63;
+          } else if (c < 240) {
+            c = (c & 15) << 12;
+            c |= (dataView.getUint8(i++) & 63) << 6;
+            c |= dataView.getUint8(i++) & 63;
+          } else {
+            c = (c & 7) << 18;
+            c |= (dataView.getUint8(i++) & 63) << 12;
+            c |= (dataView.getUint8(i++) & 63) << 6;
+            c |= dataView.getUint8(i++) & 63;
+          }
+          a.push(String.fromCharCode(c));
+        }
+      } else {
+        while (i < dataView.byteLength) {
+          a.push(String.fromCharCode(dataView.getUint8(i++)));
+        }
+      }
+      return a.join("");
+    };
+    ISOBoxer2.Utils.utf8ToByteArray = function(string) {
+      var u, i;
+      if (typeof TextEncoder !== "undefined") {
+        u = new TextEncoder().encode(string);
+      } else {
+        u = [];
+        for (i = 0; i < string.length; ++i) {
+          var c = string.charCodeAt(i);
+          if (c < 128) {
+            u.push(c);
+          } else if (c < 2048) {
+            u.push(192 | c >> 6);
+            u.push(128 | 63 & c);
+          } else if (c < 65536) {
+            u.push(224 | c >> 12);
+            u.push(128 | 63 & c >> 6);
+            u.push(128 | 63 & c);
+          } else {
+            u.push(240 | c >> 18);
+            u.push(128 | 63 & c >> 12);
+            u.push(128 | 63 & c >> 6);
+            u.push(128 | 63 & c);
+          }
+        }
+      }
+      return u;
+    };
+    ISOBoxer2.Utils.appendBox = function(parent, box, pos) {
+      box._offset = parent._cursor.offset;
+      box._root = parent._root ? parent._root : parent;
+      box._raw = parent._raw;
+      box._parent = parent;
+      if (pos === -1) {
+        return;
+      }
+      if (pos === void 0 || pos === null) {
+        parent.boxes.push(box);
+        return;
+      }
+      var index = -1, type;
+      if (typeof pos === "number") {
+        index = pos;
+      } else {
+        if (typeof pos === "string") {
+          type = pos;
+        } else if (typeof pos === "object" && pos.type) {
+          type = pos.type;
+        } else {
+          parent.boxes.push(box);
+          return;
+        }
+        for (var i = 0; i < parent.boxes.length; i++) {
+          if (type === parent.boxes[i].type) {
+            index = i + 1;
+            break;
+          }
+        }
+      }
+      parent.boxes.splice(index, 0, box);
+    };
+    if (typeof exports !== "undefined") {
+      exports.parseBuffer = ISOBoxer2.parseBuffer;
+      exports.addBoxProcessor = ISOBoxer2.addBoxProcessor;
+      exports.createFile = ISOBoxer2.createFile;
+      exports.createBox = ISOBoxer2.createBox;
+      exports.createFullBox = ISOBoxer2.createFullBox;
+      exports.Utils = ISOBoxer2.Utils;
+    }
+    ISOBoxer2.Cursor = function(initialOffset) {
+      this.offset = typeof initialOffset == "undefined" ? 0 : initialOffset;
+    };
+    var ISOFile = function(arrayBuffer) {
+      this._cursor = new ISOBoxer2.Cursor();
+      this.boxes = [];
+      if (arrayBuffer) {
+        this._raw = new DataView(arrayBuffer);
+      }
+    };
+    ISOFile.prototype.fetch = function(type) {
+      var result = this.fetchAll(type, true);
+      return result.length ? result[0] : null;
+    };
+    ISOFile.prototype.fetchAll = function(type, returnEarly) {
+      var result = [];
+      ISOFile._sweep.call(this, type, result, returnEarly);
+      return result;
+    };
+    ISOFile.prototype.parse = function() {
+      this._cursor.offset = 0;
+      this.boxes = [];
+      while (this._cursor.offset < this._raw.byteLength) {
+        var box = ISOBox.parse(this);
+        if (typeof box.type === "undefined") break;
+        this.boxes.push(box);
+      }
+      return this;
+    };
+    ISOFile._sweep = function(type, result, returnEarly) {
+      if (this.type && this.type == type) result.push(this);
+      for (var box in this.boxes) {
+        if (result.length && returnEarly) return;
+        ISOFile._sweep.call(this.boxes[box], type, result, returnEarly);
+      }
+    };
+    ISOFile.prototype.write = function() {
+      var length = 0, i;
+      for (i = 0; i < this.boxes.length; i++) {
+        length += this.boxes[i].getLength(false);
+      }
+      var bytes = new Uint8Array(length);
+      this._rawo = new DataView(bytes.buffer);
+      this.bytes = bytes;
+      this._cursor.offset = 0;
+      for (i = 0; i < this.boxes.length; i++) {
+        this.boxes[i].write();
+      }
+      return bytes.buffer;
+    };
+    ISOFile.prototype.append = function(box, pos) {
+      ISOBoxer2.Utils.appendBox(this, box, pos);
+    };
+    var ISOBox = function() {
+      this._cursor = new ISOBoxer2.Cursor();
+    };
+    ISOBox.parse = function(parent) {
+      var newBox = new ISOBox();
+      newBox._offset = parent._cursor.offset;
+      newBox._root = parent._root ? parent._root : parent;
+      newBox._raw = parent._raw;
+      newBox._parent = parent;
+      newBox._parseBox();
+      parent._cursor.offset = newBox._raw.byteOffset + newBox._raw.byteLength;
+      return newBox;
+    };
+    ISOBox.create = function(type) {
+      var newBox = new ISOBox();
+      newBox.type = type;
+      newBox.boxes = [];
+      return newBox;
+    };
+    ISOBox.prototype._boxContainers = ["dinf", "edts", "mdia", "meco", "mfra", "minf", "moof", "moov", "mvex", "stbl", "strk", "traf", "trak", "tref", "udta", "vttc", "sinf", "schi", "encv", "enca", "meta", "grpl", "prsl"];
+    ISOBox.prototype._boxProcessors = {};
+    ISOBox.prototype._procField = function(name, type, size) {
+      if (this._parsing) {
+        this[name] = this._readField(type, size);
+      } else {
+        this._writeField(type, size, this[name]);
+      }
+    };
+    ISOBox.prototype._procFieldArray = function(name, length, type, size) {
+      var i;
+      if (this._parsing) {
+        this[name] = [];
+        for (i = 0; i < length; i++) {
+          this[name][i] = this._readField(type, size);
+        }
+      } else {
+        for (i = 0; i < this[name].length; i++) {
+          this._writeField(type, size, this[name][i]);
+        }
+      }
+    };
+    ISOBox.prototype._procFullBox = function() {
+      this._procField("version", "uint", 8);
+      this._procField("flags", "uint", 24);
+    };
+    ISOBox.prototype._procEntries = function(name, length, fn) {
+      var i;
+      if (this._parsing) {
+        this[name] = [];
+        for (i = 0; i < length; i++) {
+          this[name].push({});
+          fn.call(this, this[name][i]);
+        }
+      } else {
+        for (i = 0; i < length; i++) {
+          fn.call(this, this[name][i]);
+        }
+      }
+    };
+    ISOBox.prototype._procSubEntries = function(entry, name, length, fn) {
+      var i;
+      if (this._parsing) {
+        entry[name] = [];
+        for (i = 0; i < length; i++) {
+          entry[name].push({});
+          fn.call(this, entry[name][i]);
+        }
+      } else {
+        for (i = 0; i < length; i++) {
+          fn.call(this, entry[name][i]);
+        }
+      }
+    };
+    ISOBox.prototype._procEntryField = function(entry, name, type, size) {
+      if (this._parsing) {
+        entry[name] = this._readField(type, size);
+      } else {
+        this._writeField(type, size, entry[name]);
+      }
+    };
+    ISOBox.prototype._procSubBoxes = function(name, length) {
+      var i;
+      if (this._parsing) {
+        this[name] = [];
+        for (i = 0; i < length; i++) {
+          this[name].push(ISOBox.parse(this));
+        }
+      } else {
+        for (i = 0; i < length; i++) {
+          if (this._rawo) {
+            this[name][i].write();
+          } else {
+            this.size += this[name][i].getLength();
+          }
+        }
+      }
+    };
+    ISOBox.prototype._readField = function(type, size) {
+      switch (type) {
+        case "uint":
+          return this._readUint(size);
+        case "int":
+          return this._readInt(size);
+        case "template":
+          return this._readTemplate(size);
+        case "string":
+          return size === -1 ? this._readTerminatedString() : this._readString(size);
+        case "data":
+          return this._readData(size);
+        case "utf8":
+          return this._readUTF8String();
+        case "utf8string":
+          return this._readUTF8TerminatedString();
+        default:
+          return -1;
+      }
+    };
+    ISOBox.prototype._readInt = function(size) {
+      var result = null, offset = this._cursor.offset - this._raw.byteOffset;
+      switch (size) {
+        case 8:
+          result = this._raw.getInt8(offset);
+          break;
+        case 16:
+          result = this._raw.getInt16(offset);
+          break;
+        case 32:
+          result = this._raw.getInt32(offset);
+          break;
+        case 64:
+          var s1 = this._raw.getInt32(offset);
+          var s2 = this._raw.getInt32(offset + 4);
+          result = s1 * Math.pow(2, 32) + s2;
+          break;
+      }
+      this._cursor.offset += size >> 3;
+      return result;
+    };
+    ISOBox.prototype._readUint = function(size) {
+      var result = null, offset = this._cursor.offset - this._raw.byteOffset, s1, s2;
+      switch (size) {
+        case 8:
+          result = this._raw.getUint8(offset);
+          break;
+        case 16:
+          result = this._raw.getUint16(offset);
+          break;
+        case 24:
+          s1 = this._raw.getUint16(offset);
+          s2 = this._raw.getUint8(offset + 2);
+          result = (s1 << 8) + s2;
+          break;
+        case 32:
+          result = this._raw.getUint32(offset);
+          break;
+        case 64:
+          s1 = this._raw.getUint32(offset);
+          s2 = this._raw.getUint32(offset + 4);
+          result = s1 * Math.pow(2, 32) + s2;
+          break;
+      }
+      this._cursor.offset += size >> 3;
+      return result;
+    };
+    ISOBox.prototype._readString = function(length) {
+      var str = "";
+      for (var c = 0; c < length; c++) {
+        var char = this._readUint(8);
+        str += String.fromCharCode(char);
+      }
+      return str;
+    };
+    ISOBox.prototype._readTemplate = function(size) {
+      var pre = this._readUint(size / 2);
+      var post = this._readUint(size / 2);
+      return pre + post / Math.pow(2, size / 2);
+    };
+    ISOBox.prototype._readTerminatedString = function() {
+      var str = "";
+      while (this._cursor.offset - this._offset < this._raw.byteLength) {
+        var char = this._readUint(8);
+        if (char === 0) break;
+        str += String.fromCharCode(char);
+      }
+      return str;
+    };
+    ISOBox.prototype._readData = function(size) {
+      var length = size > 0 ? size : this._raw.byteLength - (this._cursor.offset - this._offset);
+      if (length > 0) {
+        var data = new Uint8Array(this._raw.buffer, this._cursor.offset, length);
+        this._cursor.offset += length;
+        return data;
+      } else {
+        return null;
+      }
+    };
+    ISOBox.prototype._readUTF8String = function() {
+      var length = this._raw.byteLength - (this._cursor.offset - this._offset);
+      var data = null;
+      if (length > 0) {
+        data = new DataView(this._raw.buffer, this._cursor.offset, length);
+        this._cursor.offset += length;
+      }
+      return data ? ISOBoxer2.Utils.dataViewToString(data) : data;
+    };
+    ISOBox.prototype._readUTF8TerminatedString = function() {
+      var length = this._raw.byteLength - (this._cursor.offset - this._offset);
+      var data = null;
+      if (length > 0) {
+        data = new DataView(this._raw.buffer, this._cursor.offset, length);
+        var l;
+        for (l = 0; l < length; l++)
+          if (data.getUint8(l) === 0)
+            break;
+        data = new DataView(this._raw.buffer, this._cursor.offset, l);
+        this._cursor.offset += Math.min(l + 1, length);
+      }
+      return data ? ISOBoxer2.Utils.dataViewToString(data) : data;
+    };
+    ISOBox.prototype._parseBox = function() {
+      this._parsing = true;
+      this._cursor.offset = this._offset;
+      if (this._offset + 8 > this._raw.buffer.byteLength) {
+        this._root._incomplete = true;
+        return;
+      }
+      this._procField("size", "uint", 32);
+      this._procField("type", "string", 4);
+      if (this.size === 1) {
+        this._procField("largesize", "uint", 64);
+      }
+      if (this.type === "uuid") {
+        this._procFieldArray("usertype", 16, "uint", 8);
+      }
+      switch (this.size) {
+        case 0:
+          this._raw = new DataView(this._raw.buffer, this._offset);
+          break;
+        case 1:
+          if (this._offset + this.size > this._raw.buffer.byteLength) {
+            this._incomplete = true;
+            this._root._incomplete = true;
+          } else {
+            this._raw = new DataView(this._raw.buffer, this._offset, this.largesize);
+          }
+          break;
+        default:
+          if (this._offset + this.size > this._raw.buffer.byteLength) {
+            this._incomplete = true;
+            this._root._incomplete = true;
+          } else {
+            this._raw = new DataView(this._raw.buffer, this._offset, this.size);
+          }
+      }
+      if (!this._incomplete) {
+        if (this._boxProcessors[this.type]) {
+          this._boxProcessors[this.type].call(this);
+        }
+        if (this._boxContainers.indexOf(this.type) !== -1) {
+          this._parseContainerBox();
+        } else {
+          this._data = this._readData();
+        }
+      }
+    };
+    ISOBox.prototype._parseFullBox = function() {
+      this.version = this._readUint(8);
+      this.flags = this._readUint(24);
+    };
+    ISOBox.prototype._parseContainerBox = function() {
+      this.boxes = [];
+      while (this._cursor.offset - this._raw.byteOffset < this._raw.byteLength) {
+        this.boxes.push(ISOBox.parse(this));
+      }
+    };
+    ISOBox.prototype.append = function(box, pos) {
+      ISOBoxer2.Utils.appendBox(this, box, pos);
+    };
+    ISOBox.prototype.getLength = function() {
+      this._parsing = false;
+      this._rawo = null;
+      this.size = 0;
+      this._procField("size", "uint", 32);
+      this._procField("type", "string", 4);
+      if (this.size === 1) {
+        this._procField("largesize", "uint", 64);
+      }
+      if (this.type === "uuid") {
+        this._procFieldArray("usertype", 16, "uint", 8);
+      }
+      if (this._boxProcessors[this.type]) {
+        this._boxProcessors[this.type].call(this);
+      }
+      if (this._boxContainers.indexOf(this.type) !== -1) {
+        for (var i = 0; i < this.boxes.length; i++) {
+          this.size += this.boxes[i].getLength();
+        }
+      }
+      if (this._data) {
+        this._writeData(this._data);
+      }
+      return this.size;
+    };
+    ISOBox.prototype.write = function() {
+      this._parsing = false;
+      this._cursor.offset = this._parent._cursor.offset;
+      switch (this.size) {
+        case 0:
+          this._rawo = new DataView(this._parent._rawo.buffer, this._cursor.offset, this.parent._rawo.byteLength - this._cursor.offset);
+          break;
+        case 1:
+          this._rawo = new DataView(this._parent._rawo.buffer, this._cursor.offset, this.largesize);
+          break;
+        default:
+          this._rawo = new DataView(this._parent._rawo.buffer, this._cursor.offset, this.size);
+      }
+      this._procField("size", "uint", 32);
+      this._procField("type", "string", 4);
+      if (this.size === 1) {
+        this._procField("largesize", "uint", 64);
+      }
+      if (this.type === "uuid") {
+        this._procFieldArray("usertype", 16, "uint", 8);
+      }
+      if (this._boxProcessors[this.type]) {
+        this._boxProcessors[this.type].call(this);
+      }
+      if (this._boxContainers.indexOf(this.type) !== -1) {
+        for (var i = 0; i < this.boxes.length; i++) {
+          this.boxes[i].write();
+        }
+      }
+      if (this._data) {
+        this._writeData(this._data);
+      }
+      this._parent._cursor.offset += this.size;
+      return this.size;
+    };
+    ISOBox.prototype._writeInt = function(size, value) {
+      if (this._rawo) {
+        var offset = this._cursor.offset - this._rawo.byteOffset;
+        switch (size) {
+          case 8:
+            this._rawo.setInt8(offset, value);
+            break;
+          case 16:
+            this._rawo.setInt16(offset, value);
+            break;
+          case 32:
+            this._rawo.setInt32(offset, value);
+            break;
+          case 64:
+            var s1 = Math.floor(value / Math.pow(2, 32));
+            var s2 = value - s1 * Math.pow(2, 32);
+            this._rawo.setUint32(offset, s1);
+            this._rawo.setUint32(offset + 4, s2);
+            break;
+        }
+        this._cursor.offset += size >> 3;
+      } else {
+        this.size += size >> 3;
+      }
+    };
+    ISOBox.prototype._writeUint = function(size, value) {
+      if (this._rawo) {
+        var offset = this._cursor.offset - this._rawo.byteOffset, s1, s2;
+        switch (size) {
+          case 8:
+            this._rawo.setUint8(offset, value);
+            break;
+          case 16:
+            this._rawo.setUint16(offset, value);
+            break;
+          case 24:
+            s1 = (value & 16776960) >> 8;
+            s2 = value & 255;
+            this._rawo.setUint16(offset, s1);
+            this._rawo.setUint8(offset + 2, s2);
+            break;
+          case 32:
+            this._rawo.setUint32(offset, value);
+            break;
+          case 64:
+            s1 = Math.floor(value / Math.pow(2, 32));
+            s2 = value - s1 * Math.pow(2, 32);
+            this._rawo.setUint32(offset, s1);
+            this._rawo.setUint32(offset + 4, s2);
+            break;
+        }
+        this._cursor.offset += size >> 3;
+      } else {
+        this.size += size >> 3;
+      }
+    };
+    ISOBox.prototype._writeString = function(size, str) {
+      for (var c = 0; c < size; c++) {
+        this._writeUint(8, str.charCodeAt(c));
+      }
+    };
+    ISOBox.prototype._writeTerminatedString = function(str) {
+      if (str.length === 0) {
+        return;
+      }
+      for (var c = 0; c < str.length; c++) {
+        this._writeUint(8, str.charCodeAt(c));
+      }
+      this._writeUint(8, 0);
+    };
+    ISOBox.prototype._writeTemplate = function(size, value) {
+      var pre = Math.floor(value);
+      var post = (value - pre) * Math.pow(2, size / 2);
+      this._writeUint(size / 2, pre);
+      this._writeUint(size / 2, post);
+    };
+    ISOBox.prototype._writeData = function(data) {
+      var i;
+      if (data) {
+        if (this._rawo) {
+          if (data instanceof Array) {
+            var offset = this._cursor.offset - this._rawo.byteOffset;
+            for (var i = 0; i < data.length; i++) {
+              this._rawo.setInt8(offset + i, data[i]);
+            }
+            this._cursor.offset += data.length;
+          }
+          if (data instanceof Uint8Array) {
+            this._root.bytes.set(data, this._cursor.offset);
+            this._cursor.offset += data.length;
+          }
+        } else {
+          this.size += data.length;
+        }
+      }
+    };
+    ISOBox.prototype._writeUTF8String = function(string) {
+      var u = ISOBoxer2.Utils.utf8ToByteArray(string);
+      if (this._rawo) {
+        var dataView = new DataView(this._rawo.buffer, this._cursor.offset, u.length);
+        for (var i = 0; i < u.length; i++) {
+          dataView.setUint8(i, u[i]);
+        }
+      } else {
+        this.size += u.length;
+      }
+    };
+    ISOBox.prototype._writeField = function(type, size, value) {
+      switch (type) {
+        case "uint":
+          this._writeUint(size, value);
+          break;
+        case "int":
+          this._writeInt(size, value);
+          break;
+        case "template":
+          this._writeTemplate(size, value);
+          break;
+        case "string":
+          if (size == -1) {
+            this._writeTerminatedString(value);
+          } else {
+            this._writeString(size, value);
+          }
+          break;
+        case "data":
+          this._writeData(value);
+          break;
+        case "utf8":
+          this._writeUTF8String(value);
+          break;
+        default:
+          break;
+      }
+    };
+    ISOBox.prototype._boxProcessors["ardi"] = function() {
+      this._procFullBox();
+      this._procField("audio_rendering_indication", "uint", 8);
+    };
+    ISOBox.prototype._boxProcessors["avc1"] = ISOBox.prototype._boxProcessors["avc2"] = ISOBox.prototype._boxProcessors["avc3"] = ISOBox.prototype._boxProcessors["avc4"] = ISOBox.prototype._boxProcessors["hvc1"] = ISOBox.prototype._boxProcessors["hev1"] = ISOBox.prototype._boxProcessors["encv"] = function() {
+      this._procFieldArray("reserved1", 6, "uint", 8);
+      this._procField("data_reference_index", "uint", 16);
+      this._procField("pre_defined1", "uint", 16);
+      this._procField("reserved2", "uint", 16);
+      this._procFieldArray("pre_defined2", 3, "uint", 32);
+      this._procField("width", "uint", 16);
+      this._procField("height", "uint", 16);
+      this._procField("horizresolution", "template", 32);
+      this._procField("vertresolution", "template", 32);
+      this._procField("reserved3", "uint", 32);
+      this._procField("frame_count", "uint", 16);
+      this._procFieldArray("compressorname", 32, "uint", 8);
+      this._procField("depth", "uint", 16);
+      this._procField("pre_defined3", "int", 16);
+      this._procField("config", "data", -1);
+    };
+    ISOBox.prototype._boxProcessors["ctts"] = function() {
+      this._procFullBox();
+      this._procField("entry_count", "uint", 32);
+      this._procEntries("entries", this.entry_count, function(entry) {
+        this._procEntryField(entry, "sample_count", "uint", 32);
+        this._procEntryField(entry, "sample_offset", this.version === 1 ? "int" : "uint", 32);
+      });
+    };
+    ISOBox.prototype._boxProcessors["dref"] = function() {
+      this._procFullBox();
+      this._procField("entry_count", "uint", 32);
+      this._procSubBoxes("entries", this.entry_count);
+    };
+    ISOBox.prototype._boxProcessors["elng"] = function() {
+      this._procFullBox();
+      this._procField("extended_language", "utf8string");
+    };
+    ISOBox.prototype._boxProcessors["elst"] = function() {
+      this._procFullBox();
+      this._procField("entry_count", "uint", 32);
+      this._procEntries("entries", this.entry_count, function(entry) {
+        this._procEntryField(entry, "segment_duration", "uint", this.version === 1 ? 64 : 32);
+        this._procEntryField(entry, "media_time", "int", this.version === 1 ? 64 : 32);
+        this._procEntryField(entry, "media_rate_integer", "int", 16);
+        this._procEntryField(entry, "media_rate_fraction", "int", 16);
+      });
+    };
+    ISOBox.prototype._boxProcessors["emsg"] = function() {
+      this._procFullBox();
+      if (this.version == 1) {
+        this._procField("timescale", "uint", 32);
+        this._procField("presentation_time", "uint", 64);
+        this._procField("event_duration", "uint", 32);
+        this._procField("id", "uint", 32);
+        this._procField("scheme_id_uri", "string", -1);
+        this._procField("value", "string", -1);
+      } else {
+        this._procField("scheme_id_uri", "string", -1);
+        this._procField("value", "string", -1);
+        this._procField("timescale", "uint", 32);
+        this._procField("presentation_time_delta", "uint", 32);
+        this._procField("event_duration", "uint", 32);
+        this._procField("id", "uint", 32);
+      }
+      this._procField("message_data", "data", -1);
+    };
+    ISOBox.prototype._boxProcessors["free"] = ISOBox.prototype._boxProcessors["skip"] = function() {
+      this._procField("data", "data", -1);
+    };
+    ISOBox.prototype._boxProcessors["frma"] = function() {
+      this._procField("data_format", "uint", 32);
+    };
+    ISOBox.prototype._boxProcessors["ftyp"] = ISOBox.prototype._boxProcessors["styp"] = function() {
+      this._procField("major_brand", "string", 4);
+      this._procField("minor_version", "uint", 32);
+      var nbCompatibleBrands = -1;
+      if (this._parsing) {
+        nbCompatibleBrands = (this._raw.byteLength - (this._cursor.offset - this._raw.byteOffset)) / 4;
+      }
+      this._procFieldArray("compatible_brands", nbCompatibleBrands, "string", 4);
+    };
+    ISOBox.prototype._boxProcessors["hdlr"] = function() {
+      this._procFullBox();
+      this._procField("pre_defined", "uint", 32);
+      this._procField("handler_type", "string", 4);
+      this._procFieldArray("reserved", 3, "uint", 32);
+      this._procField("name", "string", -1);
+    };
+    ISOBox.prototype._boxProcessors["imda"] = function() {
+      this._procField("imda_identifier", "uint", 32);
+      this._procField("data", "data", -1);
+    };
+    ISOBox.prototype._boxProcessors["kind"] = function() {
+      this._procFullBox();
+      this._procField("schemeURI", "utf8string");
+      this._procField("value", "utf8string");
+    };
+    ISOBox.prototype._boxProcessors["labl"] = function() {
+      this._procFullBox();
+      this.is_group_label = (this.flags & 1) != 0;
+      this._procField("label_id", "uint", 16);
+      this._procField("language", "utf8string");
+      this._procField("label", "utf8string");
+    };
+    ISOBox.prototype._boxProcessors["mdat"] = function() {
+      this._procField("data", "data", -1);
+    };
+    ISOBox.prototype._boxProcessors["mdhd"] = function() {
+      this._procFullBox();
+      this._procField("creation_time", "uint", this.version == 1 ? 64 : 32);
+      this._procField("modification_time", "uint", this.version == 1 ? 64 : 32);
+      this._procField("timescale", "uint", 32);
+      this._procField("duration", "uint", this.version == 1 ? 64 : 32);
+      if (!this._parsing && typeof this.language === "string") {
+        this.language = this.language.charCodeAt(0) - 96 << 10 | this.language.charCodeAt(1) - 96 << 5 | this.language.charCodeAt(2) - 96;
+      }
+      this._procField("language", "uint", 16);
+      if (this._parsing) {
+        this.language = String.fromCharCode(
+          (this.language >> 10 & 31) + 96,
+          (this.language >> 5 & 31) + 96,
+          (this.language & 31) + 96
+        );
+      }
+      this._procField("pre_defined", "uint", 16);
+    };
+    ISOBox.prototype._boxProcessors["mehd"] = function() {
+      this._procFullBox();
+      this._procField("fragment_duration", "uint", this.version == 1 ? 64 : 32);
+    };
+    ISOBox.prototype._boxProcessors["meta"] = function() {
+      this._procFullBox();
+    };
+    ISOBox.prototype._boxProcessors["mfhd"] = function() {
+      this._procFullBox();
+      this._procField("sequence_number", "uint", 32);
+    };
+    ISOBox.prototype._boxProcessors["mfro"] = function() {
+      this._procFullBox();
+      this._procField("mfra_size", "uint", 32);
+    };
+    ISOBox.prototype._boxProcessors["mp4a"] = ISOBox.prototype._boxProcessors["enca"] = function() {
+      this._procFieldArray("reserved1", 6, "uint", 8);
+      this._procField("data_reference_index", "uint", 16);
+      this._procFieldArray("reserved2", 2, "uint", 32);
+      this._procField("channelcount", "uint", 16);
+      this._procField("samplesize", "uint", 16);
+      this._procField("pre_defined", "uint", 16);
+      this._procField("reserved3", "uint", 16);
+      this._procField("samplerate", "template", 32);
+      this._procField("esds", "data", -1);
+    };
+    ISOBox.prototype._boxProcessors["mvhd"] = function() {
+      this._procFullBox();
+      this._procField("creation_time", "uint", this.version == 1 ? 64 : 32);
+      this._procField("modification_time", "uint", this.version == 1 ? 64 : 32);
+      this._procField("timescale", "uint", 32);
+      this._procField("duration", "uint", this.version == 1 ? 64 : 32);
+      this._procField("rate", "template", 32);
+      this._procField("volume", "template", 16);
+      this._procField("reserved1", "uint", 16);
+      this._procFieldArray("reserved2", 2, "uint", 32);
+      this._procFieldArray("matrix", 9, "template", 32);
+      this._procFieldArray("pre_defined", 6, "uint", 32);
+      this._procField("next_track_ID", "uint", 32);
+    };
+    ISOBox.prototype._boxProcessors["payl"] = function() {
+      this._procField("cue_text", "utf8");
+    };
+    ISOBox.prototype._boxProcessors["prft"] = function() {
+      this._procFullBox();
+      this._procField("reference_track_ID", "uint", 32);
+      this._procField("ntp_timestamp_sec", "uint", 32);
+      this._procField("ntp_timestamp_frac", "uint", 32);
+      this._procField("media_time", "uint", this.version == 1 ? 64 : 32);
+    };
+    ISOBox.prototype._boxProcessors["prsl"] = function() {
+      this._procFullBox();
+      this._procField("group_id", "uint", 32);
+      this._procField("num_entities_in_group", "uint", 32);
+      this._procEntries("entities", this.num_entities_in_group, function(entry) {
+        this._procEntryField(entry, "entity_id", "uint", 32);
+      });
+      if (this.flags & 4096) this._procField("preselection_tag", "utf8string");
+      if (this.flags & 8192) this._procField("selection_priority", "uint", 8);
+      if (this.flags & 16384) this._procField("interleaving_tag", "utf8string");
+    };
+    ISOBox.prototype._boxProcessors["pssh"] = function() {
+      this._procFullBox();
+      this._procFieldArray("SystemID", 16, "uint", 8);
+      this._procField("DataSize", "uint", 32);
+      this._procFieldArray("Data", this.DataSize, "uint", 8);
+    };
+    ISOBox.prototype._boxProcessors["schm"] = function() {
+      this._procFullBox();
+      this._procField("scheme_type", "uint", 32);
+      this._procField("scheme_version", "uint", 32);
+      if (this.flags & 1) {
+        this._procField("scheme_uri", "string", -1);
+      }
+    };
+    ISOBox.prototype._boxProcessors["sdtp"] = function() {
+      this._procFullBox();
+      var sample_count = -1;
+      if (this._parsing) {
+        sample_count = this._raw.byteLength - (this._cursor.offset - this._raw.byteOffset);
+      }
+      this._procFieldArray("sample_dependency_table", sample_count, "uint", 8);
+    };
+    ISOBox.prototype._boxProcessors["sidx"] = function() {
+      this._procFullBox();
+      this._procField("reference_ID", "uint", 32);
+      this._procField("timescale", "uint", 32);
+      this._procField("earliest_presentation_time", "uint", this.version == 1 ? 64 : 32);
+      this._procField("first_offset", "uint", this.version == 1 ? 64 : 32);
+      this._procField("reserved", "uint", 16);
+      this._procField("reference_count", "uint", 16);
+      this._procEntries("references", this.reference_count, function(entry) {
+        if (!this._parsing) {
+          entry.reference = (entry.reference_type & 1) << 31;
+          entry.reference |= entry.referenced_size & 2147483647;
+          entry.sap = (entry.starts_with_SAP & 1) << 31;
+          entry.sap |= (entry.SAP_type & 3) << 28;
+          entry.sap |= entry.SAP_delta_time & 268435455;
+        }
+        this._procEntryField(entry, "reference", "uint", 32);
+        this._procEntryField(entry, "subsegment_duration", "uint", 32);
+        this._procEntryField(entry, "sap", "uint", 32);
+        if (this._parsing) {
+          entry.reference_type = entry.reference >> 31 & 1;
+          entry.referenced_size = entry.reference & 2147483647;
+          entry.starts_with_SAP = entry.sap >> 31 & 1;
+          entry.SAP_type = entry.sap >> 28 & 7;
+          entry.SAP_delta_time = entry.sap & 268435455;
+        }
+      });
+    };
+    ISOBox.prototype._boxProcessors["smhd"] = function() {
+      this._procFullBox();
+      this._procField("balance", "uint", 16);
+      this._procField("reserved", "uint", 16);
+    };
+    ISOBox.prototype._boxProcessors["ssix"] = function() {
+      this._procFullBox();
+      this._procField("subsegment_count", "uint", 32);
+      this._procEntries("subsegments", this.subsegment_count, function(subsegment) {
+        this._procEntryField(subsegment, "ranges_count", "uint", 32);
+        this._procSubEntries(subsegment, "ranges", subsegment.ranges_count, function(range) {
+          this._procEntryField(range, "level", "uint", 8);
+          this._procEntryField(range, "range_size", "uint", 24);
+        });
+      });
+    };
+    ISOBox.prototype._boxProcessors["stsd"] = function() {
+      this._procFullBox();
+      this._procField("entry_count", "uint", 32);
+      this._procSubBoxes("entries", this.entry_count);
+    };
+    ISOBox.prototype._boxProcessors["sttg"] = function() {
+      this._procField("settings", "utf8");
+    };
+    ISOBox.prototype._boxProcessors["stts"] = function() {
+      this._procFullBox();
+      this._procField("entry_count", "uint", 32);
+      this._procEntries("entries", this.entry_count, function(entry) {
+        this._procEntryField(entry, "sample_count", "uint", 32);
+        this._procEntryField(entry, "sample_delta", "uint", 32);
+      });
+    };
+    ISOBox.prototype._boxProcessors["subs"] = function() {
+      this._procFullBox();
+      this._procField("entry_count", "uint", 32);
+      this._procEntries("entries", this.entry_count, function(entry) {
+        this._procEntryField(entry, "sample_delta", "uint", 32);
+        this._procEntryField(entry, "subsample_count", "uint", 16);
+        this._procSubEntries(entry, "subsamples", entry.subsample_count, function(subsample) {
+          this._procEntryField(subsample, "subsample_size", "uint", this.version === 1 ? 32 : 16);
+          this._procEntryField(subsample, "subsample_priority", "uint", 8);
+          this._procEntryField(subsample, "discardable", "uint", 8);
+          this._procEntryField(subsample, "codec_specific_parameters", "uint", 32);
+        });
+      });
+    };
+    ISOBox.prototype._boxProcessors["tenc"] = function() {
+      this._procFullBox();
+      this._procField("default_IsEncrypted", "uint", 24);
+      this._procField("default_IV_size", "uint", 8);
+      this._procFieldArray("default_KID", 16, "uint", 8);
+    };
+    ISOBox.prototype._boxProcessors["tfdt"] = function() {
+      this._procFullBox();
+      this._procField("baseMediaDecodeTime", "uint", this.version == 1 ? 64 : 32);
+    };
+    ISOBox.prototype._boxProcessors["tfhd"] = function() {
+      this._procFullBox();
+      this._procField("track_ID", "uint", 32);
+      if (this.flags & 1) this._procField("base_data_offset", "uint", 64);
+      if (this.flags & 2) this._procField("sample_description_offset", "uint", 32);
+      if (this.flags & 8) this._procField("default_sample_duration", "uint", 32);
+      if (this.flags & 16) this._procField("default_sample_size", "uint", 32);
+      if (this.flags & 32) this._procField("default_sample_flags", "uint", 32);
+    };
+    ISOBox.prototype._boxProcessors["tfra"] = function() {
+      this._procFullBox();
+      this._procField("track_ID", "uint", 32);
+      if (!this._parsing) {
+        this.reserved = 0;
+        this.reserved |= (this.length_size_of_traf_num & 48) << 4;
+        this.reserved |= (this.length_size_of_trun_num & 12) << 2;
+        this.reserved |= this.length_size_of_sample_num & 3;
+      }
+      this._procField("reserved", "uint", 32);
+      if (this._parsing) {
+        this.length_size_of_traf_num = (this.reserved & 48) >> 4;
+        this.length_size_of_trun_num = (this.reserved & 12) >> 2;
+        this.length_size_of_sample_num = this.reserved & 3;
+      }
+      this._procField("number_of_entry", "uint", 32);
+      this._procEntries("entries", this.number_of_entry, function(entry) {
+        this._procEntryField(entry, "time", "uint", this.version === 1 ? 64 : 32);
+        this._procEntryField(entry, "moof_offset", "uint", this.version === 1 ? 64 : 32);
+        this._procEntryField(entry, "traf_number", "uint", (this.length_size_of_traf_num + 1) * 8);
+        this._procEntryField(entry, "trun_number", "uint", (this.length_size_of_trun_num + 1) * 8);
+        this._procEntryField(entry, "sample_number", "uint", (this.length_size_of_sample_num + 1) * 8);
+      });
+    };
+    ISOBox.prototype._boxProcessors["tkhd"] = function() {
+      this._procFullBox();
+      this._procField("creation_time", "uint", this.version == 1 ? 64 : 32);
+      this._procField("modification_time", "uint", this.version == 1 ? 64 : 32);
+      this._procField("track_ID", "uint", 32);
+      this._procField("reserved1", "uint", 32);
+      this._procField("duration", "uint", this.version == 1 ? 64 : 32);
+      this._procFieldArray("reserved2", 2, "uint", 32);
+      this._procField("layer", "uint", 16);
+      this._procField("alternate_group", "uint", 16);
+      this._procField("volume", "template", 16);
+      this._procField("reserved3", "uint", 16);
+      this._procFieldArray("matrix", 9, "template", 32);
+      this._procField("width", "template", 32);
+      this._procField("height", "template", 32);
+    };
+    ISOBox.prototype._boxProcessors["trex"] = function() {
+      this._procFullBox();
+      this._procField("track_ID", "uint", 32);
+      this._procField("default_sample_description_index", "uint", 32);
+      this._procField("default_sample_duration", "uint", 32);
+      this._procField("default_sample_size", "uint", 32);
+      this._procField("default_sample_flags", "uint", 32);
+    };
+    ISOBox.prototype._boxProcessors["trun"] = function() {
+      this._procFullBox();
+      this._procField("sample_count", "uint", 32);
+      if (this.flags & 1) this._procField("data_offset", "int", 32);
+      if (this.flags & 4) this._procField("first_sample_flags", "uint", 32);
+      this._procEntries("samples", this.sample_count, function(sample) {
+        if (this.flags & 256) this._procEntryField(sample, "sample_duration", "uint", 32);
+        if (this.flags & 512) this._procEntryField(sample, "sample_size", "uint", 32);
+        if (this.flags & 1024) this._procEntryField(sample, "sample_flags", "uint", 32);
+        if (this.flags & 2048) this._procEntryField(sample, "sample_composition_time_offset", this.version === 1 ? "int" : "uint", 32);
+      });
+    };
+    ISOBox.prototype._boxProcessors["url "] = ISOBox.prototype._boxProcessors["urn "] = function() {
+      this._procFullBox();
+      if (this.type === "urn ") {
+        this._procField("name", "string", -1);
+      }
+      this._procField("location", "string", -1);
+    };
+    ISOBox.prototype._boxProcessors["vlab"] = function() {
+      this._procField("source_label", "utf8");
+    };
+    ISOBox.prototype._boxProcessors["vmhd"] = function() {
+      this._procFullBox();
+      this._procField("graphicsmode", "uint", 16);
+      this._procFieldArray("opcolor", 3, "uint", 16);
+    };
+    ISOBox.prototype._boxProcessors["vttC"] = function() {
+      this._procField("config", "utf8");
+    };
+    ISOBox.prototype._boxProcessors["vtte"] = function() {
+    };
+  }
+});
+
+// src/constants/isobmff_box_names.js
+var MOVIE = "moov";
+var TRACK = "trak";
+var TRACK_HEADER = "tkhd";
+var META = "meta";
+var GROUPS_LIST = "grpl";
+var PRESELECTION_GROUP = "prsl";
+var USER_DATA = "udta";
+var DIALOG_PROCESSING = "diap";
+var EXTENDED_LANGUAGE_TAG = "elng";
+var AUDIO_RENDERING_INDICATION = "ardi";
+var LABEL = "labl";
+var KIND = "kind";
+var MOVIE_FRAGMENT = "moof";
+var TRACK_FRAGMENT = "traf";
+var TRACK_FRAGMENT_HEADER = "tfhd";
+var TRACK_FRAGMENT_RUN = "trun";
+
+// src/constants/toc_elements.js
+var B_PRESENTATION_ID = "b_presentation_id";
+var PRESENTATION_ID = "presentation_id";
+var PRESENTATION_LEVEL = "presentation_level";
+var PAYLOAD_BASE_MINUS1 = "payload_base_minus1";
+var BYTE_ALIGNMENT = "byte_alignment";
+var AC4_TOC_END = "ac4_toc_end";
+
+// src/bitwise_operations.js
+var shiftLeft = (data, offset, width, shift) => {
+  const startByte = offset >> 3;
+  const endByte = offset + width - 1 >> 3;
+  const startBit = offset & 7;
+  const endBit = offset + width - 1 & 7;
+  const startMask = 255 >> startBit;
+  const endMask = 255 << 7 - endBit & 255;
+  let shiftAcc = 0;
+  for (let i = endByte; i >= startByte; i--) {
+    const currByte = data.getUint8(i);
+    let mask = 255;
+    if (i === startByte) {
+      mask &= startMask;
+    }
+    if (i === endByte) {
+      mask &= endMask;
+    }
+    const clearedByte = currByte & ~mask;
+    const maskedCurrByte = currByte & mask;
+    shiftAcc = (maskedCurrByte << shift) + shiftAcc;
+    const shiftedCurrByte = clearedByte | shiftAcc & 255 & mask;
+    shiftAcc >>= 8;
+    data.setUint8(i, shiftedCurrByte);
+  }
+  return data;
+};
+var setBits = (data, offset, width, value) => {
+  const byteOffset = offset >>> 3;
+  const bitOffset = offset & 7;
+  const mask = (1 << width) - 1 << 16 - width >> bitOffset;
+  let word = data.getUint8(byteOffset) << 8 | data.getUint8(byteOffset + 1);
+  word &= ~mask;
+  word |= value << 16 - width - bitOffset;
+  data.setUint8(byteOffset, word >>> 8);
+  data.setUint8(byteOffset + 1, word & 255);
+};
+
+// src/get_sample_offsets.js
+var getSampleOffsets = (parsedBuffer) => {
+  const sampleOffsets = [];
+  const DEFAULT_BASE_IS_MOOF_FLAG_OFFSET = 131072;
+  const movieFragment = parsedBuffer.fetch(MOVIE_FRAGMENT);
+  let isFirstTrackFragment = true;
+  for (const trackFragment of parsedBuffer.fetchAll(TRACK_FRAGMENT)) {
+    const trackFragmentHeader = trackFragment.boxes.find((box) => box.type === TRACK_FRAGMENT_HEADER);
+    const baseDataOffset = trackFragmentHeader.base_data_offset || 0;
+    const defaultBaseIsMoof = trackFragmentHeader.flags & DEFAULT_BASE_IS_MOOF_FLAG_OFFSET;
+    if (baseDataOffset) {
+      throw Error(
+        "base_data_offset is relative to the file identified by the referenced data reference entry unsupported"
+      );
+    }
+    if (!defaultBaseIsMoof) {
+      if (isFirstTrackFragment) {
+        throw Error(
+          "base_data_offset is relative to the first byte of the MovieFragmentBox containing this box unsupported"
+        );
+      }
+      throw Error(
+        "base_data_offset is relative to the end of the data defined by the preceding track fragment is unsupported"
+      );
+    }
+    const relative = movieFragment._offset;
+    for (const trackFragmentRun of trackFragment.boxes.filter((box) => box.type === TRACK_FRAGMENT_RUN)) {
+      let sampleOffset = relative + baseDataOffset + trackFragmentRun.data_offset;
+      for (const sample of trackFragmentRun.samples) {
+        sampleOffsets.push({ offset: sampleOffset, size: sample.sample_size });
+        sampleOffset += sample.sample_size;
+      }
+    }
+    isFirstTrackFragment = false;
+  }
+  return sampleOffsets;
+};
+
+// src/ac4_toc_parser_wrapper/bitsource.js
+var BitSource = class {
+  /**
+   * Create the BitSource
+   * @param {Iterator<number>} iterator - an iterator object
+   */
+  constructor(iterator) {
+    this.iterator = iterator;
+    this.cache = 0;
+    this.bitsLeft = 0;
+  }
+  /**
+   * This function reads n-bit value from the source, where "n" is the specified width.
+   *
+   * It works by keeping a 32 bit wide cache.
+   * In the cache, the next bits are "left/top aligned".
+   * That is to say, to read the next three bits, you take the three most significant bits.
+   * This can be accomplished by right-shifting the cache by 32-3=29 bits, taking care that it is an unsigned shift and no sign extension takes place.
+   * To "expel" the read bits from the cache, simple left-shift the cache by 3 bits.
+   *
+   * Before any bits are read from the cache, it needs to be filled.
+   * We check if more bits are needed, and whether at least 8 can be filled in. If so, do it.
+   * This means that the cache contains 25 bits at a minimum after it is filled.
+   * Therefore, 25 bits are the most bits that the reader can deliver. We don't check for end of stream in the bit reader. That is better delegated elsewhere.
+   *
+   * @summary Get a value of specified width from the bit source
+   *
+   * @param {string} varname - Name of the variable being read (it serves only logging purposes)
+   * @param {number} bitsWidth - Width of the value to be read (maximum 25 bits)
+   * @returns {number} The value read from the bit source
+   */
+  get(varname, bitsWidth) {
+    const MAX_SHIFT = 24;
+    const MAX_SUPPORTED_WIDTH = 25;
+    const BYTE_SIZE = 8;
+    const INT_SIZE = 32;
+    if (bitsWidth > MAX_SUPPORTED_WIDTH) {
+    }
+    let width = bitsWidth;
+    while (this.bitsLeft < width) {
+      const nextByte = this.iterator.next();
+      const nextByteShift = MAX_SHIFT - this.bitsLeft;
+      this.cache |= nextByte.value << nextByteShift;
+      this.bitsLeft += BYTE_SIZE;
+      if (width > MAX_SUPPORTED_WIDTH) {
+        this.cache <<= BYTE_SIZE;
+        this.bitsLeft -= BYTE_SIZE;
+        width -= BYTE_SIZE;
+      }
+    }
+    const readValue = this.cache >>> INT_SIZE - width;
+    this.cache <<= width;
+    this.bitsLeft -= width;
+    return readValue;
+  }
+  /**
+   * Get bits needed for byte alignment
+   *
+   * @param {number} numberOfBits - Number of bits to align
+   * @returns {number} The value read for alignment
+   */
+  get_align(numberOfBits) {
+    return this.get("align", numberOfBits);
+  }
+};
+
+// src/ac4_toc_parser_wrapper/filtersink.js
+var FilterSink = class {
+  /**
+   * Create the Filter Sink
+   * @param {string[]} elements - The AC-4 TOC elements to be filtered
+   * @param {sinkCallback} callback - The callback function to be called for filtered elements
+   */
+  constructor(elements, callback) {
+    this.elements = elements;
+    this.callback = callback;
+  }
+  /**
+   * Called before calling embedded BSDL function
+   * @param {string} _fname - name of the BSDL function
+   * @param {unknown} _params - parameters passed to the BSDL function
+   * @param {string} name - name of the AC-4 TOC element
+   * @param {number} position - position read before calling embedded BSDL function
+   */
+  before_call(_fname, _params, name, position) {
+    if (this.elements.includes(name)) {
+      this.callback(name, null, null, position, "before_call");
+    }
+  }
+  /**
+   * Called after calling embedded BSDL function. The position is written after field is read
+   * @param {string} _fname - name of the BSDL function
+   * @param {number} value - value returned by the BSDL function
+   * @param {string} name - name of the AC-4 TOC element
+   * @param {number} position - position read after calling embedded BSDL function
+   */
+  after_call(_fname, value, name, position) {
+    if (this.elements.includes(name)) {
+      this.callback(name, value, null, position, "after_call");
+    }
+  }
+  /**
+   * Called when assigning a variable.
+   * @param {string} name - name of the AC-4 TOC element
+   * @param {number} width - width of the AC-4 TOC element
+   * @param {number} value - value of the AC-4 TOC element
+   * @param {number} position - position of the AC-4 TOC element
+   */
+  write_uint(name, width, value, position) {
+    if (this.elements.includes(name)) {
+      this.callback(name, value, width, position);
+    }
+  }
+  /**
+   * Called when assigning byte alignment to a variable.
+   * @param {number} width - width of the byte alignment field
+   * @param {number} value - value of byte alignment field
+   */
+  write_align(width, value) {
+    if (this.elements.includes(BYTE_ALIGNMENT)) {
+      this.callback(BYTE_ALIGNMENT, value, width, null, "write_align");
+    }
+  }
+  /**
+   * Called after BSDL position() call to obtain bit position
+   * @param {string} name - name of the variable that the position will be assigned to
+   * @param {number} position - obtained position
+   */
+  after_position(name, position) {
+    if (this.elements.includes(name)) {
+      this.callback(name, null, null, position, "after_position");
+    }
+  }
+};
+
+// src/ac4_toc_parser.js
+var ParseError = class extends Error {
+};
+var Parser = class {
+  constructor(BAM_source, BAM_sink) {
+    // Class field declarations
+    __publicField(this, "v", null);
+    __publicField(this, "content_classifier", null);
+    __publicField(this, "i", null);
+    __publicField(this, "frame_rate_factor", null);
+    __publicField(this, "bk_substream_index", null);
+    __publicField(this, "a_substream_indices", null);
+    __publicField(this, "last_referenced_substream", null);
+    __publicField(this, "referenced_substreams", null);
+    __publicField(this, "protection_bits_primary_bits", null);
+    __publicField(this, "protection_bits_secondary_bits", null);
+    __publicField(this, "toc_i", null);
+    __publicField(this, "OAMD_OBJECT_TYPE_BED", null);
+    __publicField(this, "OAMD_OBJECT_TYPE_ISF", null);
+    __publicField(this, "OAMD_OBJECT_TYPE_DYNAMIC", null);
+    __publicField(this, "OAMD_OBJECT_TYPE_RESERVED", null);
+    __publicField(this, "toc_j", null);
+    __publicField(this, "vb", null);
+    __publicField(this, "presentation_to_groups", null);
+    __publicField(this, "group_frame_rate_factor", null);
+    __publicField(this, "b_hsf_ext", null);
+    __publicField(this, "b_single_substream", null);
+    __publicField(this, "n_bed_objects", null);
+    __publicField(this, "a_num_bed_objects", null);
+    __publicField(this, "b_bed_objects_prev", null);
+    __publicField(this, "num_lfe", null);
+    __publicField(this, "n", null);
+    __publicField(this, "n_skip_bytes", null);
+    __publicField(this, "b_more_skip_bytes", null);
+    __publicField(this, "n_bits_read_0", null);
+    __publicField(this, "n_bits_read_1", null);
+    __publicField(this, "n_bits_read", null);
+    __publicField(this, "n_skip_bits", null);
+    __publicField(this, "reserved", null);
+    __publicField(this, "padding", null);
+    __publicField(this, "CHANNEL_MODE_MONO", null);
+    __publicField(this, "CHANNEL_MODE_STEREO", null);
+    __publicField(this, "CHANNEL_MODE_30", null);
+    __publicField(this, "CHANNEL_MODE_50", null);
+    __publicField(this, "CHANNEL_MODE_51", null);
+    __publicField(this, "CHANNEL_MODE_70_34", null);
+    __publicField(this, "CHANNEL_MODE_71_34", null);
+    __publicField(this, "CHANNEL_MODE_70_52", null);
+    __publicField(this, "CHANNEL_MODE_71_52", null);
+    __publicField(this, "CHANNEL_MODE_70_322", null);
+    __publicField(this, "CHANNEL_MODE_71_322", null);
+    __publicField(this, "CHANNEL_MODE_704", null);
+    __publicField(this, "CHANNEL_MODE_714", null);
+    __publicField(this, "CHANNEL_MODE_904", null);
+    __publicField(this, "CHANNEL_MODE_914", null);
+    __publicField(this, "CHANNEL_MODE_222", null);
+    __publicField(this, "presentation_config", null);
+    __publicField(this, "presentation_version", null);
+    __publicField(this, "b_add_emdf_substreams", null);
+    __publicField(this, "presentation_level", null);
+    __publicField(this, "b_presentation_id", null);
+    __publicField(this, "presentation_id", null);
+    __publicField(this, "b_pre_virtualized", null);
+    __publicField(this, "n_add_emdf_substreams", null);
+    __publicField(this, "pi_i", null);
+    __publicField(this, "b_single_substream_group", null);
+    __publicField(this, "b_presentation_filter", null);
+    __publicField(this, "b_enable_presentation", null);
+    __publicField(this, "n_substream_groups", null);
+    __publicField(this, "b_multi_pid", null);
+    __publicField(this, "n_substream_groups_minus2", null);
+    __publicField(this, "sg", null);
+    __publicField(this, "bitstream_version", null);
+    __publicField(this, "fs_index", null);
+    __publicField(this, "frame_rate_index", null);
+    __publicField(this, "BAM_g_position", 0);
+    __publicField(this, "BAM_g_table0", [0, 2, 4, 6]);
+    __publicField(this, "BAM_g_table1", [252, 253, 508, 509]);
+    __publicField(this, "BAM_g_table2", [122, 123, 124, 125]);
+    __publicField(this, "BAM_g_table3", [252, 253, 508, 509]);
+    __publicField(this, "BAM_g_table4", [4, 6, 8, 10, 12, 14]);
+    __publicField(this, "BAM_g_table5", [122, 123, 124, 125]);
+    __publicField(this, "BAM_g_table6", [0, 0]);
+    __publicField(this, "BAM_g_table7", [0, 1, 2, 3, 5, 0, 0, 0]);
+    __publicField(this, "BAM_g_table8", [2, 3, 6, 8, 10, 8, 10, 12]);
+    __publicField(this, "BAM_g_table9", [2, 1, 1, 2, 2, 2, 2, 2, 2, 1]);
+    __publicField(this, "BAM_g_table10", [4, 8, 10, 14, 15, 30, -1, -1]);
+    __publicField(this, "BAM_g_table11", [2, 3, 4, 5, 6, 7]);
+    __publicField(this, "BAM_g_table12", [2, 1, 1, 2, 2, 2, 2, 2, 2, 1]);
+    __publicField(this, "BAM_g_table13", [1920, 1920, 2048, 1536, 1536, 960, 960, 1024, 768, 768, 512, 384, 384, 2048]);
+    __publicField(this, "BAM_g_table14", [2, 3, 4]);
+    __publicField(this, "BAM_g_table15", { 0: 2, 1: 4 });
+    __publicField(this, "BAM_g_table16", [0, 1, 7, 8, 9]);
+    __publicField(this, "BAM_g_table17", { 0: 1, 1: 2 });
+    __publicField(this, "BAM_g_table18", [5, 6, 7, 8, 9]);
+    __publicField(this, "BAM_g_table19", [10, 11, 12]);
+    this.BAM_source = BAM_source;
+    this.BAM_sink = BAM_sink;
+  }
+  F_channel_mode_contains_LFE(cm) {
+    {
+      if (cm == this.CHANNEL_MODE_51 || cm == this.CHANNEL_MODE_71_34 || cm == this.CHANNEL_MODE_71_52 || cm == this.CHANNEL_MODE_71_322) {
+        return 1;
+      } else {
+        return 0;
+      }
+    }
+  }
+  F_bitrate_indicator() {
+    var bi;
+    var factor;
+    {
+      {
+        bi = this.BAM_source.get("", 3);
+        this.BAM_g_position += 3;
+      }
+      if (this.BAM_g_table0.slice(0).indexOf(bi) >= 0) {
+        {
+          bi = bi >> 1;
+        }
+      } else {
+        {
+          {
+            this.v = this.BAM_source.get("", 2);
+            this.BAM_g_position += 2;
+          }
+          {
+            this.v = (bi << 2) + this.v;
+          }
+          {
+            factor = Math.floor(this.v / 8);
+          }
+          {
+            bi = this.v - factor * 4;
+          }
+        }
+      }
+    }
+  }
+  F_content_type() {
+    var b_serialized_language_tag;
+    var n_language_tag_bytes;
+    var language_tag_chunk;
+    var language_tag_bytes;
+    var b_language_indicator;
+    var b_start_tag;
+    {
+      {
+        this.content_classifier = this.BAM_source.get("", 3);
+        this.BAM_g_position += 3;
+      }
+      {
+        b_language_indicator = this.BAM_source.get("", 1);
+        this.BAM_g_position += 1;
+      }
+      if (b_language_indicator) {
+        {
+          {
+            b_serialized_language_tag = this.BAM_source.get("", 1);
+            this.BAM_g_position += 1;
+          }
+          if (b_serialized_language_tag) {
+            {
+              {
+                b_start_tag = this.BAM_source.get("", 1);
+                this.BAM_g_position += 1;
+              }
+              {
+                language_tag_chunk = this.BAM_source.get("", 16);
+                this.BAM_g_position += 16;
+              }
+            }
+          } else {
+            {
+              {
+                n_language_tag_bytes = this.BAM_source.get("", 6);
+                this.BAM_g_position += 6;
+              }
+              for (this.i = 0; this.i < n_language_tag_bytes; this.i++) {
+                {
+                  language_tag_bytes = this.BAM_source.get("", 8);
+                  this.BAM_g_position += 8;
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  F_ac4_substream_info_chan(asio_group_index, asio_gs_index, asio_b_substreams_present_chan) {
+    var substream_index;
+    var b_sf_multiplier;
+    var b_bitrate_info;
+    var si_ch_mode;
+    var si_channel_mode;
+    var top_channels_present;
+    var b_4_back_channels_present;
+    var si_b_iframe;
+    var b_center_present;
+    var b_lfe = null;
+    var b_lfe;
+    var sf_multiplier;
+    var add_ch_base;
+    {
+      {
+        this.F_define_channel_modes();
+      }
+      {
+        this.F_define_oamd();
+      }
+      {
+        si_channel_mode = this.F_channel_mode();
+        if (si_channel_mode == null) {
+          throw ParseError("F_channel_mode", "expected to return a value, returned None");
+        }
+      }
+      if (si_channel_mode == 511) {
+        {
+          {
+            this.v = this.F_variable_bits(2);
+            if (this.v == null) {
+              throw ParseError("F_variable_bits", "expected to return a value, returned None");
+            }
+          }
+          {
+            si_channel_mode += this.v;
+          }
+        }
+      }
+      if (this.BAM_g_table1.slice(0).indexOf(si_channel_mode) >= 0) {
+        {
+          {
+            b_4_back_channels_present = this.BAM_source.get("", 1);
+            this.BAM_g_position += 1;
+          }
+          {
+            b_center_present = this.BAM_source.get("", 1);
+            this.BAM_g_position += 1;
+          }
+          {
+            top_channels_present = this.BAM_source.get("", 2);
+            this.BAM_g_position += 2;
+          }
+        }
+      }
+      if (this.fs_index == 1) {
+        {
+          {
+            b_sf_multiplier = this.BAM_source.get("", 1);
+            this.BAM_g_position += 1;
+          }
+          if (b_sf_multiplier) {
+            {
+              sf_multiplier = this.BAM_source.get("", 1);
+              this.BAM_g_position += 1;
+            }
+          }
+        }
+      }
+      {
+        b_bitrate_info = this.BAM_source.get("", 1);
+        this.BAM_g_position += 1;
+      }
+      if (b_bitrate_info) {
+        {
+          this.F_bitrate_indicator();
+        }
+      }
+      if (this.BAM_g_table2.slice(0).indexOf(si_channel_mode) >= 0) {
+        {
+          add_ch_base = this.BAM_source.get("", 1);
+          this.BAM_g_position += 1;
+        }
+      }
+      {
+        this.frame_rate_factor = this.group_frame_rate_factor[asio_group_index];
+      }
+      for (this.i = 0; this.i < this.frame_rate_factor; this.i++) {
+        {
+          si_b_iframe = this.BAM_source.get("", 1);
+          this.BAM_g_position += 1;
+        }
+      }
+      if (asio_b_substreams_present_chan == 1) {
+        {
+          {
+            substream_index = this.BAM_source.get("", 2);
+            this.BAM_g_position += 2;
+          }
+          if (substream_index == 3) {
+            {
+              {
+                this.v = this.F_variable_bits(2);
+                if (this.v == null) {
+                  throw ParseError("F_variable_bits", "expected to return a value, returned None");
+                }
+              }
+              {
+                substream_index += this.v;
+              }
+            }
+          }
+        }
+      } else {
+        {
+          {
+            substream_index = this.bk_substream_index;
+          }
+          {
+            this.bk_substream_index = this.bk_substream_index + 1;
+          }
+        }
+      }
+      {
+        this.a_substream_indices.push(substream_index);
+      }
+      for (this.i = 0; this.i < this.frame_rate_factor; this.i++) {
+        {
+          if (asio_b_substreams_present_chan == 1) {
+            {
+              {
+                this.last_referenced_substream = Math.max(this.last_referenced_substream, substream_index + this.i);
+              }
+              {
+                this.referenced_substreams.push(substream_index + this.i);
+              }
+            }
+          }
+          if (this.BAM_g_table3.slice(0).indexOf(si_channel_mode) >= 0) {
+          }
+          {
+            si_ch_mode = this.F_get_ch_mode(si_channel_mode);
+            if (si_ch_mode == null) {
+              throw ParseError("F_get_ch_mode", "expected to return a value, returned None");
+            }
+          }
+          if (this.BAM_g_table4.slice(0).indexOf(si_ch_mode) >= 0) {
+            {
+              if (b_lfe == null) {
+                b_lfe = new Array(substream_index + this.i + 1).fill(0);
+              } else if (b_lfe.length <= substream_index + this.i) {
+                b_lfe.push.apply(b_lfe, new Array(substream_index + this.i - b_lfe.length + 1).fill(0));
+              }
+              b_lfe[substream_index + this.i] = 1;
+            }
+          } else {
+            {
+              if (b_lfe == null) {
+                b_lfe = new Array(substream_index + this.i + 1).fill(0);
+              } else if (b_lfe.length <= substream_index + this.i) {
+                b_lfe.push.apply(b_lfe, new Array(substream_index + this.i - b_lfe.length + 1).fill(0));
+              }
+              b_lfe[substream_index + this.i] = 0;
+            }
+          }
+        }
+      }
+    }
+  }
+  F_channel_mode() {
+    var value;
+    var stereo_channel_mode;
+    {
+      {
+        value = this.BAM_source.get("", 1);
+        this.BAM_g_position += 1;
+      }
+      if (value == 1) {
+        {
+          {
+            this.v = this.BAM_source.get("", 1);
+            this.BAM_g_position += 1;
+          }
+          {
+            value = (value << 1) + this.v;
+          }
+          {
+            stereo_channel_mode = 2;
+          }
+          if (value == 3) {
+            {
+              {
+                this.v = this.BAM_source.get("", 2);
+                this.BAM_g_position += 2;
+              }
+              {
+                value = (value << 2) + this.v;
+              }
+              if (value == 15) {
+                {
+                  {
+                    this.v = this.BAM_source.get("", 3);
+                    this.BAM_g_position += 3;
+                  }
+                  {
+                    value = (value << 3) + this.v;
+                  }
+                  if (value == 120 || value == 121) {
+                    {
+                      {
+                        stereo_channel_mode = value;
+                      }
+                      {
+                        value = 2;
+                      }
+                    }
+                  }
+                  if (value == 126) {
+                    {
+                      {
+                        this.v = this.BAM_source.get("", 1);
+                        this.BAM_g_position += 1;
+                      }
+                      {
+                        value = (value << 1) + this.v;
+                      }
+                    }
+                  }
+                  if (value == 127) {
+                    {
+                      {
+                        this.v = this.BAM_source.get("", 2);
+                        this.BAM_g_position += 2;
+                      }
+                      {
+                        value = (value << 2) + this.v;
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      return value;
+    }
+  }
+  F_ac4_substream_info(si_b_associated, si_b_dialog, si_ps_index) {
+    var substream_index;
+    var si_b_iframe;
+    var b_sf_multiplier;
+    var b_bitrate_info;
+    var b_dialog_content;
+    var si_channel_mode;
+    var b_lfe = null;
+    var b_lfe;
+    var sf_multiplier;
+    var add_ch_base;
+    var b_associated_content;
+    var b_content_type;
+    {
+      {
+        this.F_define_channel_modes();
+      }
+      {
+        si_channel_mode = this.F_channel_mode();
+        if (si_channel_mode == null) {
+          throw ParseError("F_channel_mode", "expected to return a value, returned None");
+        }
+      }
+      if (si_channel_mode == 511) {
+        {
+          {
+            this.v = this.F_variable_bits(2);
+            if (this.v == null) {
+              throw ParseError("F_variable_bits", "expected to return a value, returned None");
+            }
+          }
+          {
+            si_channel_mode += this.v;
+          }
+        }
+      }
+      if (this.fs_index == 1) {
+        {
+          {
+            b_sf_multiplier = this.BAM_source.get("", 1);
+            this.BAM_g_position += 1;
+          }
+          if (b_sf_multiplier) {
+            {
+              sf_multiplier = this.BAM_source.get("", 1);
+              this.BAM_g_position += 1;
+            }
+          }
+        }
+      }
+      {
+        b_bitrate_info = this.BAM_source.get("", 1);
+        this.BAM_g_position += 1;
+      }
+      if (b_bitrate_info) {
+        {
+          this.F_bitrate_indicator();
+        }
+      }
+      if (this.BAM_g_table5.slice(0).indexOf(si_channel_mode) >= 0) {
+        {
+          add_ch_base = this.BAM_source.get("", 1);
+          this.BAM_g_position += 1;
+        }
+      }
+      {
+        b_content_type = this.BAM_source.get("", 1);
+        this.BAM_g_position += 1;
+      }
+      if (b_content_type) {
+        {
+          {
+            this.F_content_type();
+          }
+          if (this.content_classifier == 0) {
+            {
+              {
+                b_associated_content = 0;
+              }
+              {
+                b_dialog_content = 0;
+              }
+            }
+          } else if (this.content_classifier == 1) {
+            {
+              {
+                b_associated_content = 0;
+              }
+              {
+                b_dialog_content = 0;
+              }
+            }
+          } else if (this.content_classifier == 2) {
+            {
+              {
+                b_associated_content = 1;
+              }
+              {
+                b_dialog_content = 0;
+              }
+            }
+          } else if (this.content_classifier == 3) {
+            {
+              {
+                b_associated_content = 1;
+              }
+              {
+                b_dialog_content = 0;
+              }
+            }
+          } else if (this.content_classifier == 4) {
+            {
+              {
+                b_associated_content = 0;
+              }
+              {
+                b_dialog_content = 1;
+              }
+            }
+          } else if (this.content_classifier == 5) {
+            {
+              {
+                b_associated_content = 1;
+              }
+              {
+                b_dialog_content = 0;
+              }
+            }
+          } else if (this.content_classifier == 6) {
+            {
+              {
+                b_associated_content = 0;
+              }
+              {
+                b_dialog_content = 0;
+              }
+            }
+          } else if (this.content_classifier == 7) {
+            {
+              {
+                b_associated_content = 0;
+              }
+              {
+                b_dialog_content = 0;
+              }
+            }
+          }
+        }
+      } else {
+        {
+          {
+            b_associated_content = 0;
+          }
+          {
+            b_dialog_content = 0;
+          }
+        }
+      }
+      for (this.i = 0; this.i < this.frame_rate_factor; this.i++) {
+        {
+          si_b_iframe = this.BAM_source.get("", 1);
+          this.BAM_g_position += 1;
+        }
+      }
+      {
+        substream_index = this.BAM_source.get("", 2);
+        this.BAM_g_position += 2;
+      }
+      if (substream_index == 3) {
+        {
+          {
+            this.v = this.F_variable_bits(2);
+            if (this.v == null) {
+              throw ParseError("F_variable_bits", "expected to return a value, returned None");
+            }
+          }
+          {
+            substream_index += this.v;
+          }
+        }
+      }
+      {
+        this.a_substream_indices.push(substream_index);
+      }
+      for (this.i = 0; this.i < this.frame_rate_factor; this.i++) {
+        {
+          {
+            this.last_referenced_substream = Math.max(this.last_referenced_substream, substream_index + this.i);
+          }
+          {
+            this.referenced_substreams.push(substream_index + this.i);
+          }
+          {
+            if (b_lfe == null) {
+              b_lfe = new Array(substream_index + 1 + 1).fill(0);
+            } else if (b_lfe.length <= substream_index + 1) {
+              b_lfe.push.apply(b_lfe, new Array(substream_index + 1 - b_lfe.length + 1).fill(0));
+            }
+            b_lfe[substream_index + 1] = this.F_channel_mode_contains_LFE(si_channel_mode);
+            if (b_lfe[substream_index + 1] == null) {
+              throw ParseError("F_channel_mode_contains_LFE", "expected to return a value, returned None");
+            }
+          }
+        }
+      }
+    }
+  }
+  F_emdf_protection() {
+    var protection_bits_secondary;
+    var protection_length_secondary;
+    var protection_length_primary;
+    var protection_bits_primary;
+    {
+      {
+        protection_length_primary = this.BAM_source.get("", 2);
+        this.BAM_g_position += 2;
+      }
+      {
+        protection_length_secondary = this.BAM_source.get("", 2);
+        this.BAM_g_position += 2;
+      }
+      if (protection_length_primary == 0) {
+        if (1) {
+          throw "protection_length_primary == 0 is reserved";
+        }
+      } else if (protection_length_primary == 1) {
+        {
+          this.protection_bits_primary_bits = 8;
+        }
+      } else if (protection_length_primary == 2) {
+        {
+          this.protection_bits_primary_bits = 32;
+        }
+      } else if (protection_length_primary == 3) {
+        {
+          this.protection_bits_primary_bits = 128;
+        }
+      }
+      {
+        protection_bits_primary = this.BAM_source.get("", this.protection_bits_primary_bits);
+        this.BAM_g_position += this.protection_bits_primary_bits;
+      }
+      if (protection_length_secondary == 0) {
+        {
+          this.protection_bits_secondary_bits = 0;
+        }
+      } else if (protection_length_secondary == 1) {
+        {
+          this.protection_bits_secondary_bits = 8;
+        }
+      } else if (protection_length_secondary == 2) {
+        {
+          this.protection_bits_secondary_bits = 32;
+        }
+      } else if (protection_length_secondary == 3) {
+        {
+          this.protection_bits_secondary_bits = 128;
+        }
+      }
+      {
+        protection_bits_secondary = this.BAM_source.get("", this.protection_bits_secondary_bits);
+        this.BAM_g_position += this.protection_bits_secondary_bits;
+      }
+    }
+  }
+  F_emdf_info() {
+    var key_id;
+    var b_emdf_payloads_substream_info;
+    var emdf_version;
+    {
+      {
+        emdf_version = this.BAM_source.get("", 2);
+        this.BAM_g_position += 2;
+      }
+      if (emdf_version == 3) {
+        {
+          {
+            this.v = this.F_variable_bits(2);
+            if (this.v == null) {
+              throw ParseError("F_variable_bits", "expected to return a value, returned None");
+            }
+          }
+          {
+            emdf_version += this.v;
+          }
+        }
+      }
+      {
+        key_id = this.BAM_source.get("", 3);
+        this.BAM_g_position += 3;
+      }
+      if (key_id == 7) {
+        {
+          {
+            this.v = this.F_variable_bits(3);
+            if (this.v == null) {
+              throw ParseError("F_variable_bits", "expected to return a value, returned None");
+            }
+          }
+          {
+            key_id += this.v;
+          }
+        }
+      }
+      {
+        b_emdf_payloads_substream_info = this.BAM_source.get("", 1);
+        this.BAM_g_position += 1;
+      }
+      if (b_emdf_payloads_substream_info) {
+        {
+          this.F_emdf_payloads_substream_info(this.toc_i);
+        }
+      }
+      {
+        this.F_emdf_protection();
+      }
+    }
+  }
+  F_emdf_payloads_substream_info(toc_i) {
+    var substream_index;
+    {
+      {
+        substream_index = this.BAM_source.get("", 2);
+        this.BAM_g_position += 2;
+      }
+      if (substream_index == 3) {
+        {
+          {
+            this.v = this.F_variable_bits(2);
+            if (this.v == null) {
+              throw ParseError("F_variable_bits", "expected to return a value, returned None");
+            }
+          }
+          {
+            substream_index += this.v;
+          }
+        }
+      }
+      {
+        this.last_referenced_substream = Math.max(this.last_referenced_substream, substream_index);
+      }
+      {
+        this.referenced_substreams.push(substream_index);
+      }
+      {
+        this.a_substream_indices.push(substream_index);
+      }
+    }
+  }
+  F_ac4_hsf_ext_substream_info(ahsf_b_substreams_present) {
+    var substream_index;
+    {
+      if (ahsf_b_substreams_present == 1) {
+        {
+          {
+            substream_index = this.BAM_source.get("", 2);
+            this.BAM_g_position += 2;
+          }
+          if (substream_index == 3) {
+            {
+              {
+                this.v = this.F_variable_bits(2);
+                if (this.v == null) {
+                  throw ParseError("F_variable_bits", "expected to return a value, returned None");
+                }
+              }
+              {
+                substream_index += this.v;
+              }
+            }
+          }
+        }
+      } else {
+        {
+          {
+            substream_index = this.bk_substream_index;
+          }
+          {
+            this.bk_substream_index = this.bk_substream_index + 1;
+          }
+        }
+      }
+      if (ahsf_b_substreams_present == 1) {
+        {
+          {
+            this.last_referenced_substream = Math.max(this.last_referenced_substream, substream_index);
+          }
+          {
+            this.referenced_substreams.push(substream_index);
+          }
+        }
+      }
+    }
+  }
+  F_oamd_common_data() {
+    var add_data_bits;
+    var ocd_p1;
+    var add_data;
+    var ocd_p0;
+    var bits_used;
+    var b_bed_object_chan_distribute;
+    var master_screen_size_ratio;
+    var add_data_bytes_minus1;
+    var add_data_bytes;
+    var b_additional_data;
+    var b_default_screen_size_ratio;
+    {
+      {
+        b_default_screen_size_ratio = this.BAM_source.get("", 1);
+        this.BAM_g_position += 1;
+      }
+      if (b_default_screen_size_ratio == 0) {
+        {
+          master_screen_size_ratio = this.BAM_source.get("", 5);
+          this.BAM_g_position += 5;
+        }
+      }
+      {
+        b_bed_object_chan_distribute = this.BAM_source.get("", 1);
+        this.BAM_g_position += 1;
+      }
+      {
+        b_additional_data = this.BAM_source.get("", 1);
+        this.BAM_g_position += 1;
+      }
+      if (b_additional_data) {
+        {
+          {
+            add_data_bytes_minus1 = this.BAM_source.get("", 1);
+            this.BAM_g_position += 1;
+          }
+          {
+            add_data_bytes = add_data_bytes_minus1 + 1;
+          }
+          if (add_data_bytes == 2) {
+            {
+              {
+                this.v = this.F_variable_bits(2);
+                if (this.v == null) {
+                  throw ParseError("F_variable_bits", "expected to return a value, returned None");
+                }
+              }
+              {
+                add_data_bytes += this.v;
+              }
+            }
+          }
+          {
+            add_data_bits = add_data_bytes * 8;
+          }
+          {
+            ocd_p0 = this.BAM_g_position;
+          }
+          {
+            ocd_p1 = this.BAM_g_position;
+          }
+          {
+            bits_used = ocd_p1 - ocd_p0;
+          }
+          {
+            add_data_bits = add_data_bits - bits_used;
+          }
+          if (add_data_bits < 0) {
+            throw "Wrong add_data_bytes_minus1 size indication";
+          }
+          {
+            add_data = this.BAM_source.get("", add_data_bits);
+            this.BAM_g_position += add_data_bits;
+          }
+        }
+      }
+    }
+  }
+  F_define_oamd() {
+    var NUM_TRIM_CONFIGS;
+    {
+      {
+        this.OAMD_OBJECT_TYPE_BED = 0;
+      }
+      {
+        this.OAMD_OBJECT_TYPE_ISF = 1;
+      }
+      {
+        this.OAMD_OBJECT_TYPE_DYNAMIC = 2;
+      }
+      {
+        this.OAMD_OBJECT_TYPE_RESERVED = 3;
+      }
+      {
+        NUM_TRIM_CONFIGS = 9;
+      }
+    }
+  }
+  F_ac4_substream_info_ajoc(asio_group_index, asio_gs_index_ajoc, asio_b_substreams_present) {
+    var n_fullband_upmix_signals_minus1;
+    var substream_index;
+    var b_oamd_common_data_present;
+    var b_sf_multiplier;
+    var b_bitrate_info;
+    var n_fullband_dmx_signals;
+    var n_fullband_upmix_signals;
+    var si_b_iframe;
+    var num_objects_DYNAMIC = null;
+    var num_objects_DYNAMIC;
+    var ajoc_b_lfe;
+    var n_fullband_dmx_signals_minus1;
+    var b_lfe = null;
+    var b_lfe;
+    var si_channel_mode_j;
+    var b_static_dmx;
+    var sf_multiplier;
+    {
+      {
+        num_objects_DYNAMIC = this.BAM_g_table6.slice(0);
+      }
+      {
+        this.F_define_channel_modes();
+      }
+      {
+        ajoc_b_lfe = this.BAM_source.get("", 1);
+        this.BAM_g_position += 1;
+      }
+      {
+        b_static_dmx = this.BAM_source.get("", 1);
+        this.BAM_g_position += 1;
+      }
+      if (b_static_dmx) {
+        {
+          {
+            n_fullband_dmx_signals = 5;
+          }
+          if (ajoc_b_lfe) {
+            {
+              si_channel_mode_j = this.CHANNEL_MODE_51;
+            }
+          } else {
+            {
+              si_channel_mode_j = this.CHANNEL_MODE_50;
+            }
+          }
+        }
+      } else {
+        {
+          {
+            n_fullband_dmx_signals_minus1 = this.BAM_source.get("", 4);
+            this.BAM_g_position += 4;
+          }
+          {
+            n_fullband_dmx_signals = n_fullband_dmx_signals_minus1 + 1;
+          }
+          {
+            this.F_bed_dyn_obj_assignment(n_fullband_dmx_signals, 0, ajoc_b_lfe);
+          }
+        }
+      }
+      {
+        b_oamd_common_data_present = this.BAM_source.get("", 1);
+        this.BAM_g_position += 1;
+      }
+      if (b_oamd_common_data_present) {
+        {
+          this.F_oamd_common_data();
+        }
+      }
+      {
+        n_fullband_upmix_signals_minus1 = this.BAM_source.get("", 4);
+        this.BAM_g_position += 4;
+      }
+      {
+        n_fullband_upmix_signals = n_fullband_upmix_signals_minus1 + 1;
+      }
+      if (n_fullband_upmix_signals == 16) {
+        {
+          {
+            this.v = this.F_variable_bits(3);
+            if (this.v == null) {
+              throw ParseError("F_variable_bits", "expected to return a value, returned None");
+            }
+          }
+          {
+            n_fullband_upmix_signals = n_fullband_upmix_signals + this.v;
+          }
+        }
+      }
+      {
+        this.F_bed_dyn_obj_assignment(n_fullband_upmix_signals, 1, ajoc_b_lfe);
+      }
+      if (this.fs_index == 1) {
+        {
+          {
+            b_sf_multiplier = this.BAM_source.get("", 1);
+            this.BAM_g_position += 1;
+          }
+          if (b_sf_multiplier) {
+            {
+              sf_multiplier = this.BAM_source.get("", 1);
+              this.BAM_g_position += 1;
+            }
+          }
+        }
+      }
+      {
+        b_bitrate_info = this.BAM_source.get("", 1);
+        this.BAM_g_position += 1;
+      }
+      if (b_bitrate_info) {
+        {
+          this.F_bitrate_indicator();
+        }
+      }
+      {
+        this.frame_rate_factor = this.group_frame_rate_factor[asio_group_index];
+      }
+      for (this.i = 0; this.i < this.frame_rate_factor; this.i++) {
+        {
+          si_b_iframe = this.BAM_source.get("", 1);
+          this.BAM_g_position += 1;
+        }
+      }
+      if (asio_b_substreams_present == 1) {
+        {
+          {
+            substream_index = this.BAM_source.get("", 2);
+            this.BAM_g_position += 2;
+          }
+          if (substream_index == 3) {
+            {
+              {
+                this.v = this.F_variable_bits(2);
+                if (this.v == null) {
+                  throw ParseError("F_variable_bits", "expected to return a value, returned None");
+                }
+              }
+              {
+                substream_index += this.v;
+              }
+            }
+          }
+        }
+      } else {
+        {
+          {
+            substream_index = this.bk_substream_index;
+          }
+          {
+            this.bk_substream_index = this.bk_substream_index + 1;
+          }
+        }
+      }
+      {
+        this.a_substream_indices.push(substream_index);
+      }
+      for (this.i = 0; this.i < this.frame_rate_factor; this.i++) {
+        {
+          if (asio_b_substreams_present == 1) {
+            {
+              {
+                this.last_referenced_substream = Math.max(this.last_referenced_substream, substream_index + this.i);
+              }
+              {
+                this.referenced_substreams.push(substream_index + this.i);
+              }
+            }
+          }
+          {
+            if (b_lfe == null) {
+              b_lfe = new Array(substream_index + this.i + 1).fill(0);
+            } else if (b_lfe.length <= substream_index + this.i) {
+              b_lfe.push.apply(b_lfe, new Array(substream_index + this.i - b_lfe.length + 1).fill(0));
+            }
+            b_lfe[substream_index + this.i] = ajoc_b_lfe;
+          }
+        }
+      }
+    }
+  }
+  F_ac4_sgi_specifier(asgi_b_associated, asgi_b_dialog, group_in_presentation_index) {
+    var group_index;
+    {
+      if (this.bitstream_version == 1) {
+        {
+          {
+            this.F_ac4_substream_group_info(this.toc_j);
+          }
+          {
+            this.toc_j += 1;
+          }
+        }
+      } else {
+        {
+          {
+            group_index = this.BAM_source.get("", 3);
+            this.BAM_g_position += 3;
+          }
+          if (group_index == 7) {
+            {
+              {
+                this.vb = this.F_variable_bits(2);
+                if (this.vb == null) {
+                  throw ParseError("F_variable_bits", "expected to return a value, returned None");
+                }
+              }
+              {
+                group_index += this.vb;
+              }
+            }
+          }
+          {
+            if (this.presentation_to_groups == null) {
+              this.presentation_to_groups = new Array(this.toc_i + 1).fill(null);
+            } else if (this.presentation_to_groups.length <= this.toc_i) {
+              this.presentation_to_groups.push.apply(this.presentation_to_groups, new Array(this.toc_i - this.presentation_to_groups.length + 1).fill(null));
+            }
+            this.presentation_to_groups[this.toc_i].push(group_index);
+          }
+          {
+            if (this.group_frame_rate_factor == null) {
+              this.group_frame_rate_factor = new Array(group_index + 1).fill(0);
+            } else if (this.group_frame_rate_factor.length <= group_index) {
+              this.group_frame_rate_factor.push.apply(this.group_frame_rate_factor, new Array(group_index - this.group_frame_rate_factor.length + 1).fill(0));
+            }
+            this.group_frame_rate_factor[group_index] = this.frame_rate_factor;
+          }
+        }
+      }
+    }
+  }
+  F_ac4_substream_group_info(si_group_index) {
+    var obj_index;
+    var b_dialog_content;
+    var sus;
+    var n_lf_substreams;
+    var b_substreams_present;
+    var b_channel_coded;
+    var b_ajoc;
+    var n_lf_substreams_minus2;
+    var sus_ver;
+    var b_oamd_substream;
+    var b_content_type;
+    var b_associated_content;
+    {
+      {
+        b_substreams_present = this.BAM_source.get("", 1);
+        this.BAM_g_position += 1;
+      }
+      {
+        this.b_hsf_ext = this.BAM_source.get("", 1);
+        this.BAM_g_position += 1;
+      }
+      {
+        this.b_single_substream = this.BAM_source.get("", 1);
+        this.BAM_g_position += 1;
+      }
+      if (this.b_single_substream) {
+        {
+          n_lf_substreams = 1;
+        }
+      } else {
+        {
+          {
+            n_lf_substreams_minus2 = this.BAM_source.get("", 2);
+            this.BAM_g_position += 2;
+          }
+          {
+            n_lf_substreams = n_lf_substreams_minus2 + 2;
+          }
+          if (n_lf_substreams == 5) {
+            {
+              {
+                this.v = this.F_variable_bits(2);
+                if (this.v == null) {
+                  throw ParseError("F_variable_bits", "expected to return a value, returned None");
+                }
+              }
+              {
+                n_lf_substreams += this.v;
+              }
+            }
+          }
+        }
+      }
+      {
+        b_channel_coded = this.BAM_source.get("", 1);
+        this.BAM_g_position += 1;
+      }
+      {
+        this.n_bed_objects = -1;
+      }
+      {
+        this.a_num_bed_objects = [];
+      }
+      if (b_channel_coded) {
+        {
+          {
+            b_ajoc = 0;
+          }
+          for (sus = 0; sus < n_lf_substreams; sus++) {
+            {
+              if (this.bitstream_version == 1) {
+                {
+                  sus_ver = this.BAM_source.get("", 1);
+                  this.BAM_g_position += 1;
+                }
+              } else {
+                {
+                  sus_ver = 1;
+                }
+              }
+              {
+                this.F_ac4_substream_info_chan(si_group_index, sus, b_substreams_present);
+              }
+              if (this.b_hsf_ext) {
+                {
+                  this.F_ac4_hsf_ext_substream_info(b_substreams_present);
+                }
+              }
+            }
+          }
+        }
+      } else {
+        {
+          {
+            b_oamd_substream = this.BAM_source.get("", 1);
+            this.BAM_g_position += 1;
+          }
+          if (b_oamd_substream) {
+            {
+              this.F_oamd_substream_info(b_substreams_present);
+            }
+          }
+          {
+            obj_index = 0;
+          }
+          {
+            this.b_bed_objects_prev = 0;
+          }
+          for (sus = 0; sus < n_lf_substreams; sus++) {
+            {
+              {
+                b_ajoc = this.BAM_source.get("", 1);
+                this.BAM_g_position += 1;
+              }
+              if (b_ajoc) {
+                {
+                  {
+                    this.F_ac4_substream_info_ajoc(si_group_index, sus, b_substreams_present);
+                  }
+                  if (this.b_hsf_ext) {
+                    {
+                      this.F_ac4_hsf_ext_substream_info(b_substreams_present);
+                    }
+                  }
+                }
+              } else {
+                {
+                  {
+                    this.F_ac4_substream_info_obj(si_group_index, sus, obj_index, b_substreams_present);
+                  }
+                  {
+                    obj_index += 1;
+                  }
+                  if (this.b_hsf_ext) {
+                    {
+                      this.F_ac4_hsf_ext_substream_info(b_substreams_present);
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      {
+        b_content_type = this.BAM_source.get("", 1);
+        this.BAM_g_position += 1;
+      }
+      if (b_content_type) {
+        {
+          {
+            this.F_content_type();
+          }
+          if (this.content_classifier == 0) {
+            {
+              {
+                b_associated_content = 0;
+              }
+              {
+                b_dialog_content = 0;
+              }
+            }
+          } else if (this.content_classifier == 1) {
+            {
+              {
+                b_associated_content = 0;
+              }
+              {
+                b_dialog_content = 0;
+              }
+            }
+          } else if (this.content_classifier == 2) {
+            {
+              {
+                b_associated_content = 1;
+              }
+              {
+                b_dialog_content = 0;
+              }
+            }
+          } else if (this.content_classifier == 3) {
+            {
+              {
+                b_associated_content = 1;
+              }
+              {
+                b_dialog_content = 0;
+              }
+            }
+          } else if (this.content_classifier == 4) {
+            {
+              {
+                b_associated_content = 0;
+              }
+              {
+                b_dialog_content = 1;
+              }
+            }
+          } else if (this.content_classifier == 5) {
+            {
+              {
+                b_associated_content = 1;
+              }
+              {
+                b_dialog_content = 0;
+              }
+            }
+          } else if (this.content_classifier == 6) {
+            {
+              {
+                b_associated_content = 0;
+              }
+              {
+                b_dialog_content = 0;
+              }
+            }
+          } else if (this.content_classifier == 7) {
+            {
+              {
+                b_associated_content = 0;
+              }
+              {
+                b_dialog_content = 0;
+              }
+            }
+          }
+        }
+      } else {
+        {
+          {
+            b_associated_content = 0;
+          }
+          {
+            b_dialog_content = 0;
+          }
+        }
+      }
+    }
+  }
+  F_oamd_substream_info(oamd_b_substreams_present) {
+    var substream_index;
+    var b_iframe_oamd;
+    {
+      {
+        this.F_define_oamd();
+      }
+      {
+        b_iframe_oamd = this.BAM_source.get("", 1);
+        this.BAM_g_position += 1;
+      }
+      if (oamd_b_substreams_present == 1) {
+        {
+          {
+            substream_index = this.BAM_source.get("", 2);
+            this.BAM_g_position += 2;
+          }
+          if (substream_index == 3) {
+            {
+              {
+                this.vb = this.F_variable_bits(2);
+                if (this.vb == null) {
+                  throw ParseError("F_variable_bits", "expected to return a value, returned None");
+                }
+              }
+              {
+                substream_index += this.vb;
+              }
+            }
+          }
+        }
+      } else {
+        {
+          {
+            substream_index = this.bk_substream_index;
+          }
+          {
+            this.bk_substream_index = this.bk_substream_index + 1;
+          }
+        }
+      }
+      if (oamd_b_substreams_present == 1) {
+        {
+          {
+            this.last_referenced_substream = Math.max(this.last_referenced_substream, substream_index);
+          }
+          {
+            this.referenced_substreams.push(substream_index);
+          }
+        }
+      }
+    }
+  }
+  F_ac4_substream_info_obj(asio_group_index, asio_gs_index, asio_gs_index_obj, asio_b_substreams_present) {
+    var obj_type;
+    var b_nonstd_bed_channel_assignment;
+    var res_bytes;
+    var b_bed_start;
+    var bed_chan_assign_code;
+    var j;
+    var si_b_iframe;
+    var n_objs;
+    var si_num_channels;
+    var reserved_data;
+    var b_isf_start;
+    var n_objects_code;
+    var isf_config;
+    var substream_index;
+    var b_sf_multiplier;
+    var b_bed_objects;
+    var b_dynamic_objects;
+    var b_bitrate_info;
+    var b_isf;
+    var nonstd_bed_channel_assignment_mask;
+    var b_ch_assign_code;
+    var b_lfe = null;
+    var b_lfe;
+    var std_bed_channel_assignment_mask;
+    var sf_multiplier;
+    var si_b_lfe;
+    {
+      {
+        n_objs = 0;
+      }
+      {
+        this.F_define_oamd();
+      }
+      {
+        this.F_define_channel_modes();
+      }
+      {
+        n_objects_code = this.BAM_source.get("", 3);
+        this.BAM_g_position += 3;
+      }
+      {
+        si_num_channels = this.BAM_g_table7.slice(0)[n_objects_code];
+      }
+      {
+        b_dynamic_objects = this.BAM_source.get("", 1);
+        this.BAM_g_position += 1;
+      }
+      if (b_dynamic_objects) {
+        {
+          {
+            si_b_lfe = this.BAM_source.get("", 1);
+            this.BAM_g_position += 1;
+          }
+          {
+            obj_type = this.OAMD_OBJECT_TYPE_DYNAMIC;
+          }
+          {
+            this.b_bed_objects_prev = 0;
+          }
+        }
+      } else {
+        {
+          {
+            b_bed_objects = this.BAM_source.get("", 1);
+            this.BAM_g_position += 1;
+          }
+          if (b_bed_objects) {
+            {
+              if (this.b_bed_objects_prev && this.num_lfe == 2) {
+                {
+                  si_b_lfe = 1;
+                }
+              } else {
+                {
+                  si_b_lfe = 0;
+                }
+              }
+              {
+                this.b_bed_objects_prev = 1;
+              }
+              {
+                this.num_lfe = 0;
+              }
+              {
+                obj_type = this.OAMD_OBJECT_TYPE_BED;
+              }
+              {
+                b_bed_start = this.BAM_source.get("", 1);
+                this.BAM_g_position += 1;
+              }
+              if (b_bed_start) {
+                {
+                  {
+                    b_ch_assign_code = this.BAM_source.get("", 1);
+                    this.BAM_g_position += 1;
+                  }
+                  if (b_ch_assign_code) {
+                    {
+                      {
+                        bed_chan_assign_code = this.BAM_source.get("", 3);
+                        this.BAM_g_position += 3;
+                      }
+                      for (this.i = 0; this.i < this.BAM_g_table8.slice(0)[bed_chan_assign_code]; this.i++) {
+                        {
+                          n_objs += 1;
+                        }
+                      }
+                      if (bed_chan_assign_code >= 2) {
+                        {
+                          si_b_lfe = 1;
+                        }
+                      }
+                    }
+                  } else {
+                    {
+                      {
+                        b_nonstd_bed_channel_assignment = this.BAM_source.get("", 1);
+                        this.BAM_g_position += 1;
+                      }
+                      if (b_nonstd_bed_channel_assignment) {
+                        {
+                          {
+                            nonstd_bed_channel_assignment_mask = this.BAM_source.get("", 17);
+                            this.BAM_g_position += 17;
+                          }
+                          for (this.i = 0; this.i < 17; this.i++) {
+                            if ((nonstd_bed_channel_assignment_mask & 1 << this.i) != 0) {
+                              {
+                                if (this.i == 3 || this.i == 16) {
+                                  {
+                                    this.num_lfe += 1;
+                                  }
+                                }
+                                {
+                                  n_objs += 1;
+                                }
+                              }
+                            }
+                          }
+                        }
+                      } else {
+                        {
+                          {
+                            std_bed_channel_assignment_mask = this.BAM_source.get("", 10);
+                            this.BAM_g_position += 10;
+                          }
+                          for (this.i = 0; this.i < 10; this.i++) {
+                            if ((std_bed_channel_assignment_mask & 1 << this.i) != 0) {
+                              for (j = 0; j < this.BAM_g_table9.slice(0)[this.i]; j++) {
+                                {
+                                  if (this.i == 2 || this.i == 9) {
+                                    {
+                                      this.num_lfe += 1;
+                                    }
+                                  }
+                                  {
+                                    n_objs += 1;
+                                  }
+                                }
+                              }
+                            }
+                          }
+                        }
+                      }
+                      if (this.num_lfe > 0) {
+                        {
+                          si_b_lfe = 1;
+                        }
+                      }
+                    }
+                  }
+                  {
+                    this.n_bed_objects = n_objs;
+                  }
+                  {
+                    this.a_num_bed_objects.push(this.n_bed_objects);
+                  }
+                }
+              }
+            }
+          } else {
+            {
+              {
+                si_b_lfe = 0;
+              }
+              {
+                this.b_bed_objects_prev = 0;
+              }
+              {
+                b_isf = this.BAM_source.get("", 1);
+                this.BAM_g_position += 1;
+              }
+              if (b_isf) {
+                {
+                  {
+                    obj_type = this.OAMD_OBJECT_TYPE_ISF;
+                  }
+                  {
+                    b_isf_start = this.BAM_source.get("", 1);
+                    this.BAM_g_position += 1;
+                  }
+                  if (b_isf_start) {
+                    {
+                      isf_config = this.BAM_source.get("", 3);
+                      this.BAM_g_position += 3;
+                    }
+                  }
+                }
+              } else {
+                {
+                  {
+                    res_bytes = this.BAM_source.get("", 4);
+                    this.BAM_g_position += 4;
+                  }
+                  {
+                    reserved_data = this.BAM_source.get("", 8 * res_bytes);
+                    this.BAM_g_position += 8 * res_bytes;
+                  }
+                  {
+                    obj_type = this.OAMD_OBJECT_TYPE_RESERVED;
+                  }
+                  if (si_num_channels == 0) {
+                    throw "No non-LFE objects (of OAMD_OBJECT_TYPE_RESERVED) in substream!";
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      if (this.fs_index == 1) {
+        {
+          {
+            b_sf_multiplier = this.BAM_source.get("", 1);
+            this.BAM_g_position += 1;
+          }
+          if (b_sf_multiplier) {
+            {
+              sf_multiplier = this.BAM_source.get("", 1);
+              this.BAM_g_position += 1;
+            }
+          }
+        }
+      }
+      {
+        b_bitrate_info = this.BAM_source.get("", 1);
+        this.BAM_g_position += 1;
+      }
+      if (b_bitrate_info) {
+        {
+          this.F_bitrate_indicator();
+        }
+      }
+      {
+        this.frame_rate_factor = this.group_frame_rate_factor[asio_group_index];
+      }
+      for (this.i = 0; this.i < this.frame_rate_factor; this.i++) {
+        {
+          si_b_iframe = this.BAM_source.get("", 1);
+          this.BAM_g_position += 1;
+        }
+      }
+      if (asio_b_substreams_present == 1) {
+        {
+          {
+            substream_index = this.BAM_source.get("", 2);
+            this.BAM_g_position += 2;
+          }
+          if (substream_index == 3) {
+            {
+              {
+                this.v = this.F_variable_bits(2);
+                if (this.v == null) {
+                  throw ParseError("F_variable_bits", "expected to return a value, returned None");
+                }
+              }
+              {
+                substream_index += this.v;
+              }
+            }
+          }
+        }
+      } else {
+        {
+          {
+            substream_index = this.bk_substream_index;
+          }
+          {
+            this.bk_substream_index = this.bk_substream_index + 1;
+          }
+        }
+      }
+      {
+        this.a_substream_indices.push(substream_index);
+      }
+      for (this.i = 0; this.i < this.frame_rate_factor; this.i++) {
+        {
+          if (asio_b_substreams_present == 1) {
+            {
+              {
+                this.last_referenced_substream = Math.max(this.last_referenced_substream, substream_index + this.i);
+              }
+              {
+                this.referenced_substreams.push(substream_index + this.i);
+              }
+            }
+          }
+          {
+            if (b_lfe == null) {
+              b_lfe = new Array(substream_index + this.i + 1).fill(0);
+            } else if (b_lfe.length <= substream_index + this.i) {
+              b_lfe.push.apply(b_lfe, new Array(substream_index + this.i - b_lfe.length + 1).fill(0));
+            }
+            b_lfe[substream_index + this.i] = si_b_lfe;
+          }
+        }
+      }
+    }
+  }
+  F_bed_dyn_obj_assignment(n_signals, b_upmix, bd_lfe) {
+    var n_isf;
+    var isf_config;
+    var oc_num_channels;
+    var obj_type;
+    var n_bed_signals_minus1;
+    var b_nonstd_bed_channel_assignment;
+    var nonstd_bed_channel_assignment;
+    var bed_chan_assign_code;
+    var nonstd_bed_channel_assignment_mask;
+    var lfe_signalled;
+    var b_is_isf;
+    var n_bed_signals;
+    var bed_ch_bits;
+    var b_ch_assign_code;
+    var std_bed_channel_assignment_mask;
+    var b_dyn_objects_only;
+    var b_chan_assign_mask;
+    var b;
+    {
+      {
+        this.F_define_oamd();
+      }
+      {
+        lfe_signalled = 0;
+      }
+      {
+        b_dyn_objects_only = this.BAM_source.get("", 1);
+        this.BAM_g_position += 1;
+      }
+      if (b_dyn_objects_only == 0) {
+        {
+          {
+            b_is_isf = this.BAM_source.get("", 1);
+            this.BAM_g_position += 1;
+          }
+          if (b_is_isf) {
+            {
+              {
+                isf_config = this.BAM_source.get("", 3);
+                this.BAM_g_position += 3;
+              }
+              {
+                obj_type = this.OAMD_OBJECT_TYPE_ISF;
+              }
+              {
+                n_isf = this.BAM_g_table10.slice(0)[isf_config];
+              }
+            }
+          } else {
+            {
+              {
+                obj_type = this.OAMD_OBJECT_TYPE_BED;
+              }
+              {
+                b_ch_assign_code = this.BAM_source.get("", 1);
+                this.BAM_g_position += 1;
+              }
+              if (b_ch_assign_code) {
+                {
+                  {
+                    bed_chan_assign_code = this.BAM_source.get("", 3);
+                    this.BAM_g_position += 3;
+                  }
+                  if (this.BAM_g_table11.slice(0).indexOf(bed_chan_assign_code) >= 0) {
+                    {
+                      lfe_signalled = 1;
+                    }
+                  }
+                }
+              } else {
+                {
+                  {
+                    b_chan_assign_mask = this.BAM_source.get("", 1);
+                    this.BAM_g_position += 1;
+                  }
+                  if (b_chan_assign_mask) {
+                    {
+                      {
+                        b_nonstd_bed_channel_assignment = this.BAM_source.get("", 1);
+                        this.BAM_g_position += 1;
+                      }
+                      if (b_nonstd_bed_channel_assignment) {
+                        {
+                          {
+                            nonstd_bed_channel_assignment_mask = this.BAM_source.get("", 17);
+                            this.BAM_g_position += 17;
+                          }
+                          for (this.i = 0; this.i < 17; this.i++) {
+                            if (nonstd_bed_channel_assignment_mask >> this.i & 1) {
+                              if (this.i == 3 || this.i == 16) {
+                                {
+                                  lfe_signalled = 1;
+                                }
+                              }
+                            }
+                          }
+                        }
+                      } else {
+                        {
+                          {
+                            std_bed_channel_assignment_mask = this.BAM_source.get("", 10);
+                            this.BAM_g_position += 10;
+                          }
+                          for (this.i = 0; this.i < 10; this.i++) {
+                            if (std_bed_channel_assignment_mask >> this.i & 1) {
+                              {
+                                if (this.i == 2 || this.i == 9) {
+                                  {
+                                    lfe_signalled = 1;
+                                  }
+                                }
+                                {
+                                  oc_num_channels = this.BAM_g_table12.slice(0)[this.i];
+                                }
+                              }
+                            }
+                          }
+                        }
+                      }
+                    }
+                  } else {
+                    {
+                      if (n_signals > 1) {
+                        {
+                          {
+                            bed_ch_bits = Math.ceil(Math.log(n_signals) / Math.log(2));
+                          }
+                          {
+                            n_bed_signals_minus1 = this.BAM_source.get("", bed_ch_bits);
+                            this.BAM_g_position += bed_ch_bits;
+                          }
+                          {
+                            n_bed_signals = n_bed_signals_minus1 + 1;
+                          }
+                        }
+                      } else {
+                        {
+                          n_bed_signals = 1;
+                        }
+                      }
+                      for (b = 0; b < n_bed_signals; b++) {
+                        {
+                          {
+                            nonstd_bed_channel_assignment = this.BAM_source.get("", 4);
+                            this.BAM_g_position += 4;
+                          }
+                          if (n_bed_signals == 3 || n_bed_signals == 16) {
+                            {
+                              lfe_signalled = 1;
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  F_ac4_presentation_substream_info(aps_presentation_version) {
+    var substream_index;
+    var b_lfe = null;
+    var b_lfe;
+    var b_alternative;
+    var b_iframe_pres;
+    {
+      {
+        b_alternative = this.BAM_source.get("", 1);
+        this.BAM_g_position += 1;
+      }
+      {
+        b_iframe_pres = this.BAM_source.get("", 1);
+        this.BAM_g_position += 1;
+      }
+      {
+        substream_index = this.BAM_source.get("", 2);
+        this.BAM_g_position += 2;
+      }
+      if (substream_index == 3) {
+        {
+          {
+            this.v = this.F_variable_bits(2);
+            if (this.v == null) {
+              throw ParseError("F_variable_bits", "expected to return a value, returned None");
+            }
+          }
+          {
+            substream_index += this.v;
+          }
+        }
+      }
+      {
+        if (b_lfe == null) {
+          b_lfe = new Array(substream_index + 1).fill(0);
+        } else if (b_lfe.length <= substream_index) {
+          b_lfe.push.apply(b_lfe, new Array(substream_index - b_lfe.length + 1).fill(0));
+        }
+        b_lfe[substream_index] = 0;
+      }
+      {
+        this.last_referenced_substream = Math.max(this.last_referenced_substream, substream_index);
+      }
+      {
+        this.referenced_substreams.push(substream_index);
+      }
+    }
+  }
+  F_presentation_version() {
+    var val;
+    var b_tmp;
+    {
+      {
+        val = 0;
+      }
+      {
+        b_tmp = this.BAM_source.get("", 1);
+        this.BAM_g_position += 1;
+      }
+      while (b_tmp) {
+        {
+          {
+            val = val + 1;
+          }
+          {
+            b_tmp = this.BAM_source.get("", 1);
+            this.BAM_g_position += 1;
+          }
+        }
+      }
+      return val;
+    }
+  }
+  F_get_ch_mode(cm) {
+    {
+      if (cm == this.CHANNEL_MODE_MONO) {
+        {
+          this.n = 0;
+        }
+      } else if (cm == this.CHANNEL_MODE_STEREO) {
+        {
+          this.n = 1;
+        }
+      } else if (cm == this.CHANNEL_MODE_30) {
+        {
+          this.n = 2;
+        }
+      } else if (cm == this.CHANNEL_MODE_50) {
+        {
+          this.n = 3;
+        }
+      } else if (cm == this.CHANNEL_MODE_51) {
+        {
+          this.n = 4;
+        }
+      } else if (cm == this.CHANNEL_MODE_70_34) {
+        {
+          this.n = 5;
+        }
+      } else if (cm == this.CHANNEL_MODE_71_34) {
+        {
+          this.n = 6;
+        }
+      } else if (cm == this.CHANNEL_MODE_70_52) {
+        {
+          this.n = 7;
+        }
+      } else if (cm == this.CHANNEL_MODE_71_52) {
+        {
+          this.n = 8;
+        }
+      } else if (cm == this.CHANNEL_MODE_70_322) {
+        {
+          this.n = 9;
+        }
+      } else if (cm == this.CHANNEL_MODE_71_322) {
+        {
+          this.n = 10;
+        }
+      } else if (cm == this.CHANNEL_MODE_704) {
+        {
+          this.n = 11;
+        }
+      } else if (cm == this.CHANNEL_MODE_714) {
+        {
+          this.n = 12;
+        }
+      } else if (cm == this.CHANNEL_MODE_904) {
+        {
+          this.n = 13;
+        }
+      } else if (cm == this.CHANNEL_MODE_914) {
+        {
+          this.n = 14;
+        }
+      } else {
+        if (1) {
+          throw "Unknown channel mode!";
+        }
+      }
+      return this.n;
+    }
+  }
+  F_presentation_config_ext_info() {
+    {
+      {
+        this.n_skip_bytes = this.BAM_source.get("", 5);
+        this.BAM_g_position += 5;
+      }
+      {
+        this.b_more_skip_bytes = this.BAM_source.get("", 1);
+        this.BAM_g_position += 1;
+      }
+      if (this.b_more_skip_bytes) {
+        {
+          {
+            this.v = this.F_variable_bits(2);
+            if (this.v == null) {
+              throw ParseError("F_variable_bits", "expected to return a value, returned None");
+            }
+          }
+          {
+            this.n_skip_bytes += this.v << 5;
+          }
+        }
+      }
+      if (0) {
+        {
+          {
+            this.n_bits_read_0 = this.BAM_g_position;
+          }
+          {
+            this.F_ac4_presentation_v2_info(this.toc_i);
+          }
+          {
+            this.n_bits_read_1 = this.BAM_g_position;
+          }
+          {
+            this.n_bits_read = this.n_bits_read_1 - this.n_bits_read_0;
+          }
+          if ((n_bits_read % 8 + 8) % 8) {
+            {
+              {
+                this.n_skip_bits = 8 - (n_bits_read % 8 + 8) % 8;
+              }
+              {
+                this.reserved = this.BAM_source.get("", this.n_skip_bits);
+                this.BAM_g_position += this.n_skip_bits;
+              }
+              {
+                this.n_bits_read += this.n_skip_bits;
+              }
+            }
+          }
+          {
+            this.n_skip_bytes = this.n_skip_bytes - Math.floor(this.n_bits_read / 8);
+          }
+        }
+      }
+      if (this.bitstream_version >= 1 && this.presentation_config == 8) {
+        {
+          {
+            this.n_bits_read_0 = this.BAM_g_position;
+          }
+          {
+            this.n_bits_read_1 = this.BAM_g_position;
+          }
+          {
+            this.padding = this.BAM_source.get("", this.n_skip_bytes * 8 - (this.n_bits_read_1 - this.n_bits_read_0));
+            this.BAM_g_position += this.n_skip_bytes * 8 - (this.n_bits_read_1 - this.n_bits_read_0);
+          }
+        }
+      } else {
+        for (this.i = 0; this.i < this.n_skip_bytes; this.i++) {
+          {
+            this.reserved = this.BAM_source.get("", 8);
+            this.BAM_g_position += 8;
+          }
+        }
+      }
+    }
+  }
+  F_define_channel_modes() {
+    var CHANNEL_MODE_7X_34 = null;
+    var CHANNEL_MODE_7X_34;
+    var CHANNEL_MODE_7X_322 = null;
+    var CHANNEL_MODE_7X_322;
+    var CHANNEL_MODE_7X = null;
+    var CHANNEL_MODE_7X;
+    var CHANNEL_MODE_7X_52 = null;
+    var CHANNEL_MODE_7X_52;
+    var CHANNEL_MODE_5X = null;
+    var CHANNEL_MODE_5X;
+    {
+      {
+        this.CHANNEL_MODE_MONO = 0;
+      }
+      {
+        this.CHANNEL_MODE_STEREO = 2;
+      }
+      {
+        this.CHANNEL_MODE_30 = 12;
+      }
+      {
+        this.CHANNEL_MODE_50 = 13;
+      }
+      {
+        this.CHANNEL_MODE_51 = 14;
+      }
+      {
+        this.CHANNEL_MODE_70_34 = 120;
+      }
+      {
+        this.CHANNEL_MODE_71_34 = 121;
+      }
+      {
+        this.CHANNEL_MODE_70_52 = 122;
+      }
+      {
+        this.CHANNEL_MODE_71_52 = 123;
+      }
+      {
+        this.CHANNEL_MODE_70_322 = 124;
+      }
+      {
+        this.CHANNEL_MODE_71_322 = 125;
+      }
+      {
+        this.CHANNEL_MODE_704 = 252;
+      }
+      {
+        this.CHANNEL_MODE_714 = 253;
+      }
+      {
+        this.CHANNEL_MODE_904 = 508;
+      }
+      {
+        this.CHANNEL_MODE_914 = 509;
+      }
+      {
+        this.CHANNEL_MODE_222 = 510;
+      }
+      {
+        CHANNEL_MODE_5X = [this.CHANNEL_MODE_50, this.CHANNEL_MODE_51];
+      }
+      {
+        CHANNEL_MODE_7X_34 = [this.CHANNEL_MODE_70_34, this.CHANNEL_MODE_71_34];
+      }
+      {
+        CHANNEL_MODE_7X_52 = [this.CHANNEL_MODE_70_52, this.CHANNEL_MODE_71_52];
+      }
+      {
+        CHANNEL_MODE_7X_322 = [this.CHANNEL_MODE_70_322, this.CHANNEL_MODE_71_322];
+      }
+      {
+        CHANNEL_MODE_7X = CHANNEL_MODE_7X_34 + CHANNEL_MODE_7X_52 + CHANNEL_MODE_7X_322;
+      }
+    }
+  }
+  F_channel_mode_to_ch_mode(cm) {
+    {
+      if (cm == this.CHANNEL_MODE_MONO) {
+        return 0;
+      } else if (cm == this.CHANNEL_MODE_STEREO) {
+        return 1;
+      } else if (cm == this.CHANNEL_MODE_30) {
+        return 2;
+      } else if (cm == this.CHANNEL_MODE_50) {
+        return 3;
+      } else if (cm == this.CHANNEL_MODE_51) {
+        return 4;
+      } else if (cm == this.CHANNEL_MODE_70_34) {
+        return 5;
+      } else if (cm == this.CHANNEL_MODE_71_34) {
+        return 6;
+      } else if (cm == this.CHANNEL_MODE_70_52) {
+        return 7;
+      } else if (cm == this.CHANNEL_MODE_71_52) {
+        return 8;
+      } else if (cm == this.CHANNEL_MODE_70_322) {
+        return 9;
+      } else if (cm == this.CHANNEL_MODE_71_322) {
+        return 10;
+      } else if (cm == this.CHANNEL_MODE_704) {
+        return 11;
+      } else if (cm == this.CHANNEL_MODE_714) {
+        return 12;
+      } else if (cm == this.CHANNEL_MODE_904) {
+        return 13;
+      } else if (cm == this.CHANNEL_MODE_914) {
+        return 14;
+      } else if (cm == this.CHANNEL_MODE_222) {
+        return 15;
+      } else {
+        if (1) {
+          throw "Cannot convert extended channel mode to ch_mode!";
+        }
+      }
+    }
+  }
+  F_variable_bits(n_bits) {
+    var read;
+    var value;
+    var b_read_more;
+    {
+      {
+        value = 0;
+      }
+      {
+        b_read_more = 1;
+      }
+      while (b_read_more) {
+        {
+          {
+            read = this.BAM_source.get("", n_bits);
+            this.BAM_g_position += n_bits;
+          }
+          {
+            value += read;
+          }
+          {
+            b_read_more = this.BAM_source.get("", 1);
+            this.BAM_g_position += 1;
+          }
+          if (b_read_more) {
+            {
+              {
+                value <<= n_bits;
+              }
+              {
+                value += 1 << n_bits;
+              }
+            }
+          }
+        }
+      }
+      return value;
+    }
+  }
+  F_raw_ac4_frame_toc_only() {
+    var ac4_toc_end;
+    var ac4_toc_begin;
+    var frame_len_base;
+    {
+      {
+        ac4_toc_begin = this.BAM_g_position;
+      }
+      {
+        this.F_ac4_toc();
+      }
+      {
+        ac4_toc_end = this.BAM_g_position;
+        this.BAM_sink.after_position("ac4_toc_end", ac4_toc_end);
+      }
+      {
+        frame_len_base = this.BAM_g_table13.slice(0)[this.frame_rate_index];
+      }
+    }
+  }
+  F_ac4_presentation_info() {
+    {
+      {
+        this.b_single_substream = this.BAM_source.get("", 1);
+        this.BAM_g_position += 1;
+      }
+      if (this.b_single_substream != 1) {
+        {
+          {
+            this.presentation_config = this.BAM_source.get("", 3);
+            this.BAM_g_position += 3;
+          }
+          if (this.presentation_config == 7) {
+            {
+              {
+                this.v = this.F_variable_bits(2);
+                if (this.v == null) {
+                  throw ParseError("F_variable_bits", "expected to return a value, returned None");
+                }
+              }
+              {
+                this.presentation_config += this.v;
+              }
+            }
+          }
+        }
+      }
+      {
+        this.presentation_version = this.F_presentation_version();
+        if (this.presentation_version == null) {
+          throw ParseError("F_presentation_version", "expected to return a value, returned None");
+        }
+      }
+      if (this.b_single_substream != 1 && this.presentation_config == 6) {
+        {
+          this.b_add_emdf_substreams = 1;
+        }
+      } else {
+        {
+          {
+            this.presentation_level = this.BAM_source.get("", 3);
+            this.BAM_g_position += 3;
+            this.BAM_sink.write_uint("presentation_level", 3, this.presentation_level, this.BAM_g_position);
+          }
+          {
+            this.b_presentation_id = this.BAM_source.get("", 1);
+            this.BAM_g_position += 1;
+            this.BAM_sink.write_uint("b_presentation_id", 1, this.b_presentation_id, this.BAM_g_position);
+          }
+          if (this.b_presentation_id) {
+            {
+              this.BAM_sink.before_call("variable_bits", [2], "presentation_id", this.BAM_g_position);
+              this.presentation_id = this.F_variable_bits(2);
+              if (this.presentation_id == null) {
+                throw ParseError("F_variable_bits", "expected to return a value, returned None");
+              }
+              this.BAM_sink.after_call("variable_bits", this.presentation_id, "presentation_id", this.BAM_g_position);
+            }
+          }
+          {
+            this.F_frame_rate_multiply_info();
+          }
+          {
+            this.F_emdf_info();
+          }
+          if (this.b_single_substream == 1) {
+            {
+              this.F_ac4_substream_info(0, 0, 0);
+            }
+          } else {
+            {
+              {
+                this.b_hsf_ext = this.BAM_source.get("", 1);
+                this.BAM_g_position += 1;
+              }
+              if (this.presentation_config == 0) {
+                {
+                  {
+                    this.F_ac4_substream_info(0, 0, 0);
+                  }
+                  if (this.b_hsf_ext) {
+                    {
+                      this.F_ac4_hsf_ext_substream_info(1);
+                    }
+                  }
+                  {
+                    this.F_ac4_substream_info(0, 1, 1);
+                  }
+                }
+              } else if (this.presentation_config == 1) {
+                {
+                  {
+                    this.F_ac4_substream_info(0, 0, 0);
+                  }
+                  if (this.b_hsf_ext) {
+                    {
+                      this.F_ac4_hsf_ext_substream_info(1);
+                    }
+                  }
+                  {
+                    this.F_ac4_substream_info(0, 0, 1);
+                  }
+                }
+              } else if (this.presentation_config == 2) {
+                {
+                  {
+                    this.F_ac4_substream_info(0, 0, 0);
+                  }
+                  if (this.b_hsf_ext) {
+                    {
+                      this.F_ac4_hsf_ext_substream_info(1);
+                    }
+                  }
+                  {
+                    this.F_ac4_substream_info(1, 0, 1);
+                  }
+                }
+              } else if (this.presentation_config == 3) {
+                {
+                  {
+                    this.F_ac4_substream_info(0, 0, 0);
+                  }
+                  if (this.b_hsf_ext) {
+                    {
+                      this.F_ac4_hsf_ext_substream_info(1);
+                    }
+                  }
+                  {
+                    this.F_ac4_substream_info(0, 1, 1);
+                  }
+                  {
+                    this.F_ac4_substream_info(1, 0, 2);
+                  }
+                }
+              } else if (this.presentation_config == 4) {
+                {
+                  {
+                    this.F_ac4_substream_info(0, 0, 0);
+                  }
+                  if (this.b_hsf_ext) {
+                    {
+                      this.F_ac4_hsf_ext_substream_info(1);
+                    }
+                  }
+                  {
+                    this.F_ac4_substream_info(0, 0, 1);
+                  }
+                  {
+                    this.F_ac4_substream_info(1, 0, 2);
+                  }
+                }
+              } else if (this.presentation_config == 5) {
+                {
+                  {
+                    this.F_ac4_substream_info(0, 0, 0);
+                  }
+                  if (this.b_hsf_ext) {
+                    {
+                      this.F_ac4_hsf_ext_substream_info(1);
+                    }
+                  }
+                }
+              } else {
+                {
+                  this.F_presentation_config_ext_info();
+                }
+              }
+            }
+          }
+          {
+            this.b_pre_virtualized = this.BAM_source.get("", 1);
+            this.BAM_g_position += 1;
+          }
+          {
+            this.b_add_emdf_substreams = this.BAM_source.get("", 1);
+            this.BAM_g_position += 1;
+          }
+        }
+      }
+      if (this.b_add_emdf_substreams) {
+        {
+          {
+            this.n_add_emdf_substreams = this.BAM_source.get("", 2);
+            this.BAM_g_position += 2;
+          }
+          if (this.n_add_emdf_substreams == 0) {
+            {
+              {
+                this.v = this.F_variable_bits(2);
+                if (this.v == null) {
+                  throw ParseError("F_variable_bits", "expected to return a value, returned None");
+                }
+              }
+              {
+                this.n_add_emdf_substreams = this.v + 4;
+              }
+            }
+          }
+          for (this.pi_i = 0; this.pi_i < this.n_add_emdf_substreams; this.pi_i++) {
+            {
+              this.F_emdf_info();
+            }
+          }
+        }
+      }
+    }
+  }
+  F_substream_index_table() {
+    var b_size_present;
+    var substream_type = null;
+    var substream_type;
+    var b_substream_type_known = null;
+    var b_substream_type_known;
+    var substream_size = null;
+    var substream_size;
+    var n_substreams;
+    var s;
+    var b_more_bits;
+    {
+      {
+        n_substreams = this.BAM_source.get("", 2);
+        this.BAM_g_position += 2;
+      }
+      if (n_substreams == 0) {
+        {
+          {
+            this.v = this.F_variable_bits(2);
+            if (this.v == null) {
+              throw ParseError("F_variable_bits", "expected to return a value, returned None");
+            }
+          }
+          {
+            n_substreams = this.v + 4;
+          }
+        }
+      }
+      if (n_substreams - 1 < this.last_referenced_substream) {
+        throw "Number of substreams (n_substreams) indicated by substream_index_table is less than last referenced substream in TOC (last_referenced_substream).";
+      }
+      if (n_substreams - 1 > this.last_referenced_substream) {
+        {
+          {
+            if (b_substream_type_known == null) {
+              b_substream_type_known = new Array(n_substreams - 1 + 1).fill(0);
+            } else if (b_substream_type_known.length <= n_substreams - 1) {
+              b_substream_type_known.push.apply(b_substream_type_known, new Array(n_substreams - 1 - b_substream_type_known.length + 1).fill(0));
+            }
+            b_substream_type_known[n_substreams - 1] = 0;
+          }
+          {
+            if (substream_type == null) {
+              substream_type = new Array(n_substreams - 1 + 1).fill(null);
+            } else if (substream_type.length <= n_substreams - 1) {
+              substream_type.push.apply(substream_type, new Array(n_substreams - 1 - substream_type.length + 1).fill(null));
+            }
+            substream_type[n_substreams - 1] = "unknown";
+          }
+        }
+      }
+      if (n_substreams == 1) {
+        {
+          b_size_present = this.BAM_source.get("", 1);
+          this.BAM_g_position += 1;
+        }
+      } else {
+        {
+          b_size_present = 1;
+        }
+      }
+      if (b_size_present) {
+        for (s = 0; s < n_substreams; s++) {
+          {
+            {
+              b_more_bits = this.BAM_source.get("", 1);
+              this.BAM_g_position += 1;
+            }
+            {
+              if (substream_size == null) {
+                substream_size = new Array(s + 1).fill(0);
+              } else if (substream_size.length <= s) {
+                substream_size.push.apply(substream_size, new Array(s - substream_size.length + 1).fill(0));
+              }
+              substream_size[s] = this.BAM_source.get("", 10);
+              this.BAM_g_position += 10;
+            }
+            if (b_more_bits) {
+              {
+                {
+                  this.v = this.F_variable_bits(2);
+                  if (this.v == null) {
+                    throw ParseError("F_variable_bits", "expected to return a value, returned None");
+                  }
+                }
+                {
+                  if (substream_size == null) {
+                    substream_size = new Array(s + 1).fill(0);
+                  } else if (substream_size.length <= s) {
+                    substream_size.push.apply(substream_size, new Array(s - substream_size.length + 1).fill(0));
+                  }
+                  substream_size[s] += this.v << 10;
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  F_ac4_presentation_v2_info(apv_toc_i) {
+    {
+      {
+        if (this.presentation_to_groups == null) {
+          this.presentation_to_groups = new Array(this.toc_i + 1).fill(null);
+        } else if (this.presentation_to_groups.length <= this.toc_i) {
+          this.presentation_to_groups.push.apply(this.presentation_to_groups, new Array(this.toc_i - this.presentation_to_groups.length + 1).fill(null));
+        }
+        this.presentation_to_groups[this.toc_i] = [];
+      }
+      {
+        this.b_single_substream_group = this.BAM_source.get("", 1);
+        this.BAM_g_position += 1;
+      }
+      if (this.b_single_substream_group != 1) {
+        {
+          {
+            this.presentation_config = this.BAM_source.get("", 3);
+            this.BAM_g_position += 3;
+          }
+          if (this.presentation_config == 7) {
+            {
+              {
+                this.v = this.F_variable_bits(2);
+                if (this.v == null) {
+                  throw ParseError("F_variable_bits", "expected to return a value, returned None");
+                }
+              }
+              {
+                this.presentation_config += this.v;
+              }
+            }
+          }
+        }
+      }
+      if (this.bitstream_version != 1) {
+        {
+          this.presentation_version = this.F_presentation_version();
+          if (this.presentation_version == null) {
+            throw ParseError("F_presentation_version", "expected to return a value, returned None");
+          }
+        }
+      }
+      if (this.b_single_substream_group != 1 && this.presentation_config == 6) {
+        {
+          this.b_add_emdf_substreams = 1;
+        }
+      } else {
+        {
+          if (this.bitstream_version != 1) {
+            {
+              this.presentation_level = this.BAM_source.get("", 3);
+              this.BAM_g_position += 3;
+              this.BAM_sink.write_uint("presentation_level", 3, this.presentation_level, this.BAM_g_position);
+            }
+          }
+          {
+            this.b_presentation_id = this.BAM_source.get("", 1);
+            this.BAM_g_position += 1;
+            this.BAM_sink.write_uint("b_presentation_id", 1, this.b_presentation_id, this.BAM_g_position);
+          }
+          if (this.b_presentation_id) {
+            {
+              this.BAM_sink.before_call("variable_bits", [2], "presentation_id", this.BAM_g_position);
+              this.presentation_id = this.F_variable_bits(2);
+              if (this.presentation_id == null) {
+                throw ParseError("F_variable_bits", "expected to return a value, returned None");
+              }
+              this.BAM_sink.after_call("variable_bits", this.presentation_id, "presentation_id", this.BAM_g_position);
+            }
+          }
+          {
+            this.F_frame_rate_multiply_info();
+          }
+          {
+            this.F_frame_rate_fractions_info();
+          }
+          {
+            this.F_emdf_info();
+          }
+          {
+            this.b_presentation_filter = this.BAM_source.get("", 1);
+            this.BAM_g_position += 1;
+          }
+          if (this.b_presentation_filter) {
+            {
+              this.b_enable_presentation = this.BAM_source.get("", 1);
+              this.BAM_g_position += 1;
+            }
+          }
+          if (this.b_single_substream_group == 1) {
+            {
+              {
+                this.F_ac4_sgi_specifier(0, 0, 0);
+              }
+              {
+                this.n_substream_groups = 1;
+              }
+            }
+          } else {
+            {
+              {
+                this.b_multi_pid = this.BAM_source.get("", 1);
+                this.BAM_g_position += 1;
+              }
+              if (this.presentation_config == 0) {
+                {
+                  {
+                    this.F_ac4_sgi_specifier(0, 0, 0);
+                  }
+                  {
+                    this.F_ac4_sgi_specifier(0, 1, 1);
+                  }
+                  {
+                    this.n_substream_groups = 2;
+                  }
+                }
+              } else if (this.presentation_config == 1) {
+                {
+                  {
+                    this.F_ac4_sgi_specifier(0, 0, 0);
+                  }
+                  {
+                    this.F_ac4_sgi_specifier(0, 0, 1);
+                  }
+                  {
+                    this.n_substream_groups = 1;
+                  }
+                }
+              } else if (this.presentation_config == 2) {
+                {
+                  {
+                    this.F_ac4_sgi_specifier(0, 0, 0);
+                  }
+                  {
+                    this.F_ac4_sgi_specifier(1, 0, 1);
+                  }
+                  {
+                    this.n_substream_groups = 2;
+                  }
+                }
+              } else if (this.presentation_config == 3) {
+                {
+                  {
+                    this.F_ac4_sgi_specifier(0, 0, 0);
+                  }
+                  {
+                    this.F_ac4_sgi_specifier(0, 1, 1);
+                  }
+                  {
+                    this.F_ac4_sgi_specifier(1, 0, 2);
+                  }
+                  {
+                    this.n_substream_groups = 3;
+                  }
+                }
+              } else if (this.presentation_config == 4) {
+                {
+                  {
+                    this.F_ac4_sgi_specifier(0, 0, 0);
+                  }
+                  {
+                    this.F_ac4_sgi_specifier(0, 0, 1);
+                  }
+                  {
+                    this.F_ac4_sgi_specifier(1, 0, 2);
+                  }
+                  {
+                    this.n_substream_groups = 2;
+                  }
+                }
+              } else if (this.presentation_config == 5) {
+                {
+                  {
+                    this.n_substream_groups_minus2 = this.BAM_source.get("", 2);
+                    this.BAM_g_position += 2;
+                  }
+                  {
+                    this.n_substream_groups = this.n_substream_groups_minus2 + 2;
+                  }
+                  if (this.n_substream_groups == 5) {
+                    {
+                      {
+                        this.v = this.F_variable_bits(2);
+                        if (this.v == null) {
+                          throw ParseError("F_variable_bits", "expected to return a value, returned None");
+                        }
+                      }
+                      {
+                        this.n_substream_groups += this.v;
+                      }
+                    }
+                  }
+                  for (this.sg = 0; this.sg < this.n_substream_groups; this.sg++) {
+                    {
+                      this.F_ac4_sgi_specifier(0, 0, 0);
+                    }
+                  }
+                }
+              } else {
+                {
+                  {
+                    this.n_substream_groups = 0;
+                  }
+                  {
+                    this.F_presentation_config_ext_info();
+                  }
+                }
+              }
+            }
+          }
+          {
+            this.b_pre_virtualized = this.BAM_source.get("", 1);
+            this.BAM_g_position += 1;
+          }
+          {
+            this.b_add_emdf_substreams = this.BAM_source.get("", 1);
+            this.BAM_g_position += 1;
+          }
+          {
+            this.F_ac4_presentation_substream_info(this.presentation_version);
+          }
+        }
+      }
+      if (this.b_add_emdf_substreams) {
+        {
+          {
+            this.n_add_emdf_substreams = this.BAM_source.get("", 2);
+            this.BAM_g_position += 2;
+          }
+          if (this.n_add_emdf_substreams == 0) {
+            {
+              {
+                this.v = this.F_variable_bits(2);
+                if (this.v == null) {
+                  throw ParseError("F_variable_bits", "expected to return a value, returned None");
+                }
+              }
+              {
+                this.n_add_emdf_substreams = this.v + 4;
+              }
+            }
+          }
+          for (this.pi_i = 0; this.pi_i < this.n_add_emdf_substreams; this.pi_i++) {
+            {
+              this.F_emdf_info();
+            }
+          }
+        }
+      }
+    }
+  }
+  F_frame_size() {
+    var frame_size;
+    {
+      {
+        frame_size = this.BAM_source.get("", 16);
+        this.BAM_g_position += 16;
+      }
+      if (frame_size == 65535) {
+        {
+          frame_size = this.BAM_source.get("", 24);
+          this.BAM_g_position += 24;
+        }
+      }
+    }
+  }
+  F_ac4_toc() {
+    var b_wait_frames;
+    var payload_base_minus1;
+    var n_presentations;
+    var wait_frames;
+    var b_payload_base;
+    var program_uuid;
+    var total_n_substream_groups;
+    var payload_base;
+    var b_program_uuid_present;
+    var b_single_presentation;
+    var b_iframe_global;
+    var sequence_counter;
+    var b_program_id;
+    var b_more_presentations;
+    var short_program_id;
+    {
+      {
+        this.bitstream_version = this.BAM_source.get("", 2);
+        this.BAM_g_position += 2;
+      }
+      if (this.bitstream_version == 3) {
+        {
+          {
+            this.v = this.F_variable_bits(2);
+            if (this.v == null) {
+              throw ParseError("F_variable_bits", "expected to return a value, returned None");
+            }
+          }
+          {
+            this.bitstream_version += this.v;
+          }
+        }
+      }
+      {
+        sequence_counter = this.BAM_source.get("", 10);
+        this.BAM_g_position += 10;
+      }
+      {
+        b_wait_frames = this.BAM_source.get("", 1);
+        this.BAM_g_position += 1;
+      }
+      if (b_wait_frames) {
+        {
+          {
+            wait_frames = this.BAM_source.get("", 3);
+            this.BAM_g_position += 3;
+          }
+          if (wait_frames > 0) {
+            {
+              this.reserved = this.BAM_source.get("", 2);
+              this.BAM_g_position += 2;
+            }
+          }
+        }
+      }
+      {
+        this.fs_index = this.BAM_source.get("", 1);
+        this.BAM_g_position += 1;
+      }
+      {
+        this.frame_rate_index = this.BAM_source.get("", 4);
+        this.BAM_g_position += 4;
+      }
+      if (this.frame_rate_index > 13) {
+        throw "frame_rate_index must be in range 0..13";
+      }
+      if (this.fs_index == 0 && this.frame_rate_index != 13) {
+        throw "44.1kHz sampling rate && frame rates other than 13 are illegal. See table 84 in the ETSI spec.";
+      }
+      {
+        b_iframe_global = this.BAM_source.get("", 1);
+        this.BAM_g_position += 1;
+      }
+      {
+        b_single_presentation = this.BAM_source.get("", 1);
+        this.BAM_g_position += 1;
+      }
+      if (b_single_presentation) {
+        {
+          n_presentations = 1;
+        }
+      } else {
+        {
+          {
+            b_more_presentations = this.BAM_source.get("", 1);
+            this.BAM_g_position += 1;
+          }
+          if (b_more_presentations) {
+            {
+              {
+                this.v = this.F_variable_bits(2);
+                if (this.v == null) {
+                  throw ParseError("F_variable_bits", "expected to return a value, returned None");
+                }
+              }
+              {
+                n_presentations = this.v + 2;
+              }
+            }
+          } else {
+            {
+              n_presentations = 0;
+            }
+          }
+        }
+      }
+      {
+        payload_base = 0;
+      }
+      {
+        b_payload_base = this.BAM_source.get("", 1);
+        this.BAM_g_position += 1;
+      }
+      if (b_payload_base) {
+        {
+          {
+            payload_base_minus1 = this.BAM_source.get("", 5);
+            this.BAM_g_position += 5;
+            this.BAM_sink.write_uint("payload_base_minus1", 5, payload_base_minus1, this.BAM_g_position);
+          }
+          {
+            payload_base = payload_base_minus1 + 1;
+          }
+          if (payload_base == 32) {
+            {
+              {
+                this.v = this.F_variable_bits(3);
+                if (this.v == null) {
+                  throw ParseError("F_variable_bits", "expected to return a value, returned None");
+                }
+              }
+              {
+                payload_base += this.v;
+              }
+            }
+          }
+        }
+      }
+      {
+        this.a_substream_indices = [];
+      }
+      {
+        this.last_referenced_substream = -1;
+      }
+      {
+        this.referenced_substreams = [];
+      }
+      {
+        this.bk_substream_index = 100;
+      }
+      if (this.bitstream_version <= 1) {
+        {
+          {
+            this.toc_j = 0;
+          }
+          for (this.toc_i = 0; this.toc_i < n_presentations; this.toc_i++) {
+            {
+              this.F_ac4_presentation_info();
+            }
+          }
+        }
+      } else {
+        {
+          {
+            b_program_id = this.BAM_source.get("", 1);
+            this.BAM_g_position += 1;
+          }
+          if (b_program_id) {
+            {
+              {
+                short_program_id = this.BAM_source.get("", 16);
+                this.BAM_g_position += 16;
+              }
+              {
+                b_program_uuid_present = this.BAM_source.get("", 1);
+                this.BAM_g_position += 1;
+              }
+              if (b_program_uuid_present) {
+                {
+                  program_uuid = this.BAM_source.get("", 16 * 8);
+                  this.BAM_g_position += 16 * 8;
+                }
+              }
+            }
+          }
+          {
+            total_n_substream_groups = 0;
+          }
+          for (this.toc_i = 0; this.toc_i < n_presentations; this.toc_i++) {
+            {
+              {
+                this.F_ac4_presentation_v2_info(this.toc_i);
+              }
+              for (this.i = 0; this.i < this.presentation_to_groups[this.toc_i].length; this.i++) {
+                {
+                  total_n_substream_groups = Math.max(total_n_substream_groups, 1 + this.presentation_to_groups[this.toc_i][this.i]);
+                }
+              }
+            }
+          }
+          for (this.toc_j = 0; this.toc_j < total_n_substream_groups; this.toc_j++) {
+            {
+              this.F_ac4_substream_group_info(this.toc_j);
+            }
+          }
+        }
+      }
+      {
+        this.F_substream_index_table();
+      }
+      {
+        this.BAM_l_align = (8 - (this.BAM_g_position % 8 + 8) % 8 % 8 + 8) % 8;
+        this.BAM_l_align_val = this.BAM_source.get_align(this.BAM_l_align);
+        this.BAM_sink.write_align((8 - (this.BAM_g_position % 8 + 8) % 8 % 8 + 8) % 8, this.BAM_l_align_val);
+        this.BAM_g_position += this.BAM_l_align;
+      }
+    }
+  }
+  F_get_num_channels(cm) {
+    {
+      if (cm == this.CHANNEL_MODE_MONO) {
+        {
+          this.n = 1;
+        }
+      } else if (cm == this.CHANNEL_MODE_STEREO) {
+        {
+          this.n = 2;
+        }
+      } else if (cm == this.CHANNEL_MODE_30) {
+        {
+          this.n = 3;
+        }
+      } else if (cm == this.CHANNEL_MODE_50) {
+        {
+          this.n = 5;
+        }
+      } else if (cm == this.CHANNEL_MODE_51) {
+        {
+          this.n = 6;
+        }
+      } else if (cm == this.CHANNEL_MODE_70_34) {
+        {
+          this.n = 7;
+        }
+      } else if (cm == this.CHANNEL_MODE_71_34) {
+        {
+          this.n = 8;
+        }
+      } else if (cm == this.CHANNEL_MODE_70_52) {
+        {
+          this.n = 7;
+        }
+      } else if (cm == this.CHANNEL_MODE_71_52) {
+        {
+          this.n = 8;
+        }
+      } else if (cm == this.CHANNEL_MODE_70_322) {
+        {
+          this.n = 7;
+        }
+      } else if (cm == this.CHANNEL_MODE_71_322) {
+        {
+          this.n = 8;
+        }
+      } else if (cm == this.CHANNEL_MODE_704) {
+        {
+          this.n = 11;
+        }
+      } else if (cm == this.CHANNEL_MODE_714) {
+        {
+          this.n = 12;
+        }
+      } else if (cm == this.CHANNEL_MODE_904) {
+        {
+          this.n = 13;
+        }
+      } else if (cm == this.CHANNEL_MODE_914) {
+        {
+          this.n = 14;
+        }
+      } else {
+        if (1) {
+          throw "Unknown channel mode!";
+        }
+      }
+      return this.n;
+    }
+  }
+  F_frame_rate_multiply_info() {
+    var multiplier_bit;
+    var b_multiplier;
+    {
+      if (this.BAM_g_table14.slice(0).indexOf(this.frame_rate_index) >= 0) {
+        {
+          {
+            b_multiplier = this.BAM_source.get("", 1);
+            this.BAM_g_position += 1;
+          }
+          if (b_multiplier) {
+            {
+              {
+                multiplier_bit = this.BAM_source.get("", 1);
+                this.BAM_g_position += 1;
+              }
+              {
+                this.frame_rate_factor = this.BAM_g_table15[multiplier_bit];
+              }
+            }
+          } else {
+            {
+              this.frame_rate_factor = 1;
+            }
+          }
+        }
+      } else {
+        if (this.BAM_g_table16.slice(0).indexOf(this.frame_rate_index) >= 0) {
+          {
+            {
+              b_multiplier = this.BAM_source.get("", 1);
+              this.BAM_g_position += 1;
+            }
+            {
+              this.frame_rate_factor = this.BAM_g_table17[b_multiplier];
+            }
+          }
+        } else {
+          {
+            this.frame_rate_factor = 1;
+          }
+        }
+      }
+    }
+  }
+  F_frame_rate_fractions_info() {
+    var b_frame_rate_fraction_is_4;
+    var frame_rate_fraction;
+    var b_frame_rate_fraction;
+    {
+      {
+        frame_rate_fraction = 1;
+      }
+      if (this.BAM_g_table18.slice(0).indexOf(this.frame_rate_index) >= 0) {
+        if (this.frame_rate_factor == 1) {
+          {
+            {
+              b_frame_rate_fraction = this.BAM_source.get("", 1);
+              this.BAM_g_position += 1;
+            }
+            if (b_frame_rate_fraction == 1) {
+              {
+                frame_rate_fraction = 2;
+              }
+            }
+          }
+        }
+      }
+      if (this.BAM_g_table19.slice(0).indexOf(this.frame_rate_index) >= 0) {
+        {
+          {
+            b_frame_rate_fraction = this.BAM_source.get("", 1);
+            this.BAM_g_position += 1;
+          }
+          if (b_frame_rate_fraction == 1) {
+            {
+              {
+                b_frame_rate_fraction_is_4 = this.BAM_source.get("", 1);
+                this.BAM_g_position += 1;
+              }
+              if (b_frame_rate_fraction_is_4 == 1) {
+                {
+                  frame_rate_fraction = 4;
+                }
+              } else {
+                {
+                  frame_rate_fraction = 2;
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+};
+
+// src/ac4_toc_parser_wrapper/index.js
+var parseTocElements = (data, elements) => {
+  let parsedElements = [];
+  let index = 0;
+  const bitSourceIterator = {
+    next() {
+      if (index < data.byteLength) {
+        return { value: data.getUint8(index), done: ++index >= data.byteLength };
+      }
+      return { value: void 0, done: true };
+    }
+  };
+  const sinkCallback = (name, value, width, position, handler) => {
+    const pos = position - width;
+    parsedElements.push({ handler, name, pos, value, width });
+  };
+  const bitSource = new BitSource(bitSourceIterator);
+  const sink = new FilterSink(elements, sinkCallback);
+  const parser = new Parser(bitSource, sink);
+  try {
+    parser.F_raw_ac4_frame_toc_only();
+  } catch (err) {
+    parsedElements = null;
+  }
+  return parsedElements;
+};
+
+// src/alps_core.js
+var PRESENTATION_LEVEL_WIDTH = 3;
+var UNDECODABLE_PRESENTATION_LEVEL = 7;
+var BITS_TO_SHIFT_TO_DIVIDE_BY_8 = 3;
+var MINIMUM_PRESENTATIONS_AMOUNT = 2;
+var DIALOG_GAIN_ADJUSTMENT_FACTOR = 256;
+var elementsToParse = [
+  PRESENTATION_LEVEL,
+  B_PRESENTATION_ID,
+  PRESENTATION_ID,
+  PAYLOAD_BASE_MINUS1,
+  BYTE_ALIGNMENT,
+  AC4_TOC_END
+];
+var processIsoBmffInitSegment = (parsedSegmentBuffer) => {
+  var _a, _b, _c, _d;
+  const movie = parsedSegmentBuffer.fetch(MOVIE);
+  const meta = parsedSegmentBuffer.fetch(META);
+  const presentations = [];
+  const groupsList = meta && meta.boxes.find((box) => box.type === GROUPS_LIST);
+  const preselectionGroups = groupsList && groupsList.boxes.filter((box) => box.type === PRESELECTION_GROUP);
+  const tracks = movie && movie.boxes.filter((box) => box.type === TRACK);
+  const trackIds = (_a = tracks == null ? void 0 : tracks.map((track) => {
+    const trackHeader = track.boxes.find((box) => box.type === TRACK_HEADER);
+    return trackHeader.track_ID;
+  })) != null ? _a : [];
+  if (Array.isArray(preselectionGroups)) {
+    for (const preselectionGroup of preselectionGroups) {
+      if (preselectionGroup.entities.every((entity) => trackIds.includes(entity.entity_id))) {
+        const parsedPreselectionTag = parseInt(preselectionGroup.preselection_tag, 10);
+        const id = isNaN(parsedPreselectionTag) ? null : parsedPreselectionTag;
+        const selectionPriority = (_b = preselectionGroup.selection_priority) != null ? _b : null;
+        const udtaBox = preselectionGroup.boxes.find((box) => box.type === USER_DATA);
+        const diapBox = udtaBox == null ? void 0 : udtaBox.boxes.find((box) => box.type === DIALOG_PROCESSING);
+        const dialogGain = Number.isInteger(diapBox == null ? void 0 : diapBox.dialog_gain) ? diapBox.dialog_gain / DIALOG_GAIN_ADJUSTMENT_FACTOR : null;
+        const languageBox = preselectionGroup.boxes.find((box) => box.type === EXTENDED_LANGUAGE_TAG);
+        const extendedLanguage = (_c = languageBox == null ? void 0 : languageBox.extended_language) != null ? _c : null;
+        const audioRenderingIndicationBox = preselectionGroup.boxes.find(
+          (box) => box.type === AUDIO_RENDERING_INDICATION
+        );
+        const audioRenderingIndication = (_d = audioRenderingIndicationBox == null ? void 0 : audioRenderingIndicationBox.audio_rendering_indication) != null ? _d : null;
+        const labelBoxes = preselectionGroup.boxes.filter((box) => box.type === LABEL);
+        const labels = labelBoxes.map((labelBox) => ({
+          isGroupLabel: labelBox.is_group_label,
+          label: labelBox.label,
+          labelId: labelBox.label_id,
+          language: labelBox.language
+        }));
+        const kindBoxes = preselectionGroup.boxes.filter((box) => box.type === KIND);
+        const kinds = kindBoxes.map((kindBox) => ({
+          schemeURI: kindBox.schemeURI,
+          value: kindBox.value
+        }));
+        presentations.push({
+          audioRenderingIndication,
+          dialogGain,
+          extendedLanguage,
+          id,
+          kinds,
+          labels,
+          selectionPriority
+        });
+      }
+    }
+  } else {
+  }
+  return presentations;
+};
+var processIsoBmffMediaSegment = (parsedSegmentBuffer, activePresentationId) => {
+  const sampleOffsets = getSampleOffsets(parsedSegmentBuffer);
+  for (const sampleOffset of sampleOffsets) {
+    const sampleData = new DataView(parsedSegmentBuffer._raw.buffer, sampleOffset.offset, sampleOffset.size);
+    const parsedElements = parseTocElements(sampleData, elementsToParse);
+    if (parsedElements === null) {
+      return null;
+    }
+    const payloadBaseMinus1 = parsedElements.find((element) => element.name === PAYLOAD_BASE_MINUS1);
+    if (!payloadBaseMinus1) {
+      return null;
+    }
+    let accumulatedShift = 0;
+    const byteAlignment = parsedElements.find((element) => element.name === BYTE_ALIGNMENT);
+    if (byteAlignment) {
+      accumulatedShift = byteAlignment.width;
+    }
+    const ac4TocEnd = parsedElements.find((element) => element.name === AC4_TOC_END);
+    const presentationOffsets = [];
+    const bPresentationIds = [];
+    parsedElements.forEach((element) => {
+      switch (element.name) {
+        case PRESENTATION_LEVEL: {
+          presentationOffsets.push({ pos: element.pos, value: element.value, width: element.width });
+          break;
+        }
+        case PRESENTATION_ID: {
+          const lastPresentationOffset = presentationOffsets[presentationOffsets.length - 1];
+          if (presentationOffsets.length === 0) {
+          }
+          if (element.handler === "before_call") {
+            lastPresentationOffset.presentationIdPos = element.pos;
+          }
+          if (element.handler === "after_call") {
+            lastPresentationOffset.presentationId = element.value;
+            const width = element.pos - lastPresentationOffset.presentationIdPos;
+            lastPresentationOffset.presentationIdWidth = width;
+            accumulatedShift += width;
+          }
+          break;
+        }
+        case B_PRESENTATION_ID: {
+          bPresentationIds.push(element);
+          break;
+        }
+        case PAYLOAD_BASE_MINUS1:
+        case BYTE_ALIGNMENT:
+        case AC4_TOC_END: {
+          break;
+        }
+        default: {
+        }
+      }
+    });
+    if (presentationOffsets.length < MINIMUM_PRESENTATIONS_AMOUNT) {
+      return null;
+    }
+    if (presentationOffsets.some((presentation) => presentation.presentationId === void 0)) {
+      return null;
+    }
+    if (presentationOffsets.every((offset) => offset.presentationId !== activePresentationId)) {
+      return null;
+    }
+    presentationOffsets.forEach((presentation) => {
+      const presentationId = presentation.presentationId;
+      if (presentation.width !== PRESENTATION_LEVEL_WIDTH) {
+      }
+      if (activePresentationId !== presentationId) {
+        setBits(sampleData, presentation.pos, presentation.width, UNDECODABLE_PRESENTATION_LEVEL);
+      }
+    });
+    const availableAdditionalBytes = accumulatedShift >>> BITS_TO_SHIFT_TO_DIVIDE_BY_8;
+    setBits(
+      sampleData,
+      payloadBaseMinus1.pos,
+      payloadBaseMinus1.width,
+      payloadBaseMinus1.value + availableAdditionalBytes
+    );
+    bPresentationIds.forEach((bPresentationId) => {
+      setBits(sampleData, bPresentationId.pos, bPresentationId.width, 0);
+    });
+    presentationOffsets.slice().reverse().forEach((presentation) => {
+      const shiftWidth = ac4TocEnd.pos - presentation.presentationIdPos;
+      shiftLeft(sampleData, presentation.presentationIdPos, shiftWidth, presentation.presentationIdWidth);
+    });
+  }
+  return activePresentationId;
+};
+
+// src/alps.js
+var import_codem_isoboxer = __toESM(require_iso_boxer(), 1);
+var SEGMENT_TYPES = {
+  INIT: "init",
+  MEDIA: "media"
+};
+import_codem_isoboxer.default.addBoxProcessor("diap", function() {
+  this._procFullBox();
+  this._procField("dialog_gain", "int", 16);
+});
+var _streams, _presentationsChangedEventHandler, _Alps_instances, initializeStream_fn;
+var Alps = class {
+  /**
+   * Create the ALPS object
+   */
+  constructor() {
+    __privateAdd(this, _Alps_instances);
+    /** @type {Record<string,Stream>} */
+    __privateAdd(this, _streams, {});
+    /** @type {presentationsChangedCallback|undefined} */
+    __privateAdd(this, _presentationsChangedEventHandler);
+  }
+  /**
+   * Get presentation and activePresentationId for all streams
+   * @returns {Record<string,Stream>} Data for all streams present in current ALPS state
+   */
+  getStreams() {
+    return __privateGet(this, _streams);
+  }
+  /**
+   * Clear data for unused stream
+   * @param {string|null} streamId Stream ID which should be deleted, null for non-multi-period use
+   */
+  clearStream(streamId = null) {
+    delete __privateGet(this, _streams)[streamId];
+  }
+  /**
+   * Set presentationsChangedEventHandler
+   * @param {presentationsChangedCallback} presentationsChangedEventHandler Callback function that will be called if the list of presentations changes
+   */
+  setPresentationsChangedEventHandler(presentationsChangedEventHandler) {
+    __privateSet(this, _presentationsChangedEventHandler, presentationsChangedEventHandler);
+  }
+  /**
+   * Get the list of available presentations
+   * @param {string|null} streamId The ID of the stream, null for non-multi-period use
+   * @returns {import('./types.js').Presentation[]} An array of presentation objects
+   */
+  getPresentations(streamId = null) {
+    __privateMethod(this, _Alps_instances, initializeStream_fn).call(this, streamId);
+    return __privateGet(this, _streams)[streamId].presentations;
+  }
+  /**
+   * Get the ID of the currently active presentation
+   * @param {string|null} streamId The ID of the stream, null for non-multi-period use
+   * @returns {number|undefined} The ID of the active presentation, -1 if no presentation is set, undefined if no stream data exists
+   */
+  getActivePresentationId(streamId = null) {
+    var _b;
+    return (_b = __privateGet(this, _streams)[streamId]) == null ? void 0 : _b.activePresentationId;
+  }
+  /**
+   * Set the ID of the active presentation
+   * @param {number|undefined} presentationId - The ID of the presentation to set as active, -1 to select the default presentation or undefined to clear any active presentation
+   * @param {string|null} streamId The ID of the stream, null for non-multi-period use
+   */
+  setActivePresentationId(presentationId, streamId = null) {
+    __privateMethod(this, _Alps_instances, initializeStream_fn).call(this, streamId);
+    __privateGet(this, _streams)[streamId].activePresentationId = presentationId;
+  }
+  /**
+   * Process an ISOBMFF segment buffer
+   * @param {ArrayBuffer} segmentBuffer - The ISOBMFF segment buffer to process
+   * @param {string|null} streamId - Stream ID for Segment buffer, null for non-multi-period use
+   * @param {number|undefined} activePresentationId - Forced presentation ID that should be selected for processing, use -1 for TV default, and leave undefined to use value set by setActivePresentationId. This parameter takes precedence over this.activePresentationId
+   * @returns {ProcessIsoBmffSegmentResult} Data retrieved from processed segment
+   */
+  processIsoBmffSegment(segmentBuffer, streamId = null, activePresentationId = void 0) {
+    let forcedPresentationId = null;
+    let presentations = null;
+    let segmentType = null;
+    const parsedSegmentBuffer = import_codem_isoboxer.default.parseBuffer(segmentBuffer);
+    const movie = parsedSegmentBuffer.fetch(MOVIE);
+    const meta = parsedSegmentBuffer.fetch(META);
+    const movieFragment = parsedSegmentBuffer.fetch(MOVIE_FRAGMENT);
+    __privateMethod(this, _Alps_instances, initializeStream_fn).call(this, streamId);
+    const stream = __privateGet(this, _streams)[streamId];
+    if (movie && meta) {
+      presentations = processIsoBmffInitSegment(parsedSegmentBuffer);
+      stream.presentations = presentations;
+      if (__privateGet(this, _presentationsChangedEventHandler)) {
+        __privateGet(this, _presentationsChangedEventHandler).call(this, { streamId });
+      }
+      segmentType = SEGMENT_TYPES.INIT;
+    }
+    if (movieFragment) {
+      forcedPresentationId = processIsoBmffMediaSegment(
+        parsedSegmentBuffer,
+        activePresentationId != null ? activePresentationId : stream.activePresentationId
+      );
+      segmentType = SEGMENT_TYPES.MEDIA;
+    }
+    return {
+      forcedPresentationId,
+      presentations,
+      segmentType
+    };
+  }
+};
+_streams = new WeakMap();
+_presentationsChangedEventHandler = new WeakMap();
+_Alps_instances = new WeakSet();
+initializeStream_fn = function(streamId) {
+  if (__privateGet(this, _streams)[streamId] === void 0) {
+    __privateGet(this, _streams)[streamId] = { activePresentationId: -1, presentations: [] };
+  }
+};
+export {
+  Alps
+};
+/*! Bundled license information:
+
+codem-isoboxer/dist/iso_boxer.js:
+  (*! codem-isoboxer v0.3.10 https://github.com/madebyhiro/codem-isoboxer/blob/master/LICENSE.txt *)
+*/
+//# sourceMappingURL=alps.bundle.js.map