@opendesign-plus/components 0.0.1-rc.34 → 0.0.1-rc.36

package/dist/treeshaking/_virtual/@babel/runtime/helpers/esm/extends.js.mjs

@@ -0,0 +1,12 @@
+function _extends() {
+  return _extends = Object.assign ? Object.assign.bind() : function(n) {
+    for (var e = 1; e < arguments.length; e++) {
+      var t = arguments[e];
+      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
+    }
+    return n;
+  }, _extends.apply(null, arguments);
+}
+export {
+  _extends as default
+};

package/dist/treeshaking/_virtual/@babel/runtime/helpers/extends.js.mjs

@@ -0,0 +1,22 @@
+import { __module as _extends } from "./extends.js2.mjs";
+var hasRequired_extends;
+function require_extends() {
+  if (hasRequired_extends) return _extends.exports;
+  hasRequired_extends = 1;
+  (function(module) {
+    function _extends2() {
+      return module.exports = _extends2 = Object.assign ? Object.assign.bind() : function(n) {
+        for (var e = 1; e < arguments.length; e++) {
+          var t = arguments[e];
+          for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
+        }
+        return n;
+      }, module.exports.__esModule = true, module.exports["default"] = module.exports, _extends2.apply(null, arguments);
+    }
+    module.exports = _extends2, module.exports.__esModule = true, module.exports["default"] = module.exports;
+  })(_extends);
+  return _extends.exports;
+}
+export {
+  require_extends as __require
+};

package/dist/treeshaking/_virtual/@babel/runtime/helpers/extends.js2.mjs

@@ -0,0 +1,4 @@
+var _extends = { exports: {} };
+export {
+  _extends as __module
+};

package/dist/treeshaking/_virtual/@videojs/vhs-utils/es/byte-helpers.js.mjs

