@xiping/react-components 1.0.43 → 1.0.49

package/dist/es/node_modules/.pnpm/xgplayer@3.0.23_core-js@3.47.0/node_modules/xgplayer/es/plugins/fullscreen/backicon.js

@@ -0,0 +1,68 @@
+import { inherits as a, createSuper as c, classCallCheck as u, createClass as l } from "../../_virtual/_rollupPluginBabelHelpers.js";
+import o from "../../utils/util.js";
+import h, { POSITIONS as f } from "../../plugin/plugin.js";
+import k from "../assets/back.js";
+var v = /* @__PURE__ */ (function(r) {
+  a(t, r);
+  var s = c(t);
+  function t() {
+    return u(this, t), s.apply(this, arguments);
+  }
+  return l(t, [{
+    key: "afterCreate",
+    value: function() {
+      var n = this;
+      this.initIcons(), this.onClick = function(i) {
+        i.preventDefault(), i.stopPropagation(), n.config.onClick(i);
+      }, this.bind(["click", "touchend"], this.onClick);
+    }
+  }, {
+    key: "registerIcons",
+    value: function() {
+      return {
+        screenBack: {
+          icon: k,
+          class: "xg-fullscreen-back"
+        }
+      };
+    }
+  }, {
+    key: "initIcons",
+    value: function() {
+      var n = this.icons;
+      this.appendChild(this.root, n.screenBack);
+    }
+  }, {
+    key: "show",
+    value: function() {
+      o.addClass(this.root, "show");
+    }
+  }, {
+    key: "hide",
+    value: function() {
+      o.removeClass(this.root, "show");
+    }
+  }, {
+    key: "render",
+    value: function() {
+      return `<xg-icon class="xgplayer-back">
+    </xg-icon>`;
+    }
+  }], [{
+    key: "pluginName",
+    get: function() {
+      return "topbackicon";
+    }
+  }, {
+    key: "defaultConfig",
+    get: function() {
+      return {
+        position: f.ROOT_TOP,
+        index: 0
+      };
+    }
+  }]), t;
+})(h);
+export {
+  v as default
+};

package/dist/es/node_modules/.pnpm/xgplayer@3.0.23_core-js@3.47.0/node_modules/xgplayer/es/plugins/fullscreen/index.js

