mirror of
https://github.com/iv-org/invidious.git
synced 2025-06-28 01:28:30 +00:00
1550 lines
52 KiB
JavaScript
1550 lines
52 KiB
JavaScript
/*! @silvermine/videojs-quality-selector 2022-04-13 v1.1.2-43-gaa06e72-dirty */
|
|
|
|
!(function u(o, c, a) {
|
|
function l(e, n) {
|
|
if (!c[e]) {
|
|
if (!o[e]) {
|
|
var t = "function" == typeof require && require;
|
|
if (!n && t) return t(e, !0);
|
|
if (s) return s(e, !0);
|
|
var r = new Error("Cannot find module '" + e + "'");
|
|
throw ((r.code = "MODULE_NOT_FOUND"), r);
|
|
}
|
|
var i = (c[e] = { exports: {} });
|
|
o[e][0].call(
|
|
i.exports,
|
|
function (n) {
|
|
return l(o[e][1][n] || n);
|
|
},
|
|
i,
|
|
i.exports,
|
|
u,
|
|
o,
|
|
c,
|
|
a,
|
|
);
|
|
}
|
|
return c[e].exports;
|
|
}
|
|
for (
|
|
var s = "function" == typeof require && require, n = 0;
|
|
n < a.length;
|
|
n++
|
|
)
|
|
l(a[n]);
|
|
return l;
|
|
})(
|
|
{
|
|
1: [
|
|
function (n, e, t) {
|
|
!(function () {
|
|
var u = !1,
|
|
o = /xyz/.test(function () {
|
|
xyz;
|
|
})
|
|
? /\b_super\b/
|
|
: /.*/;
|
|
(this.Class = function () {}),
|
|
(Class.extend = function (n) {
|
|
var i = this.prototype;
|
|
u = !0;
|
|
var e = new this();
|
|
for (var t in ((u = !1), n))
|
|
e[t] =
|
|
"function" == typeof n[t] &&
|
|
"function" == typeof i[t] &&
|
|
o.test(n[t])
|
|
? (function (t, r) {
|
|
return function () {
|
|
var n = this._super;
|
|
this._super = i[t];
|
|
var e = r.apply(this, arguments);
|
|
return (this._super = n), e;
|
|
};
|
|
})(t, n[t])
|
|
: n[t];
|
|
function r() {
|
|
!u && this.init && this.init.apply(this, arguments);
|
|
}
|
|
return (
|
|
(((r.prototype = e).constructor = r).extend = arguments.callee),
|
|
r
|
|
);
|
|
}),
|
|
(e.exports = Class);
|
|
})();
|
|
},
|
|
{},
|
|
],
|
|
2: [
|
|
function (n, J, $) {
|
|
(function (V) {
|
|
!(function () {
|
|
function t() {}
|
|
var n =
|
|
("object" == typeof self && self.self === self && self) ||
|
|
("object" == typeof V && V.global === V && V) ||
|
|
this ||
|
|
{},
|
|
e = n._,
|
|
r = Array.prototype,
|
|
o = Object.prototype,
|
|
f = "undefined" != typeof Symbol ? Symbol.prototype : null,
|
|
i = r.push,
|
|
a = r.slice,
|
|
p = o.toString,
|
|
u = o.hasOwnProperty,
|
|
c = Array.isArray,
|
|
l = Object.keys,
|
|
s = Object.create,
|
|
h = function (n) {
|
|
return n instanceof h
|
|
? n
|
|
: this instanceof h
|
|
? void (this._wrapped = n)
|
|
: new h(n);
|
|
};
|
|
void 0 === $ || $.nodeType
|
|
? (n._ = h)
|
|
: (void 0 !== J &&
|
|
!J.nodeType &&
|
|
J.exports &&
|
|
($ = J.exports = h),
|
|
($._ = h)),
|
|
(h.VERSION = "1.9.1");
|
|
function d(i, u, n) {
|
|
if (void 0 === u) return i;
|
|
switch (null == n ? 3 : n) {
|
|
case 1:
|
|
return function (n) {
|
|
return i.call(u, n);
|
|
};
|
|
case 3:
|
|
return function (n, e, t) {
|
|
return i.call(u, n, e, t);
|
|
};
|
|
case 4:
|
|
return function (n, e, t, r) {
|
|
return i.call(u, n, e, t, r);
|
|
};
|
|
}
|
|
return function () {
|
|
return i.apply(u, arguments);
|
|
};
|
|
}
|
|
function y(n, e, t) {
|
|
return h.iteratee !== v
|
|
? h.iteratee(n, e)
|
|
: null == n
|
|
? h.identity
|
|
: h.isFunction(n)
|
|
? d(n, e, t)
|
|
: h.isObject(n) && !h.isArray(n)
|
|
? h.matcher(n)
|
|
: h.property(n);
|
|
}
|
|
var v;
|
|
h.iteratee = v = function (n, e) {
|
|
return y(n, e, 1 / 0);
|
|
};
|
|
function g(i, u) {
|
|
return (
|
|
(u = null == u ? i.length - 1 : +u),
|
|
function () {
|
|
for (
|
|
var n = Math.max(arguments.length - u, 0),
|
|
e = Array(n),
|
|
t = 0;
|
|
t < n;
|
|
t++
|
|
)
|
|
e[t] = arguments[t + u];
|
|
switch (u) {
|
|
case 0:
|
|
return i.call(this, e);
|
|
case 1:
|
|
return i.call(this, arguments[0], e);
|
|
case 2:
|
|
return i.call(this, arguments[0], arguments[1], e);
|
|
}
|
|
var r = Array(u + 1);
|
|
for (t = 0; t < u; t++) r[t] = arguments[t];
|
|
return (r[u] = e), i.apply(this, r);
|
|
}
|
|
);
|
|
}
|
|
function S(n) {
|
|
if (!h.isObject(n)) return {};
|
|
if (s) return s(n);
|
|
t.prototype = n;
|
|
var e = new t();
|
|
return (t.prototype = null), e;
|
|
}
|
|
function m(e) {
|
|
return function (n) {
|
|
return null == n ? void 0 : n[e];
|
|
};
|
|
}
|
|
function _(n, e) {
|
|
return null != n && u.call(n, e);
|
|
}
|
|
function b(n, e) {
|
|
for (var t = e.length, r = 0; r < t; r++) {
|
|
if (null == n) return;
|
|
n = n[e[r]];
|
|
}
|
|
return t ? n : void 0;
|
|
}
|
|
function x(n) {
|
|
var e = j(n);
|
|
return "number" == typeof e && 0 <= e && e <= k;
|
|
}
|
|
var k = Math.pow(2, 53) - 1,
|
|
j = m("length");
|
|
(h.each = h.forEach =
|
|
function (n, e, t) {
|
|
var r, i;
|
|
if (((e = d(e, t)), x(n)))
|
|
for (r = 0, i = n.length; r < i; r++) e(n[r], r, n);
|
|
else {
|
|
var u = h.keys(n);
|
|
for (r = 0, i = u.length; r < i; r++) e(n[u[r]], u[r], n);
|
|
}
|
|
return n;
|
|
}),
|
|
(h.map = h.collect =
|
|
function (n, e, t) {
|
|
e = y(e, t);
|
|
for (
|
|
var r = !x(n) && h.keys(n),
|
|
i = (r || n).length,
|
|
u = Array(i),
|
|
o = 0;
|
|
o < i;
|
|
o++
|
|
) {
|
|
var c = r ? r[o] : o;
|
|
u[o] = e(n[c], c, n);
|
|
}
|
|
return u;
|
|
});
|
|
function E(a) {
|
|
return function (n, e, t, r) {
|
|
var i = 3 <= arguments.length;
|
|
return (function (n, e, t, r) {
|
|
var i = !x(n) && h.keys(n),
|
|
u = (i || n).length,
|
|
o = 0 < a ? 0 : u - 1;
|
|
for (
|
|
r || ((t = n[i ? i[o] : o]), (o += a));
|
|
0 <= o && o < u;
|
|
o += a
|
|
) {
|
|
var c = i ? i[o] : o;
|
|
t = e(t, n[c], c, n);
|
|
}
|
|
return t;
|
|
})(n, d(e, r, 4), t, i);
|
|
};
|
|
}
|
|
(h.reduce = h.foldl = h.inject = E(1)),
|
|
(h.reduceRight = h.foldr = E(-1)),
|
|
(h.find = h.detect =
|
|
function (n, e, t) {
|
|
var r = (x(n) ? h.findIndex : h.findKey)(n, e, t);
|
|
if (void 0 !== r && -1 !== r) return n[r];
|
|
}),
|
|
(h.filter = h.select =
|
|
function (n, r, e) {
|
|
var i = [];
|
|
return (
|
|
(r = y(r, e)),
|
|
h.each(n, function (n, e, t) {
|
|
r(n, e, t) && i.push(n);
|
|
}),
|
|
i
|
|
);
|
|
}),
|
|
(h.reject = function (n, e, t) {
|
|
return h.filter(n, h.negate(y(e)), t);
|
|
}),
|
|
(h.every = h.all =
|
|
function (n, e, t) {
|
|
e = y(e, t);
|
|
for (
|
|
var r = !x(n) && h.keys(n), i = (r || n).length, u = 0;
|
|
u < i;
|
|
u++
|
|
) {
|
|
var o = r ? r[u] : u;
|
|
if (!e(n[o], o, n)) return !1;
|
|
}
|
|
return !0;
|
|
}),
|
|
(h.some = h.any =
|
|
function (n, e, t) {
|
|
e = y(e, t);
|
|
for (
|
|
var r = !x(n) && h.keys(n), i = (r || n).length, u = 0;
|
|
u < i;
|
|
u++
|
|
) {
|
|
var o = r ? r[u] : u;
|
|
if (e(n[o], o, n)) return !0;
|
|
}
|
|
return !1;
|
|
}),
|
|
(h.contains =
|
|
h.includes =
|
|
h.include =
|
|
function (n, e, t, r) {
|
|
return (
|
|
x(n) || (n = h.values(n)),
|
|
("number" == typeof t && !r) || (t = 0),
|
|
0 <= h.indexOf(n, e, t)
|
|
);
|
|
}),
|
|
(h.invoke = g(function (n, t, r) {
|
|
var i, u;
|
|
return (
|
|
h.isFunction(t)
|
|
? (u = t)
|
|
: h.isArray(t) &&
|
|
((i = t.slice(0, -1)), (t = t[t.length - 1])),
|
|
h.map(n, function (n) {
|
|
var e = u;
|
|
if (!e) {
|
|
if ((i && i.length && (n = b(n, i)), null == n)) return;
|
|
e = n[t];
|
|
}
|
|
return null == e ? e : e.apply(n, r);
|
|
})
|
|
);
|
|
})),
|
|
(h.pluck = function (n, e) {
|
|
return h.map(n, h.property(e));
|
|
}),
|
|
(h.where = function (n, e) {
|
|
return h.filter(n, h.matcher(e));
|
|
}),
|
|
(h.findWhere = function (n, e) {
|
|
return h.find(n, h.matcher(e));
|
|
}),
|
|
(h.max = function (n, r, e) {
|
|
var t,
|
|
i,
|
|
u = -1 / 0,
|
|
o = -1 / 0;
|
|
if (
|
|
null == r ||
|
|
("number" == typeof r && "object" != typeof n[0] && null != n)
|
|
)
|
|
for (
|
|
var c = 0, a = (n = x(n) ? n : h.values(n)).length;
|
|
c < a;
|
|
c++
|
|
)
|
|
null != (t = n[c]) && u < t && (u = t);
|
|
else
|
|
(r = y(r, e)),
|
|
h.each(n, function (n, e, t) {
|
|
(i = r(n, e, t)),
|
|
(o < i || (i === -1 / 0 && u === -1 / 0)) &&
|
|
((u = n), (o = i));
|
|
});
|
|
return u;
|
|
}),
|
|
(h.min = function (n, r, e) {
|
|
var t,
|
|
i,
|
|
u = 1 / 0,
|
|
o = 1 / 0;
|
|
if (
|
|
null == r ||
|
|
("number" == typeof r && "object" != typeof n[0] && null != n)
|
|
)
|
|
for (
|
|
var c = 0, a = (n = x(n) ? n : h.values(n)).length;
|
|
c < a;
|
|
c++
|
|
)
|
|
null != (t = n[c]) && t < u && (u = t);
|
|
else
|
|
(r = y(r, e)),
|
|
h.each(n, function (n, e, t) {
|
|
((i = r(n, e, t)) < o || (i === 1 / 0 && u === 1 / 0)) &&
|
|
((u = n), (o = i));
|
|
});
|
|
return u;
|
|
}),
|
|
(h.shuffle = function (n) {
|
|
return h.sample(n, 1 / 0);
|
|
}),
|
|
(h.sample = function (n, e, t) {
|
|
if (null == e || t)
|
|
return x(n) || (n = h.values(n)), n[h.random(n.length - 1)];
|
|
var r = x(n) ? h.clone(n) : h.values(n),
|
|
i = j(r);
|
|
e = Math.max(Math.min(e, i), 0);
|
|
for (var u = i - 1, o = 0; o < e; o++) {
|
|
var c = h.random(o, u),
|
|
a = r[o];
|
|
(r[o] = r[c]), (r[c] = a);
|
|
}
|
|
return r.slice(0, e);
|
|
}),
|
|
(h.sortBy = function (n, r, e) {
|
|
var i = 0;
|
|
return (
|
|
(r = y(r, e)),
|
|
h.pluck(
|
|
h
|
|
.map(n, function (n, e, t) {
|
|
return { value: n, index: i++, criteria: r(n, e, t) };
|
|
})
|
|
.sort(function (n, e) {
|
|
var t = n.criteria,
|
|
r = e.criteria;
|
|
if (t !== r) {
|
|
if (r < t || void 0 === t) return 1;
|
|
if (t < r || void 0 === r) return -1;
|
|
}
|
|
return n.index - e.index;
|
|
}),
|
|
"value",
|
|
)
|
|
);
|
|
});
|
|
function w(o, e) {
|
|
return function (r, i, n) {
|
|
var u = e ? [[], []] : {};
|
|
return (
|
|
(i = y(i, n)),
|
|
h.each(r, function (n, e) {
|
|
var t = i(n, e, r);
|
|
o(u, n, t);
|
|
}),
|
|
u
|
|
);
|
|
};
|
|
}
|
|
(h.groupBy = w(function (n, e, t) {
|
|
_(n, t) ? n[t].push(e) : (n[t] = [e]);
|
|
})),
|
|
(h.indexBy = w(function (n, e, t) {
|
|
n[t] = e;
|
|
})),
|
|
(h.countBy = w(function (n, e, t) {
|
|
_(n, t) ? n[t]++ : (n[t] = 1);
|
|
}));
|
|
var A =
|
|
/[^\ud800-\udfff]|[\ud800-\udbff][\udc00-\udfff]|[\ud800-\udfff]/g;
|
|
(h.toArray = function (n) {
|
|
return n
|
|
? h.isArray(n)
|
|
? a.call(n)
|
|
: h.isString(n)
|
|
? n.match(A)
|
|
: x(n)
|
|
? h.map(n, h.identity)
|
|
: h.values(n)
|
|
: [];
|
|
}),
|
|
(h.size = function (n) {
|
|
return null == n ? 0 : x(n) ? n.length : h.keys(n).length;
|
|
}),
|
|
(h.partition = w(function (n, e, t) {
|
|
n[t ? 0 : 1].push(e);
|
|
}, !0)),
|
|
(h.first =
|
|
h.head =
|
|
h.take =
|
|
function (n, e, t) {
|
|
return null == n || n.length < 1
|
|
? null == e
|
|
? void 0
|
|
: []
|
|
: null == e || t
|
|
? n[0]
|
|
: h.initial(n, n.length - e);
|
|
}),
|
|
(h.initial = function (n, e, t) {
|
|
return a.call(
|
|
n,
|
|
0,
|
|
Math.max(0, n.length - (null == e || t ? 1 : e)),
|
|
);
|
|
}),
|
|
(h.last = function (n, e, t) {
|
|
return null == n || n.length < 1
|
|
? null == e
|
|
? void 0
|
|
: []
|
|
: null == e || t
|
|
? n[n.length - 1]
|
|
: h.rest(n, Math.max(0, n.length - e));
|
|
}),
|
|
(h.rest =
|
|
h.tail =
|
|
h.drop =
|
|
function (n, e, t) {
|
|
return a.call(n, null == e || t ? 1 : e);
|
|
}),
|
|
(h.compact = function (n) {
|
|
return h.filter(n, Boolean);
|
|
});
|
|
var T = function (n, e, t, r) {
|
|
for (var i = (r = r || []).length, u = 0, o = j(n); u < o; u++) {
|
|
var c = n[u];
|
|
if (x(c) && (h.isArray(c) || h.isArguments(c)))
|
|
if (e) for (var a = 0, l = c.length; a < l; ) r[i++] = c[a++];
|
|
else T(c, e, t, r), (i = r.length);
|
|
else t || (r[i++] = c);
|
|
}
|
|
return r;
|
|
};
|
|
(h.flatten = function (n, e) {
|
|
return T(n, e, !1);
|
|
}),
|
|
(h.without = g(function (n, e) {
|
|
return h.difference(n, e);
|
|
})),
|
|
(h.uniq = h.unique =
|
|
function (n, e, t, r) {
|
|
h.isBoolean(e) || ((r = t), (t = e), (e = !1)),
|
|
null != t && (t = y(t, r));
|
|
for (var i = [], u = [], o = 0, c = j(n); o < c; o++) {
|
|
var a = n[o],
|
|
l = t ? t(a, o, n) : a;
|
|
e && !t
|
|
? ((o && u === l) || i.push(a), (u = l))
|
|
: t
|
|
? h.contains(u, l) || (u.push(l), i.push(a))
|
|
: h.contains(i, a) || i.push(a);
|
|
}
|
|
return i;
|
|
}),
|
|
(h.union = g(function (n) {
|
|
return h.uniq(T(n, !0, !0));
|
|
})),
|
|
(h.intersection = function (n) {
|
|
for (
|
|
var e = [], t = arguments.length, r = 0, i = j(n);
|
|
r < i;
|
|
r++
|
|
) {
|
|
var u = n[r];
|
|
if (!h.contains(e, u)) {
|
|
var o;
|
|
for (o = 1; o < t && h.contains(arguments[o], u); o++);
|
|
o === t && e.push(u);
|
|
}
|
|
}
|
|
return e;
|
|
}),
|
|
(h.difference = g(function (n, e) {
|
|
return (
|
|
(e = T(e, !0, !0)),
|
|
h.filter(n, function (n) {
|
|
return !h.contains(e, n);
|
|
})
|
|
);
|
|
})),
|
|
(h.unzip = function (n) {
|
|
for (
|
|
var e = (n && h.max(n, j).length) || 0, t = Array(e), r = 0;
|
|
r < e;
|
|
r++
|
|
)
|
|
t[r] = h.pluck(n, r);
|
|
return t;
|
|
}),
|
|
(h.zip = g(h.unzip)),
|
|
(h.object = function (n, e) {
|
|
for (var t = {}, r = 0, i = j(n); r < i; r++)
|
|
e ? (t[n[r]] = e[r]) : (t[n[r][0]] = n[r][1]);
|
|
return t;
|
|
});
|
|
function O(u) {
|
|
return function (n, e, t) {
|
|
e = y(e, t);
|
|
for (
|
|
var r = j(n), i = 0 < u ? 0 : r - 1;
|
|
0 <= i && i < r;
|
|
i += u
|
|
)
|
|
if (e(n[i], i, n)) return i;
|
|
return -1;
|
|
};
|
|
}
|
|
(h.findIndex = O(1)),
|
|
(h.findLastIndex = O(-1)),
|
|
(h.sortedIndex = function (n, e, t, r) {
|
|
for (var i = (t = y(t, r, 1))(e), u = 0, o = j(n); u < o; ) {
|
|
var c = Math.floor((u + o) / 2);
|
|
t(n[c]) < i ? (u = c + 1) : (o = c);
|
|
}
|
|
return u;
|
|
});
|
|
function C(u, o, c) {
|
|
return function (n, e, t) {
|
|
var r = 0,
|
|
i = j(n);
|
|
if ("number" == typeof t)
|
|
0 < u
|
|
? (r = 0 <= t ? t : Math.max(t + i, r))
|
|
: (i = 0 <= t ? Math.min(t + 1, i) : t + i + 1);
|
|
else if (c && t && i) return n[(t = c(n, e))] === e ? t : -1;
|
|
if (e != e)
|
|
return 0 <= (t = o(a.call(n, r, i), h.isNaN)) ? t + r : -1;
|
|
for (t = 0 < u ? r : i - 1; 0 <= t && t < i; t += u)
|
|
if (n[t] === e) return t;
|
|
return -1;
|
|
};
|
|
}
|
|
(h.indexOf = C(1, h.findIndex, h.sortedIndex)),
|
|
(h.lastIndexOf = C(-1, h.findLastIndex)),
|
|
(h.range = function (n, e, t) {
|
|
null == e && ((e = n || 0), (n = 0)),
|
|
(t = t || (e < n ? -1 : 1));
|
|
for (
|
|
var r = Math.max(Math.ceil((e - n) / t), 0),
|
|
i = Array(r),
|
|
u = 0;
|
|
u < r;
|
|
u++, n += t
|
|
)
|
|
i[u] = n;
|
|
return i;
|
|
}),
|
|
(h.chunk = function (n, e) {
|
|
if (null == e || e < 1) return [];
|
|
for (var t = [], r = 0, i = n.length; r < i; )
|
|
t.push(a.call(n, r, (r += e)));
|
|
return t;
|
|
});
|
|
function I(n, e, t, r, i) {
|
|
if (!(r instanceof e)) return n.apply(t, i);
|
|
var u = S(n.prototype),
|
|
o = n.apply(u, i);
|
|
return h.isObject(o) ? o : u;
|
|
}
|
|
(h.bind = g(function (e, t, r) {
|
|
if (!h.isFunction(e))
|
|
throw new TypeError("Bind must be called on a function");
|
|
var i = g(function (n) {
|
|
return I(e, i, t, this, r.concat(n));
|
|
});
|
|
return i;
|
|
})),
|
|
(h.partial = g(function (i, u) {
|
|
var o = h.partial.placeholder,
|
|
c = function () {
|
|
for (
|
|
var n = 0, e = u.length, t = Array(e), r = 0;
|
|
r < e;
|
|
r++
|
|
)
|
|
t[r] = u[r] === o ? arguments[n++] : u[r];
|
|
for (; n < arguments.length; ) t.push(arguments[n++]);
|
|
return I(i, c, this, this, t);
|
|
};
|
|
return c;
|
|
})),
|
|
((h.partial.placeholder = h).bindAll = g(function (n, e) {
|
|
var t = (e = T(e, !1, !1)).length;
|
|
if (t < 1)
|
|
throw new Error("bindAll must be passed function names");
|
|
for (; t--; ) {
|
|
var r = e[t];
|
|
n[r] = h.bind(n[r], n);
|
|
}
|
|
})),
|
|
(h.memoize = function (r, i) {
|
|
var u = function (n) {
|
|
var e = u.cache,
|
|
t = "" + (i ? i.apply(this, arguments) : n);
|
|
return _(e, t) || (e[t] = r.apply(this, arguments)), e[t];
|
|
};
|
|
return (u.cache = {}), u;
|
|
}),
|
|
(h.delay = g(function (n, e, t) {
|
|
return setTimeout(function () {
|
|
return n.apply(null, t);
|
|
}, e);
|
|
})),
|
|
(h.defer = h.partial(h.delay, h, 1)),
|
|
(h.throttle = function (t, r, i) {
|
|
var u,
|
|
o,
|
|
c,
|
|
a,
|
|
l = 0;
|
|
i = i || {};
|
|
function s() {
|
|
(l = !1 === i.leading ? 0 : h.now()),
|
|
(u = null),
|
|
(a = t.apply(o, c)),
|
|
u || (o = c = null);
|
|
}
|
|
function n() {
|
|
var n = h.now();
|
|
l || !1 !== i.leading || (l = n);
|
|
var e = r - (n - l);
|
|
return (
|
|
(o = this),
|
|
(c = arguments),
|
|
e <= 0 || r < e
|
|
? (u && (clearTimeout(u), (u = null)),
|
|
(l = n),
|
|
(a = t.apply(o, c)),
|
|
u || (o = c = null))
|
|
: u || !1 === i.trailing || (u = setTimeout(s, e)),
|
|
a
|
|
);
|
|
}
|
|
return (
|
|
(n.cancel = function () {
|
|
clearTimeout(u), (l = 0), (u = o = c = null);
|
|
}),
|
|
n
|
|
);
|
|
}),
|
|
(h.debounce = function (t, r, i) {
|
|
function u(n, e) {
|
|
(o = null), e && (c = t.apply(n, e));
|
|
}
|
|
var o,
|
|
c,
|
|
n = g(function (n) {
|
|
if ((o && clearTimeout(o), i)) {
|
|
var e = !o;
|
|
(o = setTimeout(u, r)), e && (c = t.apply(this, n));
|
|
} else o = h.delay(u, r, this, n);
|
|
return c;
|
|
});
|
|
return (
|
|
(n.cancel = function () {
|
|
clearTimeout(o), (o = null);
|
|
}),
|
|
n
|
|
);
|
|
}),
|
|
(h.wrap = function (n, e) {
|
|
return h.partial(e, n);
|
|
}),
|
|
(h.negate = function (n) {
|
|
return function () {
|
|
return !n.apply(this, arguments);
|
|
};
|
|
}),
|
|
(h.compose = function () {
|
|
var t = arguments,
|
|
r = t.length - 1;
|
|
return function () {
|
|
for (var n = r, e = t[r].apply(this, arguments); n--; )
|
|
e = t[n].call(this, e);
|
|
return e;
|
|
};
|
|
}),
|
|
(h.after = function (n, e) {
|
|
return function () {
|
|
if (--n < 1) return e.apply(this, arguments);
|
|
};
|
|
}),
|
|
(h.before = function (n, e) {
|
|
var t;
|
|
return function () {
|
|
return (
|
|
0 < --n && (t = e.apply(this, arguments)),
|
|
n <= 1 && (e = null),
|
|
t
|
|
);
|
|
};
|
|
}),
|
|
(h.once = h.partial(h.before, 2)),
|
|
(h.restArguments = g);
|
|
function F(n, e) {
|
|
var t = M.length,
|
|
r = n.constructor,
|
|
i = (h.isFunction(r) && r.prototype) || o,
|
|
u = "constructor";
|
|
for (_(n, u) && !h.contains(e, u) && e.push(u); t--; )
|
|
(u = M[t]) in n &&
|
|
n[u] !== i[u] &&
|
|
!h.contains(e, u) &&
|
|
e.push(u);
|
|
}
|
|
var q = !{ toString: null }.propertyIsEnumerable("toString"),
|
|
M = [
|
|
"valueOf",
|
|
"isPrototypeOf",
|
|
"toString",
|
|
"propertyIsEnumerable",
|
|
"hasOwnProperty",
|
|
"toLocaleString",
|
|
];
|
|
(h.keys = function (n) {
|
|
if (!h.isObject(n)) return [];
|
|
if (l) return l(n);
|
|
var e = [];
|
|
for (var t in n) _(n, t) && e.push(t);
|
|
return q && F(n, e), e;
|
|
}),
|
|
(h.allKeys = function (n) {
|
|
if (!h.isObject(n)) return [];
|
|
var e = [];
|
|
for (var t in n) e.push(t);
|
|
return q && F(n, e), e;
|
|
}),
|
|
(h.values = function (n) {
|
|
for (
|
|
var e = h.keys(n), t = e.length, r = Array(t), i = 0;
|
|
i < t;
|
|
i++
|
|
)
|
|
r[i] = n[e[i]];
|
|
return r;
|
|
}),
|
|
(h.mapObject = function (n, e, t) {
|
|
e = y(e, t);
|
|
for (
|
|
var r = h.keys(n), i = r.length, u = {}, o = 0;
|
|
o < i;
|
|
o++
|
|
) {
|
|
var c = r[o];
|
|
u[c] = e(n[c], c, n);
|
|
}
|
|
return u;
|
|
}),
|
|
(h.pairs = function (n) {
|
|
for (
|
|
var e = h.keys(n), t = e.length, r = Array(t), i = 0;
|
|
i < t;
|
|
i++
|
|
)
|
|
r[i] = [e[i], n[e[i]]];
|
|
return r;
|
|
}),
|
|
(h.invert = function (n) {
|
|
for (var e = {}, t = h.keys(n), r = 0, i = t.length; r < i; r++)
|
|
e[n[t[r]]] = t[r];
|
|
return e;
|
|
}),
|
|
(h.functions = h.methods =
|
|
function (n) {
|
|
var e = [];
|
|
for (var t in n) h.isFunction(n[t]) && e.push(t);
|
|
return e.sort();
|
|
});
|
|
function N(a, l) {
|
|
return function (n) {
|
|
var e = arguments.length;
|
|
if ((l && (n = Object(n)), e < 2 || null == n)) return n;
|
|
for (var t = 1; t < e; t++)
|
|
for (
|
|
var r = arguments[t], i = a(r), u = i.length, o = 0;
|
|
o < u;
|
|
o++
|
|
) {
|
|
var c = i[o];
|
|
(l && void 0 !== n[c]) || (n[c] = r[c]);
|
|
}
|
|
return n;
|
|
};
|
|
}
|
|
(h.extend = N(h.allKeys)),
|
|
(h.extendOwn = h.assign = N(h.keys)),
|
|
(h.findKey = function (n, e, t) {
|
|
e = y(e, t);
|
|
for (var r, i = h.keys(n), u = 0, o = i.length; u < o; u++)
|
|
if (e(n[(r = i[u])], r, n)) return r;
|
|
});
|
|
function R(n, e, t) {
|
|
return e in t;
|
|
}
|
|
var Q, L;
|
|
(h.pick = g(function (n, e) {
|
|
var t = {},
|
|
r = e[0];
|
|
if (null == n) return t;
|
|
h.isFunction(r)
|
|
? (1 < e.length && (r = d(r, e[1])), (e = h.allKeys(n)))
|
|
: ((r = R), (e = T(e, !1, !1)), (n = Object(n)));
|
|
for (var i = 0, u = e.length; i < u; i++) {
|
|
var o = e[i],
|
|
c = n[o];
|
|
r(c, o, n) && (t[o] = c);
|
|
}
|
|
return t;
|
|
})),
|
|
(h.omit = g(function (n, t) {
|
|
var e,
|
|
r = t[0];
|
|
return (
|
|
h.isFunction(r)
|
|
? ((r = h.negate(r)), 1 < t.length && (e = t[1]))
|
|
: ((t = h.map(T(t, !1, !1), String)),
|
|
(r = function (n, e) {
|
|
return !h.contains(t, e);
|
|
})),
|
|
h.pick(n, r, e)
|
|
);
|
|
})),
|
|
(h.defaults = N(h.allKeys, !0)),
|
|
(h.create = function (n, e) {
|
|
var t = S(n);
|
|
return e && h.extendOwn(t, e), t;
|
|
}),
|
|
(h.clone = function (n) {
|
|
return h.isObject(n)
|
|
? h.isArray(n)
|
|
? n.slice()
|
|
: h.extend({}, n)
|
|
: n;
|
|
}),
|
|
(h.tap = function (n, e) {
|
|
return e(n), n;
|
|
}),
|
|
(h.isMatch = function (n, e) {
|
|
var t = h.keys(e),
|
|
r = t.length;
|
|
if (null == n) return !r;
|
|
for (var i = Object(n), u = 0; u < r; u++) {
|
|
var o = t[u];
|
|
if (e[o] !== i[o] || !(o in i)) return !1;
|
|
}
|
|
return !0;
|
|
}),
|
|
(Q = function (n, e, t, r) {
|
|
if (n === e) return 0 !== n || 1 / n == 1 / e;
|
|
if (null == n || null == e) return !1;
|
|
if (n != n) return e != e;
|
|
var i = typeof n;
|
|
return (
|
|
("function" == i || "object" == i || "object" == typeof e) &&
|
|
L(n, e, t, r)
|
|
);
|
|
}),
|
|
(L = function (n, e, t, r) {
|
|
n instanceof h && (n = n._wrapped),
|
|
e instanceof h && (e = e._wrapped);
|
|
var i = p.call(n);
|
|
if (i !== p.call(e)) return !1;
|
|
switch (i) {
|
|
case "[object RegExp]":
|
|
case "[object String]":
|
|
return "" + n == "" + e;
|
|
case "[object Number]":
|
|
return +n != +n
|
|
? +e != +e
|
|
: 0 == +n
|
|
? 1 / +n == 1 / e
|
|
: +n == +e;
|
|
case "[object Date]":
|
|
case "[object Boolean]":
|
|
return +n == +e;
|
|
case "[object Symbol]":
|
|
return f.valueOf.call(n) === f.valueOf.call(e);
|
|
}
|
|
var u = "[object Array]" === i;
|
|
if (!u) {
|
|
if ("object" != typeof n || "object" != typeof e) return !1;
|
|
var o = n.constructor,
|
|
c = e.constructor;
|
|
if (
|
|
o !== c &&
|
|
!(
|
|
h.isFunction(o) &&
|
|
o instanceof o &&
|
|
h.isFunction(c) &&
|
|
c instanceof c
|
|
) &&
|
|
"constructor" in n &&
|
|
"constructor" in e
|
|
)
|
|
return !1;
|
|
}
|
|
r = r || [];
|
|
for (var a = (t = t || []).length; a--; )
|
|
if (t[a] === n) return r[a] === e;
|
|
if ((t.push(n), r.push(e), u)) {
|
|
if ((a = n.length) !== e.length) return !1;
|
|
for (; a--; ) if (!Q(n[a], e[a], t, r)) return !1;
|
|
} else {
|
|
var l,
|
|
s = h.keys(n);
|
|
if (((a = s.length), h.keys(e).length !== a)) return !1;
|
|
for (; a--; )
|
|
if (((l = s[a]), !_(e, l) || !Q(n[l], e[l], t, r)))
|
|
return !1;
|
|
}
|
|
return t.pop(), r.pop(), !0;
|
|
}),
|
|
(h.isEqual = function (n, e) {
|
|
return Q(n, e);
|
|
}),
|
|
(h.isEmpty = function (n) {
|
|
return (
|
|
null == n ||
|
|
(x(n) && (h.isArray(n) || h.isString(n) || h.isArguments(n))
|
|
? 0 === n.length
|
|
: 0 === h.keys(n).length)
|
|
);
|
|
}),
|
|
(h.isElement = function (n) {
|
|
return !(!n || 1 !== n.nodeType);
|
|
}),
|
|
(h.isArray =
|
|
c ||
|
|
function (n) {
|
|
return "[object Array]" === p.call(n);
|
|
}),
|
|
(h.isObject = function (n) {
|
|
var e = typeof n;
|
|
return "function" == e || ("object" == e && !!n);
|
|
}),
|
|
h.each(
|
|
[
|
|
"Arguments",
|
|
"Function",
|
|
"String",
|
|
"Number",
|
|
"Date",
|
|
"RegExp",
|
|
"Error",
|
|
"Symbol",
|
|
"Map",
|
|
"WeakMap",
|
|
"Set",
|
|
"WeakSet",
|
|
],
|
|
function (e) {
|
|
h["is" + e] = function (n) {
|
|
return p.call(n) === "[object " + e + "]";
|
|
};
|
|
},
|
|
),
|
|
h.isArguments(arguments) ||
|
|
(h.isArguments = function (n) {
|
|
return _(n, "callee");
|
|
});
|
|
var U = n.document && n.document.childNodes;
|
|
"function" != typeof /./ &&
|
|
"object" != typeof Int8Array &&
|
|
"function" != typeof U &&
|
|
(h.isFunction = function (n) {
|
|
return "function" == typeof n || !1;
|
|
}),
|
|
(h.isFinite = function (n) {
|
|
return !h.isSymbol(n) && isFinite(n) && !isNaN(parseFloat(n));
|
|
}),
|
|
(h.isNaN = function (n) {
|
|
return h.isNumber(n) && isNaN(n);
|
|
}),
|
|
(h.isBoolean = function (n) {
|
|
return !0 === n || !1 === n || "[object Boolean]" === p.call(n);
|
|
}),
|
|
(h.isNull = function (n) {
|
|
return null === n;
|
|
}),
|
|
(h.isUndefined = function (n) {
|
|
return void 0 === n;
|
|
}),
|
|
(h.has = function (n, e) {
|
|
if (!h.isArray(e)) return _(n, e);
|
|
for (var t = e.length, r = 0; r < t; r++) {
|
|
var i = e[r];
|
|
if (null == n || !u.call(n, i)) return !1;
|
|
n = n[i];
|
|
}
|
|
return !!t;
|
|
}),
|
|
(h.noConflict = function () {
|
|
return (n._ = e), this;
|
|
}),
|
|
(h.identity = function (n) {
|
|
return n;
|
|
}),
|
|
(h.constant = function (n) {
|
|
return function () {
|
|
return n;
|
|
};
|
|
}),
|
|
(h.noop = function () {}),
|
|
(h.property = function (e) {
|
|
return h.isArray(e)
|
|
? function (n) {
|
|
return b(n, e);
|
|
}
|
|
: m(e);
|
|
}),
|
|
(h.propertyOf = function (e) {
|
|
return null == e
|
|
? function () {}
|
|
: function (n) {
|
|
return h.isArray(n) ? b(e, n) : e[n];
|
|
};
|
|
}),
|
|
(h.matcher = h.matches =
|
|
function (e) {
|
|
return (
|
|
(e = h.extendOwn({}, e)),
|
|
function (n) {
|
|
return h.isMatch(n, e);
|
|
}
|
|
);
|
|
}),
|
|
(h.times = function (n, e, t) {
|
|
var r = Array(Math.max(0, n));
|
|
e = d(e, t, 1);
|
|
for (var i = 0; i < n; i++) r[i] = e(i);
|
|
return r;
|
|
}),
|
|
(h.random = function (n, e) {
|
|
return (
|
|
null == e && ((e = n), (n = 0)),
|
|
n + Math.floor(Math.random() * (e - n + 1))
|
|
);
|
|
}),
|
|
(h.now =
|
|
Date.now ||
|
|
function () {
|
|
return new Date().getTime();
|
|
});
|
|
function D(e) {
|
|
function t(n) {
|
|
return e[n];
|
|
}
|
|
var n = "(?:" + h.keys(e).join("|") + ")",
|
|
r = RegExp(n),
|
|
i = RegExp(n, "g");
|
|
return function (n) {
|
|
return (
|
|
(n = null == n ? "" : "" + n), r.test(n) ? n.replace(i, t) : n
|
|
);
|
|
};
|
|
}
|
|
var P = {
|
|
"&": "&",
|
|
"<": "<",
|
|
">": ">",
|
|
'"': """,
|
|
"'": "'",
|
|
"`": "`",
|
|
},
|
|
W = h.invert(P);
|
|
(h.escape = D(P)),
|
|
(h.unescape = D(W)),
|
|
(h.result = function (n, e, t) {
|
|
h.isArray(e) || (e = [e]);
|
|
var r = e.length;
|
|
if (!r) return h.isFunction(t) ? t.call(n) : t;
|
|
for (var i = 0; i < r; i++) {
|
|
var u = null == n ? void 0 : n[e[i]];
|
|
void 0 === u && ((u = t), (i = r)),
|
|
(n = h.isFunction(u) ? u.call(n) : u);
|
|
}
|
|
return n;
|
|
});
|
|
var B = 0;
|
|
(h.uniqueId = function (n) {
|
|
var e = ++B + "";
|
|
return n ? n + e : e;
|
|
}),
|
|
(h.templateSettings = {
|
|
evaluate: /<%([\s\S]+?)%>/g,
|
|
interpolate: /<%=([\s\S]+?)%>/g,
|
|
escape: /<%-([\s\S]+?)%>/g,
|
|
});
|
|
function Y(n) {
|
|
return "\\" + K[n];
|
|
}
|
|
var z = /(.)^/,
|
|
K = {
|
|
"'": "'",
|
|
"\\": "\\",
|
|
"\r": "r",
|
|
"\n": "n",
|
|
"\u2028": "u2028",
|
|
"\u2029": "u2029",
|
|
},
|
|
G = /\\|'|\r|\n|\u2028|\u2029/g;
|
|
(h.template = function (u, n, e) {
|
|
!n && e && (n = e), (n = h.defaults({}, n, h.templateSettings));
|
|
var t,
|
|
r = RegExp(
|
|
[
|
|
(n.escape || z).source,
|
|
(n.interpolate || z).source,
|
|
(n.evaluate || z).source,
|
|
].join("|") + "|$",
|
|
"g",
|
|
),
|
|
o = 0,
|
|
c = "__p+='";
|
|
u.replace(r, function (n, e, t, r, i) {
|
|
return (
|
|
(c += u.slice(o, i).replace(G, Y)),
|
|
(o = i + n.length),
|
|
e
|
|
? (c +=
|
|
"'+\n((__t=(" + e + "))==null?'':_.escape(__t))+\n'")
|
|
: t
|
|
? (c += "'+\n((__t=(" + t + "))==null?'':__t)+\n'")
|
|
: r && (c += "';\n" + r + "\n__p+='"),
|
|
n
|
|
);
|
|
}),
|
|
(c += "';\n"),
|
|
n.variable || (c = "with(obj||{}){\n" + c + "}\n"),
|
|
(c =
|
|
"var __t,__p='',__j=Array.prototype.join,print=function(){__p+=__j.call(arguments,'');};\n" +
|
|
c +
|
|
"return __p;\n");
|
|
try {
|
|
t = new Function(n.variable || "obj", "_", c);
|
|
} catch (n) {
|
|
throw ((n.source = c), n);
|
|
}
|
|
function i(n) {
|
|
return t.call(this, n, h);
|
|
}
|
|
var a = n.variable || "obj";
|
|
return (i.source = "function(" + a + "){\n" + c + "}"), i;
|
|
}),
|
|
(h.chain = function (n) {
|
|
var e = h(n);
|
|
return (e._chain = !0), e;
|
|
});
|
|
function H(n, e) {
|
|
return n._chain ? h(e).chain() : e;
|
|
}
|
|
(h.mixin = function (t) {
|
|
return (
|
|
h.each(h.functions(t), function (n) {
|
|
var e = (h[n] = t[n]);
|
|
h.prototype[n] = function () {
|
|
var n = [this._wrapped];
|
|
return i.apply(n, arguments), H(this, e.apply(h, n));
|
|
};
|
|
}),
|
|
h
|
|
);
|
|
}),
|
|
h.mixin(h),
|
|
h.each(
|
|
[
|
|
"pop",
|
|
"push",
|
|
"reverse",
|
|
"shift",
|
|
"sort",
|
|
"splice",
|
|
"unshift",
|
|
],
|
|
function (e) {
|
|
var t = r[e];
|
|
h.prototype[e] = function () {
|
|
var n = this._wrapped;
|
|
return (
|
|
t.apply(n, arguments),
|
|
("shift" !== e && "splice" !== e) ||
|
|
0 !== n.length ||
|
|
delete n[0],
|
|
H(this, n)
|
|
);
|
|
};
|
|
},
|
|
),
|
|
h.each(["concat", "join", "slice"], function (n) {
|
|
var e = r[n];
|
|
h.prototype[n] = function () {
|
|
return H(this, e.apply(this._wrapped, arguments));
|
|
};
|
|
}),
|
|
(h.prototype.value = function () {
|
|
return this._wrapped;
|
|
}),
|
|
(h.prototype.valueOf = h.prototype.toJSON = h.prototype.value),
|
|
(h.prototype.toString = function () {
|
|
return String(this._wrapped);
|
|
}),
|
|
"function" == typeof define &&
|
|
define.amd &&
|
|
define("underscore", [], function () {
|
|
return h;
|
|
});
|
|
})();
|
|
}).call(
|
|
this,
|
|
"undefined" != typeof global
|
|
? global
|
|
: "undefined" != typeof self
|
|
? self
|
|
: "undefined" != typeof window
|
|
? window
|
|
: {},
|
|
);
|
|
},
|
|
{},
|
|
],
|
|
3: [
|
|
function (n, e, t) {
|
|
"use strict";
|
|
var i = n("underscore"),
|
|
u = n("../events");
|
|
e.exports = function (n) {
|
|
var r = n.getComponent("MenuItem");
|
|
return n.extend(r, {
|
|
constructor: function (n, e) {
|
|
var t = e.source;
|
|
if (!i.isObject(t))
|
|
throw new Error(
|
|
'was not provided a "source" object, but rather: ' + typeof t,
|
|
);
|
|
(e = i.extend({ selectable: !0, label: t.label }, e)),
|
|
r.call(this, n, e),
|
|
(this.source = t);
|
|
},
|
|
handleClick: function (n) {
|
|
r.prototype.handleClick.call(this, n),
|
|
this.player().trigger(u.QUALITY_REQUESTED, this.source);
|
|
},
|
|
});
|
|
};
|
|
},
|
|
{ "../events": 5, underscore: 2 },
|
|
],
|
|
4: [
|
|
function (n, e, t) {
|
|
"use strict";
|
|
var i = n("underscore"),
|
|
u = n("../events"),
|
|
o = n("./QualityOption"),
|
|
c = "vjs-quality-changing";
|
|
e.exports = function (n) {
|
|
var e,
|
|
r = n.getComponent("MenuButton"),
|
|
t = o(n);
|
|
return (
|
|
(e = n.extend(r, {
|
|
constructor: function (t, n) {
|
|
r.call(this, t, n),
|
|
t.on(
|
|
u.QUALITY_REQUESTED,
|
|
function (n, e) {
|
|
this.setSelectedSource(e),
|
|
t.addClass(c),
|
|
t.one("loadeddata", function () {
|
|
t.removeClass(c);
|
|
});
|
|
}.bind(this),
|
|
),
|
|
t.on(
|
|
u.PLAYER_SOURCES_CHANGED,
|
|
function () {
|
|
this.update();
|
|
}.bind(this),
|
|
),
|
|
t.on(
|
|
u.QUALITY_SELECTED,
|
|
function (n, e) {
|
|
this.setSelectedSource(e);
|
|
}.bind(this),
|
|
),
|
|
t.one(
|
|
"ready",
|
|
function () {
|
|
(this.selectedSrc = t.src()), this.update();
|
|
}.bind(this),
|
|
),
|
|
this.controlText("Open quality selector menu");
|
|
},
|
|
setSelectedSource: function (n) {
|
|
var e = n ? n.src : void 0;
|
|
this.selectedSrc !== e &&
|
|
((this.selectedSrc = e),
|
|
i.each(this.items, function (n) {
|
|
n.selected(n.source.src === e);
|
|
}));
|
|
},
|
|
createItems: function () {
|
|
var e = this.player(),
|
|
n = e.currentSources();
|
|
return (
|
|
(n = n.filter(function (n) {
|
|
return null == n.hidequalityoption;
|
|
})),
|
|
i.map(
|
|
n,
|
|
function (n) {
|
|
return new t(e, {
|
|
source: n,
|
|
selected: n.src === this.selectedSrc,
|
|
});
|
|
}.bind(this),
|
|
)
|
|
);
|
|
},
|
|
buildWrapperCSSClass: function () {
|
|
return (
|
|
"vjs-quality-selector " +
|
|
r.prototype.buildWrapperCSSClass.call(this)
|
|
);
|
|
},
|
|
})),
|
|
n.registerComponent("QualitySelector", e),
|
|
e
|
|
);
|
|
};
|
|
},
|
|
{ "../events": 5, "./QualityOption": 3, underscore: 2 },
|
|
],
|
|
5: [
|
|
function (n, e, t) {
|
|
"use strict";
|
|
e.exports = {
|
|
QUALITY_REQUESTED: "qualityRequested",
|
|
QUALITY_SELECTED: "qualitySelected",
|
|
PLAYER_SOURCES_CHANGED: "playerSourcesChanged",
|
|
};
|
|
},
|
|
{},
|
|
],
|
|
6: [
|
|
function (n, e, t) {
|
|
"use strict";
|
|
var c = n("underscore"),
|
|
r = n("./events"),
|
|
i = n("./components/QualitySelector"),
|
|
u = n("./middleware/SourceInterceptor"),
|
|
a = n("./util/SafeSeek");
|
|
(e.exports = function (n) {
|
|
(n = n || window.videojs),
|
|
i(n),
|
|
u(n),
|
|
n.hook("setup", function (o) {
|
|
o.on(r.QUALITY_REQUESTED, function (n, e) {
|
|
var t = o.currentSources(),
|
|
r = o.currentTime(),
|
|
i = o.playbackRate(),
|
|
u = o.paused();
|
|
c.each(t, function (n) {
|
|
n.selected = !1;
|
|
}),
|
|
(c.findWhere(t, { src: e.src }).selected = !0),
|
|
o._qualitySelectorSafeSeek &&
|
|
o._qualitySelectorSafeSeek.onQualitySelectionChange(),
|
|
o.src(t),
|
|
o.ready(function () {
|
|
(o._qualitySelectorSafeSeek &&
|
|
!o._qualitySelectorSafeSeek.hasFinished()) ||
|
|
((o._qualitySelectorSafeSeek = new a(o, r)),
|
|
o.playbackRate(i)),
|
|
u || o.play();
|
|
});
|
|
});
|
|
});
|
|
}),
|
|
(e.exports.EVENTS = r);
|
|
},
|
|
{
|
|
"./components/QualitySelector": 4,
|
|
"./events": 5,
|
|
"./middleware/SourceInterceptor": 7,
|
|
"./util/SafeSeek": 9,
|
|
underscore: 2,
|
|
},
|
|
],
|
|
7: [
|
|
function (n, e, t) {
|
|
"use strict";
|
|
var u = n("underscore"),
|
|
o = n("../events");
|
|
e.exports = function (n) {
|
|
n.use("*", function (i) {
|
|
return {
|
|
setSource: function (n, e) {
|
|
var t,
|
|
r = i.currentSources();
|
|
i._qualitySelectorSafeSeek &&
|
|
i._qualitySelectorSafeSeek.onPlayerSourcesChange(),
|
|
u.isEqual(r, i._qualitySelectorPreviousSources) ||
|
|
(i.trigger(o.PLAYER_SOURCES_CHANGED, r),
|
|
(i._qualitySelectorPreviousSources = r)),
|
|
(t =
|
|
u.find(r, function (n) {
|
|
return (
|
|
!0 === n.selected ||
|
|
"true" === n.selected ||
|
|
"selected" === n.selected
|
|
);
|
|
}) || n),
|
|
i.trigger(o.QUALITY_SELECTED, t),
|
|
e(null, t);
|
|
},
|
|
};
|
|
});
|
|
};
|
|
},
|
|
{ "../events": 5, underscore: 2 },
|
|
],
|
|
8: [
|
|
function (n, e, t) {
|
|
"use strict";
|
|
n("./index")();
|
|
},
|
|
{ "./index": 6 },
|
|
],
|
|
9: [
|
|
function (n, e, t) {
|
|
"use strict";
|
|
var r = n("class.extend");
|
|
e.exports = r.extend({
|
|
init: function (n, e) {
|
|
(this._player = n),
|
|
(this._seekToTime = e),
|
|
(this._hasFinished = !1),
|
|
(this._keepThisInstanceWhenPlayerSourcesChange = !1),
|
|
this._seekWhenSafe();
|
|
},
|
|
_seekWhenSafe: function () {
|
|
this._player.readyState() < 3
|
|
? ((this._seekFn = this._seek.bind(this)),
|
|
this._player.one("canplay", this._seekFn))
|
|
: this._seek();
|
|
},
|
|
onPlayerSourcesChange: function () {
|
|
this._keepThisInstanceWhenPlayerSourcesChange
|
|
? (this._keepThisInstanceWhenPlayerSourcesChange = !1)
|
|
: this.cancel();
|
|
},
|
|
onQualitySelectionChange: function () {
|
|
this.hasFinished() ||
|
|
(this._keepThisInstanceWhenPlayerSourcesChange = !0);
|
|
},
|
|
_seek: function () {
|
|
this._player.currentTime(this._seekToTime),
|
|
(this._keepThisInstanceWhenPlayerSourcesChange = !1),
|
|
(this._hasFinished = !0);
|
|
},
|
|
hasFinished: function () {
|
|
return this._hasFinished;
|
|
},
|
|
cancel: function () {
|
|
this._player.off("canplay", this._seekFn),
|
|
(this._keepThisInstanceWhenPlayerSourcesChange = !1),
|
|
(this._hasFinished = !0);
|
|
},
|
|
});
|
|
},
|
|
{ "class.extend": 1 },
|
|
],
|
|
},
|
|
{},
|
|
[8],
|
|
);
|
|
//# sourceMappingURL=silvermine-videojs-quality-selector.min.js.map
|