@@ -0,0 +1,141 @@
+import window$1 from "../../../global/window.js.mjs";
+var countBits = function countBits2(x) {
+  return x.toString(2).length;
+};
+var countBytes = function countBytes2(x) {
+  return Math.ceil(countBits(x) / 8);
+};
+var isArrayBufferView = function isArrayBufferView2(obj) {
+  if (ArrayBuffer.isView === "function") {
+    return ArrayBuffer.isView(obj);
+  }
+  return obj && obj.buffer instanceof ArrayBuffer;
+};
+var isTypedArray = function isTypedArray2(obj) {
+  return isArrayBufferView(obj);
+};
+var toUint8 = function toUint82(bytes) {
+  if (bytes instanceof Uint8Array) {
+    return bytes;
+  }
+  if (!Array.isArray(bytes) && !isTypedArray(bytes) && !(bytes instanceof ArrayBuffer)) {
+    if (typeof bytes !== "number" || typeof bytes === "number" && bytes !== bytes) {
+      bytes = 0;
+    } else {
+      bytes = [bytes];
+    }
+  }
+  return new Uint8Array(bytes && bytes.buffer || bytes, bytes && bytes.byteOffset || 0, bytes && bytes.byteLength || 0);
+};
+var BigInt = window$1.BigInt || Number;
+var BYTE_TABLE = [BigInt("0x1"), BigInt("0x100"), BigInt("0x10000"), BigInt("0x1000000"), BigInt("0x100000000"), BigInt("0x10000000000"), BigInt("0x1000000000000"), BigInt("0x100000000000000"), BigInt("0x10000000000000000")];
+(function() {
+  var a = new Uint16Array([65484]);
+  var b = new Uint8Array(a.buffer, a.byteOffset, a.byteLength);
+  if (b[0] === 255) {
+    return "big";
+  }
+  if (b[0] === 204) {
+    return "little";
+  }
+  return "unknown";
+})();
+var bytesToNumber = function bytesToNumber2(bytes, _temp) {
+  var _ref = _temp === void 0 ? {} : _temp, _ref$signed = _ref.signed, signed = _ref$signed === void 0 ? false : _ref$signed, _ref$le = _ref.le, le = _ref$le === void 0 ? false : _ref$le;
+  bytes = toUint8(bytes);
+  var fn = le ? "reduce" : "reduceRight";
+  var obj = bytes[fn] ? bytes[fn] : Array.prototype[fn];
+  var number = obj.call(bytes, function(total, byte, i) {
+    var exponent = le ? i : Math.abs(i + 1 - bytes.length);
+    return total + BigInt(byte) * BYTE_TABLE[exponent];
+  }, BigInt(0));
+  if (signed) {
+    var max = BYTE_TABLE[bytes.length] / BigInt(2) - BigInt(1);
+    number = BigInt(number);
+    if (number > max) {
+      number -= max;
+      number -= max;
+      number -= BigInt(2);
+    }
+  }
+  return Number(number);
+};
+var numberToBytes = function numberToBytes2(number, _temp2) {
+  var _ref2 = {}, _ref2$le = _ref2.le, le = _ref2$le === void 0 ? false : _ref2$le;
+  if (typeof number !== "bigint" && typeof number !== "number" || typeof number === "number" && number !== number) {
+    number = 0;
+  }
+  number = BigInt(number);
+  var byteCount = countBytes(number);
+  var bytes = new Uint8Array(new ArrayBuffer(byteCount));
+  for (var i = 0; i < byteCount; i++) {
+    var byteIndex = le ? i : Math.abs(i + 1 - bytes.length);
+    bytes[byteIndex] = Number(number / BYTE_TABLE[i] & BigInt(255));
+    if (number < 0) {
+      bytes[byteIndex] = Math.abs(~bytes[byteIndex]);
+      bytes[byteIndex] -= i === 0 ? 1 : 2;
+    }
+  }
+  return bytes;
+};
+var stringToBytes = function stringToBytes2(string, stringIsBytes) {
+  if (typeof string !== "string" && string && typeof string.toString === "function") {
+    string = string.toString();
+  }
+  if (typeof string !== "string") {
+    return new Uint8Array();
+  }
+  if (!stringIsBytes) {
+    string = unescape(encodeURIComponent(string));
+  }
+  var view = new Uint8Array(string.length);
+  for (var i = 0; i < string.length; i++) {
+    view[i] = string.charCodeAt(i);
+  }
+  return view;
+};
+var concatTypedArrays = function concatTypedArrays2() {
+  for (var _len = arguments.length, buffers = new Array(_len), _key = 0; _key < _len; _key++) {
+    buffers[_key] = arguments[_key];
+  }
+  buffers = buffers.filter(function(b) {
+    return b && (b.byteLength || b.length) && typeof b !== "string";
+  });
+  if (buffers.length <= 1) {
+    return toUint8(buffers[0]);
+  }
+  var totalLen = buffers.reduce(function(total, buf, i) {
+    return total + (buf.byteLength || buf.length);
+  }, 0);
+  var tempBuffer = new Uint8Array(totalLen);
+  var offset = 0;
+  buffers.forEach(function(buf) {
+    buf = toUint8(buf);
+    tempBuffer.set(buf, offset);
+    offset += buf.byteLength;
+  });
+  return tempBuffer;
+};
+var bytesMatch = function bytesMatch2(a, b, _temp3) {
+  var _ref3 = _temp3 === void 0 ? {} : _temp3, _ref3$offset = _ref3.offset, offset = _ref3$offset === void 0 ? 0 : _ref3$offset, _ref3$mask = _ref3.mask, mask = _ref3$mask === void 0 ? [] : _ref3$mask;
+  a = toUint8(a);
+  b = toUint8(b);
+  var fn = b.every ? b.every : Array.prototype.every;
+  return b.length && a.length - offset >= b.length && // ie 11 doesn't support every on uin8
+  fn.call(b, function(bByte, i) {
+    var aByte = mask[i] ? mask[i] & a[offset + i] : a[offset + i];
+    return bByte === aByte;
+  });
+};
+export {
+  bytesMatch,
+  bytesToNumber,
+  concatTypedArrays,
+  countBits,
+  countBytes,
+  isArrayBufferView,
+  isTypedArray,
+  numberToBytes,
+  stringToBytes,
+  toUint8
+};