@@ -0,0 +1,150 @@
+import { inherits as p, createSuper as d, classCallCheck as y, defineProperty as C, assertThisInitialized as k, createClass as m, get as f, getPrototypeOf as h } from "../../_virtual/_rollupPluginBabelHelpers.js";
+import v from "../../utils/util.js";
+import a from "../../utils/sniffer.js";
+import { FULLSCREEN_CHANGE as F } from "../../events.js";
+import { POSITIONS as S } from "../../plugin/plugin.js";
+import { xgIconTips as I } from "../common/iconTools.js";
+import x from "../common/iconPlugin.js";
+import T from "./backicon.js";
+import w from "../assets/requestFull.js";
+import E from "../assets/exitFull.js";
+var D = /* @__PURE__ */ (function(g) {
+  p(l, g);
+  var o = d(l);
+  function l() {
+    var n;
+    y(this, l);
+    for (var e = arguments.length, t = new Array(e), i = 0; i < e; i++)
+      t[i] = arguments[i];
+    return n = o.call.apply(o, [this].concat(t)), C(k(n), "_onOrientationChange", function(c) {
+      n.player.fullscreen && n.config.rotateFullscreen && (window.orientation === 90 || window.orientation === -90 ? n.player.setRotateDeg(0) : n.player.setRotateDeg(90));
+    }), n;
+  }
+  return m(l, [{
+    key: "afterCreate",
+    value: function() {
+      var e = this;
+      f(h(l.prototype), "afterCreate", this).call(this);
+      var t = this.config, i = this.playerConfig;
+      if (!t.disable) {
+        t.target && (this.playerConfig.fullscreenTarget = this.config.target);
+        var c = v.getFullScreenEl();
+        i.fullscreenTarget === c && this.player.getFullscreen().catch(function(r) {
+        }), this.initIcons(), this.handleFullscreen = this.hook("fullscreenChange", this.toggleFullScreen, {
+          pre: function(s) {
+            var u = e.player.fullscreen;
+            e.emitUserAction(s, "switch_fullscreen", {
+              prop: "fullscreen",
+              from: u,
+              to: !u
+            });
+          }
+        }), this.bind(".xgplayer-fullscreen", ["touchend", "click"], this.handleFullscreen), this.on(F, function(r) {
+          var s = e.find(".xg-tips");
+          s && e.changeLangTextKey(s, r ? e.i18nKeys.EXITFULLSCREEN_TIPS : e.i18nKeys.FULLSCREEN_TIPS), e.animate(r);
+        }), this.config.needBackIcon && (this.topBackIcon = this.player.registerPlugin({
+          plugin: T,
+          options: {
+            config: {
+              onClick: function(s) {
+                e.handleFullscreen(s);
+              }
+            }
+          }
+        })), a.device === "mobile" && window.addEventListener("orientationchange", this._onOrientationChange);
+      }
+    }
+  }, {
+    key: "registerIcons",
+    value: function() {
+      return {
+        fullscreen: {
+          icon: w,
+          class: "xg-get-fullscreen"
+        },
+        exitFullscreen: {
+          icon: E,
+          class: "xg-exit-fullscreen"
+        }
+      };
+    }
+  }, {
+    key: "destroy",
+    value: function() {
+      f(h(l.prototype), "destroy", this).call(this), this.unbind(".xgplayer-icon", a.device === "mobile" ? "touchend" : "click", this.handleFullscreen), a.device === "mobile" && window.removeEventListener("orientationchange", this._onOrientationChange);
+    }
+  }, {
+    key: "initIcons",
+    value: function() {
+      var e = this.icons;
+      this.appendChild(".xgplayer-icon", e.fullscreen), this.appendChild(".xgplayer-icon", e.exitFullscreen);
+    }
+  }, {
+    key: "toggleFullScreen",
+    value: function(e) {
+      e instanceof Event && (e.preventDefault(), e.stopPropagation());
+      var t = this.player, i = this.config, c = i.useCssFullscreen === !0 || typeof i.useCssFullscreen == "function" && i.useCssFullscreen();
+      c ? (t.fullscreen ? t.exitCssFullscreen() : t.getCssFullscreen(), this.animate(t.fullscreen)) : i.rotateFullscreen ? (t.fullscreen ? t.exitRotateFullscreen() : t.getRotateFullscreen(), this.animate(t.fullscreen)) : i.switchCallback && typeof i.switchCallback == "function" ? i.switchCallback(t.fullscreen) : t.fullscreen ? (t.exitFullscreen(), i.useScreenOrientation && this.unlockScreen()) : (t.getFullscreen().catch(function(r) {
+      }), i.useScreenOrientation && t.aspectRatio > 1 && this.lockScreen(i.lockOrientationType));
+    }
+  }, {
+    key: "animate",
+    value: function(e) {
+      e ? this.setAttr("data-state", "full") : this.setAttr("data-state", "normal"), this.topBackIcon && (e ? (this.topBackIcon.show(), this.hide()) : (this.topBackIcon.hide(), this.show()));
+    }
+  }, {
+    key: "render",
+    value: function() {
+      if (!this.config.disable) {
+        var e = "FULLSCREEN_TIPS";
+        return `<xg-icon class="xgplayer-fullscreen">
+    <div class="xgplayer-icon">
+    </div>
+    `.concat(I(this, e, this.playerConfig.isHideTips), `
+    </xg-icon>`);
+      }
+    }
+  }, {
+    key: "lockScreen",
+    value: function(e) {
+      try {
+        screen.orientation.lock(e).catch(function(t) {
+        });
+      } catch {
+      }
+    }
+  }, {
+    key: "unlockScreen",
+    value: function() {
+      try {
+        screen.orientation.unlock().catch(function(e) {
+        });
+      } catch {
+      }
+    }
+  }], [{
+    key: "pluginName",
+    get: function() {
+      return "fullscreen";
+    }
+  }, {
+    key: "defaultConfig",
+    get: function() {
+      return {
+        position: S.CONTROLS_RIGHT,
+        index: 0,
+        useCssFullscreen: !1,
+        rotateFullscreen: !1,
+        useScreenOrientation: !1,
+        lockOrientationType: "landscape",
+        switchCallback: null,
+        target: null,
+        disable: !1,
+        needBackIcon: !1
+      };
+    }
+  }]), l;
+})(x);
+export {
+  D as default
+};

package/dist/es/node_modules/.pnpm/xgplayer@3.0.23_core-js@3.47.0/node_modules/xgplayer/es/plugins/gapJump/index.js

