diff --git a/CHANGELOG.md b/CHANGELOG.md index c036cd2..ec5326f 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,6 +6,8 @@ - Add video h/v flip filter - Add audio volume filter ([#313](https://github.com/datarhei/restreamer/issues/313)) - Add audio loudness normalization filter +- 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 - Add HLS version selection (Dwaynarang, Electra Player compatibility) 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/ic_cast_connected_white_24dp.png b/public/_player/videojs/dist/ic_cast_connected_white_24dp.png new file mode 100644 index 0000000..dcba78d Binary files /dev/null and b/public/_player/videojs/dist/ic_cast_connected_white_24dp.png differ diff --git a/public/_player/videojs/dist/ic_cast_white_24dp.png b/public/_player/videojs/dist/ic_cast_white_24dp.png new file mode 100644 index 0000000..62c086f Binary files /dev/null and b/public/_player/videojs/dist/ic_cast_white_24dp.png differ 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/dist/videojs-chromecast.css b/public/_player/videojs/dist/videojs-chromecast.css new file mode 100644 index 0000000..50338a8 --- /dev/null +++ b/public/_player/videojs/dist/videojs-chromecast.css @@ -0,0 +1,65 @@ +/** Silvermine Chromecast **/ +.vjs-chromecast-button .vjs-icon-placeholder { + background: url('ic_cast_white_24dp.png') center center no-repeat; + background-size: contain; + display: inline-block; + width: 20px; + height: 20px; +} +.vjs-chromecast-button:hover { + cursor: pointer; +} +.vjs-chromecast-button:hover .vjs-icon-placeholder { + background-image: url('ic_cast_white_24dp.png'); +} +.vjs-chromecast-button.vjs-chromecast-casting-state .vjs-icon-placeholder { + background-image: url('ic_cast_connected_white_24dp.png'); +} +.vjs-chromecast-button.vjs-chromecast-casting-state:hover .vjs-icon-placeholder { + background-image: url('ic_cast_connected_white_24dp.png'); +} +.vjs-tech-chromecast { + display: flex; + flex-direction: column; + justify-content: center; + align-items: center; + overflow: hidden; +} +.vjs-tech-chromecast .vjs-tech-chromecast-poster::after { + content: ' '; + display: block; + height: 2px; + width: 100px; + background-color: #cccccc; + position: absolute; + left: calc(50% - 50px); +} +.vjs-tech-chromecast .vjs-tech-chromecast-poster-img { + max-height: 180px; + width: auto; + border: 2px solid #cccccc; +} +.vjs-tech-chromecast .vjs-tech-chromecast-poster-img.vjs-tech-chromecast-poster-img-empty { + width: 160px; + height: 90px; +} +.vjs-tech-chromecast .vjs-tech-chromecast-title-container { + position: absolute; + bottom: 50%; + margin-bottom: 100px; + color: #cccccc; + text-align: center; +} +.vjs-tech-chromecast .vjs-tech-chromecast-title { + font-size: 22px; +} +.vjs-tech-chromecast .vjs-tech-chromecast-title.vjs-tech-chromecast-title-empty { + display: none; +} +.vjs-tech-chromecast .vjs-tech-chromecast-subtitle { + font-size: 18px; + padding-top: 0.5em; +} +.vjs-tech-chromecast .vjs-tech-chromecast-subtitle.vjs-tech-chromecast-subtitle-empty { + display: none; +} \ No newline at end of file diff --git a/public/_player/videojs/dist/videojs-chromecast.min.css b/public/_player/videojs/dist/videojs-chromecast.min.css new file mode 100644 index 0000000..8ee1b06 --- /dev/null +++ b/public/_player/videojs/dist/videojs-chromecast.min.css @@ -0,0 +1 @@ +.vjs-chromecast-button .vjs-icon-placeholder{background:url(ic_cast_white_24dp.png) center center no-repeat;background-size:contain;display:inline-block;width:20px;height:20px}.vjs-chromecast-button:hover{cursor:pointer}.vjs-chromecast-button:hover .vjs-icon-placeholder{background-image:url(ic_cast_white_24dp.png)}.vjs-chromecast-button.vjs-chromecast-casting-state .vjs-icon-placeholder{background-image:url(ic_cast_connected_white_24dp.png)}.vjs-chromecast-button.vjs-chromecast-casting-state:hover .vjs-icon-placeholder{background-image:url(ic_cast_connected_white_24dp.png)}.vjs-tech-chromecast{display:flex;flex-direction:column;justify-content:center;align-items:center;overflow:hidden}.vjs-tech-chromecast .vjs-tech-chromecast-poster::after{content:' ';display:block;height:2px;width:100px;background-color:#ccc;position:absolute;left:calc(50% - 50px)}.vjs-tech-chromecast .vjs-tech-chromecast-poster-img{max-height:180px;width:auto;border:2px solid #ccc}.vjs-tech-chromecast .vjs-tech-chromecast-poster-img.vjs-tech-chromecast-poster-img-empty{width:160px;height:90px}.vjs-tech-chromecast .vjs-tech-chromecast-title-container{position:absolute;bottom:50%;margin-bottom:100px;color:#ccc;text-align:center}.vjs-tech-chromecast .vjs-tech-chromecast-title{font-size:22px}.vjs-tech-chromecast .vjs-tech-chromecast-title.vjs-tech-chromecast-title-empty{display:none}.vjs-tech-chromecast .vjs-tech-chromecast-subtitle{font-size:18px;padding-top:.5em}.vjs-tech-chromecast .vjs-tech-chromecast-subtitle.vjs-tech-chromecast-subtitle-empty{display:none} \ No newline at end of file diff --git a/public/_player/videojs/dist/videojs-chromecast.min.js b/public/_player/videojs/dist/videojs-chromecast.min.js new file mode 100644 index 0000000..7c6abdb --- /dev/null +++ b/public/_player/videojs/dist/videojs-chromecast.min.js @@ -0,0 +1,3147 @@ +/*! @silvermine/videojs-chromecast 2021-12-03 v1.3.3 */ + +(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) { + (function() { + var initializing = false, fnTest = /xyz/.test(function() { + xyz; + }) ? /\b_super\b/ : /.*/; + this.Class = function() {}; + Class.extend = function(prop) { + var _super = this.prototype; + initializing = true; + var prototype = new this(); + initializing = false; + for (var name in prop) { + prototype[name] = typeof prop[name] == "function" && typeof _super[name] == "function" && fnTest.test(prop[name]) ? function(name, fn) { + return function() { + var tmp = this._super; + this._super = _super[name]; + var ret = fn.apply(this, arguments); + this._super = tmp; + return ret; + }; + }(name, prop[name]) : prop[name]; + } + function Class() { + if (!initializing && this.init) this.init.apply(this, arguments); + } + Class.prototype = prototype; + Class.prototype.constructor = Class; + Class.extend = arguments.callee; + return Class; + }; + module.exports = Class; + })(); + }, {} ], + 2: [ function(require, module, exports) { + (function() { + window.WebComponents = window.WebComponents || { + flags: {} + }; + var file = "webcomponents-lite.js"; + var script = document.querySelector('script[src*="' + file + '"]'); + var flags = {}; + if (!flags.noOpts) { + location.search.slice(1).split("&").forEach(function(option) { + var parts = option.split("="); + var match; + if (parts[0] && (match = parts[0].match(/wc-(.+)/))) { + flags[match[1]] = parts[1] || true; + } + }); + if (script) { + for (var i = 0, a; a = script.attributes[i]; i++) { + if (a.name !== "src") { + flags[a.name] = a.value || true; + } + } + } + if (flags.log && flags.log.split) { + var parts = flags.log.split(","); + flags.log = {}; + parts.forEach(function(f) { + flags.log[f] = true; + }); + } else { + flags.log = {}; + } + } + if (flags.register) { + window.CustomElements = window.CustomElements || { + flags: {} + }; + window.CustomElements.flags.register = flags.register; + } + WebComponents.flags = flags; + })(); + (function(scope) { + "use strict"; + var hasWorkingUrl = false; + if (!scope.forceJURL) { + try { + var u = new URL("b", "http://a"); + u.pathname = "c%20d"; + hasWorkingUrl = u.href === "http://a/c%20d"; + } catch (e) {} + } + if (hasWorkingUrl) return; + var relative = Object.create(null); + relative["ftp"] = 21; + relative["file"] = 0; + relative["gopher"] = 70; + relative["http"] = 80; + relative["https"] = 443; + relative["ws"] = 80; + relative["wss"] = 443; + var relativePathDotMapping = Object.create(null); + relativePathDotMapping["%2e"] = "."; + relativePathDotMapping[".%2e"] = ".."; + relativePathDotMapping["%2e."] = ".."; + relativePathDotMapping["%2e%2e"] = ".."; + function isRelativeScheme(scheme) { + return relative[scheme] !== undefined; + } + function invalid() { + clear.call(this); + this._isInvalid = true; + } + function IDNAToASCII(h) { + if ("" == h) { + invalid.call(this); + } + return h.toLowerCase(); + } + function percentEscape(c) { + var unicode = c.charCodeAt(0); + if (unicode > 32 && unicode < 127 && [ 34, 35, 60, 62, 63, 96 ].indexOf(unicode) == -1) { + return c; + } + return encodeURIComponent(c); + } + function percentEscapeQuery(c) { + var unicode = c.charCodeAt(0); + if (unicode > 32 && unicode < 127 && [ 34, 35, 60, 62, 96 ].indexOf(unicode) == -1) { + return c; + } + return encodeURIComponent(c); + } + var EOF = undefined, ALPHA = /[a-zA-Z]/, ALPHANUMERIC = /[a-zA-Z0-9\+\-\.]/; + function parse(input, stateOverride, base) { + function err(message) { + errors.push(message); + } + var state = stateOverride || "scheme start", cursor = 0, buffer = "", seenAt = false, seenBracket = false, errors = []; + loop: while ((input[cursor - 1] != EOF || cursor == 0) && !this._isInvalid) { + var c = input[cursor]; + switch (state) { + case "scheme start": + if (c && ALPHA.test(c)) { + buffer += c.toLowerCase(); + state = "scheme"; + } else if (!stateOverride) { + buffer = ""; + state = "no scheme"; + continue; + } else { + err("Invalid scheme."); + break loop; + } + break; + + case "scheme": + if (c && ALPHANUMERIC.test(c)) { + buffer += c.toLowerCase(); + } else if (":" == c) { + this._scheme = buffer; + buffer = ""; + if (stateOverride) { + break loop; + } + if (isRelativeScheme(this._scheme)) { + this._isRelative = true; + } + if ("file" == this._scheme) { + state = "relative"; + } else if (this._isRelative && base && base._scheme == this._scheme) { + state = "relative or authority"; + } else if (this._isRelative) { + state = "authority first slash"; + } else { + state = "scheme data"; + } + } else if (!stateOverride) { + buffer = ""; + cursor = 0; + state = "no scheme"; + continue; + } else if (EOF == c) { + break loop; + } else { + err("Code point not allowed in scheme: " + c); + break loop; + } + break; + + case "scheme data": + if ("?" == c) { + this._query = "?"; + state = "query"; + } else if ("#" == c) { + this._fragment = "#"; + state = "fragment"; + } else { + if (EOF != c && "\t" != c && "\n" != c && "\r" != c) { + this._schemeData += percentEscape(c); + } + } + break; + + case "no scheme": + if (!base || !isRelativeScheme(base._scheme)) { + err("Missing scheme."); + invalid.call(this); + } else { + state = "relative"; + continue; + } + break; + + case "relative or authority": + if ("/" == c && "/" == input[cursor + 1]) { + state = "authority ignore slashes"; + } else { + err("Expected /, got: " + c); + state = "relative"; + continue; + } + break; + + case "relative": + this._isRelative = true; + if ("file" != this._scheme) this._scheme = base._scheme; + if (EOF == c) { + this._host = base._host; + this._port = base._port; + this._path = base._path.slice(); + this._query = base._query; + this._username = base._username; + this._password = base._password; + break loop; + } else if ("/" == c || "\\" == c) { + if ("\\" == c) err("\\ is an invalid code point."); + state = "relative slash"; + } else if ("?" == c) { + this._host = base._host; + this._port = base._port; + this._path = base._path.slice(); + this._query = "?"; + this._username = base._username; + this._password = base._password; + state = "query"; + } else if ("#" == c) { + this._host = base._host; + this._port = base._port; + this._path = base._path.slice(); + this._query = base._query; + this._fragment = "#"; + this._username = base._username; + this._password = base._password; + state = "fragment"; + } else { + var nextC = input[cursor + 1]; + var nextNextC = input[cursor + 2]; + if ("file" != this._scheme || !ALPHA.test(c) || nextC != ":" && nextC != "|" || EOF != nextNextC && "/" != nextNextC && "\\" != nextNextC && "?" != nextNextC && "#" != nextNextC) { + this._host = base._host; + this._port = base._port; + this._username = base._username; + this._password = base._password; + this._path = base._path.slice(); + this._path.pop(); + } + state = "relative path"; + continue; + } + break; + + case "relative slash": + if ("/" == c || "\\" == c) { + if ("\\" == c) { + err("\\ is an invalid code point."); + } + if ("file" == this._scheme) { + state = "file host"; + } else { + state = "authority ignore slashes"; + } + } else { + if ("file" != this._scheme) { + this._host = base._host; + this._port = base._port; + this._username = base._username; + this._password = base._password; + } + state = "relative path"; + continue; + } + break; + + case "authority first slash": + if ("/" == c) { + state = "authority second slash"; + } else { + err("Expected '/', got: " + c); + state = "authority ignore slashes"; + continue; + } + break; + + case "authority second slash": + state = "authority ignore slashes"; + if ("/" != c) { + err("Expected '/', got: " + c); + continue; + } + break; + + case "authority ignore slashes": + if ("/" != c && "\\" != c) { + state = "authority"; + continue; + } else { + err("Expected authority, got: " + c); + } + break; + + case "authority": + if ("@" == c) { + if (seenAt) { + err("@ already seen."); + buffer += "%40"; + } + seenAt = true; + for (var i = 0; i < buffer.length; i++) { + var cp = buffer[i]; + if ("\t" == cp || "\n" == cp || "\r" == cp) { + err("Invalid whitespace in authority."); + continue; + } + if (":" == cp && null === this._password) { + this._password = ""; + continue; + } + var tempC = percentEscape(cp); + null !== this._password ? this._password += tempC : this._username += tempC; + } + buffer = ""; + } else if (EOF == c || "/" == c || "\\" == c || "?" == c || "#" == c) { + cursor -= buffer.length; + buffer = ""; + state = "host"; + continue; + } else { + buffer += c; + } + break; + + case "file host": + if (EOF == c || "/" == c || "\\" == c || "?" == c || "#" == c) { + if (buffer.length == 2 && ALPHA.test(buffer[0]) && (buffer[1] == ":" || buffer[1] == "|")) { + state = "relative path"; + } else if (buffer.length == 0) { + state = "relative path start"; + } else { + this._host = IDNAToASCII.call(this, buffer); + buffer = ""; + state = "relative path start"; + } + continue; + } else if ("\t" == c || "\n" == c || "\r" == c) { + err("Invalid whitespace in file host."); + } else { + buffer += c; + } + break; + + case "host": + case "hostname": + if (":" == c && !seenBracket) { + this._host = IDNAToASCII.call(this, buffer); + buffer = ""; + state = "port"; + if ("hostname" == stateOverride) { + break loop; + } + } else if (EOF == c || "/" == c || "\\" == c || "?" == c || "#" == c) { + this._host = IDNAToASCII.call(this, buffer); + buffer = ""; + state = "relative path start"; + if (stateOverride) { + break loop; + } + continue; + } else if ("\t" != c && "\n" != c && "\r" != c) { + if ("[" == c) { + seenBracket = true; + } else if ("]" == c) { + seenBracket = false; + } + buffer += c; + } else { + err("Invalid code point in host/hostname: " + c); + } + break; + + case "port": + if (/[0-9]/.test(c)) { + buffer += c; + } else if (EOF == c || "/" == c || "\\" == c || "?" == c || "#" == c || stateOverride) { + if ("" != buffer) { + var temp = parseInt(buffer, 10); + if (temp != relative[this._scheme]) { + this._port = temp + ""; + } + buffer = ""; + } + if (stateOverride) { + break loop; + } + state = "relative path start"; + continue; + } else if ("\t" == c || "\n" == c || "\r" == c) { + err("Invalid code point in port: " + c); + } else { + invalid.call(this); + } + break; + + case "relative path start": + if ("\\" == c) err("'\\' not allowed in path."); + state = "relative path"; + if ("/" != c && "\\" != c) { + continue; + } + break; + + case "relative path": + if (EOF == c || "/" == c || "\\" == c || !stateOverride && ("?" == c || "#" == c)) { + if ("\\" == c) { + err("\\ not allowed in relative path."); + } + var tmp; + if (tmp = relativePathDotMapping[buffer.toLowerCase()]) { + buffer = tmp; + } + if (".." == buffer) { + this._path.pop(); + if ("/" != c && "\\" != c) { + this._path.push(""); + } + } else if ("." == buffer && "/" != c && "\\" != c) { + this._path.push(""); + } else if ("." != buffer) { + if ("file" == this._scheme && this._path.length == 0 && buffer.length == 2 && ALPHA.test(buffer[0]) && buffer[1] == "|") { + buffer = buffer[0] + ":"; + } + this._path.push(buffer); + } + buffer = ""; + if ("?" == c) { + this._query = "?"; + state = "query"; + } else if ("#" == c) { + this._fragment = "#"; + state = "fragment"; + } + } else if ("\t" != c && "\n" != c && "\r" != c) { + buffer += percentEscape(c); + } + break; + + case "query": + if (!stateOverride && "#" == c) { + this._fragment = "#"; + state = "fragment"; + } else if (EOF != c && "\t" != c && "\n" != c && "\r" != c) { + this._query += percentEscapeQuery(c); + } + break; + + case "fragment": + if (EOF != c && "\t" != c && "\n" != c && "\r" != c) { + this._fragment += c; + } + break; + } + cursor++; + } + } + function clear() { + this._scheme = ""; + this._schemeData = ""; + this._username = ""; + this._password = null; + this._host = ""; + this._port = ""; + this._path = []; + this._query = ""; + this._fragment = ""; + this._isInvalid = false; + this._isRelative = false; + } + function jURL(url, base) { + if (base !== undefined && !(base instanceof jURL)) base = new jURL(String(base)); + this._url = url; + clear.call(this); + var input = url.replace(/^[ \t\r\n\f]+|[ \t\r\n\f]+$/g, ""); + parse.call(this, input, null, base); + } + jURL.prototype = { + toString: function() { + return this.href; + }, + get href() { + if (this._isInvalid) return this._url; + var authority = ""; + if ("" != this._username || null != this._password) { + authority = this._username + (null != this._password ? ":" + this._password : "") + "@"; + } + return this.protocol + (this._isRelative ? "//" + authority + this.host : "") + this.pathname + this._query + this._fragment; + }, + set href(href) { + clear.call(this); + parse.call(this, href); + }, + get protocol() { + return this._scheme + ":"; + }, + set protocol(protocol) { + if (this._isInvalid) return; + parse.call(this, protocol + ":", "scheme start"); + }, + get host() { + return this._isInvalid ? "" : this._port ? this._host + ":" + this._port : this._host; + }, + set host(host) { + if (this._isInvalid || !this._isRelative) return; + parse.call(this, host, "host"); + }, + get hostname() { + return this._host; + }, + set hostname(hostname) { + if (this._isInvalid || !this._isRelative) return; + parse.call(this, hostname, "hostname"); + }, + get port() { + return this._port; + }, + set port(port) { + if (this._isInvalid || !this._isRelative) return; + parse.call(this, port, "port"); + }, + get pathname() { + return this._isInvalid ? "" : this._isRelative ? "/" + this._path.join("/") : this._schemeData; + }, + set pathname(pathname) { + if (this._isInvalid || !this._isRelative) return; + this._path = []; + parse.call(this, pathname, "relative path start"); + }, + get search() { + return this._isInvalid || !this._query || "?" == this._query ? "" : this._query; + }, + set search(search) { + if (this._isInvalid || !this._isRelative) return; + this._query = "?"; + if ("?" == search[0]) search = search.slice(1); + parse.call(this, search, "query"); + }, + get hash() { + return this._isInvalid || !this._fragment || "#" == this._fragment ? "" : this._fragment; + }, + set hash(hash) { + if (this._isInvalid) return; + this._fragment = "#"; + if ("#" == hash[0]) hash = hash.slice(1); + parse.call(this, hash, "fragment"); + }, + get origin() { + var host; + if (this._isInvalid || !this._scheme) { + return ""; + } + switch (this._scheme) { + case "data": + case "file": + case "javascript": + case "mailto": + return "null"; + } + host = this.host; + if (!host) { + return ""; + } + return this._scheme + "://" + host; + } + }; + var OriginalURL = scope.URL; + if (OriginalURL) { + jURL.createObjectURL = function(blob) { + return OriginalURL.createObjectURL.apply(OriginalURL, arguments); + }; + jURL.revokeObjectURL = function(url) { + OriginalURL.revokeObjectURL(url); + }; + } + scope.URL = jURL; + })(self); + if (typeof WeakMap === "undefined") { + (function() { + var defineProperty = Object.defineProperty; + var counter = Date.now() % 1e9; + var WeakMap = function() { + this.name = "__st" + (Math.random() * 1e9 >>> 0) + (counter++ + "__"); + }; + WeakMap.prototype = { + set: function(key, value) { + var entry = key[this.name]; + if (entry && entry[0] === key) entry[1] = value; else defineProperty(key, this.name, { + value: [ key, value ], + writable: true + }); + return this; + }, + get: function(key) { + var entry; + return (entry = key[this.name]) && entry[0] === key ? entry[1] : undefined; + }, + delete: function(key) { + var entry = key[this.name]; + if (!entry || entry[0] !== key) return false; + entry[0] = entry[1] = undefined; + return true; + }, + has: function(key) { + var entry = key[this.name]; + if (!entry) return false; + return entry[0] === key; + } + }; + window.WeakMap = WeakMap; + })(); + } + (function(global) { + if (global.JsMutationObserver) { + return; + } + var registrationsTable = new WeakMap(); + var setImmediate; + if (/Trident|Edge/.test(navigator.userAgent)) { + setImmediate = setTimeout; + } else if (window.setImmediate) { + setImmediate = window.setImmediate; + } else { + var setImmediateQueue = []; + var sentinel = String(Math.random()); + window.addEventListener("message", function(e) { + if (e.data === sentinel) { + var queue = setImmediateQueue; + setImmediateQueue = []; + queue.forEach(function(func) { + func(); + }); + } + }); + setImmediate = function(func) { + setImmediateQueue.push(func); + window.postMessage(sentinel, "*"); + }; + } + var isScheduled = false; + var scheduledObservers = []; + function scheduleCallback(observer) { + scheduledObservers.push(observer); + if (!isScheduled) { + isScheduled = true; + setImmediate(dispatchCallbacks); + } + } + function wrapIfNeeded(node) { + return window.ShadowDOMPolyfill && window.ShadowDOMPolyfill.wrapIfNeeded(node) || node; + } + function dispatchCallbacks() { + isScheduled = false; + var observers = scheduledObservers; + scheduledObservers = []; + observers.sort(function(o1, o2) { + return o1.uid_ - o2.uid_; + }); + var anyNonEmpty = false; + observers.forEach(function(observer) { + var queue = observer.takeRecords(); + removeTransientObserversFor(observer); + if (queue.length) { + observer.callback_(queue, observer); + anyNonEmpty = true; + } + }); + if (anyNonEmpty) dispatchCallbacks(); + } + function removeTransientObserversFor(observer) { + observer.nodes_.forEach(function(node) { + var registrations = registrationsTable.get(node); + if (!registrations) return; + registrations.forEach(function(registration) { + if (registration.observer === observer) registration.removeTransientObservers(); + }); + }); + } + function forEachAncestorAndObserverEnqueueRecord(target, callback) { + for (var node = target; node; node = node.parentNode) { + var registrations = registrationsTable.get(node); + if (registrations) { + for (var j = 0; j < registrations.length; j++) { + var registration = registrations[j]; + var options = registration.options; + if (node !== target && !options.subtree) continue; + var record = callback(options); + if (record) registration.enqueue(record); + } + } + } + } + var uidCounter = 0; + function JsMutationObserver(callback) { + this.callback_ = callback; + this.nodes_ = []; + this.records_ = []; + this.uid_ = ++uidCounter; + } + JsMutationObserver.prototype = { + observe: function(target, options) { + target = wrapIfNeeded(target); + if (!options.childList && !options.attributes && !options.characterData || options.attributeOldValue && !options.attributes || options.attributeFilter && options.attributeFilter.length && !options.attributes || options.characterDataOldValue && !options.characterData) { + throw new SyntaxError(); + } + var registrations = registrationsTable.get(target); + if (!registrations) registrationsTable.set(target, registrations = []); + var registration; + for (var i = 0; i < registrations.length; i++) { + if (registrations[i].observer === this) { + registration = registrations[i]; + registration.removeListeners(); + registration.options = options; + break; + } + } + if (!registration) { + registration = new Registration(this, target, options); + registrations.push(registration); + this.nodes_.push(target); + } + registration.addListeners(); + }, + disconnect: function() { + this.nodes_.forEach(function(node) { + var registrations = registrationsTable.get(node); + for (var i = 0; i < registrations.length; i++) { + var registration = registrations[i]; + if (registration.observer === this) { + registration.removeListeners(); + registrations.splice(i, 1); + break; + } + } + }, this); + this.records_ = []; + }, + takeRecords: function() { + var copyOfRecords = this.records_; + this.records_ = []; + return copyOfRecords; + } + }; + function MutationRecord(type, target) { + this.type = type; + this.target = target; + this.addedNodes = []; + this.removedNodes = []; + this.previousSibling = null; + this.nextSibling = null; + this.attributeName = null; + this.attributeNamespace = null; + this.oldValue = null; + } + function copyMutationRecord(original) { + var record = new MutationRecord(original.type, original.target); + record.addedNodes = original.addedNodes.slice(); + record.removedNodes = original.removedNodes.slice(); + record.previousSibling = original.previousSibling; + record.nextSibling = original.nextSibling; + record.attributeName = original.attributeName; + record.attributeNamespace = original.attributeNamespace; + record.oldValue = original.oldValue; + return record; + } + var currentRecord, recordWithOldValue; + function getRecord(type, target) { + return currentRecord = new MutationRecord(type, target); + } + function getRecordWithOldValue(oldValue) { + if (recordWithOldValue) return recordWithOldValue; + recordWithOldValue = copyMutationRecord(currentRecord); + recordWithOldValue.oldValue = oldValue; + return recordWithOldValue; + } + function clearRecords() { + currentRecord = recordWithOldValue = undefined; + } + function recordRepresentsCurrentMutation(record) { + return record === recordWithOldValue || record === currentRecord; + } + function selectRecord(lastRecord, newRecord) { + if (lastRecord === newRecord) return lastRecord; + if (recordWithOldValue && recordRepresentsCurrentMutation(lastRecord)) return recordWithOldValue; + return null; + } + function Registration(observer, target, options) { + this.observer = observer; + this.target = target; + this.options = options; + this.transientObservedNodes = []; + } + Registration.prototype = { + enqueue: function(record) { + var records = this.observer.records_; + var length = records.length; + if (records.length > 0) { + var lastRecord = records[length - 1]; + var recordToReplaceLast = selectRecord(lastRecord, record); + if (recordToReplaceLast) { + records[length - 1] = recordToReplaceLast; + return; + } + } else { + scheduleCallback(this.observer); + } + records[length] = record; + }, + addListeners: function() { + this.addListeners_(this.target); + }, + addListeners_: function(node) { + var options = this.options; + if (options.attributes) node.addEventListener("DOMAttrModified", this, true); + if (options.characterData) node.addEventListener("DOMCharacterDataModified", this, true); + if (options.childList) node.addEventListener("DOMNodeInserted", this, true); + if (options.childList || options.subtree) node.addEventListener("DOMNodeRemoved", this, true); + }, + removeListeners: function() { + this.removeListeners_(this.target); + }, + removeListeners_: function(node) { + var options = this.options; + if (options.attributes) node.removeEventListener("DOMAttrModified", this, true); + if (options.characterData) node.removeEventListener("DOMCharacterDataModified", this, true); + if (options.childList) node.removeEventListener("DOMNodeInserted", this, true); + if (options.childList || options.subtree) node.removeEventListener("DOMNodeRemoved", this, true); + }, + addTransientObserver: function(node) { + if (node === this.target) return; + this.addListeners_(node); + this.transientObservedNodes.push(node); + var registrations = registrationsTable.get(node); + if (!registrations) registrationsTable.set(node, registrations = []); + registrations.push(this); + }, + removeTransientObservers: function() { + var transientObservedNodes = this.transientObservedNodes; + this.transientObservedNodes = []; + transientObservedNodes.forEach(function(node) { + this.removeListeners_(node); + var registrations = registrationsTable.get(node); + for (var i = 0; i < registrations.length; i++) { + if (registrations[i] === this) { + registrations.splice(i, 1); + break; + } + } + }, this); + }, + handleEvent: function(e) { + e.stopImmediatePropagation(); + switch (e.type) { + case "DOMAttrModified": + var name = e.attrName; + var namespace = e.relatedNode.namespaceURI; + var target = e.target; + var record = new getRecord("attributes", target); + record.attributeName = name; + record.attributeNamespace = namespace; + var oldValue = e.attrChange === MutationEvent.ADDITION ? null : e.prevValue; + forEachAncestorAndObserverEnqueueRecord(target, function(options) { + if (!options.attributes) return; + if (options.attributeFilter && options.attributeFilter.length && options.attributeFilter.indexOf(name) === -1 && options.attributeFilter.indexOf(namespace) === -1) { + return; + } + if (options.attributeOldValue) return getRecordWithOldValue(oldValue); + return record; + }); + break; + + case "DOMCharacterDataModified": + var target = e.target; + var record = getRecord("characterData", target); + var oldValue = e.prevValue; + forEachAncestorAndObserverEnqueueRecord(target, function(options) { + if (!options.characterData) return; + if (options.characterDataOldValue) return getRecordWithOldValue(oldValue); + return record; + }); + break; + + case "DOMNodeRemoved": + this.addTransientObserver(e.target); + + case "DOMNodeInserted": + var changedNode = e.target; + var addedNodes, removedNodes; + if (e.type === "DOMNodeInserted") { + addedNodes = [ changedNode ]; + removedNodes = []; + } else { + addedNodes = []; + removedNodes = [ changedNode ]; + } + var previousSibling = changedNode.previousSibling; + var nextSibling = changedNode.nextSibling; + var record = getRecord("childList", e.target.parentNode); + record.addedNodes = addedNodes; + record.removedNodes = removedNodes; + record.previousSibling = previousSibling; + record.nextSibling = nextSibling; + forEachAncestorAndObserverEnqueueRecord(e.relatedNode, function(options) { + if (!options.childList) return; + return record; + }); + } + clearRecords(); + } + }; + global.JsMutationObserver = JsMutationObserver; + if (!global.MutationObserver) { + global.MutationObserver = JsMutationObserver; + JsMutationObserver._isPolyfilled = true; + } + })(self); + (function() { + var needsTemplate = typeof HTMLTemplateElement === "undefined"; + if (/Trident/.test(navigator.userAgent)) { + (function() { + var importNode = document.importNode; + document.importNode = function() { + var n = importNode.apply(document, arguments); + if (n.nodeType === Node.DOCUMENT_FRAGMENT_NODE) { + var f = document.createDocumentFragment(); + f.appendChild(n); + return f; + } else { + return n; + } + }; + })(); + } + var needsCloning = function() { + if (!needsTemplate) { + var t = document.createElement("template"); + var t2 = document.createElement("template"); + t2.content.appendChild(document.createElement("div")); + t.content.appendChild(t2); + var clone = t.cloneNode(true); + return clone.content.childNodes.length === 0 || clone.content.firstChild.content.childNodes.length === 0; + } + }(); + var TEMPLATE_TAG = "template"; + var TemplateImpl = function() {}; + if (needsTemplate) { + var contentDoc = document.implementation.createHTMLDocument("template"); + var canDecorate = true; + var templateStyle = document.createElement("style"); + templateStyle.textContent = TEMPLATE_TAG + "{display:none;}"; + var head = document.head; + head.insertBefore(templateStyle, head.firstElementChild); + TemplateImpl.prototype = Object.create(HTMLElement.prototype); + TemplateImpl.decorate = function(template) { + if (template.content) { + return; + } + template.content = contentDoc.createDocumentFragment(); + var child; + while (child = template.firstChild) { + template.content.appendChild(child); + } + template.cloneNode = function(deep) { + return TemplateImpl.cloneNode(this, deep); + }; + if (canDecorate) { + try { + Object.defineProperty(template, "innerHTML", { + get: function() { + var o = ""; + for (var e = this.content.firstChild; e; e = e.nextSibling) { + o += e.outerHTML || escapeData(e.data); + } + return o; + }, + set: function(text) { + contentDoc.body.innerHTML = text; + TemplateImpl.bootstrap(contentDoc); + while (this.content.firstChild) { + this.content.removeChild(this.content.firstChild); + } + while (contentDoc.body.firstChild) { + this.content.appendChild(contentDoc.body.firstChild); + } + }, + configurable: true + }); + } catch (err) { + canDecorate = false; + } + } + TemplateImpl.bootstrap(template.content); + }; + TemplateImpl.bootstrap = function(doc) { + var templates = doc.querySelectorAll(TEMPLATE_TAG); + for (var i = 0, l = templates.length, t; i < l && (t = templates[i]); i++) { + TemplateImpl.decorate(t); + } + }; + document.addEventListener("DOMContentLoaded", function() { + TemplateImpl.bootstrap(document); + }); + var createElement = document.createElement; + document.createElement = function() { + "use strict"; + var el = createElement.apply(document, arguments); + if (el.localName === "template") { + TemplateImpl.decorate(el); + } + return el; + }; + var escapeDataRegExp = /[&\u00A0<>]/g; + function escapeReplace(c) { + switch (c) { + case "&": + return "&"; + + case "<": + return "<"; + + case ">": + return ">"; + + case " ": + return " "; + } + } + function escapeData(s) { + return s.replace(escapeDataRegExp, escapeReplace); + } + } + if (needsTemplate || needsCloning) { + var nativeCloneNode = Node.prototype.cloneNode; + TemplateImpl.cloneNode = function(template, deep) { + var clone = nativeCloneNode.call(template, false); + if (this.decorate) { + this.decorate(clone); + } + if (deep) { + clone.content.appendChild(nativeCloneNode.call(template.content, true)); + this.fixClonedDom(clone.content, template.content); + } + return clone; + }; + TemplateImpl.fixClonedDom = function(clone, source) { + if (!source.querySelectorAll) return; + var s$ = source.querySelectorAll(TEMPLATE_TAG); + var t$ = clone.querySelectorAll(TEMPLATE_TAG); + for (var i = 0, l = t$.length, t, s; i < l; i++) { + s = s$[i]; + t = t$[i]; + if (this.decorate) { + this.decorate(s); + } + t.parentNode.replaceChild(s.cloneNode(true), t); + } + }; + var originalImportNode = document.importNode; + Node.prototype.cloneNode = function(deep) { + var dom = nativeCloneNode.call(this, deep); + if (deep) { + TemplateImpl.fixClonedDom(dom, this); + } + return dom; + }; + document.importNode = function(element, deep) { + if (element.localName === TEMPLATE_TAG) { + return TemplateImpl.cloneNode(element, deep); + } else { + var dom = originalImportNode.call(document, element, deep); + if (deep) { + TemplateImpl.fixClonedDom(dom, element); + } + return dom; + } + }; + if (needsCloning) { + HTMLTemplateElement.prototype.cloneNode = function(deep) { + return TemplateImpl.cloneNode(this, deep); + }; + } + } + if (needsTemplate) { + window.HTMLTemplateElement = TemplateImpl; + } + })(); + (function(scope) { + "use strict"; + if (!(window.performance && window.performance.now)) { + var start = Date.now(); + window.performance = { + now: function() { + return Date.now() - start; + } + }; + } + if (!window.requestAnimationFrame) { + window.requestAnimationFrame = function() { + var nativeRaf = window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame; + return nativeRaf ? function(callback) { + return nativeRaf(function() { + callback(performance.now()); + }); + } : function(callback) { + return window.setTimeout(callback, 1e3 / 60); + }; + }(); + } + if (!window.cancelAnimationFrame) { + window.cancelAnimationFrame = function() { + return window.webkitCancelAnimationFrame || window.mozCancelAnimationFrame || function(id) { + clearTimeout(id); + }; + }(); + } + var workingDefaultPrevented = function() { + var e = document.createEvent("Event"); + e.initEvent("foo", true, true); + e.preventDefault(); + return e.defaultPrevented; + }(); + if (!workingDefaultPrevented) { + var origPreventDefault = Event.prototype.preventDefault; + Event.prototype.preventDefault = function() { + if (!this.cancelable) { + return; + } + origPreventDefault.call(this); + Object.defineProperty(this, "defaultPrevented", { + get: function() { + return true; + }, + configurable: true + }); + }; + } + var isIE = /Trident/.test(navigator.userAgent); + if (!window.CustomEvent || isIE && typeof window.CustomEvent !== "function") { + window.CustomEvent = function(inType, params) { + params = params || {}; + var e = document.createEvent("CustomEvent"); + e.initCustomEvent(inType, Boolean(params.bubbles), Boolean(params.cancelable), params.detail); + return e; + }; + window.CustomEvent.prototype = window.Event.prototype; + } + if (!window.Event || isIE && typeof window.Event !== "function") { + var origEvent = window.Event; + window.Event = function(inType, params) { + params = params || {}; + var e = document.createEvent("Event"); + e.initEvent(inType, Boolean(params.bubbles), Boolean(params.cancelable)); + return e; + }; + window.Event.prototype = origEvent.prototype; + } + })(window.WebComponents); + window.HTMLImports = window.HTMLImports || { + flags: {} + }; + (function(scope) { + var IMPORT_LINK_TYPE = "import"; + var useNative = Boolean(IMPORT_LINK_TYPE in document.createElement("link")); + var hasShadowDOMPolyfill = Boolean(window.ShadowDOMPolyfill); + var wrap = function(node) { + return hasShadowDOMPolyfill ? window.ShadowDOMPolyfill.wrapIfNeeded(node) : node; + }; + var rootDocument = wrap(document); + var currentScriptDescriptor = { + get: function() { + var script = window.HTMLImports.currentScript || document.currentScript || (document.readyState !== "complete" ? document.scripts[document.scripts.length - 1] : null); + return wrap(script); + }, + configurable: true + }; + Object.defineProperty(document, "_currentScript", currentScriptDescriptor); + Object.defineProperty(rootDocument, "_currentScript", currentScriptDescriptor); + var isIE = /Trident/.test(navigator.userAgent); + function whenReady(callback, doc) { + doc = doc || rootDocument; + whenDocumentReady(function() { + watchImportsLoad(callback, doc); + }, doc); + } + var requiredReadyState = isIE ? "complete" : "interactive"; + var READY_EVENT = "readystatechange"; + function isDocumentReady(doc) { + return doc.readyState === "complete" || doc.readyState === requiredReadyState; + } + function whenDocumentReady(callback, doc) { + if (!isDocumentReady(doc)) { + var checkReady = function() { + if (doc.readyState === "complete" || doc.readyState === requiredReadyState) { + doc.removeEventListener(READY_EVENT, checkReady); + whenDocumentReady(callback, doc); + } + }; + doc.addEventListener(READY_EVENT, checkReady); + } else if (callback) { + callback(); + } + } + function markTargetLoaded(event) { + event.target.__loaded = true; + } + function watchImportsLoad(callback, doc) { + var imports = doc.querySelectorAll("link[rel=import]"); + var parsedCount = 0, importCount = imports.length, newImports = [], errorImports = []; + function checkDone() { + if (parsedCount == importCount && callback) { + callback({ + allImports: imports, + loadedImports: newImports, + errorImports: errorImports + }); + } + } + function loadedImport(e) { + markTargetLoaded(e); + newImports.push(this); + parsedCount++; + checkDone(); + } + function errorLoadingImport(e) { + errorImports.push(this); + parsedCount++; + checkDone(); + } + if (importCount) { + for (var i = 0, imp; i < importCount && (imp = imports[i]); i++) { + if (isImportLoaded(imp)) { + newImports.push(this); + parsedCount++; + checkDone(); + } else { + imp.addEventListener("load", loadedImport); + imp.addEventListener("error", errorLoadingImport); + } + } + } else { + checkDone(); + } + } + function isImportLoaded(link) { + return useNative ? link.__loaded || link.import && link.import.readyState !== "loading" : link.__importParsed; + } + if (useNative) { + new MutationObserver(function(mxns) { + for (var i = 0, l = mxns.length, m; i < l && (m = mxns[i]); i++) { + if (m.addedNodes) { + handleImports(m.addedNodes); + } + } + }).observe(document.head, { + childList: true + }); + function handleImports(nodes) { + for (var i = 0, l = nodes.length, n; i < l && (n = nodes[i]); i++) { + if (isImport(n)) { + handleImport(n); + } + } + } + function isImport(element) { + return element.localName === "link" && element.rel === "import"; + } + function handleImport(element) { + var loaded = element.import; + if (loaded) { + markTargetLoaded({ + target: element + }); + } else { + element.addEventListener("load", markTargetLoaded); + element.addEventListener("error", markTargetLoaded); + } + } + (function() { + if (document.readyState === "loading") { + var imports = document.querySelectorAll("link[rel=import]"); + for (var i = 0, l = imports.length, imp; i < l && (imp = imports[i]); i++) { + handleImport(imp); + } + } + })(); + } + whenReady(function(detail) { + window.HTMLImports.ready = true; + window.HTMLImports.readyTime = new Date().getTime(); + var evt = rootDocument.createEvent("CustomEvent"); + evt.initCustomEvent("HTMLImportsLoaded", true, true, detail); + rootDocument.dispatchEvent(evt); + }); + scope.IMPORT_LINK_TYPE = IMPORT_LINK_TYPE; + scope.useNative = useNative; + scope.rootDocument = rootDocument; + scope.whenReady = whenReady; + scope.isIE = isIE; + })(window.HTMLImports); + (function(scope) { + var modules = []; + var addModule = function(module) { + modules.push(module); + }; + var initializeModules = function() { + modules.forEach(function(module) { + module(scope); + }); + }; + scope.addModule = addModule; + scope.initializeModules = initializeModules; + })(window.HTMLImports); + window.HTMLImports.addModule(function(scope) { + var CSS_URL_REGEXP = /(url\()([^)]*)(\))/g; + var CSS_IMPORT_REGEXP = /(@import[\s]+(?!url\())([^;]*)(;)/g; + var path = { + resolveUrlsInStyle: function(style, linkUrl) { + var doc = style.ownerDocument; + var resolver = doc.createElement("a"); + style.textContent = this.resolveUrlsInCssText(style.textContent, linkUrl, resolver); + return style; + }, + resolveUrlsInCssText: function(cssText, linkUrl, urlObj) { + var r = this.replaceUrls(cssText, urlObj, linkUrl, CSS_URL_REGEXP); + r = this.replaceUrls(r, urlObj, linkUrl, CSS_IMPORT_REGEXP); + return r; + }, + replaceUrls: function(text, urlObj, linkUrl, regexp) { + return text.replace(regexp, function(m, pre, url, post) { + var urlPath = url.replace(/["']/g, ""); + if (linkUrl) { + urlPath = new URL(urlPath, linkUrl).href; + } + urlObj.href = urlPath; + urlPath = urlObj.href; + return pre + "'" + urlPath + "'" + post; + }); + } + }; + scope.path = path; + }); + window.HTMLImports.addModule(function(scope) { + var xhr = { + async: true, + ok: function(request) { + return request.status >= 200 && request.status < 300 || request.status === 304 || request.status === 0; + }, + load: function(url, next, nextContext) { + var request = new XMLHttpRequest(); + if (scope.flags.debug || scope.flags.bust) { + url += "?" + Math.random(); + } + request.open("GET", url, xhr.async); + request.addEventListener("readystatechange", function(e) { + if (request.readyState === 4) { + var redirectedUrl = null; + try { + var locationHeader = request.getResponseHeader("Location"); + if (locationHeader) { + redirectedUrl = locationHeader.substr(0, 1) === "/" ? location.origin + locationHeader : locationHeader; + } + } catch (e) { + console.error(e.message); + } + next.call(nextContext, !xhr.ok(request) && request, request.response || request.responseText, redirectedUrl); + } + }); + request.send(); + return request; + }, + loadDocument: function(url, next, nextContext) { + this.load(url, next, nextContext).responseType = "document"; + } + }; + scope.xhr = xhr; + }); + window.HTMLImports.addModule(function(scope) { + var xhr = scope.xhr; + var flags = scope.flags; + var Loader = function(onLoad, onComplete) { + this.cache = {}; + this.onload = onLoad; + this.oncomplete = onComplete; + this.inflight = 0; + this.pending = {}; + }; + Loader.prototype = { + addNodes: function(nodes) { + this.inflight += nodes.length; + for (var i = 0, l = nodes.length, n; i < l && (n = nodes[i]); i++) { + this.require(n); + } + this.checkDone(); + }, + addNode: function(node) { + this.inflight++; + this.require(node); + this.checkDone(); + }, + require: function(elt) { + var url = elt.src || elt.href; + elt.__nodeUrl = url; + if (!this.dedupe(url, elt)) { + this.fetch(url, elt); + } + }, + dedupe: function(url, elt) { + if (this.pending[url]) { + this.pending[url].push(elt); + return true; + } + var resource; + if (this.cache[url]) { + this.onload(url, elt, this.cache[url]); + this.tail(); + return true; + } + this.pending[url] = [ elt ]; + return false; + }, + fetch: function(url, elt) { + flags.load && console.log("fetch", url, elt); + if (!url) { + setTimeout(function() { + this.receive(url, elt, { + error: "href must be specified" + }, null); + }.bind(this), 0); + } else if (url.match(/^data:/)) { + var pieces = url.split(","); + var header = pieces[0]; + var body = pieces[1]; + if (header.indexOf(";base64") > -1) { + body = atob(body); + } else { + body = decodeURIComponent(body); + } + setTimeout(function() { + this.receive(url, elt, null, body); + }.bind(this), 0); + } else { + var receiveXhr = function(err, resource, redirectedUrl) { + this.receive(url, elt, err, resource, redirectedUrl); + }.bind(this); + xhr.load(url, receiveXhr); + } + }, + receive: function(url, elt, err, resource, redirectedUrl) { + this.cache[url] = resource; + var $p = this.pending[url]; + for (var i = 0, l = $p.length, p; i < l && (p = $p[i]); i++) { + this.onload(url, p, resource, err, redirectedUrl); + this.tail(); + } + this.pending[url] = null; + }, + tail: function() { + --this.inflight; + this.checkDone(); + }, + checkDone: function() { + if (!this.inflight) { + this.oncomplete(); + } + } + }; + scope.Loader = Loader; + }); + window.HTMLImports.addModule(function(scope) { + var Observer = function(addCallback) { + this.addCallback = addCallback; + this.mo = new MutationObserver(this.handler.bind(this)); + }; + Observer.prototype = { + handler: function(mutations) { + for (var i = 0, l = mutations.length, m; i < l && (m = mutations[i]); i++) { + if (m.type === "childList" && m.addedNodes.length) { + this.addedNodes(m.addedNodes); + } + } + }, + addedNodes: function(nodes) { + if (this.addCallback) { + this.addCallback(nodes); + } + for (var i = 0, l = nodes.length, n, loading; i < l && (n = nodes[i]); i++) { + if (n.children && n.children.length) { + this.addedNodes(n.children); + } + } + }, + observe: function(root) { + this.mo.observe(root, { + childList: true, + subtree: true + }); + } + }; + scope.Observer = Observer; + }); + window.HTMLImports.addModule(function(scope) { + var path = scope.path; + var rootDocument = scope.rootDocument; + var flags = scope.flags; + var isIE = scope.isIE; + var IMPORT_LINK_TYPE = scope.IMPORT_LINK_TYPE; + var IMPORT_SELECTOR = "link[rel=" + IMPORT_LINK_TYPE + "]"; + var importParser = { + documentSelectors: IMPORT_SELECTOR, + importsSelectors: [ IMPORT_SELECTOR, "link[rel=stylesheet]:not([type])", "style:not([type])", "script:not([type])", 'script[type="application/javascript"]', 'script[type="text/javascript"]' ].join(","), + map: { + link: "parseLink", + script: "parseScript", + style: "parseStyle" + }, + dynamicElements: [], + parseNext: function() { + var next = this.nextToParse(); + if (next) { + this.parse(next); + } + }, + parse: function(elt) { + if (this.isParsed(elt)) { + flags.parse && console.log("[%s] is already parsed", elt.localName); + return; + } + var fn = this[this.map[elt.localName]]; + if (fn) { + this.markParsing(elt); + fn.call(this, elt); + } + }, + parseDynamic: function(elt, quiet) { + this.dynamicElements.push(elt); + if (!quiet) { + this.parseNext(); + } + }, + markParsing: function(elt) { + flags.parse && console.log("parsing", elt); + this.parsingElement = elt; + }, + markParsingComplete: function(elt) { + elt.__importParsed = true; + this.markDynamicParsingComplete(elt); + if (elt.__importElement) { + elt.__importElement.__importParsed = true; + this.markDynamicParsingComplete(elt.__importElement); + } + this.parsingElement = null; + flags.parse && console.log("completed", elt); + }, + markDynamicParsingComplete: function(elt) { + var i = this.dynamicElements.indexOf(elt); + if (i >= 0) { + this.dynamicElements.splice(i, 1); + } + }, + parseImport: function(elt) { + elt.import = elt.__doc; + if (window.HTMLImports.__importsParsingHook) { + window.HTMLImports.__importsParsingHook(elt); + } + if (elt.import) { + elt.import.__importParsed = true; + } + this.markParsingComplete(elt); + if (elt.__resource && !elt.__error) { + elt.dispatchEvent(new CustomEvent("load", { + bubbles: false + })); + } else { + elt.dispatchEvent(new CustomEvent("error", { + bubbles: false + })); + } + if (elt.__pending) { + var fn; + while (elt.__pending.length) { + fn = elt.__pending.shift(); + if (fn) { + fn({ + target: elt + }); + } + } + } + this.parseNext(); + }, + parseLink: function(linkElt) { + if (nodeIsImport(linkElt)) { + this.parseImport(linkElt); + } else { + linkElt.href = linkElt.href; + this.parseGeneric(linkElt); + } + }, + parseStyle: function(elt) { + var src = elt; + elt = cloneStyle(elt); + src.__appliedElement = elt; + elt.__importElement = src; + this.parseGeneric(elt); + }, + parseGeneric: function(elt) { + this.trackElement(elt); + this.addElementToDocument(elt); + }, + rootImportForElement: function(elt) { + var n = elt; + while (n.ownerDocument.__importLink) { + n = n.ownerDocument.__importLink; + } + return n; + }, + addElementToDocument: function(elt) { + var port = this.rootImportForElement(elt.__importElement || elt); + port.parentNode.insertBefore(elt, port); + }, + trackElement: function(elt, callback) { + var self = this; + var done = function(e) { + elt.removeEventListener("load", done); + elt.removeEventListener("error", done); + if (callback) { + callback(e); + } + self.markParsingComplete(elt); + self.parseNext(); + }; + elt.addEventListener("load", done); + elt.addEventListener("error", done); + if (isIE && elt.localName === "style") { + var fakeLoad = false; + if (elt.textContent.indexOf("@import") == -1) { + fakeLoad = true; + } else if (elt.sheet) { + fakeLoad = true; + var csr = elt.sheet.cssRules; + var len = csr ? csr.length : 0; + for (var i = 0, r; i < len && (r = csr[i]); i++) { + if (r.type === CSSRule.IMPORT_RULE) { + fakeLoad = fakeLoad && Boolean(r.styleSheet); + } + } + } + if (fakeLoad) { + setTimeout(function() { + elt.dispatchEvent(new CustomEvent("load", { + bubbles: false + })); + }); + } + } + }, + parseScript: function(scriptElt) { + var script = document.createElement("script"); + script.__importElement = scriptElt; + script.src = scriptElt.src ? scriptElt.src : generateScriptDataUrl(scriptElt); + scope.currentScript = scriptElt; + this.trackElement(script, function(e) { + if (script.parentNode) { + script.parentNode.removeChild(script); + } + scope.currentScript = null; + }); + this.addElementToDocument(script); + }, + nextToParse: function() { + this._mayParse = []; + return !this.parsingElement && (this.nextToParseInDoc(rootDocument) || this.nextToParseDynamic()); + }, + nextToParseInDoc: function(doc, link) { + if (doc && this._mayParse.indexOf(doc) < 0) { + this._mayParse.push(doc); + var nodes = doc.querySelectorAll(this.parseSelectorsForNode(doc)); + for (var i = 0, l = nodes.length, n; i < l && (n = nodes[i]); i++) { + if (!this.isParsed(n)) { + if (this.hasResource(n)) { + return nodeIsImport(n) ? this.nextToParseInDoc(n.__doc, n) : n; + } else { + return; + } + } + } + } + return link; + }, + nextToParseDynamic: function() { + return this.dynamicElements[0]; + }, + parseSelectorsForNode: function(node) { + var doc = node.ownerDocument || node; + return doc === rootDocument ? this.documentSelectors : this.importsSelectors; + }, + isParsed: function(node) { + return node.__importParsed; + }, + needsDynamicParsing: function(elt) { + return this.dynamicElements.indexOf(elt) >= 0; + }, + hasResource: function(node) { + if (nodeIsImport(node) && node.__doc === undefined) { + return false; + } + return true; + } + }; + function nodeIsImport(elt) { + return elt.localName === "link" && elt.rel === IMPORT_LINK_TYPE; + } + function generateScriptDataUrl(script) { + var scriptContent = generateScriptContent(script); + return "data:text/javascript;charset=utf-8," + encodeURIComponent(scriptContent); + } + function generateScriptContent(script) { + return script.textContent + generateSourceMapHint(script); + } + function generateSourceMapHint(script) { + var owner = script.ownerDocument; + owner.__importedScripts = owner.__importedScripts || 0; + var moniker = script.ownerDocument.baseURI; + var num = owner.__importedScripts ? "-" + owner.__importedScripts : ""; + owner.__importedScripts++; + return "\n//# sourceURL=" + moniker + num + ".js\n"; + } + function cloneStyle(style) { + var clone = style.ownerDocument.createElement("style"); + clone.textContent = style.textContent; + path.resolveUrlsInStyle(clone); + return clone; + } + scope.parser = importParser; + scope.IMPORT_SELECTOR = IMPORT_SELECTOR; + }); + window.HTMLImports.addModule(function(scope) { + var flags = scope.flags; + var IMPORT_LINK_TYPE = scope.IMPORT_LINK_TYPE; + var IMPORT_SELECTOR = scope.IMPORT_SELECTOR; + var rootDocument = scope.rootDocument; + var Loader = scope.Loader; + var Observer = scope.Observer; + var parser = scope.parser; + var importer = { + documents: {}, + documentPreloadSelectors: IMPORT_SELECTOR, + importsPreloadSelectors: [ IMPORT_SELECTOR ].join(","), + loadNode: function(node) { + importLoader.addNode(node); + }, + loadSubtree: function(parent) { + var nodes = this.marshalNodes(parent); + importLoader.addNodes(nodes); + }, + marshalNodes: function(parent) { + return parent.querySelectorAll(this.loadSelectorsForNode(parent)); + }, + loadSelectorsForNode: function(node) { + var doc = node.ownerDocument || node; + return doc === rootDocument ? this.documentPreloadSelectors : this.importsPreloadSelectors; + }, + loaded: function(url, elt, resource, err, redirectedUrl) { + flags.load && console.log("loaded", url, elt); + elt.__resource = resource; + elt.__error = err; + if (isImportLink(elt)) { + var doc = this.documents[url]; + if (doc === undefined) { + doc = err ? null : makeDocument(resource, redirectedUrl || url); + if (doc) { + doc.__importLink = elt; + this.bootDocument(doc); + } + this.documents[url] = doc; + } + elt.__doc = doc; + } + parser.parseNext(); + }, + bootDocument: function(doc) { + this.loadSubtree(doc); + this.observer.observe(doc); + parser.parseNext(); + }, + loadedAll: function() { + parser.parseNext(); + } + }; + var importLoader = new Loader(importer.loaded.bind(importer), importer.loadedAll.bind(importer)); + importer.observer = new Observer(); + function isImportLink(elt) { + return isLinkRel(elt, IMPORT_LINK_TYPE); + } + function isLinkRel(elt, rel) { + return elt.localName === "link" && elt.getAttribute("rel") === rel; + } + function hasBaseURIAccessor(doc) { + return !!Object.getOwnPropertyDescriptor(doc, "baseURI"); + } + function makeDocument(resource, url) { + var doc = document.implementation.createHTMLDocument(IMPORT_LINK_TYPE); + doc._URL = url; + var base = doc.createElement("base"); + base.setAttribute("href", url); + if (!doc.baseURI && !hasBaseURIAccessor(doc)) { + Object.defineProperty(doc, "baseURI", { + value: url + }); + } + var meta = doc.createElement("meta"); + meta.setAttribute("charset", "utf-8"); + doc.head.appendChild(meta); + doc.head.appendChild(base); + doc.body.innerHTML = resource; + if (window.HTMLTemplateElement && HTMLTemplateElement.bootstrap) { + HTMLTemplateElement.bootstrap(doc); + } + return doc; + } + if (!document.baseURI) { + var baseURIDescriptor = { + get: function() { + var base = document.querySelector("base"); + return base ? base.href : window.location.href; + }, + configurable: true + }; + Object.defineProperty(document, "baseURI", baseURIDescriptor); + Object.defineProperty(rootDocument, "baseURI", baseURIDescriptor); + } + scope.importer = importer; + scope.importLoader = importLoader; + }); + window.HTMLImports.addModule(function(scope) { + var parser = scope.parser; + var importer = scope.importer; + var dynamic = { + added: function(nodes) { + var owner, parsed, loading; + for (var i = 0, l = nodes.length, n; i < l && (n = nodes[i]); i++) { + if (!owner) { + owner = n.ownerDocument; + parsed = parser.isParsed(owner); + } + loading = this.shouldLoadNode(n); + if (loading) { + importer.loadNode(n); + } + if (this.shouldParseNode(n) && parsed) { + parser.parseDynamic(n, loading); + } + } + }, + shouldLoadNode: function(node) { + return node.nodeType === 1 && matches.call(node, importer.loadSelectorsForNode(node)); + }, + shouldParseNode: function(node) { + return node.nodeType === 1 && matches.call(node, parser.parseSelectorsForNode(node)); + } + }; + importer.observer.addCallback = dynamic.added.bind(dynamic); + var matches = HTMLElement.prototype.matches || HTMLElement.prototype.matchesSelector || HTMLElement.prototype.webkitMatchesSelector || HTMLElement.prototype.mozMatchesSelector || HTMLElement.prototype.msMatchesSelector; + }); + (function(scope) { + var initializeModules = scope.initializeModules; + var isIE = scope.isIE; + if (scope.useNative) { + return; + } + initializeModules(); + var rootDocument = scope.rootDocument; + function bootstrap() { + window.HTMLImports.importer.bootDocument(rootDocument); + } + if (document.readyState === "complete" || document.readyState === "interactive" && !window.attachEvent) { + bootstrap(); + } else { + document.addEventListener("DOMContentLoaded", bootstrap); + } + })(window.HTMLImports); + window.CustomElements = window.CustomElements || { + flags: {} + }; + (function(scope) { + var flags = scope.flags; + var modules = []; + var addModule = function(module) { + modules.push(module); + }; + var initializeModules = function() { + modules.forEach(function(module) { + module(scope); + }); + }; + scope.addModule = addModule; + scope.initializeModules = initializeModules; + scope.hasNative = Boolean(document.registerElement); + scope.isIE = /Trident/.test(navigator.userAgent); + scope.useNative = !flags.register && scope.hasNative && !window.ShadowDOMPolyfill && (!window.HTMLImports || window.HTMLImports.useNative); + })(window.CustomElements); + window.CustomElements.addModule(function(scope) { + var IMPORT_LINK_TYPE = window.HTMLImports ? window.HTMLImports.IMPORT_LINK_TYPE : "none"; + function forSubtree(node, cb) { + findAllElements(node, function(e) { + if (cb(e)) { + return true; + } + forRoots(e, cb); + }); + forRoots(node, cb); + } + function findAllElements(node, find, data) { + var e = node.firstElementChild; + if (!e) { + e = node.firstChild; + while (e && e.nodeType !== Node.ELEMENT_NODE) { + e = e.nextSibling; + } + } + while (e) { + if (find(e, data) !== true) { + findAllElements(e, find, data); + } + e = e.nextElementSibling; + } + return null; + } + function forRoots(node, cb) { + var root = node.shadowRoot; + while (root) { + forSubtree(root, cb); + root = root.olderShadowRoot; + } + } + function forDocumentTree(doc, cb) { + _forDocumentTree(doc, cb, []); + } + function _forDocumentTree(doc, cb, processingDocuments) { + doc = window.wrap(doc); + if (processingDocuments.indexOf(doc) >= 0) { + return; + } + processingDocuments.push(doc); + var imports = doc.querySelectorAll("link[rel=" + IMPORT_LINK_TYPE + "]"); + for (var i = 0, l = imports.length, n; i < l && (n = imports[i]); i++) { + if (n.import) { + _forDocumentTree(n.import, cb, processingDocuments); + } + } + cb(doc); + } + scope.forDocumentTree = forDocumentTree; + scope.forSubtree = forSubtree; + }); + window.CustomElements.addModule(function(scope) { + var flags = scope.flags; + var forSubtree = scope.forSubtree; + var forDocumentTree = scope.forDocumentTree; + function addedNode(node, isAttached) { + return added(node, isAttached) || addedSubtree(node, isAttached); + } + function added(node, isAttached) { + if (scope.upgrade(node, isAttached)) { + return true; + } + if (isAttached) { + attached(node); + } + } + function addedSubtree(node, isAttached) { + forSubtree(node, function(e) { + if (added(e, isAttached)) { + return true; + } + }); + } + var hasThrottledAttached = window.MutationObserver._isPolyfilled && flags["throttle-attached"]; + scope.hasPolyfillMutations = hasThrottledAttached; + scope.hasThrottledAttached = hasThrottledAttached; + var isPendingMutations = false; + var pendingMutations = []; + function deferMutation(fn) { + pendingMutations.push(fn); + if (!isPendingMutations) { + isPendingMutations = true; + setTimeout(takeMutations); + } + } + function takeMutations() { + isPendingMutations = false; + var $p = pendingMutations; + for (var i = 0, l = $p.length, p; i < l && (p = $p[i]); i++) { + p(); + } + pendingMutations = []; + } + function attached(element) { + if (hasThrottledAttached) { + deferMutation(function() { + _attached(element); + }); + } else { + _attached(element); + } + } + function _attached(element) { + if (element.__upgraded__ && !element.__attached) { + element.__attached = true; + if (element.attachedCallback) { + element.attachedCallback(); + } + } + } + function detachedNode(node) { + detached(node); + forSubtree(node, function(e) { + detached(e); + }); + } + function detached(element) { + if (hasThrottledAttached) { + deferMutation(function() { + _detached(element); + }); + } else { + _detached(element); + } + } + function _detached(element) { + if (element.__upgraded__ && element.__attached) { + element.__attached = false; + if (element.detachedCallback) { + element.detachedCallback(); + } + } + } + function inDocument(element) { + var p = element; + var doc = window.wrap(document); + while (p) { + if (p == doc) { + return true; + } + p = p.parentNode || p.nodeType === Node.DOCUMENT_FRAGMENT_NODE && p.host; + } + } + function watchShadow(node) { + if (node.shadowRoot && !node.shadowRoot.__watched) { + flags.dom && console.log("watching shadow-root for: ", node.localName); + var root = node.shadowRoot; + while (root) { + observe(root); + root = root.olderShadowRoot; + } + } + } + function handler(root, mutations) { + if (flags.dom) { + var mx = mutations[0]; + if (mx && mx.type === "childList" && mx.addedNodes) { + if (mx.addedNodes) { + var d = mx.addedNodes[0]; + while (d && d !== document && !d.host) { + d = d.parentNode; + } + var u = d && (d.URL || d._URL || d.host && d.host.localName) || ""; + u = u.split("/?").shift().split("/").pop(); + } + } + console.group("mutations (%d) [%s]", mutations.length, u || ""); + } + var isAttached = inDocument(root); + mutations.forEach(function(mx) { + if (mx.type === "childList") { + forEach(mx.addedNodes, function(n) { + if (!n.localName) { + return; + } + addedNode(n, isAttached); + }); + forEach(mx.removedNodes, function(n) { + if (!n.localName) { + return; + } + detachedNode(n); + }); + } + }); + flags.dom && console.groupEnd(); + } + function takeRecords(node) { + node = window.wrap(node); + if (!node) { + node = window.wrap(document); + } + while (node.parentNode) { + node = node.parentNode; + } + var observer = node.__observer; + if (observer) { + handler(node, observer.takeRecords()); + takeMutations(); + } + } + var forEach = Array.prototype.forEach.call.bind(Array.prototype.forEach); + function observe(inRoot) { + if (inRoot.__observer) { + return; + } + var observer = new MutationObserver(handler.bind(this, inRoot)); + observer.observe(inRoot, { + childList: true, + subtree: true + }); + inRoot.__observer = observer; + } + function upgradeDocument(doc) { + doc = window.wrap(doc); + flags.dom && console.group("upgradeDocument: ", doc.baseURI.split("/").pop()); + var isMainDocument = doc === window.wrap(document); + addedNode(doc, isMainDocument); + observe(doc); + flags.dom && console.groupEnd(); + } + function upgradeDocumentTree(doc) { + forDocumentTree(doc, upgradeDocument); + } + var originalCreateShadowRoot = Element.prototype.createShadowRoot; + if (originalCreateShadowRoot) { + Element.prototype.createShadowRoot = function() { + var root = originalCreateShadowRoot.call(this); + window.CustomElements.watchShadow(this); + return root; + }; + } + scope.watchShadow = watchShadow; + scope.upgradeDocumentTree = upgradeDocumentTree; + scope.upgradeDocument = upgradeDocument; + scope.upgradeSubtree = addedSubtree; + scope.upgradeAll = addedNode; + scope.attached = attached; + scope.takeRecords = takeRecords; + }); + window.CustomElements.addModule(function(scope) { + var flags = scope.flags; + function upgrade(node, isAttached) { + if (node.localName === "template") { + if (window.HTMLTemplateElement && HTMLTemplateElement.decorate) { + HTMLTemplateElement.decorate(node); + } + } + if (!node.__upgraded__ && node.nodeType === Node.ELEMENT_NODE) { + var is = node.getAttribute("is"); + var definition = scope.getRegisteredDefinition(node.localName) || scope.getRegisteredDefinition(is); + if (definition) { + if (is && definition.tag == node.localName || !is && !definition.extends) { + return upgradeWithDefinition(node, definition, isAttached); + } + } + } + } + function upgradeWithDefinition(element, definition, isAttached) { + flags.upgrade && console.group("upgrade:", element.localName); + if (definition.is) { + element.setAttribute("is", definition.is); + } + implementPrototype(element, definition); + element.__upgraded__ = true; + created(element); + if (isAttached) { + scope.attached(element); + } + scope.upgradeSubtree(element, isAttached); + flags.upgrade && console.groupEnd(); + return element; + } + function implementPrototype(element, definition) { + if (Object.__proto__) { + element.__proto__ = definition.prototype; + } else { + customMixin(element, definition.prototype, definition.native); + element.__proto__ = definition.prototype; + } + } + function customMixin(inTarget, inSrc, inNative) { + var used = {}; + var p = inSrc; + while (p !== inNative && p !== HTMLElement.prototype) { + var keys = Object.getOwnPropertyNames(p); + for (var i = 0, k; k = keys[i]; i++) { + if (!used[k]) { + Object.defineProperty(inTarget, k, Object.getOwnPropertyDescriptor(p, k)); + used[k] = 1; + } + } + p = Object.getPrototypeOf(p); + } + } + function created(element) { + if (element.createdCallback) { + element.createdCallback(); + } + } + scope.upgrade = upgrade; + scope.upgradeWithDefinition = upgradeWithDefinition; + scope.implementPrototype = implementPrototype; + }); + window.CustomElements.addModule(function(scope) { + var isIE = scope.isIE; + var upgradeDocumentTree = scope.upgradeDocumentTree; + var upgradeAll = scope.upgradeAll; + var upgradeWithDefinition = scope.upgradeWithDefinition; + var implementPrototype = scope.implementPrototype; + var useNative = scope.useNative; + function register(name, options) { + var definition = options || {}; + if (!name) { + throw new Error("document.registerElement: first argument `name` must not be empty"); + } + if (name.indexOf("-") < 0) { + throw new Error("document.registerElement: first argument ('name') must contain a dash ('-'). Argument provided was '" + String(name) + "'."); + } + if (isReservedTag(name)) { + throw new Error("Failed to execute 'registerElement' on 'Document': Registration failed for type '" + String(name) + "'. The type name is invalid."); + } + if (getRegisteredDefinition(name)) { + throw new Error("DuplicateDefinitionError: a type with name '" + String(name) + "' is already registered"); + } + if (!definition.prototype) { + definition.prototype = Object.create(HTMLElement.prototype); + } + definition.__name = name.toLowerCase(); + if (definition.extends) { + definition.extends = definition.extends.toLowerCase(); + } + definition.lifecycle = definition.lifecycle || {}; + definition.ancestry = ancestry(definition.extends); + resolveTagName(definition); + resolvePrototypeChain(definition); + overrideAttributeApi(definition.prototype); + registerDefinition(definition.__name, definition); + definition.ctor = generateConstructor(definition); + definition.ctor.prototype = definition.prototype; + definition.prototype.constructor = definition.ctor; + if (scope.ready) { + upgradeDocumentTree(document); + } + return definition.ctor; + } + function overrideAttributeApi(prototype) { + if (prototype.setAttribute._polyfilled) { + return; + } + var setAttribute = prototype.setAttribute; + prototype.setAttribute = function(name, value) { + changeAttribute.call(this, name, value, setAttribute); + }; + var removeAttribute = prototype.removeAttribute; + prototype.removeAttribute = function(name) { + changeAttribute.call(this, name, null, removeAttribute); + }; + prototype.setAttribute._polyfilled = true; + } + function changeAttribute(name, value, operation) { + name = name.toLowerCase(); + var oldValue = this.getAttribute(name); + operation.apply(this, arguments); + var newValue = this.getAttribute(name); + if (this.attributeChangedCallback && newValue !== oldValue) { + this.attributeChangedCallback(name, oldValue, newValue); + } + } + function isReservedTag(name) { + for (var i = 0; i < reservedTagList.length; i++) { + if (name === reservedTagList[i]) { + return true; + } + } + } + var reservedTagList = [ "annotation-xml", "color-profile", "font-face", "font-face-src", "font-face-uri", "font-face-format", "font-face-name", "missing-glyph" ]; + function ancestry(extnds) { + var extendee = getRegisteredDefinition(extnds); + if (extendee) { + return ancestry(extendee.extends).concat([ extendee ]); + } + return []; + } + function resolveTagName(definition) { + var baseTag = definition.extends; + for (var i = 0, a; a = definition.ancestry[i]; i++) { + baseTag = a.is && a.tag; + } + definition.tag = baseTag || definition.__name; + if (baseTag) { + definition.is = definition.__name; + } + } + function resolvePrototypeChain(definition) { + if (!Object.__proto__) { + var nativePrototype = HTMLElement.prototype; + if (definition.is) { + var inst = document.createElement(definition.tag); + nativePrototype = Object.getPrototypeOf(inst); + } + var proto = definition.prototype, ancestor; + var foundPrototype = false; + while (proto) { + if (proto == nativePrototype) { + foundPrototype = true; + } + ancestor = Object.getPrototypeOf(proto); + if (ancestor) { + proto.__proto__ = ancestor; + } + proto = ancestor; + } + if (!foundPrototype) { + console.warn(definition.tag + " prototype not found in prototype chain for " + definition.is); + } + definition.native = nativePrototype; + } + } + function instantiate(definition) { + return upgradeWithDefinition(domCreateElement(definition.tag), definition); + } + var registry = {}; + function getRegisteredDefinition(name) { + if (name) { + return registry[name.toLowerCase()]; + } + } + function registerDefinition(name, definition) { + registry[name] = definition; + } + function generateConstructor(definition) { + return function() { + return instantiate(definition); + }; + } + var HTML_NAMESPACE = "http://www.w3.org/1999/xhtml"; + function createElementNS(namespace, tag, typeExtension) { + if (namespace === HTML_NAMESPACE) { + return createElement(tag, typeExtension); + } else { + return domCreateElementNS(namespace, tag); + } + } + function createElement(tag, typeExtension) { + if (tag) { + tag = tag.toLowerCase(); + } + if (typeExtension) { + typeExtension = typeExtension.toLowerCase(); + } + var definition = getRegisteredDefinition(typeExtension || tag); + if (definition) { + if (tag == definition.tag && typeExtension == definition.is) { + return new definition.ctor(); + } + if (!typeExtension && !definition.is) { + return new definition.ctor(); + } + } + var element; + if (typeExtension) { + element = createElement(tag); + element.setAttribute("is", typeExtension); + return element; + } + element = domCreateElement(tag); + if (tag.indexOf("-") >= 0) { + implementPrototype(element, HTMLElement); + } + return element; + } + var domCreateElement = document.createElement.bind(document); + var domCreateElementNS = document.createElementNS.bind(document); + var isInstance; + if (!Object.__proto__ && !useNative) { + isInstance = function(obj, ctor) { + if (obj instanceof ctor) { + return true; + } + var p = obj; + while (p) { + if (p === ctor.prototype) { + return true; + } + p = p.__proto__; + } + return false; + }; + } else { + isInstance = function(obj, base) { + return obj instanceof base; + }; + } + function wrapDomMethodToForceUpgrade(obj, methodName) { + var orig = obj[methodName]; + obj[methodName] = function() { + var n = orig.apply(this, arguments); + upgradeAll(n); + return n; + }; + } + wrapDomMethodToForceUpgrade(Node.prototype, "cloneNode"); + wrapDomMethodToForceUpgrade(document, "importNode"); + document.registerElement = register; + document.createElement = createElement; + document.createElementNS = createElementNS; + scope.registry = registry; + scope.instanceof = isInstance; + scope.reservedTagList = reservedTagList; + scope.getRegisteredDefinition = getRegisteredDefinition; + document.register = document.registerElement; + }); + (function(scope) { + var useNative = scope.useNative; + var initializeModules = scope.initializeModules; + var isIE = scope.isIE; + if (useNative) { + var nop = function() {}; + scope.watchShadow = nop; + scope.upgrade = nop; + scope.upgradeAll = nop; + scope.upgradeDocumentTree = nop; + scope.upgradeSubtree = nop; + scope.takeRecords = nop; + scope.instanceof = function(obj, base) { + return obj instanceof base; + }; + } else { + initializeModules(); + } + var upgradeDocumentTree = scope.upgradeDocumentTree; + var upgradeDocument = scope.upgradeDocument; + if (!window.wrap) { + if (window.ShadowDOMPolyfill) { + window.wrap = window.ShadowDOMPolyfill.wrapIfNeeded; + window.unwrap = window.ShadowDOMPolyfill.unwrapIfNeeded; + } else { + window.wrap = window.unwrap = function(node) { + return node; + }; + } + } + if (window.HTMLImports) { + window.HTMLImports.__importsParsingHook = function(elt) { + if (elt.import) { + upgradeDocument(wrap(elt.import)); + } + }; + } + function bootstrap() { + upgradeDocumentTree(window.wrap(document)); + window.CustomElements.ready = true; + var requestAnimationFrame = window.requestAnimationFrame || function(f) { + setTimeout(f, 16); + }; + requestAnimationFrame(function() { + setTimeout(function() { + window.CustomElements.readyTime = Date.now(); + if (window.HTMLImports) { + window.CustomElements.elapsed = window.CustomElements.readyTime - window.HTMLImports.readyTime; + } + document.dispatchEvent(new CustomEvent("WebComponentsReady", { + bubbles: true + })); + }); + }); + } + if (document.readyState === "complete" || scope.flags.eager) { + bootstrap(); + } else if (document.readyState === "interactive" && !window.attachEvent && (!window.HTMLImports || window.HTMLImports.ready)) { + bootstrap(); + } else { + var loadEvent = window.HTMLImports && !window.HTMLImports.ready ? "HTMLImportsLoaded" : "DOMContentLoaded"; + window.addEventListener(loadEvent, bootstrap); + } + })(window.CustomElements); + (function(scope) { + var style = document.createElement("style"); + style.textContent = "" + "body {" + "transition: opacity ease-in 0.2s;" + " } \n" + "body[unresolved] {" + "opacity: 0; display: block; overflow: hidden; position: relative;" + " } \n"; + var head = document.querySelector("head"); + head.insertBefore(style, head.firstChild); + })(window.WebComponents); + }, {} ], + 3: [ function(require, module, exports) { + "use strict"; + var Class = require("class.extend"), hasConnected = false, ChromecastSessionManager; + function getCastContext() { + return cast.framework.CastContext.getInstance(); + } + ChromecastSessionManager = Class.extend({ + init: function(player) { + this.player = player; + this._sessionListener = this._onSessionStateChange.bind(this); + this._castListener = this._onCastStateChange.bind(this); + this._addCastContextEventListeners(); + this.player.on("dispose", this._removeCastContextEventListeners.bind(this)); + this._notifyPlayerOfDevicesAvailabilityChange(this.getCastContext().getCastState()); + this.remotePlayer = new cast.framework.RemotePlayer(); + this.remotePlayerController = new cast.framework.RemotePlayerController(this.remotePlayer); + }, + _addCastContextEventListeners: function() { + var sessionStateChangedEvt = cast.framework.CastContextEventType.SESSION_STATE_CHANGED, castStateChangedEvt = cast.framework.CastContextEventType.CAST_STATE_CHANGED; + this.getCastContext().addEventListener(sessionStateChangedEvt, this._sessionListener); + this.getCastContext().addEventListener(castStateChangedEvt, this._castListener); + }, + _removeCastContextEventListeners: function() { + var sessionStateChangedEvt = cast.framework.CastContextEventType.SESSION_STATE_CHANGED, castStateChangedEvt = cast.framework.CastContextEventType.CAST_STATE_CHANGED; + this.getCastContext().removeEventListener(sessionStateChangedEvt, this._sessionListener); + this.getCastContext().removeEventListener(castStateChangedEvt, this._castListener); + }, + _onSessionStateChange: function(event) { + if (event.sessionState === cast.framework.SessionState.SESSION_ENDED) { + this.player.trigger("chromecastDisconnected"); + this._reloadTech(); + } + }, + _onCastStateChange: function(event) { + this._notifyPlayerOfDevicesAvailabilityChange(event.castState); + }, + _notifyPlayerOfDevicesAvailabilityChange: function(castState) { + if (this.hasAvailableDevices(castState)) { + this.player.trigger("chromecastDevicesAvailable"); + } else { + this.player.trigger("chromecastDevicesUnavailable"); + } + }, + hasAvailableDevices: function(castState) { + castState = castState || this.getCastContext().getCastState(); + return castState === cast.framework.CastState.NOT_CONNECTED || castState === cast.framework.CastState.CONNECTING || castState === cast.framework.CastState.CONNECTED; + }, + openCastMenu: function() { + var onSessionSuccess; + if (!this.player.currentSource()) { + return; + } + onSessionSuccess = function() { + hasConnected = true; + this.player.trigger("chromecastConnected"); + this._reloadTech(); + }.bind(this); + this.getCastContext().requestSession().then(onSessionSuccess, function() {}); + }, + _reloadTech: function() { + var player = this.player, currentTime = player.currentTime(), wasPaused = player.paused(), sources = player.currentSources(); + player.src(sources); + player.ready(function() { + if (wasPaused) { + player.pause(); + } else { + player.play(); + } + player.currentTime(currentTime || 0); + }); + }, + getCastContext: getCastContext, + getRemotePlayer: function() { + return this.remotePlayer; + }, + getRemotePlayerController: function() { + return this.remotePlayerController; + } + }); + ChromecastSessionManager.isChromecastAPIAvailable = function() { + return window.chrome && window.chrome.cast && window.cast; + }; + ChromecastSessionManager.isChromecastConnected = function() { + return ChromecastSessionManager.isChromecastAPIAvailable() && getCastContext().getCastState() === cast.framework.CastState.CONNECTED && hasConnected; + }; + module.exports = ChromecastSessionManager; + }, { + "class.extend": 1 + } ], + 4: [ function(require, module, exports) { + "use strict"; + var ChromecastButton; + ChromecastButton = { + constructor: function(player) { + this.constructor.super_.apply(this, arguments); + player.on("chromecastConnected", this._onChromecastConnected.bind(this)); + player.on("chromecastDisconnected", this._onChromecastDisconnected.bind(this)); + player.on("chromecastDevicesAvailable", this._onChromecastDevicesAvailable.bind(this)); + player.on("chromecastDevicesUnavailable", this._onChromecastDevicesUnavailable.bind(this)); + this.controlText("Open Chromecast menu"); + if (player.chromecastSessionManager && player.chromecastSessionManager.hasAvailableDevices()) { + this._onChromecastDevicesAvailable(); + } else { + this._onChromecastDevicesUnavailable(); + } + }, + buildCSSClass: function() { + return "vjs-chromecast-button " + (this._isChromecastConnected ? "vjs-chromecast-casting-state " : "") + this.constructor.super_.prototype.buildCSSClass(); + }, + handleClick: function() { + this.player().trigger("chromecastRequested"); + }, + _onChromecastConnected: function() { + this._isChromecastConnected = true; + this._reloadCSSClasses(); + }, + _onChromecastDisconnected: function() { + this._isChromecastConnected = false; + this._reloadCSSClasses(); + }, + _onChromecastDevicesAvailable: function() { + this.show(); + }, + _onChromecastDevicesUnavailable: function() { + this.hide(); + }, + _reloadCSSClasses: function() { + if (!this.el_) { + return; + } + this.el_.className = this.buildCSSClass(); + } + }; + module.exports = function(videojs) { + var ChromecastButtonImpl; + ChromecastButtonImpl = videojs.extend(videojs.getComponent("Button"), ChromecastButton); + videojs.registerComponent("chromecastButton", ChromecastButtonImpl); + }; + }, {} ], + 5: [ function(require, module, exports) { + "use strict"; + var ChromecastSessionManager = require("./chromecast/ChromecastSessionManager"), CHECK_AVAILABILITY_INTERVAL = 1e3, CHECK_AVAILABILITY_TIMEOUT = 30 * 1e3; + function configureCastContext(options) { + var context = cast.framework.CastContext.getInstance(); + context.setOptions({ + receiverApplicationId: options.receiverAppID || chrome.cast.media.DEFAULT_MEDIA_RECEIVER_APP_ID, + autoJoinPolicy: chrome.cast.AutoJoinPolicy.ORIGIN_SCOPED + }); + } + function onChromecastRequested(player) { + player.chromecastSessionManager.openCastMenu(); + } + function setUpChromecastButton(player, options) { + var indexOpt; + if (options.addButtonToControlBar && !player.controlBar.getChild("chromecastButton")) { + 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("chromecastButton", options, indexOpt); + } + player.on("chromecastRequested", onChromecastRequested.bind(null, player)); + } + function createSessionManager(player) { + if (!player.chromecastSessionManager) { + player.chromecastSessionManager = new ChromecastSessionManager(player); + } + } + function enableChromecast(player, options) { + configureCastContext(options); + createSessionManager(player); + setUpChromecastButton(player, options); + } + function waitUntilChromecastAPIsAreAvailable(player, options) { + var maxTries = CHECK_AVAILABILITY_TIMEOUT / CHECK_AVAILABILITY_INTERVAL, tries = 1, intervalID; + intervalID = setInterval(function() { + if (tries > maxTries) { + clearInterval(intervalID); + return; + } + if (ChromecastSessionManager.isChromecastAPIAvailable()) { + clearInterval(intervalID); + enableChromecast(player, options); + } + tries = tries + 1; + }, CHECK_AVAILABILITY_INTERVAL); + } + module.exports = function(videojs) { + videojs.registerPlugin("chromecast", function(options) { + var pluginOptions = Object.assign({ + addButtonToControlBar: true + }, options || {}); + this.ready(function() { + if (!this.controlBar) { + return; + } + if (ChromecastSessionManager.isChromecastAPIAvailable()) { + enableChromecast(this, pluginOptions); + } else { + waitUntilChromecastAPIsAreAvailable(this, pluginOptions); + } + }.bind(this)); + }); + }; + }, { + "./chromecast/ChromecastSessionManager": 3 + } ], + 6: [ function(require, module, exports) { + "use strict"; + var preloadWebComponents = require("./preloadWebComponents"), createChromecastButton = require("./components/ChromecastButton"), createChromecastTech = require("./tech/ChromecastTech"), enableChromecast = require("./enableChromecast"); + module.exports = function(videojs, userOpts) { + var options = Object.assign({ + preloadWebComponents: false + }, userOpts); + if (options.preloadWebComponents) { + preloadWebComponents(); + } + videojs = videojs || window.videojs; + createChromecastButton(videojs); + createChromecastTech(videojs); + enableChromecast(videojs); + }; + }, { + "./components/ChromecastButton": 4, + "./enableChromecast": 5, + "./preloadWebComponents": 7, + "./tech/ChromecastTech": 9 + } ], + 7: [ function(require, module, exports) { + "use strict"; + function doesUserAgentContainString(str) { + return typeof window.navigator.userAgent === "string" && window.navigator.userAgent.indexOf(str) >= 0; + } + module.exports = function() { + var needsWebComponents = !document.registerElement, iosChrome = doesUserAgentContainString("CriOS"), androidChrome; + androidChrome = doesUserAgentContainString("Android") && doesUserAgentContainString("Chrome/") && window.navigator.presentation; + if ((androidChrome || iosChrome) && needsWebComponents) { + require("webcomponents.js/webcomponents-lite.js"); + } + }; + }, { + "webcomponents.js/webcomponents-lite.js": 2 + } ], + 8: [ function(require, module, exports) { + "use strict"; + require("./index")(undefined, window.SILVERMINE_VIDEOJS_CHROMECAST_CONFIG); + }, { + "./index": 6 + } ], + 9: [ function(require, module, exports) { + "use strict"; + var ChromecastSessionManager = require("../chromecast/ChromecastSessionManager"), ChromecastTechUI = require("./ChromecastTechUI"), SESSION_TIMEOUT = 10 * 1e3, ChromecastTech; + ChromecastTech = { + constructor: function(options) { + var subclass; + this._eventListeners = []; + this.videojsPlayer = this.videojs(options.playerId); + this._chromecastSessionManager = this.videojsPlayer.chromecastSessionManager; + this._ui = new ChromecastTechUI(); + this._ui.updatePoster(this.videojsPlayer.poster()); + subclass = this.constructor.super_.apply(this, arguments); + this._remotePlayer = this._chromecastSessionManager.getRemotePlayer(); + this._remotePlayerController = this._chromecastSessionManager.getRemotePlayerController(); + this._listenToPlayerControllerEvents(); + this.on("dispose", this._removeAllEventListeners.bind(this)); + this._hasPlayedAnyItem = false; + this._requestTitle = options.requestTitleFn || function() {}; + this._requestSubtitle = options.requestSubtitleFn || function() {}; + this._requestCustomData = options.requestCustomDataFn || function() {}; + this._initialStartTime = options.startTime || 0; + this._playSource(options.source, this._initialStartTime); + this.ready(function() { + this.setMuted(options.muted); + }.bind(this)); + return subclass; + }, + createEl: function() { + return this._ui.getDOMElement(); + }, + play: function() { + if (!this.paused()) { + return; + } + if (this.ended() && !this._isMediaLoading) { + this._playSource({ + src: this.videojsPlayer.src() + }, 0); + } else { + this._remotePlayerController.playOrPause(); + } + }, + pause: function() { + if (!this.paused() && this._remotePlayer.canPause) { + this._remotePlayerController.playOrPause(); + } + }, + paused: function() { + return this._remotePlayer.isPaused || this.ended() || this._remotePlayer.playerState === null; + }, + setSource: function(source) { + if (this._currentSource && this._currentSource.src === source.src && this._currentSource.type === source.type) { + return; + } + this._currentSource = source; + this._playSource(source, 0); + }, + _playSource: function(source, startTime) { + var castSession = this._getCastSession(), mediaInfo = new chrome.cast.media.MediaInfo(source.src, source.type), title = this._requestTitle(source), subtitle = this._requestSubtitle(source), customData = this._requestCustomData(source), request; + this.trigger("waiting"); + this._clearSessionTimeout(); + mediaInfo.metadata = new chrome.cast.media.GenericMediaMetadata(); + mediaInfo.metadata.metadataType = chrome.cast.media.MetadataType.GENERIC; + mediaInfo.metadata.title = title; + mediaInfo.metadata.subtitle = subtitle; + mediaInfo.streamType = this.videojsPlayer.liveTracker && this.videojsPlayer.liveTracker.isLive() ? chrome.cast.media.StreamType.LIVE : chrome.cast.media.StreamType.BUFFERED; + if (customData) { + mediaInfo.customData = customData; + } + this._ui.updateTitle(title); + this._ui.updateSubtitle(subtitle); + request = new chrome.cast.media.LoadRequest(mediaInfo); + request.autoplay = true; + request.currentTime = startTime; + this._isMediaLoading = true; + this._hasPlayedCurrentItem = false; + castSession.loadMedia(request).then(function() { + if (!this._hasPlayedAnyItem) { + this.triggerReady(); + } + this.trigger("loadstart"); + this.trigger("loadeddata"); + this.trigger("play"); + this.trigger("playing"); + this._hasPlayedAnyItem = true; + this._isMediaLoading = false; + this._getMediaSession().addUpdateListener(this._onMediaSessionStatusChanged.bind(this)); + }.bind(this), this._triggerErrorEvent.bind(this)); + }, + setCurrentTime: function(time) { + var duration = this.duration(); + if (time > duration || !this._remotePlayer.canSeek) { + return; + } + this._remotePlayer.currentTime = Math.min(duration - 1, time); + this._remotePlayerController.seek(); + this._triggerTimeUpdateEvent(); + }, + currentTime: function() { + if (!this._hasPlayedAnyItem) { + return this._initialStartTime; + } + return this._remotePlayer.currentTime; + }, + duration: function() { + if (!this._hasPlayedAnyItem) { + return this.videojsPlayer.duration(); + } + return this._remotePlayer.duration; + }, + ended: function() { + var mediaSession = this._getMediaSession(); + if (!mediaSession && this._hasMediaSessionEnded) { + return true; + } + return mediaSession ? mediaSession.idleReason === chrome.cast.media.IdleReason.FINISHED : false; + }, + volume: function() { + return this._remotePlayer.volumeLevel; + }, + setVolume: function(volumeLevel) { + this._remotePlayer.volumeLevel = volumeLevel; + this._remotePlayerController.setVolumeLevel(); + this._triggerVolumeChangeEvent(); + }, + muted: function() { + return this._remotePlayer.isMuted; + }, + setMuted: function(isMuted) { + if (this._remotePlayer.isMuted && !isMuted || !this._remotePlayer.isMuted && isMuted) { + this._remotePlayerController.muteOrUnmute(); + } + }, + poster: function() { + return this._ui.getPoster(); + }, + setPoster: function(poster) { + this._ui.updatePoster(poster); + }, + buffered: function() { + return undefined; + }, + seekable: function() { + return this.videojs.createTimeRange(0, this.duration()); + }, + controls: function() { + return false; + }, + playsinline: function() { + return true; + }, + supportsFullScreen: function() { + return true; + }, + setAutoplay: function() {}, + playbackRate: function() { + var mediaSession = this._getMediaSession(); + return mediaSession ? mediaSession.playbackRate : 1; + }, + setPlaybackRate: function() {}, + preload: function() {}, + load: function() {}, + readyState: function() { + if (this._remotePlayer.playerState === "IDLE" || this._remotePlayer.playerState === "BUFFERING") { + return 0; + } + return 4; + }, + _listenToPlayerControllerEvents: function() { + var eventTypes = cast.framework.RemotePlayerEventType; + this._addEventListener(this._remotePlayerController, eventTypes.PLAYER_STATE_CHANGED, this._onPlayerStateChanged, this); + this._addEventListener(this._remotePlayerController, eventTypes.VOLUME_LEVEL_CHANGED, this._triggerVolumeChangeEvent, this); + this._addEventListener(this._remotePlayerController, eventTypes.IS_MUTED_CHANGED, this._triggerVolumeChangeEvent, this); + this._addEventListener(this._remotePlayerController, eventTypes.CURRENT_TIME_CHANGED, this._triggerTimeUpdateEvent, this); + this._addEventListener(this._remotePlayerController, eventTypes.DURATION_CHANGED, this._triggerDurationChangeEvent, this); + }, + _addEventListener: function(target, type, callback, context) { + var listener; + listener = { + target: target, + type: type, + callback: callback, + context: context, + listener: callback.bind(context) + }; + target.addEventListener(type, listener.listener); + this._eventListeners.push(listener); + }, + _removeAllEventListeners: function() { + while (this._eventListeners.length > 0) { + this._removeEventListener(this._eventListeners[0]); + } + this._eventListeners = []; + }, + _removeEventListener: function(listener) { + var index = -1, pass = false, i; + listener.target.removeEventListener(listener.type, listener.listener); + for (i = 0; i < this._eventListeners.length; i++) { + pass = this._eventListeners[i].target === listener.target && this._eventListeners[i].type === listener.type && this._eventListeners[i].callback === listener.callback && this._eventListeners[i].context === listener.context; + if (pass) { + index = i; + break; + } + } + if (index !== -1) { + this._eventListeners.splice(index, 1); + } + }, + _onPlayerStateChanged: function() { + var states = chrome.cast.media.PlayerState, playerState = this._remotePlayer.playerState; + if (playerState === states.PLAYING) { + this._hasPlayedCurrentItem = true; + this.trigger("play"); + this.trigger("playing"); + } else if (playerState === states.PAUSED) { + this.trigger("pause"); + } else if (playerState === states.IDLE && this.ended() || playerState === null && this._hasPlayedCurrentItem) { + this._hasPlayedCurrentItem = false; + this._closeSessionOnTimeout(); + this.trigger("ended"); + this._triggerTimeUpdateEvent(); + } else if (playerState === states.BUFFERING) { + this.trigger("waiting"); + } + }, + _onMediaSessionStatusChanged: function(isAlive) { + this._hasMediaSessionEnded = !!isAlive; + }, + _closeSessionOnTimeout: function() { + this._clearSessionTimeout(); + this._sessionTimeoutID = setTimeout(function() { + var castSession = this._getCastSession(); + if (castSession) { + castSession.endSession(true); + } + this._clearSessionTimeout(); + }.bind(this), SESSION_TIMEOUT); + }, + _clearSessionTimeout: function() { + if (this._sessionTimeoutID) { + clearTimeout(this._sessionTimeoutID); + this._sessionTimeoutID = false; + } + }, + _getCastContext: function() { + return this._chromecastSessionManager.getCastContext(); + }, + _getCastSession: function() { + return this._getCastContext().getCurrentSession(); + }, + _getMediaSession: function() { + var castSession = this._getCastSession(); + return castSession ? castSession.getMediaSession() : null; + }, + _triggerVolumeChangeEvent: function() { + this.trigger("volumechange"); + }, + _triggerTimeUpdateEvent: function() { + this.trigger("timeupdate"); + }, + _triggerDurationChangeEvent: function() { + this.trigger("durationchange"); + }, + _triggerErrorEvent: function() { + this.trigger("error"); + } + }; + module.exports = function(videojs) { + var Tech = videojs.getComponent("Tech"), ChromecastTechImpl; + ChromecastTechImpl = videojs.extend(Tech, ChromecastTech); + ChromecastTechImpl.canPlaySource = ChromecastSessionManager.isChromecastConnected.bind(ChromecastSessionManager); + ChromecastTechImpl.isSupported = ChromecastSessionManager.isChromecastConnected.bind(ChromecastSessionManager); + ChromecastTechImpl.prototype.featuresVolumeControl = true; + ChromecastTechImpl.prototype.featuresPlaybackRate = false; + ChromecastTechImpl.prototype.movingMediaElementInDOM = false; + ChromecastTechImpl.prototype.featuresFullscreenResize = true; + ChromecastTechImpl.prototype.featuresTimeupdateEvents = true; + ChromecastTechImpl.prototype.featuresProgressEvents = false; + ChromecastTechImpl.prototype.featuresNativeTextTracks = false; + ChromecastTechImpl.prototype.featuresNativeAudioTracks = false; + ChromecastTechImpl.prototype.featuresNativeVideoTracks = false; + ChromecastTechImpl.prototype.videojs = videojs; + videojs.registerTech("chromecast", ChromecastTechImpl); + }; + }, { + "../chromecast/ChromecastSessionManager": 3, + "./ChromecastTechUI": 10 + } ], + 10: [ function(require, module, exports) { + "use strict"; + var Class = require("class.extend"), ChromecastTechUI; + ChromecastTechUI = Class.extend({ + init: function() { + this._el = this._createDOMElement(); + }, + _createDOMElement: function() { + var el = this._createElement("div", "vjs-tech vjs-tech-chromecast"), posterContainerEl = this._createElement("div", "vjs-tech-chromecast-poster"), posterImageEl = this._createElement("img", "vjs-tech-chromecast-poster-img"), titleEl = this._createElement("div", "vjs-tech-chromecast-title"), subtitleEl = this._createElement("div", "vjs-tech-chromecast-subtitle"), titleContainer = this._createElement("div", "vjs-tech-chromecast-title-container"); + posterContainerEl.appendChild(posterImageEl); + titleContainer.appendChild(titleEl); + titleContainer.appendChild(subtitleEl); + el.appendChild(titleContainer); + el.appendChild(posterContainerEl); + return el; + }, + _createElement: function(type, className) { + var el = document.createElement(type); + el.className = className; + return el; + }, + getDOMElement: function() { + return this._el; + }, + _findPosterEl: function() { + return this._el.querySelector(".vjs-tech-chromecast-poster"); + }, + _findPosterImageEl: function() { + return this._el.querySelector(".vjs-tech-chromecast-poster-img"); + }, + _findTitleEl: function() { + return this._el.querySelector(".vjs-tech-chromecast-title"); + }, + _findSubtitleEl: function() { + return this._el.querySelector(".vjs-tech-chromecast-subtitle"); + }, + updatePoster: function(poster) { + var posterImageEl = this._findPosterImageEl(); + this._poster = poster ? poster : null; + if (poster) { + posterImageEl.setAttribute("src", poster); + posterImageEl.classList.remove("vjs-tech-chromecast-poster-img-empty"); + } else { + posterImageEl.removeAttribute("src"); + posterImageEl.classList.add("vjs-tech-chromecast-poster-img-empty"); + } + }, + getPoster: function() { + return this._poster; + }, + updateTitle: function(title) { + var titleEl = this._findTitleEl(); + this._title = title; + if (title) { + titleEl.innerHTML = title; + titleEl.classList.remove("vjs-tech-chromecast-title-empty"); + } else { + titleEl.classList.add("vjs-tech-chromecast-title-empty"); + } + }, + updateSubtitle: function(subtitle) { + var subtitleEl = this._findSubtitleEl(); + this._subtitle = subtitle; + if (subtitle) { + subtitleEl.innerHTML = subtitle; + subtitleEl.classList.remove("vjs-tech-chromecast-subtitle-empty"); + } else { + subtitleEl.classList.add("vjs-tech-chromecast-subtitle-empty"); + } + } + }); + module.exports = ChromecastTechUI; + }, { + "class.extend": 1 + } ] +}, {}, [ 8 ]); \ No newline at end of file diff --git a/public/_player/videojs/files.txt b/public/_player/videojs/files.txt index 97dd578..8cba701 100644 --- a/public/_player/videojs/files.txt +++ b/public/_player/videojs/files.txt @@ -5,3 +5,10 @@ dist/videojs-overlay.min.css dist/video-js-skin.min.css dist/videojs-license.min.js 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 +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 b6ed594..fc77677 100644 --- a/public/_player/videojs/player.html +++ b/public/_player/videojs/player.html @@ -15,11 +15,12 @@ - + {{#if airplay}} + + {{/if}} + {{#if chromecast}} + + {{/if}}
@@ -28,6 +29,13 @@ +{{#if airplay}} + +{{/if}} +{{#if chromecast}} + + +{{/if}} + {{#if airplay}} + + {{/if}} + {{#if chromecast}} + + + {{/if}} {{else}} @@ -824,6 +837,8 @@ var mute = convertBoolParam("mute", playerConfig.mute); 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 10c8f27..0ed78e7 100644 --- a/public/_playersite/videojs.js +++ b/public/_playersite/videojs.js @@ -2,17 +2,28 @@ var config = { controls: true, poster: playerConfig.poster + '?t=' + String(new Date().getTime()), autoplay: autoplay ? 'muted' : false, - muted: mute, + muted: true, liveui: true, responsive: true, fluid: true, - sources: [{ src: playerConfig.source, type: 'application/x-mpegURL' }], + // Needed to append the url orgin in order for the source to properly pass to the cast device + sources: [{ src: window.location.origin + '/' + playerConfig.source, type: 'application/x-mpegURL' }], plugins: { license: playerConfig.license, }, }; +if (chromecast) { + config.techOrder = ['chromecast', 'html5']; + config.plugins.chromecast = {}; +} + +if (airplay) { + config.plugins.airPlay = {}; +} + var player = videojs('player', config); + player.ready(function () { if (playerConfig.logo.image.length != 0) { var overlay = null; diff --git a/src/utils/restreamer.js b/src/utils/restreamer.js index c176633..c8db297 100644 --- a/src/utils/restreamer.js +++ b/src/utils/restreamer.js @@ -358,7 +358,9 @@ class Restreamer { } compatibility.core.have = this.Version().number; - compatibility.ffmpeg.have = this.skills.ffmpeg.version; + if (this.skills?.ffmpeg?.version) { + compatibility.ffmpeg.have = this.skills.ffmpeg.version; + } compatibility.core.compatible = SemverSatisfies(compatibility.core.have, compatibility.core.want); compatibility.ffmpeg.compatible = SemverSatisfies(compatibility.ffmpeg.have, compatibility.ffmpeg.want); @@ -371,8 +373,13 @@ class Restreamer { } async _init() { - await this._initConfig(); + const compatibility = this.Compatibility(); + if (!compatibility.compatible) { + return; + } + await this._initSkills(); + await this._initConfig(); await this._discoverChannels(); } @@ -895,6 +902,10 @@ class Restreamer { } ConfigOverrides(name) { + if (!this.config) { + return false; + } + return this.config.overrides.includes(name); } @@ -1889,10 +1900,16 @@ class Restreamer { // Set defaults for the settings of the selfhosted player InitPlayerSettings(initSettings) { + if (!initSettings) { + initSettings = {}; + } + const settings = { autoplay: false, mute: false, statistics: false, + chromecast: false, + airplay: false, color: {}, ga: {}, logo: {}, @@ -1936,6 +1953,8 @@ class Restreamer { return false; } + metadata.player = this.InitPlayerSettings(metadata.player); + const templateData = { channelid: channelid, name: metadata.meta.name, @@ -1948,6 +1967,8 @@ class Restreamer { poster_url: this.GetIngestPosterUrlAddresses(channelid)[0], width: 640, height: 360, + chromecast: metadata.player.chromecast, + airplay: metadata.player.airplay, }; // upload player.html @@ -1981,10 +2002,6 @@ class Restreamer { } async UpdatePlayerConfig(channelid, metadata) { - if (!('player' in metadata)) { - metadata.player = {}; - } - metadata.player = this.InitPlayerSettings(metadata.player); const playerConfig = { @@ -2033,6 +2050,8 @@ class Restreamer { title: 'restreamer', share: true, support: true, + chromecast: false, + airplay: false, template: '!default', templatename: '', textcolor_title: 'rgba(255,255,255,1)', @@ -2114,6 +2133,8 @@ class Restreamer { title: settings.title, 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 b2991ed..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'].includes(what)) { + if (['playersite', 'header', 'share', 'support', 'chromecast', 'airplay'].includes(what)) { settings[what] = !settings[what]; } else { settings[what] = value; @@ -420,6 +420,22 @@ export default function Playersite(props) { onChange={handleChange('share')} /> + + Chromecast} + checked={$settings.chromecast} + disabled={!$settings.playersite} + 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 b78c49d..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'].includes(what)) { + if (['autoplay', 'mute', 'statistics', 'chromecast', 'airplay'].includes(what)) { settings[what] = !settings[what]; } else { settings[what] = value; @@ -436,6 +436,8 @@ 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')} />