@volcengine/veplayer-plugin 2.4.0-rc.3 → 2.4.0-rc.5

package/esm/veplayer.plugin.drm.development.js

@@ -0,0 +1,1580 @@
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    enumerableOnly && (symbols = symbols.filter(function(sym) {
+      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+    })), keys.push.apply(keys, symbols);
+  }
+  return keys;
+}
+function _objectSpread2(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = null != arguments[i] ? arguments[i] : {};
+    i % 2 ? ownKeys(Object(source), true).forEach(function(key) {
+      _defineProperty(target, key, source[key]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function(key) {
+      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
+  }
+  return target;
+}
+function _typeof(obj) {
+  "@babel/helpers - typeof";
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj2) {
+    return typeof obj2;
+  } : function(obj2) {
+    return obj2 && "function" == typeof Symbol && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+  }, _typeof(obj);
+}
+function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor)
+      descriptor.writable = true;
+    Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
+  }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps)
+    _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps)
+    _defineProperties(Constructor, staticProps);
+  Object.defineProperty(Constructor, "prototype", {
+    writable: false
+  });
+  return Constructor;
+}
+function _defineProperty(obj, key, value) {
+  key = _toPropertyKey(key);
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function _toConsumableArray(arr) {
+  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+function _arrayWithoutHoles(arr) {
+  if (Array.isArray(arr))
+    return _arrayLikeToArray(arr);
+}
+function _iterableToArray(iter) {
+  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null)
+    return Array.from(iter);
+}
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o)
+    return;
+  if (typeof o === "string")
+    return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor)
+    n = o.constructor.name;
+  if (n === "Map" || n === "Set")
+    return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+    return _arrayLikeToArray(o, minLen);
+}
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length)
+    len = arr.length;
+  for (var i = 0, arr2 = new Array(len); i < len; i++)
+    arr2[i] = arr[i];
+  return arr2;
+}
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _toPrimitive(input, hint) {
+  if (typeof input !== "object" || input === null)
+    return input;
+  var prim = input[Symbol.toPrimitive];
+  if (prim !== void 0) {
+    var res = prim.call(input, hint || "default");
+    if (typeof res !== "object")
+      return res;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (hint === "string" ? String : Number)(input);
+}
+function _toPropertyKey(arg) {
+  var key = _toPrimitive(arg, "string");
+  return typeof key === "symbol" ? key : String(key);
+}
+var XG_DEBUG_OPEN = typeof window !== "undefined" && window.location && window.location.href.indexOf("xgplayerdebugger=1") > -1;
+var STYLE = {
+  info: "color: #525252; background-color: #90ee90;",
+  error: "color: #525252; background-color: red;",
+  warn: "color: #525252; background-color: yellow; "
+};
+var XGTAG = "%c[xgplayer]";
+var XG_DEBUG = {
+  config: {
+    debug: XG_DEBUG_OPEN ? 3 : 0
+  },
+  logInfo: function logInfo(message) {
+    var _console;
+    for (var _len = arguments.length, optionalParams = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      optionalParams[_key - 1] = arguments[_key];
+    }
+    this.config.debug >= 3 && (_console = console).log.apply(_console, [XGTAG, STYLE.info, message].concat(optionalParams));
+  },
+  logWarn: function logWarn(message) {
+    var _console2;
+    for (var _len2 = arguments.length, optionalParams = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+      optionalParams[_key2 - 1] = arguments[_key2];
+    }
+    this.config.debug >= 1 && (_console2 = console).warn.apply(_console2, [XGTAG, STYLE.warn, message].concat(optionalParams));
+  },
+  logError: function logError(message) {
+    var _console3;
+    if (this.config.debug < 1) {
+      return;
+    }
+    var _fun = this.config.debug >= 2 ? "trace" : "error";
+    for (var _len3 = arguments.length, optionalParams = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
+      optionalParams[_key3 - 1] = arguments[_key3];
+    }
+    (_console3 = console)[_fun].apply(_console3, [XGTAG, STYLE.error, message].concat(optionalParams));
+  }
+};
+var XgplayerTimeRange = /* @__PURE__ */ function() {
+  function XgplayerTimeRange2(bufferedList) {
+    _classCallCheck(this, XgplayerTimeRange2);
+    this.bufferedList = bufferedList;
+  }
+  _createClass(XgplayerTimeRange2, [{
+    key: "start",
+    value: function start(index) {
+      return this.bufferedList[index].start;
+    }
+  }, {
+    key: "end",
+    value: function end(index) {
+      return this.bufferedList[index].end;
+    }
+  }, {
+    key: "length",
+    get: function get() {
+      return this.bufferedList.length;
+    }
+  }]);
+  return XgplayerTimeRange2;
+}();
+var util = {};
+util.createDom = function() {
+  var el = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "div";
+  var tpl = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "";
+  var attrs = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+  var cname = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : "";
+  var dom = document.createElement(el);
+  dom.className = cname;
+  dom.innerHTML = tpl;
+  Object.keys(attrs).forEach(function(item) {
+    var key = item;
+    var value = attrs[item];
+    if (el === "video" || el === "audio" || el === "live-video") {
+      if (value) {
+        dom.setAttribute(key, value);
+      }
+    } else {
+      dom.setAttribute(key, value);
+    }
+  });
+  return dom;
+};
+util.createDomFromHtml = function(html) {
+  var attrs = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+  var classname = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "";
+  try {
+    var doc = document.createElement("div");
+    doc.innerHTML = html;
+    var dom = doc.children;
+    doc = null;
+    if (dom.length > 0) {
+      dom = dom[0];
+      classname && util.addClass(dom, classname);
+      if (attrs) {
+        Object.keys(attrs).forEach(function(key) {
+          dom.setAttribute(key, attrs[key]);
+        });
+      }
+      return dom;
+    }
+    return null;
+  } catch (err) {
+    XG_DEBUG.logError("util.createDomFromHtml", err);
+    return null;
+  }
+};
+util.hasClass = function(el, className) {
+  if (!el || !className) {
+    return false;
+  }
+  try {
+    return Array.prototype.some.call(el.classList, function(item) {
+      return item === className;
+    });
+  } catch (e) {
+    var orgClassName = el.className && _typeof(el.className) === "object" ? el.getAttribute("class") : el.className;
+    return orgClassName && !!orgClassName.match(new RegExp("(\\s|^)" + className + "(\\s|$)"));
+  }
+};
+util.addClass = function(el, className) {
+  if (!el || !className) {
+    return;
+  }
+  try {
+    className.replace(/(^\s+|\s+$)/g, "").split(/\s+/g).forEach(function(item) {
+      item && el.classList.add(item);
+    });
+  } catch (e) {
+    if (!util.hasClass(el, className)) {
+      if (el.className && _typeof(el.className) === "object") {
+        el.setAttribute("class", el.getAttribute("class") + " " + className);
+      } else {
+        el.className += " " + className;
+      }
+    }
+  }
+};
+util.removeClass = function(el, className) {
+  if (!el || !className) {
+    return;
+  }
+  try {
+    className.replace(/(^\s+|\s+$)/g, "").split(/\s+/g).forEach(function(item) {
+      item && el.classList.remove(item);
+    });
+  } catch (e) {
+    if (util.hasClass(el, className)) {
+      className.split(/\s+/g).forEach(function(item) {
+        var reg = new RegExp("(\\s|^)" + item + "(\\s|$)");
+        if (el.className && _typeof(el.className) === "object") {
+          el.setAttribute("class", el.getAttribute("class").replace(reg, " "));
+        } else {
+          el.className = el.className.replace(reg, " ");
+        }
+      });
+    }
+  }
+};
+util.toggleClass = function(el, className) {
+  if (!el) {
+    return;
+  }
+  className.split(/\s+/g).forEach(function(item) {
+    if (util.hasClass(el, item)) {
+      util.removeClass(el, item);
+    } else {
+      util.addClass(el, item);
+    }
+  });
+};
+util.classNames = function() {
+  var _arguments = arguments;
+  var classname = [];
+  var _loop = function _loop2(i2) {
+    if (util.typeOf(_arguments[i2]) === "String") {
+      classname.push(_arguments[i2]);
+    } else if (util.typeOf(_arguments[i2]) === "Object") {
+      Object.keys(_arguments[i2]).map(function(key) {
+        if (_arguments[i2][key]) {
+          classname.push(key);
+        }
+      });
+    }
+  };
+  for (var i = 0; i < arguments.length; i++) {
+    _loop(i);
+  }
+  return classname.join(" ");
+};
+util.findDom = function() {
+  var el = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : document;
+  var sel = arguments.length > 1 ? arguments[1] : void 0;
+  var dom;
+  try {
+    dom = el.querySelector(sel);
+  } catch (e) {
+    XG_DEBUG.logError("util.findDom", e);
+    if (sel.indexOf("#") === 0) {
+      dom = el.getElementById(sel.slice(1));
+    }
+  }
+  return dom;
+};
+util.getCss = function(dom, key) {
+  return dom.currentStyle ? dom.currentStyle[key] : document.defaultView.getComputedStyle(dom, false)[key];
+};
+util.padStart = function(str, length, pad) {
+  var charstr = String(pad);
+  var len = length >> 0;
+  var maxlen = Math.ceil(len / charstr.length);
+  var chars = [];
+  var r = String(str);
+  while (maxlen--) {
+    chars.push(charstr);
+  }
+  return chars.join("").substring(0, len - r.length) + r;
+};
+util.format = function(time) {
+  if (window.isNaN(time)) {
+    return "";
+  }
+  time = Math.round(time);
+  var hour = util.padStart(Math.floor(time / 3600), 2, 0);
+  var minute = util.padStart(Math.floor((time - hour * 3600) / 60), 2, 0);
+  var second = util.padStart(Math.floor(time - hour * 3600 - minute * 60), 2, 0);
+  return (hour === "00" ? [minute, second] : [hour, minute, second]).join(":");
+};
+util.event = function(e) {
+  if (e.touches) {
+    var touch = e.touches[0] || e.changedTouches[0];
+    e.clientX = touch.clientX || 0;
+    e.clientY = touch.clientY || 0;
+    e.offsetX = touch.pageX - touch.target.offsetLeft;
+    e.offsetY = touch.pageY - touch.target.offsetTop;
+  }
+  e._target = e.target || e.srcElement;
+};
+util.typeOf = function(obj) {
+  return Object.prototype.toString.call(obj).match(/([^\s.*]+)(?=]$)/g)[0];
+};
+util.deepCopy = function(dst, src) {
+  if (util.typeOf(src) === "Object" && util.typeOf(dst) === "Object") {
+    Object.keys(src).forEach(function(key) {
+      if (util.typeOf(src[key]) === "Object" && !(src[key] instanceof Node)) {
+        if (dst[key] === void 0 || dst[key] === void 0) {
+          dst[key] = src[key];
+        } else {
+          util.deepCopy(dst[key], src[key]);
+        }
+      } else if (util.typeOf(src[key]) === "Array") {
+        dst[key] = util.typeOf(dst[key]) === "Array" ? dst[key].concat(src[key]) : src[key];
+      } else {
+        dst[key] = src[key];
+      }
+    });
+    return dst;
+  }
+};
+util.deepMerge = function(dst, src) {
+  Object.keys(src).map(function(key) {
+    if (util.typeOf(src[key]) === "Array" && util.typeOf(dst[key]) === "Array") {
+      if (util.typeOf(dst[key]) === "Array") {
+        var _dst$key;
+        (_dst$key = dst[key]).push.apply(_dst$key, _toConsumableArray(src[key]));
+      }
+    } else if (util.typeOf(dst[key]) === util.typeOf(src[key]) && dst[key] !== null && util.typeOf(dst[key]) === "Object" && !(src[key] instanceof window.Node)) {
+      util.deepMerge(dst[key], src[key]);
+    } else {
+      src[key] !== null && (dst[key] = src[key]);
+    }
+  });
+  return dst;
+};
+util.getBgImage = function(el) {
+  var url = (el.currentStyle || window.getComputedStyle(el, null)).backgroundImage;
+  if (!url || url === "none") {
+    return "";
+  }
+  var a = document.createElement("a");
+  a.href = url.replace(/url\("|"\)/g, "");
+  return a.href;
+};
+util.copyDom = function(dom) {
+  if (dom && dom.nodeType === 1) {
+    var back = document.createElement(dom.tagName);
+    Array.prototype.forEach.call(dom.attributes, function(node) {
+      back.setAttribute(node.name, node.value);
+    });
+    if (dom.innerHTML) {
+      back.innerHTML = dom.innerHTML;
+    }
+    return back;
+  } else {
+    return "";
+  }
+};
+util.setInterval = function(context, eventName, intervalFunc, frequency) {
+  if (!context._interval[eventName]) {
+    context._interval[eventName] = window.setInterval(intervalFunc.bind(context), frequency);
+  }
+};
+util.clearInterval = function(context, eventName) {
+  clearInterval(context._interval[eventName]);
+  context._interval[eventName] = null;
+};
+util.setTimeout = function(context, fun, time) {
+  if (!context._timers) {
+    context._timers = [];
+  }
+  var id = setTimeout(function() {
+    fun();
+    util.clearTimeout(context, id);
+  }, time);
+  context._timers.push(id);
+  return id;
+};
+util.clearTimeout = function(context, id) {
+  var _timers = context._timers;
+  if (util.typeOf(_timers) === "Array") {
+    for (var i = 0; i < _timers.length; i++) {
+      if (_timers[i] === id) {
+        _timers.splice(i, 1);
+        clearTimeout(id);
+        break;
+      }
+    }
+  } else {
+    clearTimeout(id);
+  }
+};
+util.clearAllTimers = function(context) {
+  var _timers = context._timers;
+  if (util.typeOf(_timers) === "Array") {
+    _timers.map(function(item) {
+      clearTimeout(item);
+    });
+    context._timerIds = [];
+  }
+};
+util.createImgBtn = function(name, imgUrl, width, height) {
+  var btn = util.createDom("xg-".concat(name), "", {}, "xgplayer-".concat(name, "-img"));
+  btn.style.backgroundImage = 'url("'.concat(imgUrl, '")');
+  if (width && height) {
+    var w, h, unit;
+    ["px", "rem", "em", "pt", "dp", "vw", "vh", "vm", "%"].every(function(item) {
+      if (width.indexOf(item) > -1 && height.indexOf(item) > -1) {
+        w = parseFloat(width.slice(0, width.indexOf(item)).trim());
+        h = parseFloat(height.slice(0, height.indexOf(item)).trim());
+        unit = item;
+        return false;
+      } else {
+        return true;
+      }
+    });
+    btn.style.width = "".concat(w).concat(unit);
+    btn.style.height = "".concat(h).concat(unit);
+    btn.style.backgroundSize = "".concat(w).concat(unit, " ").concat(h).concat(unit);
+    if (name === "start") {
+      btn.style.margin = "-".concat(h / 2).concat(unit, " auto auto -").concat(w / 2).concat(unit);
+    } else {
+      btn.style.margin = "auto 5px auto 5px";
+    }
+  }
+  return btn;
+};
+util.Hex2RGBA = function(hex, alpha) {
+  var rgb = [];
+  if (/^\#[0-9A-F]{3}$/i.test(hex)) {
+    var sixHex = "#";
+    hex.replace(/[0-9A-F]/ig, function(kw) {
+      sixHex += kw + kw;
+    });
+    hex = sixHex;
+  }
+  if (/^#[0-9A-F]{6}$/i.test(hex)) {
+    hex.replace(/[0-9A-F]{2}/ig, function(kw) {
+      rgb.push(parseInt(kw, 16));
+    });
+    return "rgba(".concat(rgb.join(","), ", ").concat(alpha, ")");
+  } else {
+    return "rgba(255, 255, 255, 0.1)";
+  }
+};
+util.getFullScreenEl = function() {
+  return document.fullscreenElement || document.webkitFullscreenElement || document.mozFullScreenElement || document.msFullscreenElement;
+};
+util.checkIsFunction = function(fun) {
+  return fun && typeof fun === "function";
+};
+util.checkIsObject = function(obj) {
+  return obj !== null && _typeof(obj) === "object";
+};
+util.hide = function(dom) {
+  dom.style.display = "none";
+};
+util.show = function(dom, display) {
+  dom.style.display = display || "block";
+};
+util.isUndefined = function(val) {
+  if (typeof val === "undefined" || val === null) {
+    return true;
+  }
+};
+util.isNotNull = function(val) {
+  return !(val === void 0 || val === null);
+};
+util.setStyleFromCsstext = function(dom, text) {
+  if (!text) {
+    return;
+  }
+  if (util.typeOf(text) === "String") {
+    var styleArr = text.replace(/\s+/g, "").split(";");
+    styleArr.map(function(item) {
+      if (item) {
+        var arr = item.split(":");
+        if (arr.length > 1) {
+          dom.style[arr[0]] = arr[1];
+        }
+      }
+    });
+  } else {
+    Object.keys(text).map(function(key) {
+      dom.style[key] = text[key];
+    });
+  }
+};
+function checkIsIn(key, list) {
+  for (var i = 0, len = list.length; i < len; i++) {
+    if (key.indexOf(list[i]) > -1) {
+      return true;
+    }
+  }
+  return false;
+}
+util.filterStyleFromText = function(dom) {
+  var list = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : ["width", "height", "top", "left", "bottom", "right", "position", "z-index", "padding", "margin", "transform"];
+  var _cssText = dom.style.cssText;
+  if (!_cssText) {
+    return {};
+  }
+  var styleArr = _cssText.replace(/\s+/g, "").split(";");
+  var ret = {};
+  var remain = {};
+  styleArr.map(function(item) {
+    if (item) {
+      var arr = item.split(":");
+      if (arr.length > 1) {
+        if (checkIsIn(arr[0], list)) {
+          ret[arr[0]] = arr[1];
+        } else {
+          remain[arr[0]] = arr[1];
+        }
+      }
+    }
+  });
+  dom.setAttribute("style", "");
+  Object.keys(remain).map(function(key) {
+    dom.style[key] = remain[key];
+  });
+  return ret;
+};
+util.getStyleFromCsstext = function(dom) {
+  var _cssText = dom.style.cssText;
+  if (!_cssText) {
+    return {};
+  }
+  var styleArr = _cssText.replace(/\s+/g, "").split(";");
+  var ret = {};
+  styleArr.map(function(item) {
+    if (item) {
+      var arr = item.split(":");
+      if (arr.length > 1) {
+        ret[arr[0]] = arr[1];
+      }
+    }
+  });
+  return ret;
+};
+util.preloadImg = function(url) {
+  var onload = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : function() {
+  };
+  var onerror = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : function() {
+  };
+  if (!url) {
+    return;
+  }
+  var img = new window.Image();
+  img.onload = function(e) {
+    img = null;
+    onload && onload(e);
+  };
+  img.onerror = function(e) {
+    img = null;
+    onerror && onerror(e);
+  };
+  img.src = url;
+};
+util.stopPropagation = function(e) {
+  if (e) {
+    e.stopPropagation();
+  }
+};
+util.scrollTop = function() {
+  return window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop || 0;
+};
+util.scrollLeft = function() {
+  return window.pageXOffset || document.documentElement.scrollLeft || document.body.scrollLeft || 0;
+};
+util.checkTouchSupport = function() {
+  return "ontouchstart" in window;
+};
+util.getBuffered2 = function(vbuffered) {
+  var maxHoleDuration = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0.5;
+  var buffered = [];
+  for (var i = 0; i < vbuffered.length; i++) {
+    buffered.push({
+      start: vbuffered.start(i) < 0.5 ? 0 : vbuffered.start(i),
+      end: vbuffered.end(i)
+    });
+  }
+  buffered.sort(function(a, b) {
+    var diff = a.start - b.start;
+    if (diff) {
+      return diff;
+    } else {
+      return b.end - a.end;
+    }
+  });
+  var buffered2 = [];
+  if (maxHoleDuration) {
+    for (var _i = 0; _i < buffered.length; _i++) {
+      var buf2len = buffered2.length;
+      if (buf2len) {
+        var buf2end = buffered2[buf2len - 1].end;
+        if (buffered[_i].start - buf2end < maxHoleDuration) {
+          if (buffered[_i].end > buf2end) {
+            buffered2[buf2len - 1].end = buffered[_i].end;
+          }
+        } else {
+          buffered2.push(buffered[_i]);
+        }
+      } else {
+        buffered2.push(buffered[_i]);
+      }
+    }
+  } else {
+    buffered2 = buffered;
+  }
+  return new XgplayerTimeRange(buffered2);
+};
+util.getEventPos = function(e) {
+  var zoom = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 1;
+  if (e.touches && e.touches.length > 0) {
+    e = e.touches[0];
+  }
+  return {
+    x: e.x / zoom,
+    y: e.y / zoom,
+    clientX: e.clientX / zoom,
+    clientY: e.clientY / zoom,
+    offsetX: e.offsetX / zoom,
+    offsetY: e.offsetY / zoom,
+    pageX: e.pageX / zoom,
+    pageY: e.pageY / zoom
+  };
+};
+util.requestAnimationFrame = function(callback) {
+  var _fun = window.requestAnimationFrame || window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame || window.oRequestAnimationFrame || window.msRequestAnimationFrame;
+  if (_fun) {
+    return _fun(callback);
+  }
+};
+util.getHostFromUrl = function(url) {
+  if (util.typeOf(url) !== "String") {
+    return "";
+  }
+  var results = url.split("/");
+  var domain = "";
+  if (results.length > 3 && results[2]) {
+    domain = results[2];
+  }
+  return domain;
+};
+util.cancelAnimationFrame = function(frameId) {
+  var _fun = window.cancelAnimationFrame || window.mozCancelAnimationFrame || window.cancelRequestAnimationFrame;
+  _fun && _fun(frameId);
+};
+util.isMSE = function(video) {
+  if (video.media) {
+    video = video.media;
+  }
+  if (!video || !(video instanceof HTMLMediaElement)) {
+    return false;
+  }
+  return /^blob/.test(video.currentSrc) || /^blob/.test(video.src);
+};
+util.isBlob = function(url) {
+  return typeof url === "string" && /^blob/.test(url);
+};
+util.generateSessionId = function() {
+  var did = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 0;
+  var d = (/* @__PURE__ */ new Date()).getTime();
+  try {
+    did = parseInt(did);
+  } catch (e) {
+    did = 0;
+  }
+  d += did;
+  if (window.performance && typeof window.performance.now === "function") {
+    d += parseInt(window.performance.now());
+  }
+  var uuid = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
+    var r = (d + Math.random() * 16) % 16 | 0;
+    d = Math.floor(d / 16);
+    return (c === "x" ? r : r & 3 | 8).toString(16);
+  });
+  return uuid;
+};
+util.createEvent = function(eventName) {
+  var event;
+  if (typeof window.Event === "function") {
+    event = new Event(eventName);
+  } else {
+    event = document.createEvent("Event");
+    event.initEvent(eventName, true, true);
+  }
+  return event;
+};
+util.adjustTimeByDuration = function(time, duration, isEnded) {
+  if (!duration || !time) {
+    return time;
+  }
+  if (time > duration || isEnded && time < duration) {
+    return duration;
+  }
+  return time;
+};
+util.createPositionBar = function(className, root) {
+  var dom = util.createDom("xg-bar", "", {
+    "data-index": -1
+  }, className);
+  root.appendChild(dom);
+  return dom;
+};
+util.getTransformStyle = function() {
+  var pos = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {
+    x: 0,
+    y: 0,
+    scale: 1,
+    rotate: 0
+  };
+  var transformValue = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "";
+  var styles = {
+    scale: "".concat(pos.scale || 1),
+    translate: "".concat(pos.x || 0, "%, ").concat(pos.y || 0, "%"),
+    rotate: "".concat(pos.rotate || 0, "deg")
+  };
+  var stylesKeys = Object.keys(styles);
+  stylesKeys.forEach(function(key) {
+    var reg = new RegExp("".concat(key, "\\([^\\(]+\\)"), "g");
+    var fn = "".concat(key, "(").concat(styles[key], ")");
+    if (reg.test(transformValue)) {
+      reg.lastIndex = -1;
+      transformValue = transformValue.replace(reg, fn);
+    } else {
+      transformValue += "".concat(fn, " ");
+    }
+  });
+  return transformValue;
+};
+util.convertDeg = function(val) {
+  if (Math.abs(val) <= 1) {
+    return val * 360;
+  }
+  return val % 360;
+};
+util.getIndexByTime = function(time, segments) {
+  var _len = segments.length;
+  var _index = -1;
+  if (_len < 1) {
+    return _index;
+  }
+  if (time <= segments[0].end || _len < 2) {
+    _index = 0;
+  } else if (time > segments[_len - 1].end) {
+    _index = _len - 1;
+  } else {
+    for (var i = 1; i < _len; i++) {
+      if (time > segments[i - 1].end && time <= segments[i].end) {
+        _index = i;
+        break;
+      }
+    }
+  }
+  return _index;
+};
+util.getOffsetCurrentTime = function(currentTime, segments) {
+  var index = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : -1;
+  var _index = -1;
+  if (index >= 0 && index < segments.length) {
+    _index = index;
+  } else {
+    _index = util.getIndexByTime(currentTime, segments);
+  }
+  if (_index < 0) {
+    return -1;
+  }
+  var _len = segments.length;
+  var _segments$_index = segments[_index], start = _segments$_index.start, end = _segments$_index.end, cTime = _segments$_index.cTime, offset = _segments$_index.offset;
+  if (currentTime < start) {
+    return cTime;
+  } else if (currentTime >= start && currentTime <= end) {
+    return currentTime - offset;
+  } else if (currentTime > end && _index >= _len - 1) {
+    return end;
+  }
+  return -1;
+};
+util.getCurrentTimeByOffset = function(offsetTime, segments) {
+  var _index = -1;
+  if (!segments || segments.length < 0) {
+    return offsetTime;
+  }
+  for (var i = 0; i < segments.length; i++) {
+    if (offsetTime <= segments[i].duration) {
+      _index = i;
+      break;
+    }
+  }
+  if (_index !== -1) {
+    var start = segments[_index].start;
+    if (_index - 1 < 0) {
+      return start + offsetTime;
+    } else {
+      return start + (offsetTime - segments[_index - 1].duration);
+    }
+  }
+  return offsetTime;
+};
+function callHandler(obj, handler, next) {
+  for (var _len = arguments.length, args = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++) {
+    args[_key - 3] = arguments[_key];
+  }
+  var ret = handler.call.apply(handler, [obj].concat(args));
+  if (!next || typeof next !== "function") {
+    return;
+  }
+  if (ret && ret.then) {
+    ret.then(function() {
+      for (var _len2 = arguments.length, args2 = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        args2[_key2] = arguments[_key2];
+      }
+      next.call.apply(next, [obj].concat(args2));
+    });
+  } else {
+    next.call.apply(next, [obj].concat(args));
+  }
+}
+function hook(hookName, handler) {
+  var preset = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {
+    pre: null,
+    next: null
+  };
+  if (!this.__hooks) {
+    this.__hooks = {};
+  }
+  !this.__hooks[hookName] && (this.__hooks[hookName] = null);
+  return function() {
+    var _arguments = arguments, _this = this;
+    if (preset.pre) {
+      try {
+        var _preset$pre;
+        (_preset$pre = preset.pre).call.apply(_preset$pre, [this].concat(Array.prototype.slice.call(arguments)));
+      } catch (e) {
+        e.message = "[pluginName: ".concat(this.pluginName, ":").concat(hookName, ":pre error] >> ").concat(e.message);
+        throw e;
+      }
+    }
+    if (this.__hooks && this.__hooks[hookName]) {
+      try {
+        var _this$__hooks$hookNam;
+        var preRet = (_this$__hooks$hookNam = this.__hooks[hookName]).call.apply(_this$__hooks$hookNam, [this, this].concat(Array.prototype.slice.call(arguments)));
+        if (preRet) {
+          if (preRet.then) {
+            preRet.then(function(isContinue) {
+              if (isContinue !== false) {
+                callHandler.apply(void 0, [_this, handler, preset.next].concat(_toConsumableArray(_arguments)));
+              }
+            }).catch(function(e) {
+              throw e;
+            });
+          } else {
+            callHandler.apply(void 0, [this, handler, preset.next].concat(Array.prototype.slice.call(arguments)));
+          }
+        } else if (preRet === void 0) {
+          callHandler.apply(void 0, [this, handler, preset.next].concat(Array.prototype.slice.call(arguments)));
+        }
+      } catch (e) {
+        e.message = "[pluginName: ".concat(this.pluginName, ":").concat(hookName, "] >> ").concat(e.message);
+        throw e;
+      }
+    } else {
+      callHandler.apply(void 0, [this, handler, preset.next].concat(Array.prototype.slice.call(arguments)));
+    }
+  }.bind(this);
+}
+function useHooks(hookName, handler) {
+  var __hooks = this.__hooks;
+  if (!__hooks) {
+    return;
+  }
+  if (!__hooks.hasOwnProperty(hookName)) {
+    console.warn("has no supported hook which name [".concat(hookName, "]"));
+    return false;
+  }
+  __hooks && (__hooks[hookName] = handler);
+  return true;
+}
+function removeHooks(hookName, handler) {
+  var __hooks = this.__hooks;
+  if (!__hooks) {
+    return;
+  }
+  delete __hooks[hookName];
+}
+function hooksDescriptor(instance) {
+  var presetHooks = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [];
+  instance.__hooks = {};
+  presetHooks && presetHooks.map(function(item) {
+    instance.__hooks[item] = null;
+  });
+  Object.defineProperty(instance, "hooks", {
+    get: function get() {
+      return instance.__hooks && Object.keys(instance.__hooks).map(function(key) {
+        if (instance.__hooks[key]) {
+          return key;
+        }
+      });
+    }
+  });
+}
+function delHooksDescriptor(instance) {
+  instance.__hooks = null;
+}
+function showErrorMsg(pluginName, msg) {
+  XG_DEBUG.logError("[".concat(pluginName, "] event or callback cant be undefined or null when call ").concat(msg));
+}
+var BasePlugin = /* @__PURE__ */ function() {
+  function BasePlugin2(args) {
+    _classCallCheck(this, BasePlugin2);
+    if (util.checkIsFunction(this.beforeCreate)) {
+      this.beforeCreate(args);
+    }
+    hooksDescriptor(this);
+    this.__args = args;
+    this.__events = {};
+    this.__onceEvents = {};
+    this.config = args.config || {};
+    this.player = null;
+    this.playerConfig = {};
+    this.pluginName = "";
+    this.__init(args);
+  }
+  _createClass(BasePlugin2, [{
+    key: "beforeCreate",
+    value: function beforeCreate(args) {
+    }
+  }, {
+    key: "afterCreate",
+    value: function afterCreate() {
+    }
+  }, {
+    key: "beforePlayerInit",
+    value: function beforePlayerInit() {
+    }
+  }, {
+    key: "onPluginsReady",
+    value: function onPluginsReady() {
+    }
+  }, {
+    key: "afterPlayerInit",
+    value: function afterPlayerInit() {
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+    }
+  }, {
+    key: "__init",
+    value: function __init(args) {
+      this.player = args.player;
+      this.playerConfig = args.player && args.player.config;
+      this.pluginName = args.pluginName ? args.pluginName.toLowerCase() : this.constructor.pluginName.toLowerCase();
+      this.logger = args.player && args.player.logger;
+    }
+  }, {
+    key: "updateLang",
+    value: function updateLang(lang) {
+      if (!lang) {
+        lang = this.lang;
+      }
+    }
+  }, {
+    key: "lang",
+    get: function get() {
+      return this.player.lang;
+    }
+  }, {
+    key: "i18n",
+    get: function get() {
+      return this.player.i18n;
+    }
+  }, {
+    key: "i18nKeys",
+    get: function get() {
+      return this.player.i18nKeys;
+    }
+  }, {
+    key: "domEventType",
+    get: function get() {
+      var _e = util.checkTouchSupport() ? "touch" : "mouse";
+      if (this.playerConfig && (this.playerConfig.domEventType === "touch" || this.playerConfig.domEventType === "mouse")) {
+        _e = this.playerConfig.domEventType;
+      }
+      return _e;
+    }
+  }, {
+    key: "on",
+    value: function on(event, callback) {
+      var _this = this;
+      if (!event || !callback || !this.player) {
+        showErrorMsg(this.pluginName, "plugin.on(event, callback)");
+        return;
+      }
+      if (typeof event === "string") {
+        this.__events[event] = callback;
+        this.player.on(event, callback);
+      } else if (Array.isArray(event)) {
+        event.forEach(function(item) {
+          _this.__events[item] = callback;
+          _this.player.on(item, callback);
+        });
+      }
+    }
+  }, {
+    key: "once",
+    value: function once(event, callback) {
+      var _this2 = this;
+      if (!event || !callback || !this.player) {
+        showErrorMsg(this.pluginName, "plugin.once(event, callback)");
+        return;
+      }
+      if (typeof event === "string") {
+        this.__onceEvents[event] = callback;
+        this.player.once(event, callback);
+      } else if (Array.isArray(event)) {
+        event.forEach(function(item) {
+          _this2.__onceEvents[item] = callback;
+          _this2.player.once(event, callback);
+        });
+      }
+    }
+  }, {
+    key: "off",
+    value: function off(event, callback) {
+      var _this3 = this;
+      if (!event || !callback || !this.player) {
+        showErrorMsg(this.pluginName, "plugin.off(event, callback)");
+        return;
+      }
+      if (typeof event === "string") {
+        delete this.__events[event];
+        this.player.off(event, callback);
+      } else if (Array.isArray(event)) {
+        event.forEach(function(item) {
+          delete _this3.__events[event];
+          _this3.player.off(item, callback);
+        });
+      }
+    }
+  }, {
+    key: "offAll",
+    value: function offAll() {
+      var _this4 = this;
+      ["__events", "__onceEvents"].forEach(function(key) {
+        Object.keys(_this4[key]).forEach(function(item) {
+          _this4[key][item] && _this4.off(item, _this4[key][item]);
+          item && delete _this4[key][item];
+        });
+      });
+      this.__events = {};
+      this.__onceEvents = {};
+    }
+  }, {
+    key: "emit",
+    value: function emit(event) {
+      var _this$player;
+      if (!this.player) {
+        return;
+      }
+      for (var _len = arguments.length, res = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        res[_key - 1] = arguments[_key];
+      }
+      (_this$player = this.player).emit.apply(_this$player, [event].concat(res));
+    }
+  }, {
+    key: "emitUserAction",
+    value: function emitUserAction(event, action) {
+      var params = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+      if (!this.player) {
+        return;
+      }
+      var nParams = _objectSpread2(_objectSpread2({}, params), {}, {
+        pluginName: this.pluginName
+      });
+      this.player.emitUserAction(event, action, nParams);
+    }
+  }, {
+    key: "hook",
+    value: function hook$1(hookName, handler) {
+      return hook.call.apply(hook, [this].concat(Array.prototype.slice.call(arguments)));
+    }
+  }, {
+    key: "useHooks",
+    value: function useHooks$1(hookName, handler) {
+      for (var _len2 = arguments.length, args = new Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
+        args[_key2 - 2] = arguments[_key2];
+      }
+      return useHooks.call.apply(useHooks, [this].concat(Array.prototype.slice.call(arguments)));
+    }
+  }, {
+    key: "removeHooks",
+    value: function removeHooks$1(hookName, handler) {
+      for (var _len3 = arguments.length, args = new Array(_len3 > 2 ? _len3 - 2 : 0), _key3 = 2; _key3 < _len3; _key3++) {
+        args[_key3 - 2] = arguments[_key3];
+      }
+      return removeHooks.call.apply(removeHooks, [this].concat(Array.prototype.slice.call(arguments)));
+    }
+  }, {
+    key: "registerPlugin",
+    value: function registerPlugin(plugin) {
+      var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+      var name = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "";
+      if (!this.player) {
+        return;
+      }
+      name && (options.pluginName = name);
+      return this.player.registerPlugin({
+        plugin,
+        options
+      });
+    }
+  }, {
+    key: "getPlugin",
+    value: function getPlugin(name) {
+      return this.player ? this.player.getPlugin(name) : null;
+    }
+  }, {
+    key: "__destroy",
+    value: function __destroy() {
+      var _this5 = this;
+      var player = this.player;
+      var pluginName = this.pluginName;
+      this.offAll();
+      util.clearAllTimers(this);
+      if (util.checkIsFunction(this.destroy)) {
+        this.destroy();
+      }
+      ["player", "playerConfig", "pluginName", "logger", "__args", "__hooks"].map(function(item) {
+        _this5[item] = null;
+      });
+      player.unRegisterPlugin(pluginName);
+      delHooksDescriptor(this);
+    }
+  }], [{
+    key: "defineGetterOrSetter",
+    value: function defineGetterOrSetter(Obj, map) {
+      for (var key in map) {
+        if (Object.prototype.hasOwnProperty.call(map, key)) {
+          Object.defineProperty(Obj, key, map[key]);
+        }
+      }
+    }
+  }, {
+    key: "defaultConfig",
+    get: function get() {
+      return {};
+    }
+  }, {
+    key: "pluginName",
+    get: function get() {
+      return "pluginName";
+    }
+  }]);
+  return BasePlugin2;
+}();
+var KeySystem = /* @__PURE__ */ ((KeySystem2) => {
+  KeySystem2["widevine"] = "com.widevine.alpha";
+  KeySystem2["fairplay"] = "com.apple.fps.1_0";
+  KeySystem2["playready"] = "com.microsoft.playready";
+  return KeySystem2;
+})(KeySystem || {});
+function selectKeySystem() {
+  const options = [
+    {
+      initDataTypes: ["keyids", "webm"],
+      audioCapabilities: [{ contentType: 'audio/mp4; codecs="mp4a.40.2"' }],
+      videoCapabilities: [
+        { contentType: 'video/mp4; codecs="avc1.42c01e"' },
+        { contentType: 'video/mp4; codecs="hev1.1.6.L120.90"' },
+        { contentType: 'video/webm; codecs="vp8"' }
+      ]
+    }
+  ];
+  return new Promise((resolve, reject) => {
+    navigator.requestMediaKeySystemAccess(KeySystem.fairplay, options).then((access) => {
+      resolve({
+        access,
+        system: KeySystem.fairplay
+      });
+    }).catch(() => {
+      if (globalThis.WebKitMediaKeys && globalThis.WebKitMediaKeys.isTypeSupported(
+        KeySystem.fairplay,
+        "video/mp4"
+      )) {
+        resolve({
+          access: null,
+          system: KeySystem.fairplay
+        });
+        return;
+      }
+      navigator.requestMediaKeySystemAccess(KeySystem.widevine, options).then((access) => {
+        resolve({
+          access,
+          system: KeySystem.widevine
+        });
+      }).catch(() => {
+        navigator.requestMediaKeySystemAccess(KeySystem.playready, options).then((access) => {
+          resolve({
+            access,
+            system: KeySystem.playready
+          });
+        }).catch(reject);
+      });
+    });
+  });
+}
+function arrayToString(array) {
+  var uint16array = new Uint16Array(array.buffer);
+  return String.fromCharCode.apply(null, uint16array);
+}
+function stringToArray(string) {
+  var buffer = new ArrayBuffer(string.length * 2);
+  var array = new Uint16Array(buffer);
+  for (var i = 0, strLen = string.length; i < strLen; i++) {
+    array[i] = string.charCodeAt(i);
+  }
+  return array;
+}
+class Mobile extends BasePlugin {
+  constructor(options) {
+    super(options);
+    this.unsupported = false;
+    this.unRecord = true;
+    this.needKeyed = false;
+    this.onNeedKey = (event) => {
+      if (this.needKeyed)
+        return;
+      if (this.unsupported)
+        return;
+      this.needKeyed = true;
+      event.target;
+      let initData = event.initData;
+      const initDataType = event.initDataType;
+      const contentId = this.extractContentId(initData);
+      if (this.keySystem === KeySystem.fairplay && !this.certificate) {
+        return this.suspend = () => {
+          this.afterInitDate(initData, contentId, initDataType);
+        };
+      }
+      this.afterInitDate(initData, contentId, initDataType);
+    };
+    this.licenseRequestReady = (event) => {
+      if (!this.serverProcessSPCPath) {
+        this.emitError("lack serverProcessSPCPath");
+        return;
+      }
+      const message = event.message;
+      const request = new XMLHttpRequest();
+      request.responseType = "arraybuffer";
+      request.addEventListener("load", this.licenseRequestLoaded, false);
+      request.addEventListener("error", this.licenseRequestFailed(event), false);
+      var params = new Uint8Array(message);
+      request.open("POST", this.serverProcessSPCPath, true);
+      if (this.keySystem === KeySystem.playready) {
+        request.setRequestHeader("Content-type", "text/xml");
+      } else {
+        request.setRequestHeader("Content-type", "application/octet-stream");
+      }
+      request.send(params);
+    };
+    this.licenseRequestLoaded = (event) => {
+      const request = event.target;
+      const arrayBuffer = request.response;
+      let license;
+      if (this.keySystem === KeySystem.playready) {
+        license = this.parseServerResponse(arrayBuffer);
+      } else {
+        license = new Uint8Array(arrayBuffer);
+      }
+      if (license) {
+        this.keySession.update(license);
+      } else {
+        this.emitError(
+          `The license response no array buffer, licence: ${license}`
+        );
+      }
+    };
+    this.licenseRequestFailed = (event1) => (event) => {
+      if (this.licenseRetryTime > 0) {
+        this.licenseRequestReady(event1);
+        this.licenseRetryTime--;
+      } else {
+        const request = event.target;
+        this.emitError(
+          `The license request fail, status: ${request.status}, statusText: ${request.statusText}`
+        );
+      }
+    };
+    this.onKeyError = () => {
+      this.emitError("A decryption key error was encountered");
+    };
+    this.loadCertificate = () => {
+      if (!this.serverCertificatePath) {
+        this.emitError("lack serverCertificatePath");
+        return;
+      }
+      const request = new XMLHttpRequest();
+      request.responseType = "arraybuffer";
+      request.addEventListener("load", this.onCertificateLoaded, false);
+      request.addEventListener("error", this.onCertificateError, false);
+      request.open("GET", this.serverCertificatePath, true);
+      request.send();
+    };
+    this.emitError = (message) => {
+      this.emit("error", {
+        errorCode: 7100,
+        message,
+        drm_sdk_version: "0.0.0-alpha.5"
+      });
+    };
+    this.onCertificateLoaded = (event) => {
+      const request = event.target;
+      this.certificate = new Uint8Array(request.response);
+      this.suspend && this.suspend();
+    };
+    this.onCertificateError = (event) => {
+      if (this.certRetryTime > 0) {
+        this.loadCertificate();
+        this.certRetryTime--;
+      } else {
+        const request = event.target;
+        this.emitError(
+          `get cert fail, status: ${request.status}, statusText: ${request.statusText}`
+        );
+      }
+    };
+    this.restart = () => {
+      this.reset();
+    };
+    this.reset();
+    const config = options.config || {};
+    this.serverCertificatePath = config.serverCertificatePath;
+    this.serverProcessSPCPath = config.serverProcessSPCPath;
+    if (typeof config.unRecord === "boolean") {
+      this.unRecord = config.unRecord;
+    }
+    this.checkUnrecord();
+  }
+  static get pluginName() {
+    return "drm";
+  }
+  set serverCertificatePath(x) {
+    if (!x || this._serverCertificatePath === x)
+      return;
+    this._serverCertificatePath = x;
+    if (this.keySystem === KeySystem.fairplay) {
+      this.certificate = void 0;
+      this.suspend = () => {
+      };
+      this.loadCertificate();
+    }
+  }
+  get serverCertificatePath() {
+    return this._serverCertificatePath;
+  }
+  afterCreate() {
+    this.media = this.player.video;
+    this.media.addEventListener("webkitneedkey", this.onNeedKey, false);
+    this.media.addEventListener("needkey", this.onNeedKey, false);
+    this.media.addEventListener("encrypted", this.onNeedKey);
+    this.player.on("urlchange", this.restart);
+  }
+  async checkUnrecord() {
+    if (this.unRecord) {
+      try {
+        const { powerEfficient } = await navigator.mediaCapabilities.decodingInfo({
+          type: "file",
+          video: {
+            contentType: 'video/mp4; codecs="avc1.42c01e"',
+            width: 426,
+            height: 238,
+            bitrate: 1e3,
+            framerate: 30
+          }
+        });
+        this.unsupported = !powerEfficient;
+      } catch (error) {
+        this.emitError(`check powerEfficient failed, ${error.message}`);
+        this.unsupported = true;
+      }
+    }
+    if (this.unsupported)
+      return;
+    selectKeySystem().then(({ access, system }) => {
+      this.keySystem = system;
+      if (system === KeySystem.fairplay) {
+        this.loadCertificate();
+      }
+      if (access) {
+        this.keySystemAccess = access;
+      }
+    }).catch((error) => {
+      this.emitError(error.message);
+      this.unsupported = true;
+    });
+  }
+  afterInitDate(initData, contentId, initDataType) {
+    if (!this.keySystemAccess) {
+      const mediaKeys = new globalThis.WebKitMediaKeys(this.keySystem);
+      this.media.webkitSetMediaKeys(mediaKeys);
+      if (!this.media.webkitKeys) {
+        this.emitError("Could not create MediaKeys");
+        return;
+      }
+      const keySession = mediaKeys.createSession(
+        "video/mp4",
+        this.concatInitDataIdAndCertificate(initData, contentId)
+      );
+      this.keySession = keySession;
+      if (!keySession) {
+        this.emitError("Could not create key session");
+        return;
+      }
+      keySession.addEventListener("webkitkeymessage", this.licenseRequestReady);
+      keySession.addEventListener("webkitkeyerror", this.onKeyError);
+    } else {
+      this.keySystemAccess.createMediaKeys().then((mediaKeys) => {
+        this.media.setMediaKeys(mediaKeys);
+        if (this.media.mediaKeys) {
+          this.emitError("Could not create MediaKeys");
+          return;
+        }
+        const keySession = mediaKeys.createSession();
+        this.keySession = keySession;
+        if (!keySession) {
+          this.emitError("Could not create key session");
+          return;
+        }
+        keySession.addEventListener("message", this.licenseRequestReady);
+        keySession.generateRequest(initDataType, initData).catch((error) => {
+          this.emitError(
+            `generateRequest failed, code: ${error.errorCode}, message: ${error.message}`
+          );
+        });
+      }).catch(() => {
+        throw "Could not create MediaKeys";
+      });
+    }
+  }
+  parseServerResponse(serverResponse) {
+    const soap = "http://schemas.xmlsoap.org/soap/envelope/";
+    if (DOMParser) {
+      const stringResponse = this.uintToString(serverResponse);
+      const parser = new DOMParser();
+      const xmlDoc = parser.parseFromString(stringResponse, "text/xml");
+      const envelope = xmlDoc ? xmlDoc.getElementsByTagNameNS(soap, "Envelope")[0] : null;
+      const body = envelope ? envelope.getElementsByTagNameNS(soap, "Body")[0] : null;
+      const fault = body ? body.getElementsByTagNameNS(soap, "Fault")[0] : null;
+      if (fault) {
+        return null;
+      }
+    }
+    return serverResponse;
+  }
+  uintToString(arrayBuffer) {
+    const encodedString = String.fromCharCode.apply(
+      null,
+      new Uint8Array(arrayBuffer)
+    );
+    const decodedString = decodeURIComponent(escape(encodedString));
+    return decodedString;
+  }
+  extractContentId(initData) {
+    const contentId = arrayToString(initData);
+    var link = document.createElement("a");
+    link.href = contentId;
+    return link.hostname;
+  }
+  concatInitDataIdAndCertificate(initData, id) {
+    if (typeof id == "string")
+      id = stringToArray(id);
+    let offset = 0;
+    let buffer;
+    const cert = this.certificate;
+    if (cert) {
+      buffer = new ArrayBuffer(
+        initData.byteLength + 4 + id.byteLength + 4 + cert.byteLength
+      );
+    } else {
+      buffer = new ArrayBuffer(initData.byteLength + 4 + id.byteLength);
+    }
+    var dataView = new DataView(buffer);
+    var initDataArray = new Uint8Array(buffer, offset, initData.byteLength);
+    initDataArray.set(initData);
+    offset += initData.byteLength;
+    dataView.setUint32(offset, id.byteLength, true);
+    offset += 4;
+    var idArray = new Uint16Array(buffer, offset, id.length);
+    idArray.set(id);
+    offset += idArray.byteLength;
+    if (cert) {
+      dataView.setUint32(offset, cert.byteLength, true);
+      offset += 4;
+      var certArray = new Uint8Array(buffer, offset, cert.byteLength);
+      certArray.set(cert);
+    }
+    return new Uint8Array(buffer, 0, buffer.byteLength);
+  }
+  reset() {
+    this.certRetryTime = 2;
+    this.licenseRetryTime = 2;
+    this.suspend = void 0;
+    this.keySession = void 0;
+    this.needKeyed = false;
+  }
+  destroy() {
+    this.player.off("urlchange", this.restart);
+  }
+}
+class DrmPlugin extends Mobile {
+  updateDrmConfig(data) {
+    data.serverProcessSPCPath && (this.serverProcessSPCPath = data.serverProcessSPCPath);
+    data.serverCertificatePath && (this.serverCertificatePath = data.serverCertificatePath);
+  }
+}
+const DynamicModule = window["VePlayer"].DynamicModule;
+const __PLUGIN_NAME__ = DynamicModule.PluginDrm;
+export {
+  DrmPlugin,
+  __PLUGIN_NAME__
+};