From 2ded21e9880b2aa3b1a49966299cd492a55344b9 Mon Sep 17 00:00:00 2001 From: Ingo Oppermann Date: Wed, 13 Jul 2022 20:21:02 +0200 Subject: [PATCH] Add AirPlay support with silvermine videojs plugin --- CHANGELOG.md | 1 + .../videojs/dist/ic_airplay_white_24px.svg | 15 + .../videojs/dist/videojs-airplay.min.css | 1 + .../videojs/dist/videojs-airplay.min.js | 1315 +++++++++++++++++ public/_player/videojs/files.txt | 5 +- public/_player/videojs/player.html | 10 + public/_playersite/index.html | 7 + public/_playersite/videojs.js | 4 + src/utils/restreamer.js | 4 + src/views/Playersite.js | 10 +- src/views/Publication/Player.js | 3 +- 11 files changed, 1372 insertions(+), 3 deletions(-) create mode 100644 public/_player/videojs/dist/ic_airplay_white_24px.svg create mode 100644 public/_player/videojs/dist/videojs-airplay.min.css create mode 100644 public/_player/videojs/dist/videojs-airplay.min.js 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')} />