package/dist/treeshaking/_virtual/@videojs/vhs-utils/es/codecs.js.mjs

@@ -0,0 +1,158 @@
+import window$1 from "../../../global/window.js.mjs";
+var regexs = {
+  // to determine mime types
+  mp4: /^(av0?1|avc0?[1234]|vp0?9|flac|opus|mp3|mp4a|mp4v|stpp.ttml.im1t)/,
+  webm: /^(vp0?[89]|av0?1|opus|vorbis)/,
+  ogg: /^(vp0?[89]|theora|flac|opus|vorbis)/,
+  // to determine if a codec is audio or video
+  video: /^(av0?1|avc0?[1234]|vp0?[89]|hvc1|hev1|theora|mp4v)/,
+  audio: /^(mp4a|flac|vorbis|opus|ac-[34]|ec-3|alac|mp3|speex|aac)/,
+  text: /^(stpp.ttml.im1t)/,
+  // mux.js support regex
+  muxerVideo: /^(avc0?1)/,
+  muxerAudio: /^(mp4a)/,
+  // match nothing as muxer does not support text right now.
+  // there cannot never be a character before the start of a string
+  // so this matches nothing.
+  muxerText: /a^/
+};
+var mediaTypes = ["video", "audio", "text"];
+var upperMediaTypes = ["Video", "Audio", "Text"];
+var translateLegacyCodec = function translateLegacyCodec2(codec) {
+  if (!codec) {
+    return codec;
+  }
+  return codec.replace(/avc1\.(\d+)\.(\d+)/i, function(orig, profile, avcLevel) {
+    var profileHex = ("00" + Number(profile).toString(16)).slice(-2);
+    var avcLevelHex = ("00" + Number(avcLevel).toString(16)).slice(-2);
+    return "avc1." + profileHex + "00" + avcLevelHex;
+  });
+};
+var parseCodecs = function parseCodecs2(codecString) {
+  if (codecString === void 0) {
+    codecString = "";
+  }
+  var codecs = codecString.split(",");
+  var result = [];
+  codecs.forEach(function(codec) {
+    codec = codec.trim();
+    var codecType;
+    mediaTypes.forEach(function(name) {
+      var match = regexs[name].exec(codec.toLowerCase());
+      if (!match || match.length <= 1) {
+        return;
+      }
+      codecType = name;
+      var type = codec.substring(0, match[1].length);
+      var details = codec.replace(type, "");
+      result.push({
+        type,
+        details,
+        mediaType: name
+      });
+    });
+    if (!codecType) {
+      result.push({
+        type: codec,
+        details: "",
+        mediaType: "unknown"
+      });
+    }
+  });
+  return result;
+};
+var codecsFromDefault = function codecsFromDefault2(master, audioGroupId) {
+  if (!master.mediaGroups.AUDIO || !audioGroupId) {
+    return null;
+  }
+  var audioGroup = master.mediaGroups.AUDIO[audioGroupId];
+  if (!audioGroup) {
+    return null;
+  }
+  for (var name in audioGroup) {
+    var audioType = audioGroup[name];
+    if (audioType.default && audioType.playlists) {
+      return parseCodecs(audioType.playlists[0].attributes.CODECS);
+    }
+  }
+  return null;
+};
+var isAudioCodec = function isAudioCodec2(codec) {
+  if (codec === void 0) {
+    codec = "";
+  }
+  return regexs.audio.test(codec.trim().toLowerCase());
+};
+var isTextCodec = function isTextCodec2(codec) {
+  if (codec === void 0) {
+    codec = "";
+  }
+  return regexs.text.test(codec.trim().toLowerCase());
+};
+var getMimeForCodec = function getMimeForCodec2(codecString) {
+  if (!codecString || typeof codecString !== "string") {
+    return;
+  }
+  var codecs = codecString.toLowerCase().split(",").map(function(c) {
+    return translateLegacyCodec(c.trim());
+  });
+  var type = "video";
+  if (codecs.length === 1 && isAudioCodec(codecs[0])) {
+    type = "audio";
+  } else if (codecs.length === 1 && isTextCodec(codecs[0])) {
+    type = "application";
+  }
+  var container = "mp4";
+  if (codecs.every(function(c) {
+    return regexs.mp4.test(c);
+  })) {
+    container = "mp4";
+  } else if (codecs.every(function(c) {
+    return regexs.webm.test(c);
+  })) {
+    container = "webm";
+  } else if (codecs.every(function(c) {
+    return regexs.ogg.test(c);
+  })) {
+    container = "ogg";
+  }
+  return type + "/" + container + ';codecs="' + codecString + '"';
+};
+var browserSupportsCodec = function browserSupportsCodec2(codecString, withMMS) {
+  if (codecString === void 0) {
+    codecString = "";
+  }
+  if (withMMS === void 0) {
+    withMMS = false;
+  }
+  return window$1.MediaSource && window$1.MediaSource.isTypeSupported && window$1.MediaSource.isTypeSupported(getMimeForCodec(codecString)) || withMMS && window$1.ManagedMediaSource && window$1.ManagedMediaSource.isTypeSupported && window$1.ManagedMediaSource.isTypeSupported(getMimeForCodec(codecString)) || false;
+};
+var muxerSupportsCodec = function muxerSupportsCodec2(codecString) {
+  if (codecString === void 0) {
+    codecString = "";
+  }
+  return codecString.toLowerCase().split(",").every(function(codec) {
+    codec = codec.trim();
+    for (var i = 0; i < upperMediaTypes.length; i++) {
+      var type = upperMediaTypes[i];
+      if (regexs["muxer" + type].test(codec)) {
+        return true;
+      }
+    }
+    return false;
+  });
+};
+var DEFAULT_AUDIO_CODEC = "mp4a.40.2";
+var DEFAULT_VIDEO_CODEC = "avc1.4d400d";
+export {
+  DEFAULT_AUDIO_CODEC,
+  DEFAULT_VIDEO_CODEC,
+  browserSupportsCodec,
+  codecsFromDefault,
+  getMimeForCodec,
+  isAudioCodec,
+  isTextCodec,
+  muxerSupportsCodec,
+  parseCodecs,
+  translateLegacyCodec
+};