@@ -0,0 +1,96 @@
+import { inherits as _, createSuper as y, classCallCheck as E, defineProperty as S, assertThisInitialized as c, createClass as k } from "../../_virtual/_rollupPluginBabelHelpers.js";
+import { WAITING as C, PLAY as I, SEEKING as P } from "../../events.js";
+import J from "../../plugin/plugin.js";
+var R = /* @__PURE__ */ (function(v) {
+  _(s, v);
+  var m = y(s);
+  function s() {
+    var a;
+    E(this, s);
+    for (var e = arguments.length, i = new Array(e), r = 0; r < e; r++)
+      i[r] = arguments[r];
+    return a = m.call.apply(m, [this].concat(i)), S(c(a), "onGapJump", function() {
+      var u = c(a), t = u.player, n = u.config;
+      if (t.media.readyState !== HTMLMediaElement.HAVE_NOTHING) {
+        if (t.media.seeking) {
+          if (!a.seekingEventReceived)
+            return;
+        } else
+          a.seekingEventReceived = !1;
+        if (!(t.media.paused && t.media.currentTime !== 0 && a.hasPlayed)) {
+          var l = t.media.buffered, h = n.smallGapLimit || 0.5, G = n.gapDetectionThreshold || 0.3, p = t.media.currentTime, o = a._getIndex(l, p, G);
+          if (!(o === null || o === 0)) {
+            console.log("GapJump  bufferRange ", l.start(o), l.end(o));
+            var f = l.start(o) + 0.1, T = t.media.duration;
+            if (!(f > T)) {
+              var d = f - p, g = d <= h;
+              d < s.BROWSER_GAP_TOLERANCE || g && (n.useGapJump !== !1 && (t.media.currentTime = a.isSafari ? f + 0.1 : f), a.player && a.player.emit("detectGap"), console.log("gapJump gapIndex", o, " isGapSamll:", g, " currentTime:", t.media.currentTime, " jumpSize:", p - t.media.currentTime), f !== 0.08 && t && t.emit("log", {
+                type: "oneevent",
+                end_type: "gap",
+                vid: t.config.vid,
+                ext: {
+                  video_postion: Math.floor(f * 1e3)
+                }
+              }));
+            }
+          }
+        }
+      }
+    }), a;
+  }
+  return k(s, [{
+    key: "afterCreate",
+    value: function() {
+      var e = this, i = this.config.useGapJump;
+      i !== !1 && (this.hasPlayed = !1, this.seekingEventReceived = !1, this.isSafari = /(Safari|iPhone|iPad|iPod)/.test(navigator.userAgent) && !/Chrome/.test(navigator.userAgent) && !/BlackBerry/.test(navigator.platform), this.on(C, this.onGapJump), this.on(I, function() {
+        e.hasPlayed = !0;
+      }), this.on(P, function() {
+        e.seekingEventReceived = !0;
+      }));
+    }
+  }, {
+    key: "_getIndex",
+    value: function(e, i, r) {
+      if (!e || !e.length || e.length === 1 && e.end(0) - e.start(0) < 1e-6)
+        return null;
+      for (var u = this._getBuffered(e), t = null, n = 0; n < u.length; n++) {
+        var l = u[n];
+        if (l.start > i && (n === 0 || u[n - 1].end - i <= r)) {
+          t = n;
+          break;
+        }
+      }
+      return t;
+    }
+  }, {
+    key: "_getBuffered",
+    value: function(e) {
+      if (!e)
+        return [];
+      for (var i = [], r = 0; r < e.length; r++)
+        i.push({
+          start: e.start(r),
+          end: e.end(r)
+        });
+      return i;
+    }
+  }], [{
+    key: "pluginName",
+    get: function() {
+      return "gapJump";
+    }
+  }, {
+    key: "defaultConfig",
+    get: function() {
+      return {
+        useGapJump: !1,
+        smallGapLimit: 0.5,
+        gapDetectionThreshold: 0.3
+      };
+    }
+  }]), s;
+})(J);
+R.BROWSER_GAP_TOLERANCE = 1e-3;
+export {
+  R as default
+};

package/dist/es/node_modules/.pnpm/xgplayer@3.0.23_core-js@3.47.0/node_modules/xgplayer/es/plugins/keyboard/index.js

