dasha 3.1.2 → 3.1.4

package/dist/dasha.mjs

@@ -1,1524 +0,0 @@
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-var __commonJS = (cb, mod) => function __require2() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-
-// lib/xml.js
-var require_xml = __commonJS({
-  "lib/xml.js"(exports, module) {
-    "use strict";
-    function parse(text, options = {}) {
-      var pos = options.pos || 0;
-      var keepComments = !!options.keepComments;
-      var keepWhitespace = !!options.keepWhitespace;
-      var openBracket = "<";
-      var openBracketCC = "<".charCodeAt(0);
-      var closeBracket = ">";
-      var closeBracketCC = ">".charCodeAt(0);
-      var minusCC = "-".charCodeAt(0);
-      var slashCC = "/".charCodeAt(0);
-      var exclamationCC = "!".charCodeAt(0);
-      var singleQuoteCC = "'".charCodeAt(0);
-      var doubleQuoteCC = '"'.charCodeAt(0);
-      var openCornerBracketCC = "[".charCodeAt(0);
-      var closeCornerBracketCC = "]".charCodeAt(0);
-      function parseChildren(tagName) {
-        var children = [];
-        while (text[pos]) {
-          if (text.charCodeAt(pos) == openBracketCC) {
-            if (text.charCodeAt(pos + 1) === slashCC) {
-              var closeStart = pos + 2;
-              pos = text.indexOf(closeBracket, pos);
-              var closeTag = text.substring(closeStart, pos);
-              if (closeTag.indexOf(tagName) == -1) {
-                const parsedText = text.substring(0, pos).split("\n");
-                throw new Error(
-                  "Unexpected close tag\nLine: " + (parsedText.length - 1) + "\nColumn: " + (parsedText[parsedText.length - 1].length + 1) + "\nChar: " + text[pos]
-                );
-              }
-              if (pos + 1) pos += 1;
-              return children;
-            } else if (text.charCodeAt(pos + 1) === exclamationCC) {
-              if (text.charCodeAt(pos + 2) == minusCC) {
-                const startCommentPos = pos;
-                while (pos !== -1 && !(text.charCodeAt(pos) === closeBracketCC && text.charCodeAt(pos - 1) == minusCC && text.charCodeAt(pos - 2) == minusCC && pos != -1)) {
-                  pos = text.indexOf(closeBracket, pos + 1);
-                }
-                if (pos === -1) {
-                  pos = text.length;
-                }
-                if (keepComments) {
-                  children.push(text.substring(startCommentPos, pos + 1));
-                }
-              } else if (text.charCodeAt(pos + 2) === openCornerBracketCC && text.charCodeAt(pos + 8) === openCornerBracketCC && text.substr(pos + 3, 5).toLowerCase() === "cdata") {
-                var cdataEndIndex = text.indexOf("]]>", pos);
-                if (cdataEndIndex == -1) {
-                  children.push(text.substr(pos + 9));
-                  pos = text.length;
-                } else {
-                  children.push(text.substring(pos + 9, cdataEndIndex));
-                  pos = cdataEndIndex + 3;
-                }
-                continue;
-              } else {
-                const startDoctype = pos + 1;
-                pos += 2;
-                var encapsuled = false;
-                while ((text.charCodeAt(pos) !== closeBracketCC || encapsuled === true) && text[pos]) {
-                  if (text.charCodeAt(pos) === openCornerBracketCC) {
-                    encapsuled = true;
-                  } else if (encapsuled === true && text.charCodeAt(pos) === closeCornerBracketCC) {
-                    encapsuled = false;
-                  }
-                  pos++;
-                }
-                children.push(text.substring(startDoctype, pos));
-              }
-              pos++;
-              continue;
-            }
-            var node = parseNode();
-            children.push(node);
-            if (node.tagName[0] === "?") {
-              children.push(...node.children);
-              node.children = [];
-            }
-          } else {
-            const parsedText = parseText();
-            if (keepWhitespace) {
-              if (parsedText.length > 0) {
-                children.push(parsedText);
-              }
-            } else {
-              var trimmed = parsedText.trim();
-              if (trimmed.length > 0) {
-                children.push(trimmed);
-              }
-            }
-            pos++;
-          }
-        }
-        return children;
-      }
-      function parseText() {
-        var start = pos;
-        pos = text.indexOf(openBracket, pos) - 1;
-        if (pos === -2) pos = text.length;
-        return text.slice(start, pos + 1);
-      }
-      var nameSpacer = "\r\n	>/= ";
-      function parseName() {
-        var start = pos;
-        while (nameSpacer.indexOf(text[pos]) === -1 && text[pos]) {
-          pos++;
-        }
-        return text.slice(start, pos);
-      }
-      var NoChildNodes = options.noChildNodes || [
-        "img",
-        "br",
-        "input",
-        "meta",
-        "link",
-        "hr"
-      ];
-      function parseNode() {
-        pos++;
-        const tagName = parseName();
-        const attributes = {};
-        let children = [];
-        while (text.charCodeAt(pos) !== closeBracketCC && text[pos]) {
-          var c = text.charCodeAt(pos);
-          if (c > 64 && c < 91 || c > 96 && c < 123) {
-            var name = parseName();
-            var code = text.charCodeAt(pos);
-            while (code && code !== singleQuoteCC && code !== doubleQuoteCC && !(code > 64 && code < 91 || code > 96 && code < 123) && code !== closeBracketCC) {
-              pos++;
-              code = text.charCodeAt(pos);
-            }
-            if (code === singleQuoteCC || code === doubleQuoteCC) {
-              var value = parseString();
-              if (pos === -1) {
-                return {
-                  tagName,
-                  attributes,
-                  children
-                };
-              }
-            } else {
-              value = null;
-              pos--;
-            }
-            attributes[name] = value;
-          }
-          pos++;
-        }
-        if (text.charCodeAt(pos - 1) !== slashCC) {
-          if (tagName == "script") {
-            const start = pos + 1;
-            pos = text.indexOf("</script>", pos);
-            children = [text.slice(start, pos)];
-            pos += 9;
-          } else if (tagName == "style") {
-            const start = pos + 1;
-            pos = text.indexOf("</style>", pos);
-            children = [text.slice(start, pos)];
-            pos += 8;
-          } else if (NoChildNodes.indexOf(tagName) === -1) {
-            pos++;
-            children = parseChildren(tagName);
-          } else {
-            pos++;
-          }
-        } else {
-          pos++;
-        }
-        return {
-          tagName,
-          attributes,
-          children
-        };
-      }
-      function parseString() {
-        var startChar = text[pos];
-        var startpos = pos + 1;
-        pos = text.indexOf(startChar, startpos);
-        return text.slice(startpos, pos);
-      }
-      function findElements() {
-        var r = new RegExp(
-          "\\s" + options.attrName + `\\s*=['"]` + options.attrValue + `['"]`
-        ).exec(text);
-        if (r) {
-          return r.index;
-        } else {
-          return -1;
-        }
-      }
-      let out = null;
-      if (options.attrValue !== void 0) {
-        options.attrName = options.attrName || "id";
-        out = [];
-        while ((pos = findElements()) !== -1) {
-          pos = text.lastIndexOf("<", pos);
-          if (pos !== -1) {
-            out.push(parseNode());
-          }
-          text = text.substr(pos);
-          pos = 0;
-        }
-      } else if (options.parseNode) {
-        out = parseNode();
-      } else {
-        out = parseChildren("");
-      }
-      if (options.filter) {
-        out = filter(out, options.filter);
-      }
-      if (options.setPos) {
-        out.pos = pos;
-      }
-      return out;
-    }
-    function filter(children, f, dept = 0, path = "") {
-      var out = [];
-      children.forEach(function(child, i) {
-        if (typeof child === "object" && f(child, i, dept, path)) out.push(child);
-        if (child.children) {
-          var kids = filter(
-            child.children,
-            f,
-            dept + 1,
-            (path ? path + "." : "") + i + "." + child.tagName
-          );
-          out = out.concat(kids);
-        }
-      });
-      return out;
-    }
-    module.exports = { parse, filter };
-  }
-});
-
-// lib/util.js
-var require_util = __commonJS({
-  "lib/util.js"(exports, module) {
-    "use strict";
-    var formatBytes = (bytes, sizes = ["Bytes", "KB", "MB", "GB", "TB"]) => {
-      if (bytes == 0) return `0 ${sizes[0]}`;
-      const i = parseInt(Math.floor(Math.log(bytes) / Math.log(1024)));
-      if (i == 0) return bytes + " " + sizes[i];
-      return (bytes / Math.pow(1024, i)).toFixed(1) + " " + sizes[i];
-    };
-    var parseSize = (bandwidth, duration) => ({
-      b: bandwidth * duration,
-      kb: bandwidth / 1e3 * duration,
-      mb: bandwidth / 8e6 * duration,
-      gb: bandwidth / 8e9 * duration,
-      toString() {
-        return formatBytes(bandwidth * duration);
-      }
-    });
-    var parseBitrate = (bandwidth) => ({
-      bps: bandwidth,
-      kbps: bandwidth / 1e3,
-      mbps: bandwidth / 8e6,
-      gbps: bandwidth / 8e9,
-      toString() {
-        return formatBytes(bandwidth, ["bps", "Kbps", "Mbps", "Gbps"]);
-      }
-    });
-    var qualities = [
-      { width: 7680, height: 4320 },
-      { width: 3840, height: 2160 },
-      { width: 2560, height: 1440 },
-      { width: 1920, height: 1080 },
-      { width: 1280, height: 720 },
-      { width: 1024, height: 576 },
-      { width: 854, height: 480 },
-      { width: 640, height: 360 },
-      { width: 426, height: 240 },
-      { width: 256, height: 144 }
-    ];
-    var getWidth = (height) => qualities.find((q) => q.height === height)?.width;
-    var getHeight = (width) => qualities.find((q) => q.width === width)?.height;
-    var getQualityLabel = (resolution) => `${getHeight(resolution.width) || resolution.height}p`;
-    var getBestTrack = (tracks) => {
-      const maxBitrate = Math.max(...tracks.map((track) => track.bitrate.bps));
-      return tracks.find((track) => track.bitrate.bps === maxBitrate);
-    };
-    var parseDuration = (str) => {
-      const SECONDS_IN_YEAR = 365 * 24 * 60 * 60;
-      const SECONDS_IN_MONTH = 30 * 24 * 60 * 60;
-      const SECONDS_IN_DAY = 24 * 60 * 60;
-      const SECONDS_IN_HOUR = 60 * 60;
-      const SECONDS_IN_MIN = 60;
-      const durationRegex = /P(?:(\d*)Y)?(?:(\d*)M)?(?:(\d*)D)?(?:T(?:(\d*)H)?(?:(\d*)M)?(?:([\d.]*)S)?)?/;
-      const match = durationRegex.exec(str);
-      if (!match) {
-        return 0;
-      }
-      const [year, month, day, hour, minute, second] = match.slice(1);
-      return parseFloat(year || 0) * SECONDS_IN_YEAR + parseFloat(month || 0) * SECONDS_IN_MONTH + parseFloat(day || 0) * SECONDS_IN_DAY + parseFloat(hour || 0) * SECONDS_IN_HOUR + parseFloat(minute || 0) * SECONDS_IN_MIN + parseFloat(second || 0);
-    };
-    var isLanguageTagValid = (value) => {
-      try {
-        Intl.getCanonicalLocales(value);
-        return true;
-      } catch (e) {
-        return;
-      }
-    };
-    module.exports = {
-      parseSize,
-      parseBitrate,
-      getWidth,
-      getHeight,
-      getQualityLabel,
-      getBestTrack,
-      parseDuration,
-      isLanguageTagValid
-    };
-  }
-});
-
-// lib/video.js
-var require_video = __commonJS({
-  "lib/video.js"(exports, module) {
-    "use strict";
-    var { parseBitrate, getQualityLabel, parseSize } = require_util();
-    var VIDEO_CODECS = {
-      avc: "H.264",
-      hevc: "H.265",
-      vc1: "VC-1",
-      vp8: "VP8",
-      vp9: "VP9",
-      av1: "AV1"
-    };
-    var DYNAMIC_RANGE = {
-      sdr: "SDR",
-      // Standart Dynamic Range
-      hlg: "HLG",
-      // Hybrid log-gamma (HDR)
-      hdr10: "HDR10",
-      hdr10p: "HDR10+",
-      dv: "DV"
-      // Dolby Vision
-    };
-    var PRIMARIES = {
-      Unspecified: 0,
-      BT_709: 1,
-      BT_601_625: 5,
-      BT_601_525: 6,
-      BT_2020_and_2100: 9,
-      SMPTE_ST_2113_and_EG_4321: 12
-      // P3D65
-    };
-    var TRANSFER = {
-      Unspecified: 0,
-      BT_709: 1,
-      BT_601: 6,
-      BT_2020: 14,
-      BT_2100: 15,
-      BT_2100_PQ: 16,
-      BT_2100_HLG: 18
-    };
-    var MATRIX = {
-      RGB: 0,
-      YCbCr_BT_709: 1,
-      YCbCr_BT_601_625: 5,
-      YCbCr_BT_601_525: 6,
-      YCbCr_BT_2020_and_2100: 9,
-      // YCbCr BT.2100 shares the same CP
-      ICtCp_BT_2100: 14
-    };
-    var parseVideoCodecFromMime = (mime) => {
-      const target = mime.toLowerCase().trim().split(".")[0];
-      const avc = ["avc1", "avc2", "avc3", "dva1", "dvav"];
-      const hevc = [
-        "hev1",
-        "hev2",
-        "hev3",
-        "hvc1",
-        "hvc2",
-        "hvc3",
-        "dvh1",
-        "dvhe",
-        "lhv1",
-        "lhe1"
-      ];
-      const vc1 = ["vc-1"];
-      const vp8 = ["vp08", "vp8"];
-      const vp9 = ["vp09", "vp9"];
-      const av1 = ["av01"];
-      if (avc.includes(target)) return VIDEO_CODECS.avc;
-      if (hevc.includes(target)) return VIDEO_CODECS.hevc;
-      if (vc1.includes(target)) return VIDEO_CODECS.hevc;
-      if (vp8.includes(target)) return VIDEO_CODECS.vp8;
-      if (vp9.includes(target)) return VIDEO_CODECS.vp9;
-      if (av1.includes(target)) return VIDEO_CODECS.av1;
-      throw new Error(`The MIME ${mime} is not supported as video codec`);
-    };
-    var parseDynamicRangeFromCicp = (primaries, transfer, matrix) => {
-      if (transfer == 5) transfer = TRANSFER.BT_601;
-      if (primaries == PRIMARIES.Unspecified && transfer == TRANSFER.Unspecified && matrix == MATRIX.RGB)
-        return DYNAMIC_RANGE.sdr;
-      else if ([PRIMARIES.BT_601_625, PRIMARIES.BT_601_525].includes(primaries))
-        return DYNAMIC_RANGE.sdr;
-      else if (TRANSFER.BT_2100_PQ === transfer) return DYNAMIC_RANGE.hdr10;
-      else if (TRANSFER.BT_2100_HLG === transfer) return DYNAMIC_RANGE.hlg;
-      else return DYNAMIC_RANGE.sdr;
-    };
-    var createVideoTrack = ({
-      id,
-      label,
-      type,
-      codec,
-      dynamicRange,
-      contentProtection,
-      bitrate,
-      duration,
-      width,
-      height,
-      fps,
-      language,
-      segments
-    }) => {
-      const parsedBitrate = parseBitrate(Number(bitrate));
-      const parsedWidth = Number(width);
-      const parsedHeight = Number(height);
-      const size = duration ? parseSize(Number(bitrate), Number(duration)) : void 0;
-      return {
-        id,
-        label,
-        type,
-        codec,
-        bitrate: parsedBitrate,
-        size,
-        protection: contentProtection,
-        segments,
-        dynamicRange,
-        language,
-        width: parsedWidth,
-        height: parsedHeight,
-        fps: Number(fps),
-        quality: getQualityLabel({ width: parsedWidth, height: parsedHeight }),
-        toString() {
-          return [
-            "VIDEO",
-            `[${codec}, ${dynamicRange}]`,
-            language,
-            `${width}x${height} @ ${parsedBitrate.kbps} kb/s, ${fps} FPS`
-          ].join(" | ");
-        }
-      };
-    };
-    var parseVideoCodec = (codecs) => {
-      for (const codec of codecs.toLowerCase().split(",")) {
-        const mime = codec.trim().split(".")[0];
-        try {
-          return parseVideoCodecFromMime(mime);
-        } catch (e) {
-          continue;
-        }
-      }
-      throw new Error(
-        `No MIME types matched any supported Video Codecs in ${codecs}`
-      );
-    };
-    var parseDynamicRange = (codecs, supplementalProps = [], essentialProps = []) => {
-      const dv = ["dva1", "dvav", "dvhe", "dvh1"];
-      if (dv.some((value) => codecs.startsWith(value))) return DYNAMIC_RANGE.dv;
-      const primariesScheme = "urn:mpeg:mpegB:cicp:ColourPrimaries";
-      const transferScheme = "urn:mpeg:mpegB:cicp:TransferCharacteristics";
-      const matrixScheme = "urn:mpeg:mpegB:cicp:MatrixCoefficients";
-      const allProps = [...essentialProps, ...supplementalProps];
-      const getValues = (scheme) => allProps.filter((prop) => prop.attributes.schemeIdUri === scheme).map((prop) => parseInt(prop.attributes.value));
-      const primaries = getValues(primariesScheme).reduce(
-        (acc, current) => acc + current,
-        0
-      );
-      const transfer = getValues(transferScheme).reduce(
-        (acc, current) => acc + current,
-        0
-      );
-      const matrix = getValues(matrixScheme).reduce(
-        (acc, current) => acc + current,
-        0
-      );
-      return parseDynamicRangeFromCicp(primaries, transfer, matrix);
-    };
-    module.exports = {
-      parseVideoCodec,
-      parseDynamicRange,
-      createVideoTrack,
-      VIDEO_CODECS
-    };
-  }
-});
-
-// lib/track.js
-var require_track = __commonJS({
-  "lib/track.js"(exports, module) {
-    "use strict";
-    var { getBestTrack } = require_util();
-    var parseMimes = (codecs) => codecs.toLowerCase().split(",").map((codec) => codec.trim().split(".")[0]);
-    var createResolutionFilter = (videos) => {
-      return ({ width, height }) => {
-        return videos.filter(
-          (track) => (!width || track.width === width) && (!height || track.height === height)
-        );
-      };
-    };
-    var createCodecFilter = (tracks) => {
-      return (codecs) => {
-        if (!codecs?.length) return tracks;
-        const results = tracks.filter((track) => codecs.includes(track.codec));
-        results.sort((a, b) => b.bitrate.bps - a.bitrate.bps);
-        return results;
-      };
-    };
-    var createVideoCodecFilter = (videos) => createCodecFilter(videos);
-    var createVideoQualityFilter = (videos) => {
-      return (quality) => {
-        if (!quality) return [getBestTrack(videos)];
-        const trackQuality = String(quality).includes("p") ? quality : `${quality}p`;
-        const results = videos.filter((track) => track.quality === trackQuality);
-        results.sort((a, b) => b.bitrate.bps - a.bitrate.bps);
-        return results.length ? results : [getBestTrack(videos)];
-      };
-    };
-    var createAudioCodecFilter = (audios) => createCodecFilter(audios);
-    var createAudioLanguageFilter = (audios) => {
-      return (languages = [], maxTracksPerLanguage) => {
-        if (!languages.length) {
-          const audiosWithLanguage = audios.filter((track) => track.language);
-          if (audiosWithLanguage.length) {
-            for (const audio of audiosWithLanguage) {
-              const alreadyAdded = languages.includes(audio.language);
-              if (!alreadyAdded) languages.push(audio.language);
-            }
-          } else {
-            audios.sort((a, b) => b.bitrate.bps - a.bitrate.bps);
-            return audios.slice(0, maxTracksPerLanguage);
-          }
-        }
-        const filtered = [];
-        for (const language of languages) {
-          const tracks = audios.filter(
-            (track) => track.language?.startsWith(language)
-          );
-          filtered.push(...tracks);
-        }
-        const results = [];
-        const filteredLanguages = [
-          ...new Set(filtered.map((track) => track.language))
-        ];
-        for (const language of filteredLanguages) {
-          const tracks = filtered.filter((track) => track.language === language).slice(0, maxTracksPerLanguage);
-          results.push(...tracks);
-        }
-        return results;
-      };
-    };
-    var createAudioChannelsFilter = (audios) => {
-      return (channels) => {
-        if (!channels) return audios;
-        const value = typeof channels === "string" ? parseFloat(channels) : channels;
-        return audios.filter((track) => track.channels === value);
-      };
-    };
-    var createSubtitleLanguageFilter = (subtitles) => {
-      return (languages) => {
-        if (!languages.length) return subtitles;
-        return subtitles.filter(
-          (track) => languages.some(
-            (language) => track.language?.startsWith(language) || track.label?.startsWith(language)
-          )
-        );
-      };
-    };
-    var filterByResolution = (tracks, resolution) => createResolutionFilter(tracks)(resolution);
-    var filterByQuality = (tracks, quality) => createVideoQualityFilter(tracks)(quality);
-    var filterByCodecs = (tracks, codecs) => createCodecFilter(tracks)(codecs);
-    var filterByLanguages = (tracks, languages, maxTracksPerLanguage) => createAudioLanguageFilter(tracks)(languages, maxTracksPerLanguage);
-    var filterByChannels = (tracks, channels) => createAudioChannelsFilter(tracks)(channels);
-    module.exports = {
-      parseMimes,
-      createResolutionFilter,
-      createVideoCodecFilter,
-      createVideoQualityFilter,
-      createAudioCodecFilter,
-      createAudioLanguageFilter,
-      createAudioChannelsFilter,
-      createSubtitleLanguageFilter,
-      filterByResolution,
-      filterByQuality,
-      filterByCodecs,
-      filterByLanguages,
-      filterByChannels
-    };
-  }
-});
-
-// lib/audio.js
-var require_audio = __commonJS({
-  "lib/audio.js"(exports, module) {
-    "use strict";
-    var { parseMimes } = require_track();
-    var { parseBitrate, parseSize } = require_util();
-    var AUDIO_CODECS = {
-      AAC: "AAC",
-      // https://wikipedia.org/wiki/Advanced_Audio_Coding
-      AC3: "DD",
-      // https://wikipedia.org/wiki/Dolby_Digital
-      EC3: "DD+",
-      // https://wikipedia.org/wiki/Dolby_Digital_Plus
-      OPUS: "OPUS",
-      // https://wikipedia.org/wiki/Opus_(audio_format)
-      OGG: "VORB",
-      // https://wikipedia.org/wiki/Vorbis
-      DTS: "DTS",
-      // https://en.wikipedia.org/wiki/DTS_(company)#DTS_Digital_Surround
-      ALAC: "ALAC",
-      // https://en.wikipedia.org/wiki/Apple_Lossless_Audio_Codec
-      FLAC: "FLAC"
-      // https://en.wikipedia.org/wiki/FLAC
-    };
-    var parseAudioCodecFromMime = (mime) => {
-      const target = mime.toLowerCase().trim().split(".")[0];
-      switch (target) {
-        case "mp4a":
-          return AUDIO_CODECS.AAC;
-        case "ac-3":
-          return AUDIO_CODECS.AC3;
-        case "ec-3":
-          return AUDIO_CODECS.EC3;
-        case "opus":
-          return AUDIO_CODECS.OPUS;
-        case "dtsc":
-          return AUDIO_CODECS.DTS;
-        case "alac":
-          return AUDIO_CODECS.ALAC;
-        case "flac":
-          return AUDIO_CODECS.FLAC;
-        default:
-          throw new Error(`The MIME ${mime} is not supported as audio codec`);
-      }
-    };
-    var parseAudioCodec = (codecs) => {
-      const mimes = parseMimes(codecs);
-      for (const mime of mimes) {
-        try {
-          return parseAudioCodecFromMime(mime);
-        } catch (e) {
-          continue;
-        }
-      }
-      throw new Error(
-        `No MIME types matched any supported Audio Codecs in ${codecs}`
-      );
-    };
-    var getDolbyDigitalPlusComplexityIndex = (supplementalProps = []) => {
-      const targetScheme = "tag:dolby.com,2018:dash:EC3_ExtensionComplexityIndex:2018";
-      for (const prop of supplementalProps)
-        if (prop.attributes.schemeIdUri === targetScheme)
-          return parseInt(prop.attributes.value);
-    };
-    var checkIsDescriptive = (accessibilities = []) => {
-      for (const accessibility of accessibilities) {
-        const { schemeIdUri, value } = accessibility.attributes;
-        const firstMatch = schemeIdUri == "urn:mpeg:dash:role:2011" && value === "descriptive";
-        const secondMatch = schemeIdUri == "urn:tva:metadata:cs:AudioPurposeCS:2007" && value === "1";
-        const isDescriptive = firstMatch || secondMatch;
-        if (isDescriptive) return true;
-      }
-      return false;
-    };
-    var parseChannels = (channels) => {
-      const isDigit = (char) => char >= "0" && char <= "9";
-      if (typeof channels === "string") {
-        if (channels.toUpperCase() == "A000") return 2;
-        else if (channels.toUpperCase() == "F801") return 5.1;
-        else if (isDigit(channels.replace("ch", "").replace(".", "")[0]))
-          return parseFloat(channels.replace("ch", ""));
-        throw new Error(`Unsupported audio channels value, '${channels}'`);
-      }
-      return parseFloat(channels);
-    };
-    var createAudioTrack = ({
-      id,
-      label,
-      type,
-      codec,
-      channels,
-      bitrate,
-      duration,
-      jointObjectCoding = 0,
-      isDescriptive = false,
-      language,
-      segments
-    }) => {
-      const parsedBitrate = parseBitrate(Number(bitrate));
-      const parsedChannels = parseChannels(channels);
-      const size = duration ? parseSize(Number(bitrate), Number(duration)) : void 0;
-      return {
-        id,
-        label,
-        type,
-        codec,
-        bitrate: parsedBitrate,
-        size,
-        language,
-        segments,
-        channels: parsedChannels,
-        jointObjectCoding,
-        isDescriptive,
-        toString() {
-          return [
-            "AUDIO",
-            `[${codec}]`,
-            `${parsedChannels || "?"}` + (jointObjectCoding ? ` (JOC ${jointObjectCoding})` : ""),
-            `${parsedBitrate.kbps} kb/s`,
-            language
-          ].join(" | ");
-        }
-      };
-    };
-    module.exports = {
-      AUDIO_CODECS,
-      parseAudioCodec,
-      createAudioTrack,
-      getDolbyDigitalPlusComplexityIndex,
-      checkIsDescriptive
-    };
-  }
-});
-
-// lib/subtitle.js
-var require_subtitle = __commonJS({
-  "lib/subtitle.js"(exports, module) {
-    "use strict";
-    var { parseMimes } = require_track();
-    var { parseBitrate, parseSize } = require_util();
-    var SUBTITLE_CODECS = {
-      SubRip: "SRT",
-      // https://wikipedia.org/wiki/SubRip
-      SubStationAlpha: "SSA",
-      // https://wikipedia.org/wiki/SubStation_Alpha
-      SubStationAlphav4: "ASS",
-      // https://wikipedia.org/wiki/SubStation_Alpha#Advanced_SubStation_Alpha=
-      TimedTextMarkupLang: "TTML",
-      // https://wikipedia.org/wiki/Timed_Text_Markup_Language
-      WebVTT: "VTT",
-      // https://wikipedia.org/wiki/WebVTT
-      // MPEG-DASH box-encapsulated subtitle formats
-      fTTML: "STPP",
-      // https://www.w3.org/TR/2018/REC-ttml-imsc1.0.1-20180424
-      fVTT: "WVTT"
-      // https://www.w3.org/TR/webvtt1
-    };
-    var parseSubtitleCodecFromMime = (mime) => {
-      const target = mime.toLowerCase().trim().split(".")[0];
-      switch (target) {
-        case "srt":
-        case "x-subrip":
-          return SUBTITLE_CODECS.SubRip;
-        case "ssa":
-          return SUBTITLE_CODECS.SubStationAlpha;
-        case "ass":
-          return SUBTITLE_CODECS.SubStationAlphav4;
-        case "ttml":
-          return SUBTITLE_CODECS.TimedTextMarkupLang;
-        case "vtt":
-          return SUBTITLE_CODECS.WebVTT;
-        case "stpp":
-          return SUBTITLE_CODECS.fTTML;
-        case "wvtt":
-          return SUBTITLE_CODECS.fVTT;
-        default:
-          throw new Error(`The MIME ${mime} is not supported as subtitle codec`);
-      }
-    };
-    var parseSubtitleCodec = (codecs) => {
-      const mimes = parseMimes(codecs);
-      for (const mime of mimes) {
-        try {
-          return parseSubtitleCodecFromMime(mime);
-        } catch (e) {
-          continue;
-        }
-      }
-      throw new Error(
-        `No MIME types matched any supported Subtitle Codecs in ${codecs}`
-      );
-    };
-    var checkIsClosedCaption = (roles = []) => {
-      for (const role of roles) {
-        const isClosedCaption = role.attributes.schemeIdUri === "urn:mpeg:dash:role:2011" && role.attributes.value === "caption";
-        if (isClosedCaption) return true;
-      }
-      return false;
-    };
-    var checkIsSdh = (accessibilities = []) => {
-      for (const accessibility of accessibilities) {
-        const { schemeIdUri, value } = accessibility.attributes;
-        const isSdh = schemeIdUri === "urn:tva:metadata:cs:AudioPurposeCS:2007" && value === "2";
-        if (isSdh) return true;
-      }
-      return false;
-    };
-    var checkIsForced = (roles = []) => {
-      for (const role of roles) {
-        const isForced = role.attributes.schemeIdUri === "urn:mpeg:dash:role:2011" && (role.attributes.value === "forced-subtitle" || role.attributes.value === "forced_subtitle");
-        if (isForced) return true;
-      }
-      return false;
-    };
-    var createSubtitleTrack = ({
-      id,
-      label,
-      bitrate,
-      duration,
-      type,
-      codec,
-      isClosedCaption,
-      isSdh,
-      isForced,
-      language,
-      segments
-    }) => {
-      const parsedBitrate = parseBitrate(Number(bitrate));
-      const size = duration ? parseSize(Number(bitrate), Number(duration)) : void 0;
-      return {
-        id,
-        label,
-        bitrate: parsedBitrate,
-        size,
-        type,
-        codec,
-        isClosedCaption,
-        isSdh,
-        isForced,
-        segments,
-        language,
-        toString() {
-          return ["SUBTITLE", `[${codec}]`, language].join(" | ");
-        }
-      };
-    };
-    module.exports = {
-      parseSubtitleCodec,
-      checkIsClosedCaption,
-      checkIsSdh,
-      checkIsForced,
-      createSubtitleTrack
-    };
-  }
-});
-
-// lib/dash.js
-var require_dash = __commonJS({
-  "lib/dash.js"(exports, module) {
-    "use strict";
-    var xml = require_xml();
-    var { parseDuration, isLanguageTagValid } = require_util();
-    var {
-      parseVideoCodec,
-      parseDynamicRange,
-      createVideoTrack
-    } = require_video();
-    var {
-      parseAudioCodec,
-      createAudioTrack,
-      getDolbyDigitalPlusComplexityIndex,
-      checkIsDescriptive
-    } = require_audio();
-    var {
-      parseSubtitleCodec,
-      checkIsClosedCaption,
-      checkIsSdh,
-      checkIsForced,
-      createSubtitleTrack
-    } = require_subtitle();
-    var {
-      createResolutionFilter,
-      createVideoQualityFilter,
-      createAudioLanguageFilter,
-      createSubtitleLanguageFilter,
-      createVideoCodecFilter,
-      createAudioCodecFilter,
-      createAudioChannelsFilter
-    } = require_track();
-    var appendUtils = (element) => {
-      if (!element) return element;
-      if (Array.isArray(element)) {
-        element.get = (name) => appendUtils(element.find((item) => item.tagName === name));
-      } else {
-        element.getAttr = (name) => element.attributes[name];
-        element.getChild = (name) => {
-          const tag = element.children.find((item) => item.tagName === name);
-          const isString = !name && typeof element.children?.[0] === "string";
-          return isString ? element.children[0] : appendUtils(tag);
-        };
-        element.set = (name, value) => element.attributes[name] = value;
-        element.get = (name) => element.getAttr(name) || element.getChild(name);
-        element.getNumber = (name) => Number(element.find(name));
-        element.getAll = (name) => element.children.filter((item) => item.tagName === name).map(appendUtils);
-        element.getBaseUrls = () => element.getAll("BaseURL").map((item) => item.children[0]);
-        element.getBaseUrl = () => element.getBaseUrls()[0];
-      }
-      return element;
-    };
-    var combineGetters = (representation, adaptationSet) => {
-      const prevGet = representation.get;
-      const prevGetAll = representation.getAll;
-      const get = (name) => prevGet(name) || adaptationSet.get(name);
-      const getAll = (name) => [...prevGetAll(name), ...adaptationSet.getAll(name)].filter(Boolean);
-      representation.get = get;
-      representation.getAll = getAll;
-      return { get, getAll };
-    };
-    var parseBaseUrl = (manifestUrl, mpd, period, representation) => {
-      let base = mpd.getBaseUrl();
-      if (!base) base = manifestUrl;
-      else if (!base.startsWith("https://"))
-        base = new URL(base, manifestUrl).toString();
-      if (!!period.getBaseUrl() || !!base)
-        base = new URL(period.getBaseUrl() || "", base).toString();
-      const baseUrl = new URL(representation.getBaseUrl() || "", base).toString();
-      return baseUrl;
-    };
-    var parseContentTypes = (representation) => {
-      const mimeType = representation.get("mimeType");
-      const contentType = representation.get("contentType") || mimeType?.split("/")[0];
-      if (!contentType && !mimeType)
-        throw new Error(
-          "Unable to determine the format of a Representation, cannot continue..."
-        );
-      return { contentType, mimeType };
-    };
-    var parseCodecs = (representation, contentType, mimeType) => {
-      const shouldUseCodecsFromMime = contentType === "text" && !mimeType.includes("mp4");
-      const codecs = shouldUseCodecsFromMime ? mimeType.split("/")[1] : representation.get("codecs");
-      return codecs;
-    };
-    var parseLanguage = (representation, adaptationSet, fallbackLanguage) => {
-      let language = "";
-      const options = [];
-      const lang = representation.get("lang");
-      const id = representation.get("id");
-      if (representation) {
-        options.push(lang);
-        if (id) {
-          const m = id.match(/\w+_(\w+)=\d+/);
-          if (m && m[1]) options.push(m[1]);
-        }
-      }
-      options.push(adaptationSet.get("lang"));
-      if (fallbackLanguage) options.push(fallbackLanguage);
-      for (const option of options) {
-        const value = (option || "").trim();
-        if (!isLanguageTagValid(value) || value.startsWith("und")) continue;
-        language = value;
-        continue;
-      }
-      if (!language) {
-      }
-      return language;
-    };
-    var buildSegmentUrl = (template, fields) => {
-      let result = template;
-      for (const [key, value] of Object.entries(fields))
-        result = result.replace("$" + key + "$", value);
-      return result;
-    };
-    var resolveSegmentTemplateUrls = (segmentTemplate, baseUrl, manifestUrl) => {
-      for (const type of ["initialization", "media"]) {
-        let value = segmentTemplate.get(type);
-        if (!value) continue;
-        if (!value.startsWith("https://")) {
-          if (!baseUrl)
-            throw new Error(
-              `Resolved Segment URL is not absolute, and no Base URL is available.`
-            );
-          value = new URL(value, baseUrl).toString();
-        }
-        if (!new URL(value).search) {
-          const manifestUrlQuery = new URL(manifestUrl).search;
-          if (manifestUrlQuery) value += `?${manifestUrlQuery}`;
-        }
-        segmentTemplate.set(type, value);
-      }
-    };
-    var parseSegmentsFromTimeline = (segmentTimeline, segmentTemplate, representation, startNumber) => {
-      const times = [];
-      let currentTime = 0;
-      for (const s of segmentTimeline.getAll("S")) {
-        const t = Number(s.get("t"));
-        const r = Number(s.get("r") || 0);
-        const d = Number(s.get("d"));
-        if (t) currentTime = t;
-        for (let i = 0; i < r + 1; i++) {
-          times.push(currentTime);
-          currentTime += d;
-        }
-      }
-      const segments = [];
-      const numbers = [...Array(times.length).keys()].map((n) => n + startNumber);
-      for (let i = 0; i < times.length; i++) {
-        const t = times[i];
-        const n = numbers[i];
-        const url = buildSegmentUrl(segmentTemplate.get("media"), {
-          Bandwidth: representation.get("bandwidth"),
-          RepresentationID: representation.get("id"),
-          Number: n,
-          Time: t
-        });
-        segments.push({ url });
-      }
-      return segments;
-    };
-    var parseSegmentsFromTemplate = (segmentTemplate, baseUrl, manifestUrl, duration, representation) => {
-      const startNumber = Number(segmentTemplate.get("startNumber") || 1);
-      const segmentTimeline = segmentTemplate.get("SegmentTimeline");
-      resolveSegmentTemplateUrls(segmentTemplate, baseUrl, manifestUrl);
-      const segmentDuration = parseFloat(segmentTemplate.get("duration"));
-      const segmentTimescale = parseFloat(segmentTemplate.get("timescale") || 1);
-      const DEFAULT_SEGMENTS_COUNT = 35;
-      const segmentsCount = duration ? Math.ceil(duration / (segmentDuration / segmentTimescale)) : DEFAULT_SEGMENTS_COUNT;
-      const bandwidth = representation.get("bandwidth");
-      const id = representation.get("id");
-      const segments = [];
-      if (segmentTimeline) {
-        segments.push(
-          ...parseSegmentsFromTimeline(
-            segmentTimeline,
-            segmentTemplate,
-            representation,
-            startNumber
-          )
-        );
-      } else {
-        for (let i = startNumber; i < startNumber + segmentsCount; i++) {
-          const url = buildSegmentUrl(segmentTemplate.get("media"), {
-            Bandwidth: bandwidth,
-            RepresentationID: id,
-            Number: i,
-            Time: i
-          });
-          segments.push({ url });
-        }
-      }
-      const initialization = segmentTemplate.get("initialization");
-      if (initialization) {
-        const url = buildSegmentUrl(initialization, {
-          Bandwidth: bandwidth,
-          RepresentationID: id
-        });
-        segments.unshift({ url, init: true });
-      }
-      return segments;
-    };
-    var parseSegmentsFromList = (segmentList, baseUrl) => {
-      const segmentUrls = segmentList.get("SegmentURL");
-      const segments = [];
-      for (const segmentUrl of segmentUrls) {
-        let mediaUrl = segmentUrl.get("media");
-        if (!mediaUrl) mediaUrl = baseUrl;
-        else if (!mediaUrl.startsWith("https://"))
-          mediaUrl = new URL(mediaUrl, baseUrl).toString();
-        segments.push({ url: mediaUrl, range: segmentUrl.get("mediaRange") });
-      }
-      return segments;
-    };
-    var parseSegmentFromBase = async (segmentBase, baseUrl) => {
-      const initialization = segmentBase.get("Initialization");
-      let mediaRange = "";
-      if (initialization) {
-      }
-      return { url: baseUrl, range: mediaRange };
-    };
-    var transformSegmentUrls = (segments) => {
-      for (const segment of segments) {
-        const hasHtmlEscapeCode = segment.url.includes("&amp;");
-        if (hasHtmlEscapeCode) {
-          const url = new URL(segment.url);
-          const entries = new URLSearchParams(
-            url.searchParams.toString()
-          ).entries();
-          for (const [key, value] of entries) {
-            url.searchParams.delete(key);
-            url.searchParams.append(key.replaceAll("amp;", ""), value);
-          }
-          segment.url = url.toString();
-        }
-      }
-    };
-    var protectionSchemas = {
-      "urn:mpeg:dash:mp4protection:2011": "common",
-      "urn:uuid:9a04f079-9840-4286-ab92-e65be0885f95": "playready",
-      "urn:uuid:edef8ba9-79d6-4ace-a3c8-27dcd51d21ed": "widevine"
-    };
-    var parseContentProtection = (contentProtections) => {
-      const protection = {};
-      for (const contentProtection of contentProtections) {
-        const id = contentProtection.get("schemeIdUri")?.toLowerCase();
-        const value = contentProtection.get("value");
-        const pssh = contentProtection.get("cenc:pssh")?.get();
-        const defaultKeyId = contentProtection.get("cenc:default_KID");
-        const data = { id, value, pssh, defaultKeyId };
-        protection[protectionSchemas[id]] = data;
-      }
-      return protection;
-    };
-    var parseManifest = async (text, url, fallbackLanguage) => {
-      const mpd = appendUtils(xml.parse(text)).get("MPD");
-      const period = mpd.get("Period");
-      const durationString = period.get("duration") || mpd.get("mediaPresentationDuration");
-      const duration = parseDuration(durationString);
-      const videos = [];
-      const audios = [];
-      const subtitles = [];
-      for (const adaptationSet of period.getAll("AdaptationSet")) {
-        for (const representation of adaptationSet.getAll("Representation")) {
-          const { get, getAll } = combineGetters(representation, adaptationSet);
-          const { contentType, mimeType } = parseContentTypes(representation);
-          const codecs = parseCodecs(representation, contentType, mimeType);
-          const language = parseLanguage(
-            representation,
-            adaptationSet,
-            fallbackLanguage
-          );
-          const baseUrl = parseBaseUrl(url, mpd, period, representation);
-          const segmentTemplate = get("SegmentTemplate");
-          const segmentList = get("SegmentList");
-          const segmentBase = get("SegmentBase");
-          const segments = [];
-          if (segmentTemplate) {
-            const segmentsFromTemplate = parseSegmentsFromTemplate(
-              segmentTemplate,
-              baseUrl,
-              url,
-              duration,
-              representation
-            );
-            segments.push(...segmentsFromTemplate);
-          } else if (segmentList) {
-            const segmentsFromList = parseSegmentsFromList(segmentList, baseUrl);
-            segments.push(...segmentsFromList);
-          } else if (segmentBase) {
-            const segmentFromBase = await parseSegmentFromBase(
-              segmentBase,
-              baseUrl
-            );
-            segments.push(segmentFromBase);
-          } else if (baseUrl) {
-            segments.push({ url: baseUrl });
-          } else {
-            throw new Error(
-              "Could not find a way to get segments from this MPD manifest."
-            );
-          }
-          transformSegmentUrls(segments);
-          const label = get("label");
-          const fps = get("frameRate") ?? segmentBase?.attributes.timescale;
-          const width = get("width") ?? 0;
-          const height = get("height") ?? 0;
-          const bitrate = get("bandwidth");
-          const supplementalProps = getAll("SupplementalProperty");
-          const essentialProps = getAll("EssentialProperty");
-          const accessibilities = adaptationSet.getAll("Accessibility");
-          const roles = adaptationSet.getAll("Role");
-          const contentProtections = getAll("ContentProtection");
-          const id = [
-            new URL(baseUrl).hostname,
-            contentType,
-            codecs,
-            bitrate,
-            language,
-            mpd.get("id"),
-            period.get("id"),
-            get("id"),
-            get("audioTrackId")
-          ].filter(Boolean).join("-").replaceAll("/", "-");
-          switch (contentType) {
-            case "video": {
-              const track = createVideoTrack({
-                id,
-                label,
-                type: contentType,
-                codec: parseVideoCodec(codecs),
-                dynamicRange: parseDynamicRange(
-                  codecs,
-                  supplementalProps,
-                  essentialProps
-                ),
-                contentProtection: parseContentProtection(contentProtections),
-                bitrate,
-                duration,
-                width,
-                height,
-                fps,
-                language,
-                segments
-              });
-              videos.push(track);
-              break;
-            }
-            case "audio": {
-              const track = createAudioTrack({
-                id,
-                label,
-                type: contentType,
-                codec: parseAudioCodec(codecs),
-                channels: get("AudioChannelConfiguration")?.get("value"),
-                jointObjectCoding: getDolbyDigitalPlusComplexityIndex(supplementalProps),
-                isDescriptive: checkIsDescriptive(accessibilities),
-                bitrate,
-                duration,
-                language,
-                segments
-              });
-              audios.push(track);
-              break;
-            }
-            case "text": {
-              const track = createSubtitleTrack({
-                id,
-                label,
-                type: contentType,
-                codec: parseSubtitleCodec(codecs || "vtt"),
-                isClosedCaption: checkIsClosedCaption(roles),
-                isSdh: checkIsSdh(accessibilities),
-                isForced: checkIsForced(roles),
-                bitrate,
-                duration,
-                language,
-                segments
-              });
-              subtitles.push(track);
-              break;
-            }
-            case "image":
-              break;
-            default:
-              throw new Error(`Unknown content type: ${contentType}`);
-          }
-        }
-      }
-      videos.sort((a, b) => b.bitrate.bps - a.bitrate.bps);
-      return {
-        duration,
-        tracks: {
-          all: videos.concat(audios).concat(subtitles),
-          videos,
-          audios,
-          subtitles,
-          withResolution: createResolutionFilter(videos),
-          withVideoCodecs: createVideoCodecFilter(videos),
-          withVideoQuality: createVideoQualityFilter(videos),
-          withAudioCodecs: createAudioCodecFilter(audios),
-          withAudioLanguages: createAudioLanguageFilter(audios),
-          withAudioChannels: createAudioChannelsFilter(audios),
-          withSubtitleLanguages: createSubtitleLanguageFilter(subtitles)
-        }
-      };
-    };
-    module.exports = { parseManifest };
-  }
-});
-
-// lib/hls.js
-var require_hls = __commonJS({
-  "lib/hls.js"(exports, module) {
-    "use strict";
-    var { dirname, basename } = __require("node:path");
-    var m3u8Parser = __require("m3u8-parser");
-    var { parseBitrate, getQualityLabel } = require_util();
-    var {
-      createResolutionFilter,
-      createVideoQualityFilter,
-      createAudioLanguageFilter,
-      createSubtitleLanguageFilter,
-      createVideoCodecFilter,
-      createAudioCodecFilter,
-      createAudioChannelsFilter
-    } = require_track();
-    var { createAudioTrack } = require_audio();
-    var { createVideoTrack } = require_video();
-    var parseM3u8 = (manifestString) => {
-      const parser = new m3u8Parser.Parser();
-      parser.push(manifestString);
-      parser.end();
-      return parser.manifest;
-    };
-    var fetchPlaylist = async (url) => {
-      const response = await fetch(url);
-      if (!response.ok)
-        throw new Error(`Failed to fetch playlist (${response.status}): ${url}`);
-      const text = await response.text();
-      return parseM3u8(text);
-    };
-    var parseUrl = (playlistUri, manifestUri) => {
-      let value = playlistUri;
-      if (!value.startsWith("https://"))
-        value = new URL(value, manifestUri).toString() + new URL(manifestUri).search;
-      return value;
-    };
-    var urlsSame = (url1, url2) => {
-      return new URL(url1).pathname === new URL(url2).pathname;
-    };
-    var parseMediaGroup = (groups, manifestUri) => {
-      const results = [];
-      if (!groups) return results;
-      for (const [groupId, group] of Object.entries(groups)) {
-        for (const [label, entity] of Object.entries(group)) {
-          const url = parseUrl(entity.uri, manifestUri);
-          const existing = results.find((result) => urlsSame(result.url, url));
-          if (!existing)
-            results.push({
-              groupId,
-              id: entity.uri.replace("/", ""),
-              type: groupId,
-              label,
-              language: entity.language,
-              url,
-              default: entity.default
-            });
-        }
-      }
-      return results;
-    };
-    var getAudioPlaylists = (m3u8, manifestUri) => {
-      if (!m3u8.mediaGroups) return [];
-      return parseMediaGroup(m3u8.mediaGroups.AUDIO, manifestUri);
-    };
-    var getSubtitlePlaylists = (m3u8, manifestUri) => {
-      if (!m3u8.mediaGroups) return [];
-      return parseMediaGroup(m3u8.mediaGroups.SUBTITLES, manifestUri);
-    };
-    var getVideoPlaylists = (m3u8, manifestUri) => {
-      if (!m3u8.playlists) return [];
-      return m3u8.playlists.map((data) => {
-        const bandwidth = data.attributes?.BANDWIDTH;
-        const url = data.resolvedUri || parseUrl(data.uri, manifestUri);
-        const track = {
-          id: data.uri.replace("/", ""),
-          bitrate: parseBitrate(bandwidth),
-          url
-        };
-        track.type = "video";
-        if (data.attributes.RESOLUTION) {
-          track.resolution = data.attributes.RESOLUTION;
-          track.quality = getQualityLabel(track.resolution);
-        }
-        if (data.attributes["VIDEO-RANGE"])
-          track.dynamicRange = data.attributes["VIDEO-RANGE"];
-        if (data.attributes.CODECS) track.codecs = data.attributes.CODECS;
-        if (data.attributes["FRAME-RATE"])
-          track.frameRate = data.attributes["FRAME-RATE"];
-        return track;
-      });
-    };
-    var segmentsDto = (data = [], track) => {
-      const mapSegment = (item) => {
-        let url = item.resolvedUri || item.uri;
-        if (!url.startsWith("https://") && track.url) {
-          const baseUrl = dirname(track.url) + "/";
-          url = new URL(url, baseUrl).toString();
-        }
-        return {
-          url,
-          duration: item.duration,
-          number: item.number,
-          presentationTime: item.presentationTime
-        };
-      };
-      const segments = data.map(mapSegment);
-      const init = data[0].map;
-      if (data.length && (init?.resolvedUri || init?.uri)) {
-        const url = init?.resolvedUri || parseUrl(init.uri, track.url);
-        segments.unshift({
-          url,
-          init: true,
-          duration: 0,
-          number: 0,
-          presentationTime: 0
-        });
-      }
-      return segments;
-    };
-    var parseSegments = (playlist, track) => {
-      track.segments = segmentsDto(playlist.segments, track);
-      if (playlist.contentProtection) {
-        track.protection = {};
-        const fairplayLegacy = playlist.contentProtection["com.apple.fps.1_0"];
-        if (fairplayLegacy)
-          track.protection.fairplay = {
-            keyFormat: fairplayLegacy.attributes.KEYFORMAT,
-            uri: fairplayLegacy.attributes.URI,
-            method: fairplayLegacy.attributes.METHOD
-          };
-        const widevine = playlist.contentProtection["com.widevine.alpha"];
-        if (widevine) {
-          track.protection.widevine = {
-            pssh: widevine.pssh,
-            uri: widevine.attributes.schemeIdUri,
-            keyId: widevine.attributes.keyId
-          };
-        }
-      }
-    };
-    var fetchTrackSegments = (tracks) => {
-      return Promise.all(
-        tracks.map(async (track) => {
-          const playlist = await fetchPlaylist(track.url);
-          parseSegments(playlist, track);
-        })
-      );
-    };
-    var parseManifest = async (manifestString, manifestUri) => {
-      const m3u8 = parseM3u8(manifestString);
-      const videos = getVideoPlaylists(m3u8, manifestUri);
-      const audios = getAudioPlaylists(m3u8, manifestUri);
-      const subtitles = getSubtitlePlaylists(m3u8, manifestUri);
-      if (!m3u8.playlists && m3u8.segments) {
-        const { pathname } = new URL(manifestUri);
-        const isAudio = pathname.includes(".m4a") || pathname.includes(".mp3") || pathname.includes(".opus");
-        if (isAudio) {
-          const track = createAudioTrack({
-            id: "audio" + basename(pathname),
-            label: "audio",
-            type: "audio",
-            codec: "",
-            channels: 2,
-            jointObjectCoding: "",
-            isDescriptive: false,
-            bitrate: NaN,
-            duration: NaN,
-            language: ""
-          });
-          parseSegments(m3u8, track);
-          audios.push(track);
-        } else {
-          const track = createVideoTrack({
-            id: "video" + basename(pathname),
-            label: "video",
-            type: "video",
-            codec: "",
-            dynamicRange: "",
-            contentProtection: "",
-            bitrate: NaN,
-            duration: NaN,
-            width: NaN,
-            height: NaN,
-            fps: NaN,
-            language: ""
-          });
-          parseSegments(m3u8, track);
-          videos.push(track);
-        }
-      } else {
-        await Promise.all([
-          fetchTrackSegments(videos),
-          fetchTrackSegments(audios),
-          fetchTrackSegments(subtitles)
-        ]);
-      }
-      const manifest = {
-        tracks: {
-          all: videos.concat(audios).concat(subtitles),
-          videos,
-          audios,
-          subtitles,
-          withResolution: createResolutionFilter(videos),
-          withVideoCodecs: createVideoCodecFilter(videos),
-          withVideoQuality: createVideoQualityFilter(videos),
-          withAudioCodecs: createAudioCodecFilter(audios),
-          withAudioLanguages: createAudioLanguageFilter(audios),
-          withAudioChannels: createAudioChannelsFilter(audios),
-          withSubtitleLanguages: createSubtitleLanguageFilter(subtitles)
-        }
-      };
-      return manifest;
-    };
-    module.exports = { parseManifest };
-  }
-});
-
-// dasha.js
-var require_dasha = __commonJS({
-  "dasha.js"(exports, module) {
-    var dash = require_dash();
-    var hls = require_hls();
-    var {
-      filterByResolution,
-      filterByQuality,
-      filterByCodecs,
-      filterByLanguages,
-      filterByChannels
-    } = require_track();
-    var parse = (text, url, fallbackLanguage) => {
-      if (text.includes("<MPD"))
-        return dash.parseManifest(text, url, fallbackLanguage);
-      else if (text.includes("#EXTM3U")) return hls.parseManifest(text, url);
-      else throw new Error("Invalid manifest");
-    };
-    module.exports = {
-      parse,
-      filterByResolution,
-      filterByQuality,
-      filterByCodecs,
-      filterByLanguages,
-      filterByChannels
-    };
-  }
-});
-export default require_dasha();