package/dist/treeshaking/_virtual/@videojs/vhs-utils/es/containers.js.mjs

@@ -0,0 +1,161 @@
+import { toUint8, bytesMatch } from "./byte-helpers.js.mjs";
+import { findBox } from "./mp4-helpers.js.mjs";
+import { findEbml, EBML_TAGS } from "./ebml-helpers.js.mjs";
+import { getId3Offset } from "./id3-helpers.js.mjs";
+import { findH265Nal, findH264Nal } from "./nal-helpers.js.mjs";
+var CONSTANTS = {
+  // "webm" string literal in hex
+  "webm": toUint8([119, 101, 98, 109]),
+  // "matroska" string literal in hex
+  "matroska": toUint8([109, 97, 116, 114, 111, 115, 107, 97]),
+  // "fLaC" string literal in hex
+  "flac": toUint8([102, 76, 97, 67]),
+  // "OggS" string literal in hex
+  "ogg": toUint8([79, 103, 103, 83]),
+  // ac-3 sync byte, also works for ec-3 as that is simply a codec
+  // of ac-3
+  "ac3": toUint8([11, 119]),
+  // "RIFF" string literal in hex used for wav and avi
+  "riff": toUint8([82, 73, 70, 70]),
+  // "AVI" string literal in hex
+  "avi": toUint8([65, 86, 73]),
+  // "WAVE" string literal in hex
+  "wav": toUint8([87, 65, 86, 69]),
+  // "ftyp3g" string literal in hex
+  "3gp": toUint8([102, 116, 121, 112, 51, 103]),
+  // "ftyp" string literal in hex
+  "mp4": toUint8([102, 116, 121, 112]),
+  // "styp" string literal in hex
+  "fmp4": toUint8([115, 116, 121, 112]),
+  // "ftypqt" string literal in hex
+  "mov": toUint8([102, 116, 121, 112, 113, 116]),
+  // moov string literal in hex
+  "moov": toUint8([109, 111, 111, 118]),
+  // moof string literal in hex
+  "moof": toUint8([109, 111, 111, 102])
+};
+var _isLikely = {
+  aac: function aac(bytes) {
+    var offset = getId3Offset(bytes);
+    return bytesMatch(bytes, [255, 16], {
+      offset,
+      mask: [255, 22]
+    });
+  },
+  mp3: function mp3(bytes) {
+    var offset = getId3Offset(bytes);
+    return bytesMatch(bytes, [255, 2], {
+      offset,
+      mask: [255, 6]
+    });
+  },
+  webm: function webm(bytes) {
+    var docType = findEbml(bytes, [EBML_TAGS.EBML, EBML_TAGS.DocType])[0];
+    return bytesMatch(docType, CONSTANTS.webm);
+  },
+  mkv: function mkv(bytes) {
+    var docType = findEbml(bytes, [EBML_TAGS.EBML, EBML_TAGS.DocType])[0];
+    return bytesMatch(docType, CONSTANTS.matroska);
+  },
+  mp4: function mp4(bytes) {
+    if (_isLikely["3gp"](bytes) || _isLikely.mov(bytes)) {
+      return false;
+    }
+    if (bytesMatch(bytes, CONSTANTS.mp4, {
+      offset: 4
+    }) || bytesMatch(bytes, CONSTANTS.fmp4, {
+      offset: 4
+    })) {
+      return true;
+    }
+    if (bytesMatch(bytes, CONSTANTS.moof, {
+      offset: 4
+    }) || bytesMatch(bytes, CONSTANTS.moov, {
+      offset: 4
+    })) {
+      return true;
+    }
+  },
+  mov: function mov(bytes) {
+    return bytesMatch(bytes, CONSTANTS.mov, {
+      offset: 4
+    });
+  },
+  "3gp": function gp(bytes) {
+    return bytesMatch(bytes, CONSTANTS["3gp"], {
+      offset: 4
+    });
+  },
+  ac3: function ac3(bytes) {
+    var offset = getId3Offset(bytes);
+    return bytesMatch(bytes, CONSTANTS.ac3, {
+      offset
+    });
+  },
+  ts: function ts(bytes) {
+    if (bytes.length < 189 && bytes.length >= 1) {
+      return bytes[0] === 71;
+    }
+    var i = 0;
+    while (i + 188 < bytes.length && i < 188) {
+      if (bytes[i] === 71 && bytes[i + 188] === 71) {
+        return true;
+      }
+      i += 1;
+    }
+    return false;
+  },
+  flac: function flac(bytes) {
+    var offset = getId3Offset(bytes);
+    return bytesMatch(bytes, CONSTANTS.flac, {
+      offset
+    });
+  },
+  ogg: function ogg(bytes) {
+    return bytesMatch(bytes, CONSTANTS.ogg);
+  },
+  avi: function avi(bytes) {
+    return bytesMatch(bytes, CONSTANTS.riff) && bytesMatch(bytes, CONSTANTS.avi, {
+      offset: 8
+    });
+  },
+  wav: function wav(bytes) {
+    return bytesMatch(bytes, CONSTANTS.riff) && bytesMatch(bytes, CONSTANTS.wav, {
+      offset: 8
+    });
+  },
+  "h264": function h264(bytes) {
+    return findH264Nal(bytes, 7, 3).length;
+  },
+  "h265": function h265(bytes) {
+    return findH265Nal(bytes, [32, 33], 3).length;
+  }
+};
+var isLikelyTypes = Object.keys(_isLikely).filter(function(t) {
+  return t !== "ts" && t !== "h264" && t !== "h265";
+}).concat(["ts", "h264", "h265"]);
+isLikelyTypes.forEach(function(type) {
+  var isLikelyFn = _isLikely[type];
+  _isLikely[type] = function(bytes) {
+    return isLikelyFn(toUint8(bytes));
+  };
+});
+var isLikely = _isLikely;
+var detectContainerForBytes = function detectContainerForBytes2(bytes) {
+  bytes = toUint8(bytes);
+  for (var i = 0; i < isLikelyTypes.length; i++) {
+    var type = isLikelyTypes[i];
+    if (isLikely[type](bytes)) {
+      return type;
+    }
+  }
+  return "";
+};
+var isLikelyFmp4MediaSegment = function isLikelyFmp4MediaSegment2(bytes) {
+  return findBox(bytes, ["moof"]).length > 0;
+};
+export {
+  detectContainerForBytes,
+  isLikely,
+  isLikelyFmp4MediaSegment
+};