@@ -0,0 +1,299 @@
+import { inherits as C, createSuper as K, classCallCheck as w, defineProperty as v, assertThisInitialized as d, createClass as T, objectSpread2 as S } from "../../_virtual/_rollupPluginBabelHelpers.js";
+import m from "../../utils/util.js";
+import { SHORTCUT as _ } from "../../events.js";
+import B from "../../plugin/basePlugin.js";
+import "../../../../../../../../_virtual/delegate.js";
+function D(c) {
+  c.preventDefault(), c.returnValue = !1;
+}
+function g(c) {
+  var h = c.tagName;
+  return !!(h === "INPUT" || h === "TEXTAREA" || c.isContentEditable);
+}
+var M = /* @__PURE__ */ (function(c) {
+  C(k, c);
+  var h = K(k);
+  function k() {
+    var t;
+    w(this, k);
+    for (var i = arguments.length, e = new Array(i), a = 0; a < i; a++)
+      e[a] = arguments[a];
+    return t = h.call.apply(h, [this].concat(e)), v(d(t), "onBodyKeyDown", function(r) {
+      if (t.player) {
+        var s = r || window.event, n = s.keyCode, l = d(t), o = l._keyState, y = l.player, u = t.config, p = u.disable, f = u.disableBodyTrigger, b = u.isIgnoreUserActive;
+        if (p || f || !(y.isUserActive || b) || g(s.target) || !t.checkIsVisible() || s.metaKey || s.altKey || s.ctrlKey) {
+          o.isBodyKeyDown = !1;
+          return;
+        }
+        !r.repeat && !o.isKeyDown && ((s.target === document.body || t.config.isGlobalTrigger && !g(s.target)) && t.checkCode(n, !0) && (o.isBodyKeyDown = !0), document.addEventListener("keyup", t.onBodyKeyUp)), o.isBodyKeyDown && t.handleKeyDown(s);
+      }
+    }), v(d(t), "onBodyKeyUp", function(r) {
+      t.player && (document.removeEventListener("keyup", t.onBodyKeyUp), t.handleKeyUp(r));
+    }), v(d(t), "onKeydown", function(r) {
+      if (t.player) {
+        var s = r || window.event, n = d(t), l = n._keyState;
+        if (!s.repeat) {
+          if (t.config.disable || t.config.disableRootTrigger || s.metaKey || s.altKey || s.ctrlKey)
+            return;
+          s && (s.keyCode === 37 || t.checkCode(s.keyCode)) && (s.target === t.player.root || s.target === t.player.video || s.target === t.player.controls.el) && (l.isKeyDown = !0), t.player.root.addEventListener("keyup", t.onKeyup);
+        }
+        l.isKeyDown && t.handleKeyDown(s);
+      }
+    }), v(d(t), "onKeyup", function(r) {
+      t.player && (t.player.root.removeEventListener("keyup", t.onKeyup), t.handleKeyUp(r));
+    }), t;
+  }
+  return T(k, [{
+    key: "mergekeyCodeMap",
+    value: function() {
+      var i = this, e = this.config.keyCodeMap;
+      e && Object.keys(e).map(function(a) {
+        i.keyCodeMap[a] ? ["keyCode", "action", "disable", "pressAction", "disablePress", "isBodyTarget"].map(function(r) {
+          e[a][r] && (i.keyCodeMap[a][r] = e[a][r]);
+        }) : i.keyCodeMap[a] = e[a];
+      });
+    }
+  }, {
+    key: "afterCreate",
+    value: function() {
+      this.config.disable = !this.playerConfig.keyShortcut;
+      var i = typeof this.config.seekStep == "function" ? this.config.seekStep(this.player) : this.config.seekStep;
+      !i || typeof i != "number" || (this.seekStep = i), this.keyCodeMap = {
+        space: {
+          keyCode: 32,
+          action: "playPause",
+          disable: !1,
+          disablePress: !1,
+          noBodyTarget: !1
+        },
+        up: {
+          keyCode: 38,
+          action: "upVolume",
+          disable: !1,
+          disablePress: !1,
+          noBodyTarget: !0
+        },
+        down: {
+          keyCode: 40,
+          action: "downVolume",
+          disable: !1,
+          disablePress: !1,
+          noBodyTarget: !0
+        },
+        left: {
+          keyCode: 37,
+          action: "seekBack",
+          disablePress: !1,
+          disable: !1
+        },
+        right: {
+          keyCode: 39,
+          action: "seek",
+          pressAction: "changePlaybackRate",
+          disablePress: !1,
+          disable: !1
+        },
+        esc: {
+          keyCode: 27,
+          action: "exitFullscreen",
+          disablePress: !0,
+          disable: !1
+        }
+      }, this.mergekeyCodeMap(), this._keyState = {
+        isKeyDown: !1,
+        isBodyKeyDown: !1,
+        isPress: !1,
+        tt: 0,
+        playbackRate: 0
+      }, this.player.root.addEventListener("keydown", this.onKeydown), document.addEventListener("keydown", this.onBodyKeyDown);
+    }
+  }, {
+    key: "setConfig",
+    value: function(i) {
+      var e = this;
+      Object.keys(i).forEach(function(a) {
+        e.config[a] = i[a];
+      });
+    }
+  }, {
+    key: "checkIsVisible",
+    value: function() {
+      if (!this.config.checkVisible)
+        return !0;
+      var i = this.player.root.getBoundingClientRect(), e = i.height, a = i.top, r = i.bottom, s = window.innerHeight;
+      return !(a < 0 && a < 0 - e * 0.9 || r > 0 && r - s > e * 0.9);
+    }
+  }, {
+    key: "checkCode",
+    value: function(i, e) {
+      var a = this, r = !1;
+      return Object.keys(this.keyCodeMap).map(function(s) {
+        a.keyCodeMap[s] && i === a.keyCodeMap[s].keyCode && !a.keyCodeMap[s].disable && (r = !e || e && !a.keyCodeMap[s].noBodyTarget);
+      }), r;
+    }
+  }, {
+    key: "downVolume",
+    value: function(i) {
+      var e = this.player;
+      if (!(e.volume <= 0)) {
+        var a = parseFloat((e.volume - 0.1).toFixed(1)), r = {
+          volume: {
+            from: e.volume,
+            to: a
+          }
+        };
+        this.emitUserAction(i, "change_volume", {
+          props: r
+        }), a >= 0 ? e.volume = a : e.volume = 0;
+      }
+    }
+  }, {
+    key: "upVolume",
+    value: function(i) {
+      var e = this.player;
+      if (!(e.volume >= 1)) {
+        var a = parseFloat((e.volume + 0.1).toFixed(1)), r = {
+          volume: {
+            from: e.volume,
+            to: a
+          }
+        };
+        this.emitUserAction(i, "change_volume", {
+          props: r
+        }), a <= 1 ? e.volume = a : e.volume = 1;
+      }
+    }
+  }, {
+    key: "seek",
+    value: function(i) {
+      var e = this.player, a = e.currentTime, r = e.offsetCurrentTime, s = e.duration, n = e.offsetDuration, l = e.timeSegments, o = r > -1 ? r : a, y = n || s, u = i.repeat && this.seekStep >= 4 ? parseInt(this.seekStep / 2, 10) : this.seekStep;
+      o + u <= y ? o = o + u : o = y;
+      var p = m.getCurrentTimeByOffset(o, l), f = {
+        currentTime: {
+          from: a,
+          to: p
+        }
+      };
+      this.emitUserAction(i, "seek", {
+        props: f
+      }), this.player.currentTime = p;
+    }
+  }, {
+    key: "seekBack",
+    value: function(i) {
+      var e = this.player, a = e.currentTime, r = e.offsetCurrentTime, s = e.timeSegments, n = i.repeat ? parseInt(this.seekStep / 2, 10) : this.seekStep, l = r > -1 ? r : a, o = l - n;
+      o < 0 && (o = 0), o = m.getCurrentTimeByOffset(o, s);
+      var y = {
+        currentTime: {
+          from: a,
+          to: o
+        }
+      };
+      this.emitUserAction(i, "seek", {
+        props: y
+      }), this.player.currentTime = o;
+    }
+  }, {
+    key: "changePlaybackRate",
+    value: function(i) {
+      var e = this._keyState, a = this.config, r = this.player;
+      e.playbackRate === 0 && (e.playbackRate = r.playbackRate, r.playbackRate = a.playbackRate);
+    }
+  }, {
+    key: "playPause",
+    value: function(i) {
+      var e = this.player;
+      e && (this.emitUserAction(i, "switch_play_pause"), e.paused ? e.play() : e.pause());
+    }
+  }, {
+    key: "exitFullscreen",
+    value: function(i) {
+      var e = this.player, a = e.fullscreen, r = e.cssfullscreen;
+      a && (this.emitUserAction("keyup", "switch_fullscreen", {
+        prop: "fullscreen",
+        from: a,
+        to: !a
+      }), e.exitFullscreen()), r && (this.emitUserAction("keyup", "switch_css_fullscreen", {
+        prop: "cssfullscreen",
+        from: r,
+        to: !r
+      }), e.exitCssFullscreen());
+    }
+  }, {
+    key: "handleKeyDown",
+    value: function(i) {
+      var e = this._keyState;
+      if (i.repeat) {
+        e.isPress = !0;
+        var a = Date.now();
+        if (a - e.tt < 200)
+          return;
+        e.tt = a;
+      }
+      this.handleKeyCode(i.keyCode, i, e.isPress);
+    }
+  }, {
+    key: "handleKeyUp",
+    value: function(i) {
+      var e = this._keyState;
+      e.playbackRate > 0 && (this.player.playbackRate = e.playbackRate, e.playbackRate = 0), e.isKeyDown = !1, e.isPress = !1, e.tt = 0;
+    }
+  }, {
+    key: "handleKeyCode",
+    value: function(i, e, a) {
+      for (var r = Object.keys(this.keyCodeMap), s = 0; s < r.length; s++) {
+        var n = this.keyCodeMap[r[s]], l = n.action, o = n.keyCode, y = n.disable, u = n.pressAction, p = n.disablePress;
+        if (o === i) {
+          if (!y && !(a && p)) {
+            var f = a && u || l;
+            typeof f == "function" ? l(e, this.player, a) : typeof f == "string" && typeof this[f] == "function" && this[f](e, this.player, a), this.emit(_, S({
+              key: r[s],
+              target: e.target,
+              isPress: a
+            }, this.keyCodeMap[r[s]]));
+          }
+          D(e), e.stopPropagation();
+          break;
+        }
+      }
+    }
+  }, {
+    key: "destroy",
+    value: function() {
+      this.player.root.removeEventListener("keydown", this.onKeydown), document.removeEventListener("keydown", this.onBodyKeyDown), this.player.root.removeEventListener("keyup", this.onKeyup), document.removeEventListener("keyup", this.onBodyKeyUp);
+    }
+  }, {
+    key: "disable",
+    value: function() {
+      this.config.disable = !0;
+    }
+  }, {
+    key: "enable",
+    value: function() {
+      this.config.disable = !1;
+    }
+  }], [{
+    key: "pluginName",
+    get: function() {
+      return "keyboard";
+    }
+  }, {
+    key: "defaultConfig",
+    get: function() {
+      return {
+        seekStep: 10,
+        checkVisible: !1,
+        disableBodyTrigger: !1,
+        disableRootTrigger: !1,
+        isGlobalTrigger: !0,
+        keyCodeMap: {},
+        disable: !1,
+        playbackRate: 2,
+        isIgnoreUserActive: !0
+      };
+    }
+  }]), k;
+})(B);
+export {
+  M as default
+};

