diff --git a/CHANGELOG.md b/CHANGELOG.md
index b45f072..540f35d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,7 @@
#### v1.1.0 > v1.2.0
+- Add AirPlay support with silvermine videojs plugin
- Add Chromecast support (thx badincite, [#10](https://github.com/datarhei/restreamer-ui/pull/10))
- Add stream distribution across multiple internal servers
- Add SRT settings
diff --git a/public/_player/videojs/dist/ic_airplay_white_24px.svg b/public/_player/videojs/dist/ic_airplay_white_24px.svg
new file mode 100644
index 0000000..aa50dc5
--- /dev/null
+++ b/public/_player/videojs/dist/ic_airplay_white_24px.svg
@@ -0,0 +1,15 @@
+
diff --git a/public/_player/videojs/dist/videojs-airplay.min.css b/public/_player/videojs/dist/videojs-airplay.min.css
new file mode 100644
index 0000000..abb4591
--- /dev/null
+++ b/public/_player/videojs/dist/videojs-airplay.min.css
@@ -0,0 +1 @@
+.vjs-airplay-button .vjs-icon-placeholder{background:url("ic_airplay_white_24px.svg") center center no-repeat;background-size:contain;display:inline-block;width:20px;height:20px}.vjs-airplay-button:hover{cursor:pointer}.vjs-airplay-button:hover .vjs-icon-placeholder{background-image:url("ic_airplay_white_24px.svg")}
diff --git a/public/_player/videojs/dist/videojs-airplay.min.js b/public/_player/videojs/dist/videojs-airplay.min.js
new file mode 100644
index 0000000..4ec1cd4
--- /dev/null
+++ b/public/_player/videojs/dist/videojs-airplay.min.js
@@ -0,0 +1,1315 @@
+/*! @silvermine/videojs-airplay 2022-07-12 v1.1.0-7-g2c81dfd-dirty */
+
+(function() {
+ function r(e, n, t) {
+ function o(i, f) {
+ if (!n[i]) {
+ if (!e[i]) {
+ var c = "function" == typeof require && require;
+ if (!f && c) return c(i, !0);
+ if (u) return u(i, !0);
+ var a = new Error("Cannot find module '" + i + "'");
+ throw a.code = "MODULE_NOT_FOUND", a;
+ }
+ var p = n[i] = {
+ exports: {}
+ };
+ e[i][0].call(p.exports, function(r) {
+ var n = e[i][1][r];
+ return o(n || r);
+ }, p, p.exports, r, e, n, t);
+ }
+ return n[i].exports;
+ }
+ for (var u = "function" == typeof require && require, i = 0; i < t.length; i++) o(t[i]);
+ return o;
+ }
+ return r;
+})()({
+ 1: [ function(require, module, exports) {
+ var isCallable = require("../internals/is-callable");
+ var tryToString = require("../internals/try-to-string");
+ var $TypeError = TypeError;
+ module.exports = function(argument) {
+ if (isCallable(argument)) return argument;
+ throw $TypeError(tryToString(argument) + " is not a function");
+ };
+ }, {
+ "../internals/is-callable": 32,
+ "../internals/try-to-string": 64
+ } ],
+ 2: [ function(require, module, exports) {
+ var isObject = require("../internals/is-object");
+ var $String = String;
+ var $TypeError = TypeError;
+ module.exports = function(argument) {
+ if (isObject(argument)) return argument;
+ throw $TypeError($String(argument) + " is not an object");
+ };
+ }, {
+ "../internals/is-object": 34
+ } ],
+ 3: [ function(require, module, exports) {
+ var toIndexedObject = require("../internals/to-indexed-object");
+ var toAbsoluteIndex = require("../internals/to-absolute-index");
+ var lengthOfArrayLike = require("../internals/length-of-array-like");
+ var createMethod = function(IS_INCLUDES) {
+ return function($this, el, fromIndex) {
+ var O = toIndexedObject($this);
+ var length = lengthOfArrayLike(O);
+ var index = toAbsoluteIndex(fromIndex, length);
+ var value;
+ if (IS_INCLUDES && el != el) while (length > index) {
+ value = O[index++];
+ if (value != value) return true;
+ } else for (;length > index; index++) {
+ if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;
+ }
+ return !IS_INCLUDES && -1;
+ };
+ };
+ module.exports = {
+ includes: createMethod(true),
+ indexOf: createMethod(false)
+ };
+ }, {
+ "../internals/length-of-array-like": 37,
+ "../internals/to-absolute-index": 57,
+ "../internals/to-indexed-object": 58
+ } ],
+ 4: [ function(require, module, exports) {
+ var uncurryThis = require("../internals/function-uncurry-this");
+ module.exports = uncurryThis([].slice);
+ }, {
+ "../internals/function-uncurry-this": 22
+ } ],
+ 5: [ function(require, module, exports) {
+ var uncurryThis = require("../internals/function-uncurry-this");
+ var toString = uncurryThis({}.toString);
+ var stringSlice = uncurryThis("".slice);
+ module.exports = function(it) {
+ return stringSlice(toString(it), 8, -1);
+ };
+ }, {
+ "../internals/function-uncurry-this": 22
+ } ],
+ 6: [ function(require, module, exports) {
+ var hasOwn = require("../internals/has-own-property");
+ var ownKeys = require("../internals/own-keys");
+ var getOwnPropertyDescriptorModule = require("../internals/object-get-own-property-descriptor");
+ var definePropertyModule = require("../internals/object-define-property");
+ module.exports = function(target, source, exceptions) {
+ var keys = ownKeys(source);
+ var defineProperty = definePropertyModule.f;
+ var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
+ for (var i = 0; i < keys.length; i++) {
+ var key = keys[i];
+ if (!hasOwn(target, key) && !(exceptions && hasOwn(exceptions, key))) {
+ defineProperty(target, key, getOwnPropertyDescriptor(source, key));
+ }
+ }
+ };
+ }, {
+ "../internals/has-own-property": 26,
+ "../internals/object-define-property": 43,
+ "../internals/object-get-own-property-descriptor": 44,
+ "../internals/own-keys": 52
+ } ],
+ 7: [ function(require, module, exports) {
+ var DESCRIPTORS = require("../internals/descriptors");
+ var definePropertyModule = require("../internals/object-define-property");
+ var createPropertyDescriptor = require("../internals/create-property-descriptor");
+ module.exports = DESCRIPTORS ? function(object, key, value) {
+ return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));
+ } : function(object, key, value) {
+ object[key] = value;
+ return object;
+ };
+ }, {
+ "../internals/create-property-descriptor": 8,
+ "../internals/descriptors": 11,
+ "../internals/object-define-property": 43
+ } ],
+ 8: [ function(require, module, exports) {
+ module.exports = function(bitmap, value) {
+ return {
+ enumerable: !(bitmap & 1),
+ configurable: !(bitmap & 2),
+ writable: !(bitmap & 4),
+ value: value
+ };
+ };
+ }, {} ],
+ 9: [ function(require, module, exports) {
+ var isCallable = require("../internals/is-callable");
+ var definePropertyModule = require("../internals/object-define-property");
+ var makeBuiltIn = require("../internals/make-built-in");
+ var defineGlobalProperty = require("../internals/define-global-property");
+ module.exports = function(O, key, value, options) {
+ if (!options) options = {};
+ var simple = options.enumerable;
+ var name = options.name !== undefined ? options.name : key;
+ if (isCallable(value)) makeBuiltIn(value, name, options);
+ if (options.global) {
+ if (simple) O[key] = value; else defineGlobalProperty(key, value);
+ } else {
+ try {
+ if (!options.unsafe) delete O[key]; else if (O[key]) simple = true;
+ } catch (error) {}
+ if (simple) O[key] = value; else definePropertyModule.f(O, key, {
+ value: value,
+ enumerable: false,
+ configurable: !options.nonConfigurable,
+ writable: !options.nonWritable
+ });
+ }
+ return O;
+ };
+ }, {
+ "../internals/define-global-property": 10,
+ "../internals/is-callable": 32,
+ "../internals/make-built-in": 38,
+ "../internals/object-define-property": 43
+ } ],
+ 10: [ function(require, module, exports) {
+ var global = require("../internals/global");
+ var defineProperty = Object.defineProperty;
+ module.exports = function(key, value) {
+ try {
+ defineProperty(global, key, {
+ value: value,
+ configurable: true,
+ writable: true
+ });
+ } catch (error) {
+ global[key] = value;
+ }
+ return value;
+ };
+ }, {
+ "../internals/global": 25
+ } ],
+ 11: [ function(require, module, exports) {
+ var fails = require("../internals/fails");
+ module.exports = !fails(function() {
+ return Object.defineProperty({}, 1, {
+ get: function() {
+ return 7;
+ }
+ })[1] != 7;
+ });
+ }, {
+ "../internals/fails": 17
+ } ],
+ 12: [ function(require, module, exports) {
+ var global = require("../internals/global");
+ var isObject = require("../internals/is-object");
+ var document = global.document;
+ var EXISTS = isObject(document) && isObject(document.createElement);
+ module.exports = function(it) {
+ return EXISTS ? document.createElement(it) : {};
+ };
+ }, {
+ "../internals/global": 25,
+ "../internals/is-object": 34
+ } ],
+ 13: [ function(require, module, exports) {
+ var getBuiltIn = require("../internals/get-built-in");
+ module.exports = getBuiltIn("navigator", "userAgent") || "";
+ }, {
+ "../internals/get-built-in": 23
+ } ],
+ 14: [ function(require, module, exports) {
+ var global = require("../internals/global");
+ var userAgent = require("../internals/engine-user-agent");
+ var process = global.process;
+ var Deno = global.Deno;
+ var versions = process && process.versions || Deno && Deno.version;
+ var v8 = versions && versions.v8;
+ var match, version;
+ if (v8) {
+ match = v8.split(".");
+ version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]);
+ }
+ if (!version && userAgent) {
+ match = userAgent.match(/Edge\/(\d+)/);
+ if (!match || match[1] >= 74) {
+ match = userAgent.match(/Chrome\/(\d+)/);
+ if (match) version = +match[1];
+ }
+ }
+ module.exports = version;
+ }, {
+ "../internals/engine-user-agent": 13,
+ "../internals/global": 25
+ } ],
+ 15: [ function(require, module, exports) {
+ module.exports = [ "constructor", "hasOwnProperty", "isPrototypeOf", "propertyIsEnumerable", "toLocaleString", "toString", "valueOf" ];
+ }, {} ],
+ 16: [ function(require, module, exports) {
+ var global = require("../internals/global");
+ var getOwnPropertyDescriptor = require("../internals/object-get-own-property-descriptor").f;
+ var createNonEnumerableProperty = require("../internals/create-non-enumerable-property");
+ var defineBuiltIn = require("../internals/define-built-in");
+ var defineGlobalProperty = require("../internals/define-global-property");
+ var copyConstructorProperties = require("../internals/copy-constructor-properties");
+ var isForced = require("../internals/is-forced");
+ module.exports = function(options, source) {
+ var TARGET = options.target;
+ var GLOBAL = options.global;
+ var STATIC = options.stat;
+ var FORCED, target, key, targetProperty, sourceProperty, descriptor;
+ if (GLOBAL) {
+ target = global;
+ } else if (STATIC) {
+ target = global[TARGET] || defineGlobalProperty(TARGET, {});
+ } else {
+ target = (global[TARGET] || {}).prototype;
+ }
+ if (target) for (key in source) {
+ sourceProperty = source[key];
+ if (options.dontCallGetSet) {
+ descriptor = getOwnPropertyDescriptor(target, key);
+ targetProperty = descriptor && descriptor.value;
+ } else targetProperty = target[key];
+ FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? "." : "#") + key, options.forced);
+ if (!FORCED && targetProperty !== undefined) {
+ if (typeof sourceProperty == typeof targetProperty) continue;
+ copyConstructorProperties(sourceProperty, targetProperty);
+ }
+ if (options.sham || targetProperty && targetProperty.sham) {
+ createNonEnumerableProperty(sourceProperty, "sham", true);
+ }
+ defineBuiltIn(target, key, sourceProperty, options);
+ }
+ };
+ }, {
+ "../internals/copy-constructor-properties": 6,
+ "../internals/create-non-enumerable-property": 7,
+ "../internals/define-built-in": 9,
+ "../internals/define-global-property": 10,
+ "../internals/global": 25,
+ "../internals/is-forced": 33,
+ "../internals/object-get-own-property-descriptor": 44
+ } ],
+ 17: [ function(require, module, exports) {
+ module.exports = function(exec) {
+ try {
+ return !!exec();
+ } catch (error) {
+ return true;
+ }
+ };
+ }, {} ],
+ 18: [ function(require, module, exports) {
+ var fails = require("../internals/fails");
+ module.exports = !fails(function() {
+ var test = function() {}.bind();
+ return typeof test != "function" || test.hasOwnProperty("prototype");
+ });
+ }, {
+ "../internals/fails": 17
+ } ],
+ 19: [ function(require, module, exports) {
+ "use strict";
+ var uncurryThis = require("../internals/function-uncurry-this");
+ var aCallable = require("../internals/a-callable");
+ var isObject = require("../internals/is-object");
+ var hasOwn = require("../internals/has-own-property");
+ var arraySlice = require("../internals/array-slice");
+ var NATIVE_BIND = require("../internals/function-bind-native");
+ var $Function = Function;
+ var concat = uncurryThis([].concat);
+ var join = uncurryThis([].join);
+ var factories = {};
+ var construct = function(C, argsLength, args) {
+ if (!hasOwn(factories, argsLength)) {
+ for (var list = [], i = 0; i < argsLength; i++) list[i] = "a[" + i + "]";
+ factories[argsLength] = $Function("C,a", "return new C(" + join(list, ",") + ")");
+ }
+ return factories[argsLength](C, args);
+ };
+ module.exports = NATIVE_BIND ? $Function.bind : function bind(that) {
+ var F = aCallable(this);
+ var Prototype = F.prototype;
+ var partArgs = arraySlice(arguments, 1);
+ var boundFunction = function bound() {
+ var args = concat(partArgs, arraySlice(arguments));
+ return this instanceof boundFunction ? construct(F, args.length, args) : F.apply(that, args);
+ };
+ if (isObject(Prototype)) boundFunction.prototype = Prototype;
+ return boundFunction;
+ };
+ }, {
+ "../internals/a-callable": 1,
+ "../internals/array-slice": 4,
+ "../internals/function-bind-native": 18,
+ "../internals/function-uncurry-this": 22,
+ "../internals/has-own-property": 26,
+ "../internals/is-object": 34
+ } ],
+ 20: [ function(require, module, exports) {
+ var NATIVE_BIND = require("../internals/function-bind-native");
+ var call = Function.prototype.call;
+ module.exports = NATIVE_BIND ? call.bind(call) : function() {
+ return call.apply(call, arguments);
+ };
+ }, {
+ "../internals/function-bind-native": 18
+ } ],
+ 21: [ function(require, module, exports) {
+ var DESCRIPTORS = require("../internals/descriptors");
+ var hasOwn = require("../internals/has-own-property");
+ var FunctionPrototype = Function.prototype;
+ var getDescriptor = DESCRIPTORS && Object.getOwnPropertyDescriptor;
+ var EXISTS = hasOwn(FunctionPrototype, "name");
+ var PROPER = EXISTS && function something() {}.name === "something";
+ var CONFIGURABLE = EXISTS && (!DESCRIPTORS || DESCRIPTORS && getDescriptor(FunctionPrototype, "name").configurable);
+ module.exports = {
+ EXISTS: EXISTS,
+ PROPER: PROPER,
+ CONFIGURABLE: CONFIGURABLE
+ };
+ }, {
+ "../internals/descriptors": 11,
+ "../internals/has-own-property": 26
+ } ],
+ 22: [ function(require, module, exports) {
+ var NATIVE_BIND = require("../internals/function-bind-native");
+ var FunctionPrototype = Function.prototype;
+ var bind = FunctionPrototype.bind;
+ var call = FunctionPrototype.call;
+ var uncurryThis = NATIVE_BIND && bind.bind(call, call);
+ module.exports = NATIVE_BIND ? function(fn) {
+ return fn && uncurryThis(fn);
+ } : function(fn) {
+ return fn && function() {
+ return call.apply(fn, arguments);
+ };
+ };
+ }, {
+ "../internals/function-bind-native": 18
+ } ],
+ 23: [ function(require, module, exports) {
+ var global = require("../internals/global");
+ var isCallable = require("../internals/is-callable");
+ var aFunction = function(argument) {
+ return isCallable(argument) ? argument : undefined;
+ };
+ module.exports = function(namespace, method) {
+ return arguments.length < 2 ? aFunction(global[namespace]) : global[namespace] && global[namespace][method];
+ };
+ }, {
+ "../internals/global": 25,
+ "../internals/is-callable": 32
+ } ],
+ 24: [ function(require, module, exports) {
+ var aCallable = require("../internals/a-callable");
+ module.exports = function(V, P) {
+ var func = V[P];
+ return func == null ? undefined : aCallable(func);
+ };
+ }, {
+ "../internals/a-callable": 1
+ } ],
+ 25: [ function(require, module, exports) {
+ (function(global) {
+ (function() {
+ var check = function(it) {
+ return it && it.Math == Math && it;
+ };
+ module.exports = check(typeof globalThis == "object" && globalThis) || check(typeof window == "object" && window) || check(typeof self == "object" && self) || check(typeof global == "object" && global) || function() {
+ return this;
+ }() || Function("return this")();
+ }).call(this);
+ }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {});
+ }, {} ],
+ 26: [ function(require, module, exports) {
+ var uncurryThis = require("../internals/function-uncurry-this");
+ var toObject = require("../internals/to-object");
+ var hasOwnProperty = uncurryThis({}.hasOwnProperty);
+ module.exports = Object.hasOwn || function hasOwn(it, key) {
+ return hasOwnProperty(toObject(it), key);
+ };
+ }, {
+ "../internals/function-uncurry-this": 22,
+ "../internals/to-object": 61
+ } ],
+ 27: [ function(require, module, exports) {
+ module.exports = {};
+ }, {} ],
+ 28: [ function(require, module, exports) {
+ var DESCRIPTORS = require("../internals/descriptors");
+ var fails = require("../internals/fails");
+ var createElement = require("../internals/document-create-element");
+ module.exports = !DESCRIPTORS && !fails(function() {
+ return Object.defineProperty(createElement("div"), "a", {
+ get: function() {
+ return 7;
+ }
+ }).a != 7;
+ });
+ }, {
+ "../internals/descriptors": 11,
+ "../internals/document-create-element": 12,
+ "../internals/fails": 17
+ } ],
+ 29: [ function(require, module, exports) {
+ var uncurryThis = require("../internals/function-uncurry-this");
+ var fails = require("../internals/fails");
+ var classof = require("../internals/classof-raw");
+ var $Object = Object;
+ var split = uncurryThis("".split);
+ module.exports = fails(function() {
+ return !$Object("z").propertyIsEnumerable(0);
+ }) ? function(it) {
+ return classof(it) == "String" ? split(it, "") : $Object(it);
+ } : $Object;
+ }, {
+ "../internals/classof-raw": 5,
+ "../internals/fails": 17,
+ "../internals/function-uncurry-this": 22
+ } ],
+ 30: [ function(require, module, exports) {
+ var uncurryThis = require("../internals/function-uncurry-this");
+ var isCallable = require("../internals/is-callable");
+ var store = require("../internals/shared-store");
+ var functionToString = uncurryThis(Function.toString);
+ if (!isCallable(store.inspectSource)) {
+ store.inspectSource = function(it) {
+ return functionToString(it);
+ };
+ }
+ module.exports = store.inspectSource;
+ }, {
+ "../internals/function-uncurry-this": 22,
+ "../internals/is-callable": 32,
+ "../internals/shared-store": 55
+ } ],
+ 31: [ function(require, module, exports) {
+ var NATIVE_WEAK_MAP = require("../internals/native-weak-map");
+ var global = require("../internals/global");
+ var uncurryThis = require("../internals/function-uncurry-this");
+ var isObject = require("../internals/is-object");
+ var createNonEnumerableProperty = require("../internals/create-non-enumerable-property");
+ var hasOwn = require("../internals/has-own-property");
+ var shared = require("../internals/shared-store");
+ var sharedKey = require("../internals/shared-key");
+ var hiddenKeys = require("../internals/hidden-keys");
+ var OBJECT_ALREADY_INITIALIZED = "Object already initialized";
+ var TypeError = global.TypeError;
+ var WeakMap = global.WeakMap;
+ var set, get, has;
+ var enforce = function(it) {
+ return has(it) ? get(it) : set(it, {});
+ };
+ var getterFor = function(TYPE) {
+ return function(it) {
+ var state;
+ if (!isObject(it) || (state = get(it)).type !== TYPE) {
+ throw TypeError("Incompatible receiver, " + TYPE + " required");
+ }
+ return state;
+ };
+ };
+ if (NATIVE_WEAK_MAP || shared.state) {
+ var store = shared.state || (shared.state = new WeakMap());
+ var wmget = uncurryThis(store.get);
+ var wmhas = uncurryThis(store.has);
+ var wmset = uncurryThis(store.set);
+ set = function(it, metadata) {
+ if (wmhas(store, it)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);
+ metadata.facade = it;
+ wmset(store, it, metadata);
+ return metadata;
+ };
+ get = function(it) {
+ return wmget(store, it) || {};
+ };
+ has = function(it) {
+ return wmhas(store, it);
+ };
+ } else {
+ var STATE = sharedKey("state");
+ hiddenKeys[STATE] = true;
+ set = function(it, metadata) {
+ if (hasOwn(it, STATE)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);
+ metadata.facade = it;
+ createNonEnumerableProperty(it, STATE, metadata);
+ return metadata;
+ };
+ get = function(it) {
+ return hasOwn(it, STATE) ? it[STATE] : {};
+ };
+ has = function(it) {
+ return hasOwn(it, STATE);
+ };
+ }
+ module.exports = {
+ set: set,
+ get: get,
+ has: has,
+ enforce: enforce,
+ getterFor: getterFor
+ };
+ }, {
+ "../internals/create-non-enumerable-property": 7,
+ "../internals/function-uncurry-this": 22,
+ "../internals/global": 25,
+ "../internals/has-own-property": 26,
+ "../internals/hidden-keys": 27,
+ "../internals/is-object": 34,
+ "../internals/native-weak-map": 41,
+ "../internals/shared-key": 54,
+ "../internals/shared-store": 55
+ } ],
+ 32: [ function(require, module, exports) {
+ module.exports = function(argument) {
+ return typeof argument == "function";
+ };
+ }, {} ],
+ 33: [ function(require, module, exports) {
+ var fails = require("../internals/fails");
+ var isCallable = require("../internals/is-callable");
+ var replacement = /#|\.prototype\./;
+ var isForced = function(feature, detection) {
+ var value = data[normalize(feature)];
+ return value == POLYFILL ? true : value == NATIVE ? false : isCallable(detection) ? fails(detection) : !!detection;
+ };
+ var normalize = isForced.normalize = function(string) {
+ return String(string).replace(replacement, ".").toLowerCase();
+ };
+ var data = isForced.data = {};
+ var NATIVE = isForced.NATIVE = "N";
+ var POLYFILL = isForced.POLYFILL = "P";
+ module.exports = isForced;
+ }, {
+ "../internals/fails": 17,
+ "../internals/is-callable": 32
+ } ],
+ 34: [ function(require, module, exports) {
+ var isCallable = require("../internals/is-callable");
+ module.exports = function(it) {
+ return typeof it == "object" ? it !== null : isCallable(it);
+ };
+ }, {
+ "../internals/is-callable": 32
+ } ],
+ 35: [ function(require, module, exports) {
+ module.exports = false;
+ }, {} ],
+ 36: [ function(require, module, exports) {
+ var getBuiltIn = require("../internals/get-built-in");
+ var isCallable = require("../internals/is-callable");
+ var isPrototypeOf = require("../internals/object-is-prototype-of");
+ var USE_SYMBOL_AS_UID = require("../internals/use-symbol-as-uid");
+ var $Object = Object;
+ module.exports = USE_SYMBOL_AS_UID ? function(it) {
+ return typeof it == "symbol";
+ } : function(it) {
+ var $Symbol = getBuiltIn("Symbol");
+ return isCallable($Symbol) && isPrototypeOf($Symbol.prototype, $Object(it));
+ };
+ }, {
+ "../internals/get-built-in": 23,
+ "../internals/is-callable": 32,
+ "../internals/object-is-prototype-of": 47,
+ "../internals/use-symbol-as-uid": 66
+ } ],
+ 37: [ function(require, module, exports) {
+ var toLength = require("../internals/to-length");
+ module.exports = function(obj) {
+ return toLength(obj.length);
+ };
+ }, {
+ "../internals/to-length": 60
+ } ],
+ 38: [ function(require, module, exports) {
+ var fails = require("../internals/fails");
+ var isCallable = require("../internals/is-callable");
+ var hasOwn = require("../internals/has-own-property");
+ var DESCRIPTORS = require("../internals/descriptors");
+ var CONFIGURABLE_FUNCTION_NAME = require("../internals/function-name").CONFIGURABLE;
+ var inspectSource = require("../internals/inspect-source");
+ var InternalStateModule = require("../internals/internal-state");
+ var enforceInternalState = InternalStateModule.enforce;
+ var getInternalState = InternalStateModule.get;
+ var defineProperty = Object.defineProperty;
+ var CONFIGURABLE_LENGTH = DESCRIPTORS && !fails(function() {
+ return defineProperty(function() {}, "length", {
+ value: 8
+ }).length !== 8;
+ });
+ var TEMPLATE = String(String).split("String");
+ var makeBuiltIn = module.exports = function(value, name, options) {
+ if (String(name).slice(0, 7) === "Symbol(") {
+ name = "[" + String(name).replace(/^Symbol\(([^)]*)\)/, "$1") + "]";
+ }
+ if (options && options.getter) name = "get " + name;
+ if (options && options.setter) name = "set " + name;
+ if (!hasOwn(value, "name") || CONFIGURABLE_FUNCTION_NAME && value.name !== name) {
+ if (DESCRIPTORS) defineProperty(value, "name", {
+ value: name,
+ configurable: true
+ }); else value.name = name;
+ }
+ if (CONFIGURABLE_LENGTH && options && hasOwn(options, "arity") && value.length !== options.arity) {
+ defineProperty(value, "length", {
+ value: options.arity
+ });
+ }
+ try {
+ if (options && hasOwn(options, "constructor") && options.constructor) {
+ if (DESCRIPTORS) defineProperty(value, "prototype", {
+ writable: false
+ });
+ } else if (value.prototype) value.prototype = undefined;
+ } catch (error) {}
+ var state = enforceInternalState(value);
+ if (!hasOwn(state, "source")) {
+ state.source = TEMPLATE.join(typeof name == "string" ? name : "");
+ }
+ return value;
+ };
+ Function.prototype.toString = makeBuiltIn(function toString() {
+ return isCallable(this) && getInternalState(this).source || inspectSource(this);
+ }, "toString");
+ }, {
+ "../internals/descriptors": 11,
+ "../internals/fails": 17,
+ "../internals/function-name": 21,
+ "../internals/has-own-property": 26,
+ "../internals/inspect-source": 30,
+ "../internals/internal-state": 31,
+ "../internals/is-callable": 32
+ } ],
+ 39: [ function(require, module, exports) {
+ var ceil = Math.ceil;
+ var floor = Math.floor;
+ module.exports = Math.trunc || function trunc(x) {
+ var n = +x;
+ return (n > 0 ? floor : ceil)(n);
+ };
+ }, {} ],
+ 40: [ function(require, module, exports) {
+ var V8_VERSION = require("../internals/engine-v8-version");
+ var fails = require("../internals/fails");
+ module.exports = !!Object.getOwnPropertySymbols && !fails(function() {
+ var symbol = Symbol();
+ return !String(symbol) || !(Object(symbol) instanceof Symbol) || !Symbol.sham && V8_VERSION && V8_VERSION < 41;
+ });
+ }, {
+ "../internals/engine-v8-version": 14,
+ "../internals/fails": 17
+ } ],
+ 41: [ function(require, module, exports) {
+ var global = require("../internals/global");
+ var isCallable = require("../internals/is-callable");
+ var inspectSource = require("../internals/inspect-source");
+ var WeakMap = global.WeakMap;
+ module.exports = isCallable(WeakMap) && /native code/.test(inspectSource(WeakMap));
+ }, {
+ "../internals/global": 25,
+ "../internals/inspect-source": 30,
+ "../internals/is-callable": 32
+ } ],
+ 42: [ function(require, module, exports) {
+ "use strict";
+ var DESCRIPTORS = require("../internals/descriptors");
+ var uncurryThis = require("../internals/function-uncurry-this");
+ var call = require("../internals/function-call");
+ var fails = require("../internals/fails");
+ var objectKeys = require("../internals/object-keys");
+ var getOwnPropertySymbolsModule = require("../internals/object-get-own-property-symbols");
+ var propertyIsEnumerableModule = require("../internals/object-property-is-enumerable");
+ var toObject = require("../internals/to-object");
+ var IndexedObject = require("../internals/indexed-object");
+ var $assign = Object.assign;
+ var defineProperty = Object.defineProperty;
+ var concat = uncurryThis([].concat);
+ module.exports = !$assign || fails(function() {
+ if (DESCRIPTORS && $assign({
+ b: 1
+ }, $assign(defineProperty({}, "a", {
+ enumerable: true,
+ get: function() {
+ defineProperty(this, "b", {
+ value: 3,
+ enumerable: false
+ });
+ }
+ }), {
+ b: 2
+ })).b !== 1) return true;
+ var A = {};
+ var B = {};
+ var symbol = Symbol();
+ var alphabet = "abcdefghijklmnopqrst";
+ A[symbol] = 7;
+ alphabet.split("").forEach(function(chr) {
+ B[chr] = chr;
+ });
+ return $assign({}, A)[symbol] != 7 || objectKeys($assign({}, B)).join("") != alphabet;
+ }) ? function assign(target, source) {
+ var T = toObject(target);
+ var argumentsLength = arguments.length;
+ var index = 1;
+ var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
+ var propertyIsEnumerable = propertyIsEnumerableModule.f;
+ while (argumentsLength > index) {
+ var S = IndexedObject(arguments[index++]);
+ var keys = getOwnPropertySymbols ? concat(objectKeys(S), getOwnPropertySymbols(S)) : objectKeys(S);
+ var length = keys.length;
+ var j = 0;
+ var key;
+ while (length > j) {
+ key = keys[j++];
+ if (!DESCRIPTORS || call(propertyIsEnumerable, S, key)) T[key] = S[key];
+ }
+ }
+ return T;
+ } : $assign;
+ }, {
+ "../internals/descriptors": 11,
+ "../internals/fails": 17,
+ "../internals/function-call": 20,
+ "../internals/function-uncurry-this": 22,
+ "../internals/indexed-object": 29,
+ "../internals/object-get-own-property-symbols": 46,
+ "../internals/object-keys": 49,
+ "../internals/object-property-is-enumerable": 50,
+ "../internals/to-object": 61
+ } ],
+ 43: [ function(require, module, exports) {
+ var DESCRIPTORS = require("../internals/descriptors");
+ var IE8_DOM_DEFINE = require("../internals/ie8-dom-define");
+ var V8_PROTOTYPE_DEFINE_BUG = require("../internals/v8-prototype-define-bug");
+ var anObject = require("../internals/an-object");
+ var toPropertyKey = require("../internals/to-property-key");
+ var $TypeError = TypeError;
+ var $defineProperty = Object.defineProperty;
+ var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+ var ENUMERABLE = "enumerable";
+ var CONFIGURABLE = "configurable";
+ var WRITABLE = "writable";
+ exports.f = DESCRIPTORS ? V8_PROTOTYPE_DEFINE_BUG ? function defineProperty(O, P, Attributes) {
+ anObject(O);
+ P = toPropertyKey(P);
+ anObject(Attributes);
+ if (typeof O === "function" && P === "prototype" && "value" in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {
+ var current = $getOwnPropertyDescriptor(O, P);
+ if (current && current[WRITABLE]) {
+ O[P] = Attributes.value;
+ Attributes = {
+ configurable: CONFIGURABLE in Attributes ? Attributes[CONFIGURABLE] : current[CONFIGURABLE],
+ enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE],
+ writable: false
+ };
+ }
+ }
+ return $defineProperty(O, P, Attributes);
+ } : $defineProperty : function defineProperty(O, P, Attributes) {
+ anObject(O);
+ P = toPropertyKey(P);
+ anObject(Attributes);
+ if (IE8_DOM_DEFINE) try {
+ return $defineProperty(O, P, Attributes);
+ } catch (error) {}
+ if ("get" in Attributes || "set" in Attributes) throw $TypeError("Accessors not supported");
+ if ("value" in Attributes) O[P] = Attributes.value;
+ return O;
+ };
+ }, {
+ "../internals/an-object": 2,
+ "../internals/descriptors": 11,
+ "../internals/ie8-dom-define": 28,
+ "../internals/to-property-key": 63,
+ "../internals/v8-prototype-define-bug": 67
+ } ],
+ 44: [ function(require, module, exports) {
+ var DESCRIPTORS = require("../internals/descriptors");
+ var call = require("../internals/function-call");
+ var propertyIsEnumerableModule = require("../internals/object-property-is-enumerable");
+ var createPropertyDescriptor = require("../internals/create-property-descriptor");
+ var toIndexedObject = require("../internals/to-indexed-object");
+ var toPropertyKey = require("../internals/to-property-key");
+ var hasOwn = require("../internals/has-own-property");
+ var IE8_DOM_DEFINE = require("../internals/ie8-dom-define");
+ var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+ exports.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {
+ O = toIndexedObject(O);
+ P = toPropertyKey(P);
+ if (IE8_DOM_DEFINE) try {
+ return $getOwnPropertyDescriptor(O, P);
+ } catch (error) {}
+ if (hasOwn(O, P)) return createPropertyDescriptor(!call(propertyIsEnumerableModule.f, O, P), O[P]);
+ };
+ }, {
+ "../internals/create-property-descriptor": 8,
+ "../internals/descriptors": 11,
+ "../internals/function-call": 20,
+ "../internals/has-own-property": 26,
+ "../internals/ie8-dom-define": 28,
+ "../internals/object-property-is-enumerable": 50,
+ "../internals/to-indexed-object": 58,
+ "../internals/to-property-key": 63
+ } ],
+ 45: [ function(require, module, exports) {
+ var internalObjectKeys = require("../internals/object-keys-internal");
+ var enumBugKeys = require("../internals/enum-bug-keys");
+ var hiddenKeys = enumBugKeys.concat("length", "prototype");
+ exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
+ return internalObjectKeys(O, hiddenKeys);
+ };
+ }, {
+ "../internals/enum-bug-keys": 15,
+ "../internals/object-keys-internal": 48
+ } ],
+ 46: [ function(require, module, exports) {
+ exports.f = Object.getOwnPropertySymbols;
+ }, {} ],
+ 47: [ function(require, module, exports) {
+ var uncurryThis = require("../internals/function-uncurry-this");
+ module.exports = uncurryThis({}.isPrototypeOf);
+ }, {
+ "../internals/function-uncurry-this": 22
+ } ],
+ 48: [ function(require, module, exports) {
+ var uncurryThis = require("../internals/function-uncurry-this");
+ var hasOwn = require("../internals/has-own-property");
+ var toIndexedObject = require("../internals/to-indexed-object");
+ var indexOf = require("../internals/array-includes").indexOf;
+ var hiddenKeys = require("../internals/hidden-keys");
+ var push = uncurryThis([].push);
+ module.exports = function(object, names) {
+ var O = toIndexedObject(object);
+ var i = 0;
+ var result = [];
+ var key;
+ for (key in O) !hasOwn(hiddenKeys, key) && hasOwn(O, key) && push(result, key);
+ while (names.length > i) if (hasOwn(O, key = names[i++])) {
+ ~indexOf(result, key) || push(result, key);
+ }
+ return result;
+ };
+ }, {
+ "../internals/array-includes": 3,
+ "../internals/function-uncurry-this": 22,
+ "../internals/has-own-property": 26,
+ "../internals/hidden-keys": 27,
+ "../internals/to-indexed-object": 58
+ } ],
+ 49: [ function(require, module, exports) {
+ var internalObjectKeys = require("../internals/object-keys-internal");
+ var enumBugKeys = require("../internals/enum-bug-keys");
+ module.exports = Object.keys || function keys(O) {
+ return internalObjectKeys(O, enumBugKeys);
+ };
+ }, {
+ "../internals/enum-bug-keys": 15,
+ "../internals/object-keys-internal": 48
+ } ],
+ 50: [ function(require, module, exports) {
+ "use strict";
+ var $propertyIsEnumerable = {}.propertyIsEnumerable;
+ var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+ var NASHORN_BUG = getOwnPropertyDescriptor && !$propertyIsEnumerable.call({
+ 1: 2
+ }, 1);
+ exports.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
+ var descriptor = getOwnPropertyDescriptor(this, V);
+ return !!descriptor && descriptor.enumerable;
+ } : $propertyIsEnumerable;
+ }, {} ],
+ 51: [ function(require, module, exports) {
+ var call = require("../internals/function-call");
+ var isCallable = require("../internals/is-callable");
+ var isObject = require("../internals/is-object");
+ var $TypeError = TypeError;
+ module.exports = function(input, pref) {
+ var fn, val;
+ if (pref === "string" && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;
+ if (isCallable(fn = input.valueOf) && !isObject(val = call(fn, input))) return val;
+ if (pref !== "string" && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;
+ throw $TypeError("Can't convert object to primitive value");
+ };
+ }, {
+ "../internals/function-call": 20,
+ "../internals/is-callable": 32,
+ "../internals/is-object": 34
+ } ],
+ 52: [ function(require, module, exports) {
+ var getBuiltIn = require("../internals/get-built-in");
+ var uncurryThis = require("../internals/function-uncurry-this");
+ var getOwnPropertyNamesModule = require("../internals/object-get-own-property-names");
+ var getOwnPropertySymbolsModule = require("../internals/object-get-own-property-symbols");
+ var anObject = require("../internals/an-object");
+ var concat = uncurryThis([].concat);
+ module.exports = getBuiltIn("Reflect", "ownKeys") || function ownKeys(it) {
+ var keys = getOwnPropertyNamesModule.f(anObject(it));
+ var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
+ return getOwnPropertySymbols ? concat(keys, getOwnPropertySymbols(it)) : keys;
+ };
+ }, {
+ "../internals/an-object": 2,
+ "../internals/function-uncurry-this": 22,
+ "../internals/get-built-in": 23,
+ "../internals/object-get-own-property-names": 45,
+ "../internals/object-get-own-property-symbols": 46
+ } ],
+ 53: [ function(require, module, exports) {
+ var $TypeError = TypeError;
+ module.exports = function(it) {
+ if (it == undefined) throw $TypeError("Can't call method on " + it);
+ return it;
+ };
+ }, {} ],
+ 54: [ function(require, module, exports) {
+ var shared = require("../internals/shared");
+ var uid = require("../internals/uid");
+ var keys = shared("keys");
+ module.exports = function(key) {
+ return keys[key] || (keys[key] = uid(key));
+ };
+ }, {
+ "../internals/shared": 56,
+ "../internals/uid": 65
+ } ],
+ 55: [ function(require, module, exports) {
+ var global = require("../internals/global");
+ var defineGlobalProperty = require("../internals/define-global-property");
+ var SHARED = "__core-js_shared__";
+ var store = global[SHARED] || defineGlobalProperty(SHARED, {});
+ module.exports = store;
+ }, {
+ "../internals/define-global-property": 10,
+ "../internals/global": 25
+ } ],
+ 56: [ function(require, module, exports) {
+ var IS_PURE = require("../internals/is-pure");
+ var store = require("../internals/shared-store");
+ (module.exports = function(key, value) {
+ return store[key] || (store[key] = value !== undefined ? value : {});
+ })("versions", []).push({
+ version: "3.23.4",
+ mode: IS_PURE ? "pure" : "global",
+ copyright: "© 2014-2022 Denis Pushkarev (zloirock.ru)",
+ license: "https://github.com/zloirock/core-js/blob/v3.23.4/LICENSE",
+ source: "https://github.com/zloirock/core-js"
+ });
+ }, {
+ "../internals/is-pure": 35,
+ "../internals/shared-store": 55
+ } ],
+ 57: [ function(require, module, exports) {
+ var toIntegerOrInfinity = require("../internals/to-integer-or-infinity");
+ var max = Math.max;
+ var min = Math.min;
+ module.exports = function(index, length) {
+ var integer = toIntegerOrInfinity(index);
+ return integer < 0 ? max(integer + length, 0) : min(integer, length);
+ };
+ }, {
+ "../internals/to-integer-or-infinity": 59
+ } ],
+ 58: [ function(require, module, exports) {
+ var IndexedObject = require("../internals/indexed-object");
+ var requireObjectCoercible = require("../internals/require-object-coercible");
+ module.exports = function(it) {
+ return IndexedObject(requireObjectCoercible(it));
+ };
+ }, {
+ "../internals/indexed-object": 29,
+ "../internals/require-object-coercible": 53
+ } ],
+ 59: [ function(require, module, exports) {
+ var trunc = require("../internals/math-trunc");
+ module.exports = function(argument) {
+ var number = +argument;
+ return number !== number || number === 0 ? 0 : trunc(number);
+ };
+ }, {
+ "../internals/math-trunc": 39
+ } ],
+ 60: [ function(require, module, exports) {
+ var toIntegerOrInfinity = require("../internals/to-integer-or-infinity");
+ var min = Math.min;
+ module.exports = function(argument) {
+ return argument > 0 ? min(toIntegerOrInfinity(argument), 9007199254740991) : 0;
+ };
+ }, {
+ "../internals/to-integer-or-infinity": 59
+ } ],
+ 61: [ function(require, module, exports) {
+ var requireObjectCoercible = require("../internals/require-object-coercible");
+ var $Object = Object;
+ module.exports = function(argument) {
+ return $Object(requireObjectCoercible(argument));
+ };
+ }, {
+ "../internals/require-object-coercible": 53
+ } ],
+ 62: [ function(require, module, exports) {
+ var call = require("../internals/function-call");
+ var isObject = require("../internals/is-object");
+ var isSymbol = require("../internals/is-symbol");
+ var getMethod = require("../internals/get-method");
+ var ordinaryToPrimitive = require("../internals/ordinary-to-primitive");
+ var wellKnownSymbol = require("../internals/well-known-symbol");
+ var $TypeError = TypeError;
+ var TO_PRIMITIVE = wellKnownSymbol("toPrimitive");
+ module.exports = function(input, pref) {
+ if (!isObject(input) || isSymbol(input)) return input;
+ var exoticToPrim = getMethod(input, TO_PRIMITIVE);
+ var result;
+ if (exoticToPrim) {
+ if (pref === undefined) pref = "default";
+ result = call(exoticToPrim, input, pref);
+ if (!isObject(result) || isSymbol(result)) return result;
+ throw $TypeError("Can't convert object to primitive value");
+ }
+ if (pref === undefined) pref = "number";
+ return ordinaryToPrimitive(input, pref);
+ };
+ }, {
+ "../internals/function-call": 20,
+ "../internals/get-method": 24,
+ "../internals/is-object": 34,
+ "../internals/is-symbol": 36,
+ "../internals/ordinary-to-primitive": 51,
+ "../internals/well-known-symbol": 68
+ } ],
+ 63: [ function(require, module, exports) {
+ var toPrimitive = require("../internals/to-primitive");
+ var isSymbol = require("../internals/is-symbol");
+ module.exports = function(argument) {
+ var key = toPrimitive(argument, "string");
+ return isSymbol(key) ? key : key + "";
+ };
+ }, {
+ "../internals/is-symbol": 36,
+ "../internals/to-primitive": 62
+ } ],
+ 64: [ function(require, module, exports) {
+ var $String = String;
+ module.exports = function(argument) {
+ try {
+ return $String(argument);
+ } catch (error) {
+ return "Object";
+ }
+ };
+ }, {} ],
+ 65: [ function(require, module, exports) {
+ var uncurryThis = require("../internals/function-uncurry-this");
+ var id = 0;
+ var postfix = Math.random();
+ var toString = uncurryThis(1..toString);
+ module.exports = function(key) {
+ return "Symbol(" + (key === undefined ? "" : key) + ")_" + toString(++id + postfix, 36);
+ };
+ }, {
+ "../internals/function-uncurry-this": 22
+ } ],
+ 66: [ function(require, module, exports) {
+ var NATIVE_SYMBOL = require("../internals/native-symbol");
+ module.exports = NATIVE_SYMBOL && !Symbol.sham && typeof Symbol.iterator == "symbol";
+ }, {
+ "../internals/native-symbol": 40
+ } ],
+ 67: [ function(require, module, exports) {
+ var DESCRIPTORS = require("../internals/descriptors");
+ var fails = require("../internals/fails");
+ module.exports = DESCRIPTORS && fails(function() {
+ return Object.defineProperty(function() {}, "prototype", {
+ value: 42,
+ writable: false
+ }).prototype != 42;
+ });
+ }, {
+ "../internals/descriptors": 11,
+ "../internals/fails": 17
+ } ],
+ 68: [ function(require, module, exports) {
+ var global = require("../internals/global");
+ var shared = require("../internals/shared");
+ var hasOwn = require("../internals/has-own-property");
+ var uid = require("../internals/uid");
+ var NATIVE_SYMBOL = require("../internals/native-symbol");
+ var USE_SYMBOL_AS_UID = require("../internals/use-symbol-as-uid");
+ var WellKnownSymbolsStore = shared("wks");
+ var Symbol = global.Symbol;
+ var symbolFor = Symbol && Symbol["for"];
+ var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol : Symbol && Symbol.withoutSetter || uid;
+ module.exports = function(name) {
+ if (!hasOwn(WellKnownSymbolsStore, name) || !(NATIVE_SYMBOL || typeof WellKnownSymbolsStore[name] == "string")) {
+ var description = "Symbol." + name;
+ if (NATIVE_SYMBOL && hasOwn(Symbol, name)) {
+ WellKnownSymbolsStore[name] = Symbol[name];
+ } else if (USE_SYMBOL_AS_UID && symbolFor) {
+ WellKnownSymbolsStore[name] = symbolFor(description);
+ } else {
+ WellKnownSymbolsStore[name] = createWellKnownSymbol(description);
+ }
+ }
+ return WellKnownSymbolsStore[name];
+ };
+ }, {
+ "../internals/global": 25,
+ "../internals/has-own-property": 26,
+ "../internals/native-symbol": 40,
+ "../internals/shared": 56,
+ "../internals/uid": 65,
+ "../internals/use-symbol-as-uid": 66
+ } ],
+ 69: [ function(require, module, exports) {
+ var $ = require("../internals/export");
+ var bind = require("../internals/function-bind");
+ $({
+ target: "Function",
+ proto: true,
+ forced: Function.bind !== bind
+ }, {
+ bind: bind
+ });
+ }, {
+ "../internals/export": 16,
+ "../internals/function-bind": 19
+ } ],
+ 70: [ function(require, module, exports) {
+ var $ = require("../internals/export");
+ var assign = require("../internals/object-assign");
+ $({
+ target: "Object",
+ stat: true,
+ arity: 2,
+ forced: Object.assign !== assign
+ }, {
+ assign: assign
+ });
+ }, {
+ "../internals/export": 16,
+ "../internals/object-assign": 42
+ } ],
+ 71: [ function(require, module, exports) {
+ "use strict";
+ var hasAirPlayAPISupport = require("../lib/hasAirPlayAPISupport"), AirPlayButton;
+ AirPlayButton = {
+ constructor: function constructor() {
+ this.constructor.super_.apply(this, arguments);
+ if (!hasAirPlayAPISupport()) {
+ this.hide();
+ }
+ this.controlText("Start AirPlay");
+ this._reactToAirPlayAvailableEvents();
+ },
+ buildCSSClass: function buildCSSClass() {
+ return "vjs-airplay-button " + this.constructor.super_.prototype.buildCSSClass();
+ },
+ handleClick: function handleClick() {
+ this.player().trigger("airPlayRequested");
+ },
+ _getMediaEl: function _getMediaEl() {
+ var playerEl = this.player().el();
+ return playerEl.querySelector("video, audio");
+ },
+ _reactToAirPlayAvailableEvents: function _reactToAirPlayAvailableEvents() {
+ var mediaEl = this._getMediaEl(), self = this;
+ if (!mediaEl || !hasAirPlayAPISupport()) {
+ return;
+ }
+ function onTargetAvailabilityChanged(event) {
+ if (event.availability === "available") {
+ self.show();
+ } else {
+ self.hide();
+ }
+ }
+ mediaEl.addEventListener("webkitplaybacktargetavailabilitychanged", onTargetAvailabilityChanged);
+ this.on("dispose", function() {
+ mediaEl.removeEventListener("webkitplaybacktargetavailabilitychanged", onTargetAvailabilityChanged);
+ });
+ }
+ };
+ module.exports = function(videojs) {
+ var AirPlayButtonImpl;
+ AirPlayButtonImpl = videojs.extend(videojs.getComponent("Button"), AirPlayButton);
+ videojs.registerComponent("airPlayButton", AirPlayButtonImpl);
+ };
+ }, {
+ "../lib/hasAirPlayAPISupport": 74
+ } ],
+ 72: [ function(require, module, exports) {
+ "use strict";
+ require("core-js/modules/es.function.bind.js");
+ require("core-js/modules/es.object.assign.js");
+ var hasAirPlayAPISupport = require("./lib/hasAirPlayAPISupport");
+ function getExistingAirPlayButton(player) {
+ return player.controlBar.getChild("airPlayButton");
+ }
+ function ensureAirPlayButtonExists(player, options) {
+ var existingAirPlayButton = getExistingAirPlayButton(player), indexOpt;
+ if (options.addButtonToControlBar && !existingAirPlayButton) {
+ indexOpt = player.controlBar.children().length;
+ if (typeof options.buttonPositionIndex !== "undefined") {
+ indexOpt = options.buttonPositionIndex >= 0 ? options.buttonPositionIndex : player.controlBar.children().length + options.buttonPositionIndex;
+ }
+ player.controlBar.addChild("airPlayButton", options, indexOpt);
+ }
+ }
+ function onAirPlayRequested(player) {
+ var mediaEl = player.el().querySelector("video, audio");
+ if (mediaEl && mediaEl.webkitShowPlaybackTargetPicker) {
+ mediaEl.webkitShowPlaybackTargetPicker();
+ }
+ }
+ function listenForAirPlayEvents(player) {
+ player.on("airPlayRequested", onAirPlayRequested.bind(null, player));
+ }
+ function enableAirPlay(player, options) {
+ if (!player.controlBar) {
+ return;
+ }
+ if (hasAirPlayAPISupport()) {
+ listenForAirPlayEvents(player);
+ ensureAirPlayButtonExists(player, options);
+ }
+ }
+ module.exports = function(videojs) {
+ videojs.registerPlugin("airPlay", function(options) {
+ var pluginOptions = Object.assign({
+ addButtonToControlBar: true
+ }, options || {});
+ this.ready(enableAirPlay.bind(this, this, pluginOptions));
+ });
+ };
+ }, {
+ "./lib/hasAirPlayAPISupport": 74,
+ "core-js/modules/es.function.bind.js": 69,
+ "core-js/modules/es.object.assign.js": 70
+ } ],
+ 73: [ function(require, module, exports) {
+ "use strict";
+ var createAirPlayButton = require("./components/AirPlayButton"), createAirPlayPlugin = require("./enableAirPlay");
+ module.exports = function(videojs) {
+ videojs = videojs || window.videojs;
+ createAirPlayButton(videojs);
+ createAirPlayPlugin(videojs);
+ };
+ }, {
+ "./components/AirPlayButton": 71,
+ "./enableAirPlay": 72
+ } ],
+ 74: [ function(require, module, exports) {
+ "use strict";
+ module.exports = function() {
+ return !!window.WebKitPlaybackTargetAvailabilityEvent;
+ };
+ }, {} ],
+ 75: [ function(require, module, exports) {
+ "use strict";
+ require("./index")();
+ }, {
+ "./index": 73
+ } ]
+}, {}, [ 75 ]);
\ No newline at end of file
diff --git a/public/_player/videojs/files.txt b/public/_player/videojs/files.txt
index c980484..8cba701 100644
--- a/public/_player/videojs/files.txt
+++ b/public/_player/videojs/files.txt
@@ -8,4 +8,7 @@ dist/videojs-license.min.css
dist/videojs-chromecast.min.js
dist/videojs-chromecast.min.css
dist/ic_cast_connected_white_24dp.png
-dist/ic_cast_white_24dp.png
\ No newline at end of file
+dist/ic_cast_white_24dp.png
+dist/videojs-airplay.min.js
+dist/videojs-airplay.min.css
+dist/ic_airplay_white_24px.svg
diff --git a/public/_player/videojs/player.html b/public/_player/videojs/player.html
index 01272f0..fc77677 100644
--- a/public/_player/videojs/player.html
+++ b/public/_player/videojs/player.html
@@ -15,6 +15,9 @@
+ {{#if airplay}}
+
+ {{/if}}
{{#if chromecast}}
{{/if}}
@@ -26,6 +29,9 @@
+{{#if airplay}}
+
+{{/if}}
{{#if chromecast}}
@@ -87,6 +93,10 @@
config.plugins.chromecast = {};
}
+ if (playerConfig.airplay) {
+ config.plugins.airPlay = {};
+ }
+
var player = videojs('player', config);
player.ready(function() {
if(playerConfig.logo.image.length != 0) {
diff --git a/public/_playersite/index.html b/public/_playersite/index.html
index d754297..b0afefd 100644
--- a/public/_playersite/index.html
+++ b/public/_playersite/index.html
@@ -44,6 +44,9 @@
+ {{#if airplay}}
+
+ {{/if}}
{{#if chromecast}}
{{/if}}
@@ -785,6 +788,9 @@
+ {{#if airplay}}
+
+ {{/if}}
{{#if chromecast}}
@@ -832,6 +838,7 @@
var statistics = convertBoolParam("stats", playerConfig.statistics);
var color = convertColorParam("color", playerConfig.color.buttons);
var chromecast = {{#if chromecast}}true{{else}}false{{/if}};
+ var airplay = {{#if airplay}}true{{else}}false{{/if}};
diff --git a/public/_playersite/videojs.js b/public/_playersite/videojs.js
index ecc29e4..0ed78e7 100644
--- a/public/_playersite/videojs.js
+++ b/public/_playersite/videojs.js
@@ -18,6 +18,10 @@ if (chromecast) {
config.plugins.chromecast = {};
}
+if (airplay) {
+ config.plugins.airPlay = {};
+}
+
var player = videojs('player', config);
player.ready(function () {
diff --git a/src/utils/restreamer.js b/src/utils/restreamer.js
index 090d21c..54729e0 100644
--- a/src/utils/restreamer.js
+++ b/src/utils/restreamer.js
@@ -1892,6 +1892,7 @@ class Restreamer {
mute: false,
statistics: false,
chromecast: false,
+ airplay: false,
color: {},
ga: {},
logo: {},
@@ -1950,6 +1951,7 @@ class Restreamer {
width: 640,
height: 360,
chromecast: metadata.player.chromecast,
+ airplay: metadata.player.airplay,
};
// upload player.html
@@ -2032,6 +2034,7 @@ class Restreamer {
share: true,
support: true,
chromecast: false,
+ airplay: false,
template: '!default',
templatename: '',
textcolor_title: 'rgba(255,255,255,1)',
@@ -2114,6 +2117,7 @@ class Restreamer {
share: settings.share,
support: settings.support,
chromecast: settings.chromecast,
+ airplay: settings.airplay,
url: this.GetPlayersiteUrl(),
textcolor_title: settings.textcolor_title,
textcolor_default: settings.textcolor_default,
diff --git a/src/views/Playersite.js b/src/views/Playersite.js
index 7d8a386..9a86675 100644
--- a/src/views/Playersite.js
+++ b/src/views/Playersite.js
@@ -98,7 +98,7 @@ export default function Playersite(props) {
const value = event.target.value;
const settings = $settings;
- if (['playersite', 'header', 'share', 'support', 'chromecast'].includes(what)) {
+ if (['playersite', 'header', 'share', 'support', 'chromecast', 'airplay'].includes(what)) {
settings[what] = !settings[what];
} else {
settings[what] = value;
@@ -428,6 +428,14 @@ export default function Playersite(props) {
onChange={handleChange('chromecast')}
/>
+
+ AirPlay}
+ checked={$settings.airplay}
+ disabled={!$settings.playersite}
+ onChange={handleChange('airplay')}
+ />
+
Support datarhei Restreamer}
diff --git a/src/views/Publication/Player.js b/src/views/Publication/Player.js
index a6637be..fd397ec 100644
--- a/src/views/Publication/Player.js
+++ b/src/views/Publication/Player.js
@@ -118,7 +118,7 @@ export default function Edit(props) {
const settings = $settings;
if (section === '') {
- if (['autoplay', 'mute', 'statistics', 'chromecast'].includes(what)) {
+ if (['autoplay', 'mute', 'statistics', 'chromecast', 'airplay'].includes(what)) {
settings[what] = !settings[what];
} else {
settings[what] = value;
@@ -437,6 +437,7 @@ export default function Edit(props) {
Autoplay} checked={$settings.autoplay} onChange={handleChange('autoplay')} />
Mute} checked={$settings.mute} onChange={handleChange('mute')} />
Chromecast} checked={$settings.chromecast} onChange={handleChange('chromecast')} />
+ AirPlay} checked={$settings.airplay} onChange={handleChange('airplay')} />