package/dist/treeshaking/_virtual/@videojs/vhs-utils/es/decode-b64-to-uint8-array.js.mjs

@@ -0,0 +1,15 @@
+import window$1 from "../../../global/window.js.mjs";
+var atob = function atob2(s) {
+  return window$1.atob ? window$1.atob(s) : Buffer.from(s, "base64").toString("binary");
+};
+function decodeB64ToUint8Array(b64Text) {
+  var decodedString = atob(b64Text);
+  var array = new Uint8Array(decodedString.length);
+  for (var i = 0; i < decodedString.length; i++) {
+    array[i] = decodedString.charCodeAt(i);
+  }
+  return array;
+}
+export {
+  decodeB64ToUint8Array as default
+};

package/dist/treeshaking/_virtual/@videojs/vhs-utils/es/ebml-helpers.js.mjs

@@ -0,0 +1,126 @@
+import { toUint8, bytesMatch, bytesToNumber, numberToBytes } from "./byte-helpers.js.mjs";
+var EBML_TAGS = {
+  EBML: toUint8([26, 69, 223, 163]),
+  DocType: toUint8([66, 130]),
+  Segment: toUint8([24, 83, 128, 103]),
+  SegmentInfo: toUint8([21, 73, 169, 102]),
+  Tracks: toUint8([22, 84, 174, 107]),
+  Track: toUint8([174]),
+  TrackNumber: toUint8([215]),
+  DefaultDuration: toUint8([35, 227, 131]),
+  TrackEntry: toUint8([174]),
+  TrackType: toUint8([131]),
+  FlagDefault: toUint8([136]),
+  CodecID: toUint8([134]),
+  CodecPrivate: toUint8([99, 162]),
+  VideoTrack: toUint8([224]),
+  AudioTrack: toUint8([225]),
+  // Not used yet, but will be used for live webm/mkv
+  // see https://www.matroska.org/technical/basics.html#block-structure
+  // see https://www.matroska.org/technical/basics.html#simpleblock-structure
+  Cluster: toUint8([31, 67, 182, 117]),
+  Timestamp: toUint8([231]),
+  TimestampScale: toUint8([42, 215, 177]),
+  BlockGroup: toUint8([160]),
+  BlockDuration: toUint8([155]),
+  Block: toUint8([161]),
+  SimpleBlock: toUint8([163])
+};
+var LENGTH_TABLE = [128, 64, 32, 16, 8, 4, 2, 1];
+var getLength = function getLength2(byte) {
+  var len = 1;
+  for (var i = 0; i < LENGTH_TABLE.length; i++) {
+    if (byte & LENGTH_TABLE[i]) {
+      break;
+    }
+    len++;
+  }
+  return len;
+};
+var getvint = function getvint2(bytes, offset, removeLength, signed) {
+  if (removeLength === void 0) {
+    removeLength = true;
+  }
+  if (signed === void 0) {
+    signed = false;
+  }
+  var length = getLength(bytes[offset]);
+  var valueBytes = bytes.subarray(offset, offset + length);
+  if (removeLength) {
+    valueBytes = Array.prototype.slice.call(bytes, offset, offset + length);
+    valueBytes[0] ^= LENGTH_TABLE[length - 1];
+  }
+  return {
+    length,
+    value: bytesToNumber(valueBytes, {
+      signed
+    }),
+    bytes: valueBytes
+  };
+};
+var normalizePath = function normalizePath2(path) {
+  if (typeof path === "string") {
+    return path.match(/.{1,2}/g).map(function(p) {
+      return normalizePath2(p);
+    });
+  }
+  if (typeof path === "number") {
+    return numberToBytes(path);
+  }
+  return path;
+};
+var normalizePaths = function normalizePaths2(paths) {
+  if (!Array.isArray(paths)) {
+    return [normalizePath(paths)];
+  }
+  return paths.map(function(p) {
+    return normalizePath(p);
+  });
+};
+var getInfinityDataSize = function getInfinityDataSize2(id, bytes, offset) {
+  if (offset >= bytes.length) {
+    return bytes.length;
+  }
+  var innerid = getvint(bytes, offset, false);
+  if (bytesMatch(id.bytes, innerid.bytes)) {
+    return offset;
+  }
+  var dataHeader = getvint(bytes, offset + innerid.length);
+  return getInfinityDataSize2(id, bytes, offset + dataHeader.length + dataHeader.value + innerid.length);
+};
+var findEbml = function findEbml2(bytes, paths) {
+  paths = normalizePaths(paths);
+  bytes = toUint8(bytes);
+  var results = [];
+  if (!paths.length) {
+    return results;
+  }
+  var i = 0;
+  while (i < bytes.length) {
+    var id = getvint(bytes, i, false);
+    var dataHeader = getvint(bytes, i + id.length);
+    var dataStart = i + id.length + dataHeader.length;
+    if (dataHeader.value === 127) {
+      dataHeader.value = getInfinityDataSize(id, bytes, dataStart);
+      if (dataHeader.value !== bytes.length) {
+        dataHeader.value -= dataStart;
+      }
+    }
+    var dataEnd = dataStart + dataHeader.value > bytes.length ? bytes.length : dataStart + dataHeader.value;
+    var data = bytes.subarray(dataStart, dataEnd);
+    if (bytesMatch(paths[0], id.bytes)) {
+      if (paths.length === 1) {
+        results.push(data);
+      } else {
+        results = results.concat(findEbml2(data, paths.slice(1)));
+      }
+    }
+    var totalLength = id.length + dataHeader.length + data.length;
+    i += totalLength;
+  }
+  return results;
+};
+export {
+  EBML_TAGS,
+  findEbml
+};