package/dist/es/node_modules/.pnpm/xgplayer@3.0.23_core-js@3.47.0/node_modules/xgplayer/es/plugins/loading/index.js

@@ -0,0 +1,46 @@
+import { inherits as i, createSuper as t, classCallCheck as o, createClass as s } from "../../_virtual/_rollupPluginBabelHelpers.js";
+import l, { POSITIONS as g } from "../../plugin/plugin.js";
+import u from "../assets/loading.js";
+var p = /* @__PURE__ */ (function(r) {
+  i(e, r);
+  var a = t(e);
+  function e() {
+    return o(this, e), a.apply(this, arguments);
+  }
+  return s(e, [{
+    key: "registerIcons",
+    value: function() {
+      return {
+        loadingIcon: u
+      };
+    }
+  }, {
+    key: "afterCreate",
+    value: function() {
+      this.appendChild("xg-loading-inner", this.icons.loadingIcon);
+    }
+  }, {
+    key: "render",
+    value: function() {
+      return `
+    <xg-loading class="xgplayer-loading">
+      <xg-loading-inner></xg-loading-inner>
+    </xg-loading>`;
+    }
+  }], [{
+    key: "pluginName",
+    get: function() {
+      return "loading";
+    }
+  }, {
+    key: "defaultConfig",
+    get: function() {
+      return {
+        position: g.ROOT
+      };
+    }
+  }]), e;
+})(l);
+export {
+  p as default
+};