Proyectos de Subversion Moodle

/**

 * @license

 * Video.js 8.10.0 <http://videojs.com/>

 * Copyright Brightcove, Inc. <https://www.brightcove.com/>

 * Available under Apache License Version 2.0

 * <https://github.com/videojs/video.js/blob/main/LICENSE>

 *

 * Includes vtt.js <https://github.com/mozilla/vtt.js>

 * Available under Apache License Version 2.0

 * <https://github.com/mozilla/vtt.js/blob/main/LICENSE>

 */

(function (global, factory) {

    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :

        typeof define === 'function' && define.amd ? define(factory) :

            (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.videojs = factory());

})(this, (function () { 'use strict';

    var version$5 = "8.10.0";

    /**

     * An Object that contains lifecycle hooks as keys which point to an array

     * of functions that are run when a lifecycle is triggered

     *

     * @private

     */

    const hooks_ = {};

    /**

     * Get a list of hooks for a specific lifecycle

     *

     * @param  {string} type

     *         the lifecycle to get hooks from

     *

     * @param  {Function|Function[]} [fn]

     *         Optionally add a hook (or hooks) to the lifecycle that your are getting.

     *

     * @return {Array}

     *         an array of hooks, or an empty array if there are none.

     */

    const hooks = function (type, fn) {

        hooks_[type] = hooks_[type] || [];

        if (fn) {

            hooks_[type] = hooks_[type].concat(fn);

        }

        return hooks_[type];

    };

    /**

     * Add a function hook to a specific videojs lifecycle.

     *

     * @param {string} type

     *        the lifecycle to hook the function to.

     *

     * @param {Function|Function[]}

     *        The function or array of functions to attach.

     */

    const hook = function (type, fn) {

        hooks(type, fn);

    };

    /**

     * Remove a hook from a specific videojs lifecycle.

     *

     * @param  {string} type

     *         the lifecycle that the function hooked to

     *

     * @param  {Function} fn

     *         The hooked function to remove

     *

     * @return {boolean}

     *         The function that was removed or undef

     */

    const removeHook = function (type, fn) {

        const index = hooks(type).indexOf(fn);

        if (index <= -1) {

            return false;

        }

        hooks_[type] = hooks_[type].slice();

        hooks_[type].splice(index, 1);

        return true;

    };

    /**

     * Add a function hook that will only run once to a specific videojs lifecycle.

     *

     * @param {string} type

     *        the lifecycle to hook the function to.

     *

     * @param {Function|Function[]}

     *        The function or array of functions to attach.

     */

    const hookOnce = function (type, fn) {

        hooks(type, [].concat(fn).map(original => {

            const wrapper = (...args) => {

                removeHook(type, wrapper);

                return original(...args);

            };

            return wrapper;

        }));

    };

    /**

     * @file fullscreen-api.js

     * @module fullscreen-api

     */

    /**

     * Store the browser-specific methods for the fullscreen API.

     *

     * @type {Object}

     * @see [Specification]{@link https://fullscreen.spec.whatwg.org}

     * @see [Map Approach From Screenfull.js]{@link https://github.com/sindresorhus/screenfull.js}

     */

    const FullscreenApi = {

        prefixed: true

    };

    // browser API methods

    const apiMap = [['requestFullscreen', 'exitFullscreen', 'fullscreenElement', 'fullscreenEnabled', 'fullscreenchange', 'fullscreenerror', 'fullscreen'],

        // WebKit

        ['webkitRequestFullscreen', 'webkitExitFullscreen', 'webkitFullscreenElement', 'webkitFullscreenEnabled', 'webkitfullscreenchange', 'webkitfullscreenerror', '-webkit-full-screen']];

    const specApi = apiMap[0];

    let browserApi;

    // determine the supported set of functions

    for (let i = 0; i < apiMap.length; i++) {

        // check for exitFullscreen function

        if (apiMap[i][1] in document) {

            browserApi = apiMap[i];

            break;

        }

    }

    // map the browser API names to the spec API names

    if (browserApi) {

        for (let i = 0; i < browserApi.length; i++) {

            FullscreenApi[specApi[i]] = browserApi[i];

        }

        FullscreenApi.prefixed = browserApi[0] !== specApi[0];

    }

    /**

     * @file create-logger.js

     * @module create-logger

     */

        // This is the private tracking variable for the logging history.

    let history = [];

    /**

     * Log messages to the console and history based on the type of message

     *

     * @private

     * @param  {string} name

     *         The name of the console method to use.

     *

     * @param  {Object} log

     *         The arguments to be passed to the matching console method.

     *

     * @param {string} [styles]

     *        styles for name

     */

    const LogByTypeFactory = (name, log, styles) => (type, level, args) => {

        const lvl = log.levels[level];

        const lvlRegExp = new RegExp(`^(${lvl})$`);

        let resultName = name;

        if (type !== 'log') {

            // Add the type to the front of the message when it's not "log".

            args.unshift(type.toUpperCase() + ':');

        }

        if (styles) {

            resultName = `%c${name}`;

            args.unshift(styles);

        }

        // Add console prefix after adding to history.

        args.unshift(resultName + ':');

        // Add a clone of the args at this point to history.

        if (history) {

            history.push([].concat(args));

            // only store 1000 history entries

            const splice = history.length - 1000;

            history.splice(0, splice > 0 ? splice : 0);

        }

        // If there's no console then don't try to output messages, but they will

        // still be stored in history.

        if (!window.console) {

            return;

        }

        // Was setting these once outside of this function, but containing them

        // in the function makes it easier to test cases where console doesn't exist

        // when the module is executed.

        let fn = window.console[type];

        if (!fn && type === 'debug') {

            // Certain browsers don't have support for console.debug. For those, we

            // should default to the closest comparable log.

            fn = window.console.info || window.console.log;

        }

        // Bail out if there's no console or if this type is not allowed by the

        // current logging level.

        if (!fn || !lvl || !lvlRegExp.test(type)) {

            return;

        }

        fn[Array.isArray(args) ? 'apply' : 'call'](window.console, args);

    };

    function createLogger$1(name, delimiter = ':', styles = '') {

        // This is the private tracking variable for logging level.

        let level = 'info';

        // the curried logByType bound to the specific log and history

        let logByType;

        /**

         * Logs plain debug messages. Similar to `console.log`.

         *

         * Due to [limitations](https://github.com/jsdoc3/jsdoc/issues/955#issuecomment-313829149)

         * of our JSDoc template, we cannot properly document this as both a function

         * and a namespace, so its function signature is documented here.

         *

         * #### Arguments

         * ##### *args

         * *[]

         *

         * Any combination of values that could be passed to `console.log()`.

         *

         * #### Return Value

         *

         * `undefined`

         *

         * @namespace

         * @param    {...*} args

         *           One or more messages or objects that should be logged.

         */

        const log = function (...args) {

            logByType('log', level, args);

        };

        // This is the logByType helper that the logging methods below use

        logByType = LogByTypeFactory(name, log, styles);

        /**

         * Create a new subLogger which chains the old name to the new name.

         *

         * For example, doing `videojs.log.createLogger('player')` and then using that logger will log the following:

         * ```js

         *  mylogger('foo');

         *  // > VIDEOJS: player: foo

         * ```

         *

         * @param {string} subName

         *        The name to add call the new logger

         * @param {string} [subDelimiter]

         *        Optional delimiter

         * @param {string} [subStyles]

         *        Optional styles

         * @return {Object}

         */

        log.createLogger = (subName, subDelimiter, subStyles) => {

            const resultDelimiter = subDelimiter !== undefined ? subDelimiter : delimiter;

            const resultStyles = subStyles !== undefined ? subStyles : styles;

            const resultName = `${name} ${resultDelimiter} ${subName}`;

            return createLogger$1(resultName, resultDelimiter, resultStyles);

        };

        /**

         * Create a new logger.

         *

         * @param {string} newName

         *        The name for the new logger

         * @param {string} [newDelimiter]

         *        Optional delimiter

         * @param {string} [newStyles]

         *        Optional styles

         * @return {Object}

         */

        log.createNewLogger = (newName, newDelimiter, newStyles) => {

            return createLogger$1(newName, newDelimiter, newStyles);

        };

        /**

         * Enumeration of available logging levels, where the keys are the level names

         * and the values are `|`-separated strings containing logging methods allowed

         * in that logging level. These strings are used to create a regular expression

         * matching the function name being called.

         *

         * Levels provided by Video.js are:

         *

         * - `off`: Matches no calls. Any value that can be cast to `false` will have

         *   this effect. The most restrictive.

         * - `all`: Matches only Video.js-provided functions (`debug`, `log`,

         *   `log.warn`, and `log.error`).

         * - `debug`: Matches `log.debug`, `log`, `log.warn`, and `log.error` calls.

         * - `info` (default): Matches `log`, `log.warn`, and `log.error` calls.

         * - `warn`: Matches `log.warn` and `log.error` calls.

         * - `error`: Matches only `log.error` calls.

         *

         * @type {Object}

         */

        log.levels = {

            all: 'debug|log|warn|error',

            off: '',

            debug: 'debug|log|warn|error',

            info: 'log|warn|error',

            warn: 'warn|error',

            error: 'error',

            DEFAULT: level

        };

        /**

         * Get or set the current logging level.

         *

         * If a string matching a key from {@link module:log.levels} is provided, acts

         * as a setter.

         *

         * @param  {'all'|'debug'|'info'|'warn'|'error'|'off'} [lvl]

         *         Pass a valid level to set a new logging level.

         *

         * @return {string}

         *         The current logging level.

         */

        log.level = lvl => {

            if (typeof lvl === 'string') {

                if (!log.levels.hasOwnProperty(lvl)) {

                    throw new Error(`"${lvl}" in not a valid log level`);

                }

                level = lvl;

            }

            return level;

        };

        /**

         * Returns an array containing everything that has been logged to the history.

         *

         * This array is a shallow clone of the internal history record. However, its

         * contents are _not_ cloned; so, mutating objects inside this array will

         * mutate them in history.

         *

         * @return {Array}

         */

        log.history = () => history ? [].concat(history) : [];

        /**

         * Allows you to filter the history by the given logger name

         *

         * @param {string} fname

         *        The name to filter by

         *

         * @return {Array}

         *         The filtered list to return

         */

        log.history.filter = fname => {

            return (history || []).filter(historyItem => {

                // if the first item in each historyItem includes `fname`, then it's a match

                return new RegExp(`.*${fname}.*`).test(historyItem[0]);

            });

        };

        /**

         * Clears the internal history tracking, but does not prevent further history

         * tracking.

         */

        log.history.clear = () => {

            if (history) {

                history.length = 0;

            }

        };

        /**

         * Disable history tracking if it is currently enabled.

         */

        log.history.disable = () => {

            if (history !== null) {

                history.length = 0;

                history = null;

            }

        };

        /**

         * Enable history tracking if it is currently disabled.

         */

        log.history.enable = () => {

            if (history === null) {

                history = [];

            }

        };

        /**

         * Logs error messages. Similar to `console.error`.

         *

         * @param {...*} args

         *        One or more messages or objects that should be logged as an error

         */

        log.error = (...args) => logByType('error', level, args);

        /**

         * Logs warning messages. Similar to `console.warn`.

         *

         * @param {...*} args

         *        One or more messages or objects that should be logged as a warning.

         */

        log.warn = (...args) => logByType('warn', level, args);

        /**

         * Logs debug messages. Similar to `console.debug`, but may also act as a comparable

         * log if `console.debug` is not available

         *

         * @param {...*} args

         *        One or more messages or objects that should be logged as debug.

         */

        log.debug = (...args) => logByType('debug', level, args);

        return log;

    }

    /**

     * @file log.js

     * @module log

     */

    const log$1 = createLogger$1('VIDEOJS');

    const createLogger = log$1.createLogger;

    /**

     * @file obj.js

     * @module obj

     */

    /**

     * @callback obj:EachCallback

     *

     * @param {*} value

     *        The current key for the object that is being iterated over.

     *

     * @param {string} key

     *        The current key-value for object that is being iterated over

     */

    /**

     * @callback obj:ReduceCallback

     *

     * @param {*} accum

     *        The value that is accumulating over the reduce loop.

     *

     * @param {*} value

     *        The current key for the object that is being iterated over.

     *

     * @param {string} key

     *        The current key-value for object that is being iterated over

     *

     * @return {*}

     *         The new accumulated value.

     */

    const toString$1 = Object.prototype.toString;

    /**

     * Get the keys of an Object

     *

     * @param {Object}

     *        The Object to get the keys from

     *

     * @return {string[]}

     *         An array of the keys from the object. Returns an empty array if the

     *         object passed in was invalid or had no keys.

     *

     * @private

     */

    const keys = function (object) {

        return isObject$1(object) ? Object.keys(object) : [];

    };

    /**

     * Array-like iteration for objects.

     *

     * @param {Object} object

     *        The object to iterate over

     *

     * @param {obj:EachCallback} fn

     *        The callback function which is called for each key in the object.

     */

    function each(object, fn) {

        keys(object).forEach(key => fn(object[key], key));

    }

    /**

     * Array-like reduce for objects.

     *

     * @param {Object} object

     *        The Object that you want to reduce.

     *

     * @param {Function} fn

     *         A callback function which is called for each key in the object. It

     *         receives the accumulated value and the per-iteration value and key

     *         as arguments.

     *

     * @param {*} [initial = 0]

     *        Starting value

     *

     * @return {*}

     *         The final accumulated value.

     */

    function reduce(object, fn, initial = 0) {

        return keys(object).reduce((accum, key) => fn(accum, object[key], key), initial);

    }

    /**

     * Returns whether a value is an object of any kind - including DOM nodes,

     * arrays, regular expressions, etc. Not functions, though.

     *

     * This avoids the gotcha where using `typeof` on a `null` value

     * results in `'object'`.

     *

     * @param  {Object} value

     * @return {boolean}

     */

    function isObject$1(value) {

        return !!value && typeof value === 'object';

    }

    /**

     * Returns whether an object appears to be a "plain" object - that is, a

     * direct instance of `Object`.

     *

     * @param  {Object} value

     * @return {boolean}

     */

    function isPlain(value) {

        return isObject$1(value) && toString$1.call(value) === '[object Object]' && value.constructor === Object;

    }

    /**

     * Merge two objects recursively.

     *

     * Performs a deep merge like

     * {@link https://lodash.com/docs/4.17.10#merge|lodash.merge}, but only merges

     * plain objects (not arrays, elements, or anything else).

     *

     * Non-plain object values will be copied directly from the right-most

     * argument.

     *

     * @param   {Object[]} sources

     *          One or more objects to merge into a new object.

     *

     * @return {Object}

     *          A new object that is the merged result of all sources.

     */

    function merge$2(...sources) {

        const result = {};

        sources.forEach(source => {

            if (!source) {

                return;

            }

            each(source, (value, key) => {

                if (!isPlain(value)) {

                    result[key] = value;

                    return;

                }

                if (!isPlain(result[key])) {

                    result[key] = {};

                }

                result[key] = merge$2(result[key], value);

            });

        });

        return result;

    }

    /**

     * Returns an array of values for a given object

     *

     * @param  {Object} source - target object

     * @return {Array<unknown>} - object values

     */

    function values$1(source = {}) {

        const result = [];

        for (const key in source) {

            if (source.hasOwnProperty(key)) {

                const value = source[key];

                result.push(value);

            }

        }

        return result;

    }

    /**

     * Object.defineProperty but "lazy", which means that the value is only set after

     * it is retrieved the first time, rather than being set right away.

     *

     * @param {Object} obj the object to set the property on

     * @param {string} key the key for the property to set

     * @param {Function} getValue the function used to get the value when it is needed.

     * @param {boolean} setter whether a setter should be allowed or not

     */

    function defineLazyProperty(obj, key, getValue, setter = true) {

        const set = value => Object.defineProperty(obj, key, {

            value,

            enumerable: true,

            writable: true

        });

        const options = {

            configurable: true,

            enumerable: true,

            get() {

                const value = getValue();

                set(value);

                return value;

            }

        };

        if (setter) {

            options.set = set;

        }

        return Object.defineProperty(obj, key, options);

    }

    var Obj = /*#__PURE__*/Object.freeze({

        __proto__: null,

        each: each,

        reduce: reduce,

        isObject: isObject$1,

        isPlain: isPlain,

        merge: merge$2,

        values: values$1,

        defineLazyProperty: defineLazyProperty

    });

    /**

     * @file browser.js

     * @module browser

     */

    /**

     * Whether or not this device is an iPod.

     *

     * @static

     * @type {Boolean}

     */

    let IS_IPOD = false;

    /**

     * The detected iOS version - or `null`.

     *

     * @static

     * @type {string|null}

     */

    let IOS_VERSION = null;

    /**

     * Whether or not this is an Android device.

     *

     * @static

     * @type {Boolean}

     */

    let IS_ANDROID = false;

    /**

     * The detected Android version - or `null` if not Android or indeterminable.

     *

     * @static

     * @type {number|string|null}

     */

    let ANDROID_VERSION;

    /**

     * Whether or not this is Mozilla Firefox.

     *

     * @static

     * @type {Boolean}

     */

    let IS_FIREFOX = false;

    /**

     * Whether or not this is Microsoft Edge.

     *

     * @static

     * @type {Boolean}

     */

    let IS_EDGE = false;

    /**

     * Whether or not this is any Chromium Browser

     *

     * @static

     * @type {Boolean}

     */

    let IS_CHROMIUM = false;

    /**

     * Whether or not this is any Chromium browser that is not Edge.

     *

     * This will also be `true` for Chrome on iOS, which will have different support

     * as it is actually Safari under the hood.

     *

     * Deprecated, as the behaviour to not match Edge was to prevent Legacy Edge's UA matching.

     * IS_CHROMIUM should be used instead.

     * "Chromium but not Edge" could be explicitly tested with IS_CHROMIUM && !IS_EDGE

     *

     * @static

     * @deprecated

     * @type {Boolean}

     */

    let IS_CHROME = false;

    /**

     * The detected Chromium version - or `null`.

     *

     * @static

     * @type {number|null}

     */

    let CHROMIUM_VERSION = null;

    /**

     * The detected Google Chrome version - or `null`.

     * This has always been the _Chromium_ version, i.e. would return on Chromium Edge.

     * Deprecated, use CHROMIUM_VERSION instead.

     *

     * @static

     * @deprecated

     * @type {number|null}

     */

    let CHROME_VERSION = null;

    /**

     * The detected Internet Explorer version - or `null`.

     *

     * @static

     * @deprecated

     * @type {number|null}

     */

    let IE_VERSION = null;

    /**

     * Whether or not this is desktop Safari.

     *

     * @static

     * @type {Boolean}

     */

    let IS_SAFARI = false;

    /**

     * Whether or not this is a Windows machine.

     *

     * @static

     * @type {Boolean}

     */

    let IS_WINDOWS = false;

    /**

     * Whether or not this device is an iPad.

     *

     * @static

     * @type {Boolean}

     */

    let IS_IPAD = false;

    /**

     * Whether or not this device is an iPhone.

     *

     * @static

     * @type {Boolean}

     */

        // The Facebook app's UIWebView identifies as both an iPhone and iPad, so

        // to identify iPhones, we need to exclude iPads.

        // http://artsy.github.io/blog/2012/10/18/the-perils-of-ios-user-agent-sniffing/

    let IS_IPHONE = false;

    /**

     * Whether or not this device is touch-enabled.

     *

     * @static

     * @const

     * @type {Boolean}

     */

    const TOUCH_ENABLED = Boolean(isReal() && ('ontouchstart' in window || window.navigator.maxTouchPoints || window.DocumentTouch && window.document instanceof window.DocumentTouch));

    const UAD = window.navigator && window.navigator.userAgentData;

    if (UAD && UAD.platform && UAD.brands) {

        // If userAgentData is present, use it instead of userAgent to avoid warnings

        // Currently only implemented on Chromium

        // userAgentData does not expose Android version, so ANDROID_VERSION remains `null`

        IS_ANDROID = UAD.platform === 'Android';

        IS_EDGE = Boolean(UAD.brands.find(b => b.brand === 'Microsoft Edge'));

        IS_CHROMIUM = Boolean(UAD.brands.find(b => b.brand === 'Chromium'));

        IS_CHROME = !IS_EDGE && IS_CHROMIUM;

        CHROMIUM_VERSION = CHROME_VERSION = (UAD.brands.find(b => b.brand === 'Chromium') || {}).version || null;

        IS_WINDOWS = UAD.platform === 'Windows';

    }

    // If the browser is not Chromium, either userAgentData is not present which could be an old Chromium browser,

    //  or it's a browser that has added userAgentData since that we don't have tests for yet. In either case,

    // the checks need to be made agiainst the regular userAgent string.

    if (!IS_CHROMIUM) {

        const USER_AGENT = window.navigator && window.navigator.userAgent || '';

        IS_IPOD = /iPod/i.test(USER_AGENT);

        IOS_VERSION = function () {

            const match = USER_AGENT.match(/OS (\d+)_/i);

            if (match && match[1]) {

                return match[1];

            }

            return null;

        }();

        IS_ANDROID = /Android/i.test(USER_AGENT);

        ANDROID_VERSION = function () {

            // This matches Android Major.Minor.Patch versions

            // ANDROID_VERSION is Major.Minor as a Number, if Minor isn't available, then only Major is returned

            const match = USER_AGENT.match(/Android (\d+)(?:\.(\d+))?(?:\.(\d+))*/i);

            if (!match) {

                return null;

            }

            const major = match[1] && parseFloat(match[1]);

            const minor = match[2] && parseFloat(match[2]);

            if (major && minor) {

                return parseFloat(match[1] + '.' + match[2]);

            } else if (major) {

                return major;

            }

            return null;

        }();

        IS_FIREFOX = /Firefox/i.test(USER_AGENT);

        IS_EDGE = /Edg/i.test(USER_AGENT);

        IS_CHROMIUM = /Chrome/i.test(USER_AGENT) || /CriOS/i.test(USER_AGENT);

        IS_CHROME = !IS_EDGE && IS_CHROMIUM;

        CHROMIUM_VERSION = CHROME_VERSION = function () {

            const match = USER_AGENT.match(/(Chrome|CriOS)\/(\d+)/);

            if (match && match[2]) {

                return parseFloat(match[2]);

            }

            return null;

        }();

        IE_VERSION = function () {

            const result = /MSIE\s(\d+)\.\d/.exec(USER_AGENT);

            let version = result && parseFloat(result[1]);

            if (!version && /Trident\/7.0/i.test(USER_AGENT) && /rv:11.0/.test(USER_AGENT)) {

                // IE 11 has a different user agent string than other IE versions

                version = 11.0;

            }

            return version;

        }();

        IS_SAFARI = /Safari/i.test(USER_AGENT) && !IS_CHROME && !IS_ANDROID && !IS_EDGE;

        IS_WINDOWS = /Windows/i.test(USER_AGENT);

        IS_IPAD = /iPad/i.test(USER_AGENT) || IS_SAFARI && TOUCH_ENABLED && !/iPhone/i.test(USER_AGENT);

        IS_IPHONE = /iPhone/i.test(USER_AGENT) && !IS_IPAD;

    }

    /**

     * Whether or not this is an iOS device.

     *

     * @static

     * @const

     * @type {Boolean}

     */

    const IS_IOS = IS_IPHONE || IS_IPAD || IS_IPOD;

    /**

     * Whether or not this is any flavor of Safari - including iOS.

     *

     * @static

     * @const

     * @type {Boolean}

     */

    const IS_ANY_SAFARI = (IS_SAFARI || IS_IOS) && !IS_CHROME;

    var browser = /*#__PURE__*/Object.freeze({

        __proto__: null,

        get IS_IPOD () { return IS_IPOD; },

        get IOS_VERSION () { return IOS_VERSION; },

        get IS_ANDROID () { return IS_ANDROID; },

        get ANDROID_VERSION () { return ANDROID_VERSION; },

        get IS_FIREFOX () { return IS_FIREFOX; },

        get IS_EDGE () { return IS_EDGE; },

        get IS_CHROMIUM () { return IS_CHROMIUM; },

        get IS_CHROME () { return IS_CHROME; },

        get CHROMIUM_VERSION () { return CHROMIUM_VERSION; },

        get CHROME_VERSION () { return CHROME_VERSION; },

        get IE_VERSION () { return IE_VERSION; },

        get IS_SAFARI () { return IS_SAFARI; },

        get IS_WINDOWS () { return IS_WINDOWS; },

        get IS_IPAD () { return IS_IPAD; },

        get IS_IPHONE () { return IS_IPHONE; },

        TOUCH_ENABLED: TOUCH_ENABLED,

        IS_IOS: IS_IOS,

        IS_ANY_SAFARI: IS_ANY_SAFARI

    });

    /**

     * @file dom.js

     * @module dom

     */

    /**

     * Detect if a value is a string with any non-whitespace characters.

     *

     * @private

     * @param  {string} str

     *         The string to check

     *

     * @return {boolean}

     *         Will be `true` if the string is non-blank, `false` otherwise.

     *

     */

    function isNonBlankString(str) {

        // we use str.trim as it will trim any whitespace characters

        // from the front or back of non-whitespace characters. aka

        // Any string that contains non-whitespace characters will

        // still contain them after `trim` but whitespace only strings

        // will have a length of 0, failing this check.

        return typeof str === 'string' && Boolean(str.trim());

    }

    /**

     * Throws an error if the passed string has whitespace. This is used by

     * class methods to be relatively consistent with the classList API.

     *

     * @private

     * @param  {string} str

     *         The string to check for whitespace.

     *

     * @throws {Error}

     *         Throws an error if there is whitespace in the string.

     */

    function throwIfWhitespace(str) {

        // str.indexOf instead of regex because str.indexOf is faster performance wise.

        if (str.indexOf(' ') >= 0) {

            throw new Error('class has illegal whitespace characters');

        }

    }

    /**

     * Whether the current DOM interface appears to be real (i.e. not simulated).

     *

     * @return {boolean}

     *         Will be `true` if the DOM appears to be real, `false` otherwise.

     */

    function isReal() {

        // Both document and window will never be undefined thanks to `global`.

        return document === window.document;

    }

    /**

     * Determines, via duck typing, whether or not a value is a DOM element.

     *

     * @param  {*} value

     *         The value to check.

     *

     * @return {boolean}

     *         Will be `true` if the value is a DOM element, `false` otherwise.

     */

    function isEl(value) {

        return isObject$1(value) && value.nodeType === 1;

    }

    /**

     * Determines if the current DOM is embedded in an iframe.

     *

     * @return {boolean}

     *         Will be `true` if the DOM is embedded in an iframe, `false`

     *         otherwise.

     */

    function isInFrame() {

        // We need a try/catch here because Safari will throw errors when attempting

        // to get either `parent` or `self`

        try {

            return window.parent !== window.self;

        } catch (x) {

            return true;

        }

    }

    /**

     * Creates functions to query the DOM using a given method.

     *

     * @private

     * @param   {string} method

     *          The method to create the query with.

     *

     * @return  {Function}

     *          The query method

     */

    function createQuerier(method) {

        return function (selector, context) {

            if (!isNonBlankString(selector)) {

                return document[method](null);

            }

            if (isNonBlankString(context)) {

                context = document.querySelector(context);

            }

            const ctx = isEl(context) ? context : document;

            return ctx[method] && ctx[method](selector);

        };

    }

    /**

     * Creates an element and applies properties, attributes, and inserts content.

     *

     * @param  {string} [tagName='div']

     *         Name of tag to be created.