package/dist/treeshaking/_virtual/@videojs/vhs-utils/es/id3-helpers.js.mjs

@@ -0,0 +1,32 @@
+import { toUint8, bytesMatch } from "./byte-helpers.js.mjs";
+var ID3 = toUint8([73, 68, 51]);
+var getId3Size = function getId3Size2(bytes, offset) {
+  if (offset === void 0) {
+    offset = 0;
+  }
+  bytes = toUint8(bytes);
+  var flags = bytes[offset + 5];
+  var returnSize = bytes[offset + 6] << 21 | bytes[offset + 7] << 14 | bytes[offset + 8] << 7 | bytes[offset + 9];
+  var footerPresent = (flags & 16) >> 4;
+  if (footerPresent) {
+    return returnSize + 20;
+  }
+  return returnSize + 10;
+};
+var getId3Offset = function getId3Offset2(bytes, offset) {
+  if (offset === void 0) {
+    offset = 0;
+  }
+  bytes = toUint8(bytes);
+  if (bytes.length - offset < 10 || !bytesMatch(bytes, ID3, {
+    offset
+  })) {
+    return offset;
+  }
+  offset += getId3Size(bytes, offset);
+  return getId3Offset2(bytes, offset);
+};
+export {
+  getId3Offset,
+  getId3Size
+};

package/dist/treeshaking/_virtual/@videojs/vhs-utils/es/media-groups.js.mjs

@@ -0,0 +1,13 @@
+var forEachMediaGroup = function forEachMediaGroup2(master, groups, callback) {
+  groups.forEach(function(mediaType) {
+    for (var groupKey in master.mediaGroups[mediaType]) {
+      for (var labelKey in master.mediaGroups[mediaType][groupKey]) {
+        var mediaProperties = master.mediaGroups[mediaType][groupKey][labelKey];
+        callback(mediaProperties, mediaType, groupKey, labelKey);
+      }
+    }
+  });
+};
+export {
+  forEachMediaGroup
+};