text: /*!
    * CoreUI v2.1.12 (https://coreui.io)
    * Copyright 2019 Łukasz Holeczek
    * Licensed under MIT (https://coreui.io)
    */
  (function (global, factory) {
    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('jquery'), require('perfect-scrollbar')) :
    typeof define === 'function' && define.amd ? define(['exports', 'jquery', 'perfect-scrollbar'], factory) :
    (global = global || self, factory(global.coreui = {}, global.jQuery, global.PerfectScrollbar));
  }(this, function (exports, $, PerfectScrollbar) { 'use strict';
  
    $ = $ && $.hasOwnProperty('default') ? $['default'] : $;
    PerfectScrollbar = PerfectScrollbar && PerfectScrollbar.hasOwnProperty('default') ? PerfectScrollbar['default'] : PerfectScrollbar;
  
    var fails = function (exec) {
      try {
        return !!exec();
      } catch (error) {
        return true;
      }
    };
  
    // Thank's IE8 for his funny defineProperty
    var descriptors = !fails(function () {
      return Object.defineProperty({}, 'a', { get: function () { return 7; } }).a != 7;
    });
  
    var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
  
    function createCommonjsModule(fn, module) {
    	return module = { exports: {} }, fn(module, module.exports), module.exports;
    }
  
    var O = 'object';
    var check = function (it) {
      return it && it.Math == Math && it;
    };
  
    // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
    var global_1 =
      // eslint-disable-next-line no-undef
      check(typeof globalThis == O && globalThis) ||
      check(typeof window == O && window) ||
      check(typeof self == O && self) ||
      check(typeof commonjsGlobal == O && commonjsGlobal) ||
      // eslint-disable-next-line no-new-func
      Function('return this')();
  
    var isObject = function (it) {
      return typeof it === 'object' ? it !== null : typeof it === 'function';
    };
  
    var document$1 = global_1.document;
    // typeof document.createElement is 'object' in old IE
    var exist = isObject(document$1) && isObject(document$1.createElement);
  
    var documentCreateElement = function (it) {
      return exist ? document$1.createElement(it) : {};
    };
  
    // Thank's IE8 for his funny defineProperty
    var ie8DomDefine = !descriptors && !fails(function () {
      return Object.defineProperty(documentCreateElement('div'), 'a', {
        get: function () { return 7; }
      }).a != 7;
    });
  
    var anObject = function (it) {
      if (!isObject(it)) {
        throw TypeError(String(it) + ' is not an object');
      } return it;
    };
  
    // 7.1.1 ToPrimitive(input [, PreferredType])
    // instead of the ES6 spec version, we didn't implement @@toPrimitive case
    // and the second argument - flag - preferred type is a string
    var toPrimitive = function (it, S) {
      if (!isObject(it)) return it;
      var fn, val;
      if (S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val;
      if (typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it))) return val;
      if (!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val;
      throw TypeError("Can't convert object to primitive value");
    };
  
    var nativeDefineProperty = Object.defineProperty;
  
    var f = descriptors ? nativeDefineProperty : function defineProperty(O, P, Attributes) {
      anObject(O);
      P = toPrimitive(P, true);
      anObject(Attributes);
      if (ie8DomDefine) try {
        return nativeDefineProperty(O, P, Attributes);
      } catch (error) { /* empty */ }
      if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported');
      if ('value' in Attributes) O[P] = Attributes.value;
      return O;
    };
  
    var objectDefineProperty = {
    	f: f
    };
  
    var createPropertyDescriptor = function (bitmap, value) {
      return {
        enumerable: !(bitmap & 1),
        configurable: !(bitmap & 2),
        writable: !(bitmap & 4),
        value: value
      };
    };
  
    var hide = descriptors ? function (object, key, value) {
      return objectDefineProperty.f(object, key, createPropertyDescriptor(1, value));
    } : function (object, key, value) {
      object[key] = value;
      return object;
    };
  
    var setGlobal = function (key, value) {
      try {
        hide(global_1, key, value);
      } catch (error) {
        global_1[key] = value;
      } return value;
    };
  
    var shared = createCommonjsModule(function (module) {
    var SHARED = '__core-js_shared__';
    var store = global_1[SHARED] || setGlobal(SHARED, {});
  
    (module.exports = function (key, value) {
      return store[key] || (store[key] = value !== undefined ? value : {});
    })('versions', []).push({
      version: '3.1.3',
      mode: 'global',
      copyright: '© 2019 Denis Pushkarev (zloirock.ru)'
    });
    });
  
    var hasOwnProperty = {}.hasOwnProperty;
  
    var has = function (it, key) {
      return hasOwnProperty.call(it, key);
    };
  
    var functionToString = shared('native-function-to-string', Function.toString);
  
    var WeakMap = global_1.WeakMap;
  
    var nativeWeakMap = typeof WeakMap === 'function' && /native code/.test(functionToString.call(WeakMap));
  
    var id = 0;
    var postfix = Math.random();
  
    var uid = function (key) {
      return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + postfix).toString(36));
    };
  
    var keys = shared('keys');
  
    var sharedKey = function (key) {
      return keys[key] || (keys[key] = uid(key));
    };
  
    var hiddenKeys = {};
  
    var WeakMap$1 = global_1.WeakMap;
    var set, get, has$1;
  
    var enforce = function (it) {
      return has$1(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 (nativeWeakMap) {
      var store = new WeakMap$1();
      var wmget = store.get;
      var wmhas = store.has;
      var wmset = store.set;
      set = function (it, metadata) {
        wmset.call(store, it, metadata);
        return metadata;
      };
      get = function (it) {
        return wmget.call(store, it) || {};
      };
      has$1 = function (it) {
        return wmhas.call(store, it);
      };
    } else {
      var STATE = sharedKey('state');
      hiddenKeys[STATE] = true;
      set = function (it, metadata) {
        hide(it, STATE, metadata);
        return metadata;
      };
      get = function (it) {
        return has(it, STATE) ? it[STATE] : {};
      };
      has$1 = function (it) {
        return has(it, STATE);
      };
    }
  
    var internalState = {
      set: set,
      get: get,
      has: has$1,
      enforce: enforce,
      getterFor: getterFor
    };
  
    var redefine = createCommonjsModule(function (module) {
    var getInternalState = internalState.get;
    var enforceInternalState = internalState.enforce;
    var TEMPLATE = String(functionToString).split('toString');
  
    shared('inspectSource', function (it) {
      return functionToString.call(it);
    });
  
    (module.exports = function (O, key, value, options) {
      var unsafe = options ? !!options.unsafe : false;
      var simple = options ? !!options.enumerable : false;
      var noTargetGet = options ? !!options.noTargetGet : false;
      if (typeof value == 'function') {
        if (typeof key == 'string' && !has(value, 'name')) hide(value, 'name', key);
        enforceInternalState(value).source = TEMPLATE.join(typeof key == 'string' ? key : '');
      }
      if (O === global_1) {
        if (simple) O[key] = value;
        else setGlobal(key, value);
        return;
      } else if (!unsafe) {
        delete O[key];
      } else if (!noTargetGet && O[key]) {
        simple = true;
      }
      if (simple) O[key] = value;
      else hide(O, key, value);
    // add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
    })(Function.prototype, 'toString', function toString() {
      return typeof this == 'function' && getInternalState(this).source || functionToString.call(this);
    });
    });
  
    var nativeSymbol = !!Object.getOwnPropertySymbols && !fails(function () {
      // Chrome 38 Symbol has incorrect toString conversion
      // eslint-disable-next-line no-undef
      return !String(Symbol());
    });
  
    var Symbol$1 = global_1.Symbol;
    var store$1 = shared('wks');
  
    var wellKnownSymbol = function (name) {
      return store$1[name] || (store$1[name] = nativeSymbol && Symbol$1[name]
        || (nativeSymbol ? Symbol$1 : uid)('Symbol.' + name));
    };
  
    // `RegExp.prototype.flags` getter implementation
    // https://tc39.github.io/ecma262/#sec-get-regexp.prototype.flags
    var regexpFlags = function () {
      var that = anObject(this);
      var result = '';
      if (that.global) result += 'g';
      if (that.ignoreCase) result += 'i';
      if (that.multiline) result += 'm';
      if (that.unicode) result += 'u';
      if (that.sticky) result += 'y';
      return result;
    };
  
    var nativeExec = RegExp.prototype.exec;
    // This always refers to the native implementation, because the
    // String#replace polyfill uses ./fix-regexp-well-known-symbol-logic.js,
    // which loads this file before patching the method.
    var nativeReplace = String.prototype.replace;
  
    var patchedExec = nativeExec;
  
    var UPDATES_LAST_INDEX_WRONG = (function () {
      var re1 = /a/;
      var re2 = /b*/g;
      nativeExec.call(re1, 'a');
      nativeExec.call(re2, 'a');
      return re1.lastIndex !== 0 || re2.lastIndex !== 0;
    })();
  
    // nonparticipating capturing group, copied from es5-shim's String#split patch.
    var NPCG_INCLUDED = /()??/.exec('')[1] !== undefined;
  
    var PATCH = UPDATES_LAST_INDEX_WRONG || NPCG_INCLUDED;
  
    if (PATCH) {
      patchedExec = function exec(str) {
        var re = this;
        var lastIndex, reCopy, match, i;
  
        if (NPCG_INCLUDED) {
          reCopy = new RegExp('^' + re.source + '$(?!\\s)', regexpFlags.call(re));
        }
        if (UPDATES_LAST_INDEX_WRONG) lastIndex = re.lastIndex;
  
        match = nativeExec.call(re, str);
  
        if (UPDATES_LAST_INDEX_WRONG && match) {
          re.lastIndex = re.global ? match.index + match[0].length : lastIndex;
        }
        if (NPCG_INCLUDED && match && match.length > 1) {
          // Fix browsers whose `exec` methods don't consistently return `undefined`
          // for NPCG, like IE8. NOTE: This doesn' work for /(.?)?/
          nativeReplace.call(match[0], reCopy, function () {
            for (i = 1; i < arguments.length - 2; i++) {
              if (arguments[i] === undefined) match[i] = undefined;
            }
          });
        }
  
        return match;
      };
    }
  
    var regexpExec = patchedExec;
  
    var SPECIES = wellKnownSymbol('species');
  
    var REPLACE_SUPPORTS_NAMED_GROUPS = !fails(function () {
      // #replace needs built-in support for named groups.
      // #match works fine because it just return the exec results, even if it has
      // a "grops" property.
      var re = /./;
      re.exec = function () {
        var result = [];
        result.groups = { a: '7' };
        return result;
      };
      return ''.replace(re, '$<a>') !== '7';
    });
  
    // Chrome 51 has a buggy "split" implementation when RegExp#exec !== nativeExec
    // Weex JS has frozen built-in prototypes, so use try / catch wrapper
    var SPLIT_WORKS_WITH_OVERWRITTEN_EXEC = !fails(function () {
      var re = /(?:)/;
      var originalExec = re.exec;
      re.exec = function () { return originalExec.apply(this, arguments); };
      var result = 'ab'.split(re);
      return result.length !== 2 || result[0] !== 'a' || result[1] !== 'b';
    });
  
    var fixRegexpWellKnownSymbolLogic = function (KEY, length, exec, sham) {
      var SYMBOL = wellKnownSymbol(KEY);
  
      var DELEGATES_TO_SYMBOL = !fails(function () {
        // String methods call symbol-named RegEp methods
        var O = {};
        O[SYMBOL] = function () { return 7; };
        return ''[KEY](O) != 7;
      });
  
      var DELEGATES_TO_EXEC = DELEGATES_TO_SYMBOL && !fails(function () {
        // Symbol-named RegExp methods call .exec
        var execCalled = false;
        var re = /a/;
        re.exec = function () { execCalled = true; return null; };
  
        if (KEY === 'split') {
          // RegExp[@@split] doesn't call the regex's exec method, but first creates
          // a new one. We need to return the patched regex when creating the new one.
          re.constructor = {};
          re.constructor[SPECIES] = function () { return re; };
        }
  
        re[SYMBOL]('');
        return !execCalled;
      });
  
      if (
        !DELEGATES_TO_SYMBOL ||
        !DELEGATES_TO_EXEC ||
        (KEY === 'replace' && !REPLACE_SUPPORTS_NAMED_GROUPS) ||
        (KEY === 'split' && !SPLIT_WORKS_WITH_OVERWRITTEN_EXEC)
      ) {
        var nativeRegExpMethod = /./[SYMBOL];
        var methods = exec(SYMBOL, ''[KEY], function (nativeMethod, regexp, str, arg2, forceStringMethod) {
          if (regexp.exec === regexpExec) {
            if (DELEGATES_TO_SYMBOL && !forceStringMethod) {
              // The native String method already delegates to @@method (this
              // polyfilled function), leasing to infinite recursion.
              // We avoid it by directly calling the native @@method method.
              return { done: true, value: nativeRegExpMethod.call(regexp, str, arg2) };
            }
            return { done: true, value: nativeMethod.call(str, regexp, arg2) };
          }
          return { done: false };
        });
        var stringMethod = methods[0];
        var regexMethod = methods[1];
  
        redefine(String.prototype, KEY, stringMethod);
        redefine(RegExp.prototype, SYMBOL, length == 2
          // 21.2.5.8 RegExp.prototype[@@replace](string, replaceValue)
          // 21.2.5.11 RegExp.prototype[@@split](string, limit)
          ? function (string, arg) { return regexMethod.call(string, this, arg); }
          // 21.2.5.6 RegExp.prototype[@@match](string)
          // 21.2.5.9 RegExp.prototype[@@search](string)
          : function (string) { return regexMethod.call(string, this); }
        );
        if (sham) hide(RegExp.prototype[SYMBOL], 'sham', true);
      }
    };
  
    var toString = {}.toString;
  
    var classofRaw = function (it) {
      return toString.call(it).slice(8, -1);
    };
  
    var MATCH = wellKnownSymbol('match');
  
    // `IsRegExp` abstract operation
    // https://tc39.github.io/ecma262/#sec-isregexp
    var isRegexp = function (it) {
      var isRegExp;
      return isObject(it) && ((isRegExp = it[MATCH]) !== undefined ? !!isRegExp : classofRaw(it) == 'RegExp');
    };
  
    // `RequireObjectCoercible` abstract operation
    // https://tc39.github.io/ecma262/#sec-requireobjectcoercible
    var requireObjectCoercible = function (it) {
      if (it == undefined) throw TypeError("Can't call method on " + it);
      return it;
    };
  
    var aFunction = function (it) {
      if (typeof it != 'function') {
        throw TypeError(String(it) + ' is not a function');
      } return it;
    };
  
    var SPECIES$1 = wellKnownSymbol('species');
  
    // `SpeciesConstructor` abstract operation
    // https://tc39.github.io/ecma262/#sec-speciesconstructor
    var speciesConstructor = function (O, defaultConstructor) {
      var C = anObject(O).constructor;
      var S;
      return C === undefined || (S = anObject(C)[SPECIES$1]) == undefined ? defaultConstructor : aFunction(S);
    };
  
    var ceil = Math.ceil;
    var floor = Math.floor;
  
    // `ToInteger` abstract operation
    // https://tc39.github.io/ecma262/#sec-tointeger
    var toInteger = function (argument) {
      return isNaN(argument = +argument) ? 0 : (argument > 0 ? floor : ceil)(argument);
    };
  
    // CONVERT_TO_STRING: true  -> String#at
    // CONVERT_TO_STRING: false -> String#codePointAt
    var stringAt = function (that, pos, CONVERT_TO_STRING) {
      var S = String(requireObjectCoercible(that));
      var position = toInteger(pos);
      var size = S.length;
      var first, second;
      if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined;
      first = S.charCodeAt(position);
      return first < 0xD800 || first > 0xDBFF || position + 1 === size
        || (second = S.charCodeAt(position + 1)) < 0xDC00 || second > 0xDFFF
          ? CONVERT_TO_STRING ? S.charAt(position) : first
          : CONVERT_TO_STRING ? S.slice(position, position + 2) : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;
    };
  
    // `AdvanceStringIndex` abstract operation
    // https://tc39.github.io/ecma262/#sec-advancestringindex
    var advanceStringIndex = function (S, index, unicode) {
      return index + (unicode ? stringAt(S, index, true).length : 1);
    };
  
    var min = Math.min;
  
    // `ToLength` abstract operation
    // https://tc39.github.io/ecma262/#sec-tolength
    var toLength = function (argument) {
      return argument > 0 ? min(toInteger(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991
    };
  
    // `RegExpExec` abstract operation
    // https://tc39.github.io/ecma262/#sec-regexpexec
    var regexpExecAbstract = function (R, S) {
      var exec = R.exec;
      if (typeof exec === 'function') {
        var result = exec.call(R, S);
        if (typeof result !== 'object') {
          throw TypeError('RegExp exec method returned something other than an Object or null');
        }
        return result;
      }
  
      if (classofRaw(R) !== 'RegExp') {
        throw TypeError('RegExp#exec called on incompatible receiver');
      }
  
      return regexpExec.call(R, S);
    };
  
    var arrayPush = [].push;
    var min$1 = Math.min;
    var MAX_UINT32 = 0xFFFFFFFF;
  
    // babel-minify transpiles RegExp('x', 'y') -> /x/y and it causes SyntaxError
    var SUPPORTS_Y = !fails(function () { return !RegExp(MAX_UINT32, 'y'); });
  
    // @@split logic
    fixRegexpWellKnownSymbolLogic('split', 2, function (SPLIT, nativeSplit, maybeCallNative) {
      var internalSplit;
      if (
        'abbc'.split(/(b)*/)[1] == 'c' ||
        'test'.split(/(?:)/, -1).length != 4 ||
        'ab'.split(/(?:ab)*/).length != 2 ||
        '.'.split(/(.?)(.?)/).length != 4 ||
        '.'.split(/()()/).length > 1 ||
        ''.split(/.?/).length
      ) {
        // based on es5-shim implementation, need to rework it
        internalSplit = function (separator, limit) {
          var string = String(requireObjectCoercible(this));
          var lim = limit === undefined ? MAX_UINT32 : limit >>> 0;
          if (lim === 0) return [];
          if (separator === undefined) return [string];
          // If `separator` is not a regex, use native split
          if (!isRegexp(separator)) {
            return nativeSplit.call(string, separator, lim);
          }
          var output = [];
          var flags = (separator.ignoreCase ? 'i' : '') +
                      (separator.multiline ? 'm' : '') +
                      (separator.unicode ? 'u' : '') +
                      (separator.sticky ? 'y' : '');
          var lastLastIndex = 0;
          // Make `global` and avoid `lastIndex` issues by working with a copy
          var separatorCopy = new RegExp(separator.source, flags + 'g');
          var match, lastIndex, lastLength;
          while (match = regexpExec.call(separatorCopy, string)) {
            lastIndex = separatorCopy.lastIndex;
            if (lastIndex > lastLastIndex) {
              output.push(string.slice(lastLastIndex, match.index));
              if (match.length > 1 && match.index < string.length) arrayPush.apply(output, match.slice(1));
              lastLength = match[0].length;
              lastLastIndex = lastIndex;
              if (output.length >= lim) break;
            }
            if (separatorCopy.lastIndex === match.index) separatorCopy.lastIndex++; // Avoid an infinite loop
          }
          if (lastLastIndex === string.length) {
            if (lastLength || !separatorCopy.test('')) output.push('');
          } else output.push(string.slice(lastLastIndex));
          return output.length > lim ? output.slice(0, lim) : output;
        };
      // Chakra, V8
      } else if ('0'.split(undefined, 0).length) {
        internalSplit = function (separator, limit) {
          return separator === undefined && limit === 0 ? [] : nativeSplit.call(this, separator, limit);
        };
      } else internalSplit = nativeSplit;
  
      return [
        // `String.prototype.split` method
        // https://tc39.github.io/ecma262/#sec-string.prototype.split
        function split(separator, limit) {
          var O = requireObjectCoercible(this);
          var splitter = separator == undefined ? undefined : separator[SPLIT];
          return splitter !== undefined
            ? splitter.call(separator, O, limit)
            : internalSplit.call(String(O), separator, limit);
        },
        // `RegExp.prototype[@@split]` method
        // https://tc39.github.io/ecma262/#sec-regexp.prototype-@@split
        //
        // NOTE: This cannot be properly polyfilled in engines that don't support
        // the 'y' flag.
        function (regexp, limit) {
          var res = maybeCallNative(internalSplit, regexp, this, limit, internalSplit !== nativeSplit);
          if (res.done) return res.value;
  
          var rx = anObject(regexp);
          var S = String(this);
          var C = speciesConstructor(rx, RegExp);
  
          var unicodeMatching = rx.unicode;
          var flags = (rx.ignoreCase ? 'i' : '') +
                      (rx.multiline ? 'm' : '') +
                      (rx.unicode ? 'u' : '') +
                      (SUPPORTS_Y ? 'y' : 'g');
  
          // ^(? + rx + ) is needed, in combination with some S slicing, to
          // simulate the 'y' flag.
          var splitter = new C(SUPPORTS_Y ? rx : '^(?:' + rx.source + ')', flags);
          var lim = limit === undefined ? MAX_UINT32 : limit >>> 0;
          if (lim === 0) return [];
          if (S.length === 0) return regexpExecAbstract(splitter, S) === null ? [S] : [];
          var p = 0;
          var q = 0;
          var A = [];
          while (q < S.length) {
            splitter.lastIndex = SUPPORTS_Y ? q : 0;
            var z = regexpExecAbstract(splitter, SUPPORTS_Y ? S : S.slice(q));
            var e;
            if (
              z === null ||
              (e = min$1(toLength(splitter.lastIndex + (SUPPORTS_Y ? 0 : q)), S.length)) === p
            ) {
              q = advanceStringIndex(S, q, unicodeMatching);
            } else {
              A.push(S.slice(p, q));
              if (A.length === lim) return A;
              for (var i = 1; i <= z.length - 1; i++) {
                A.push(z[i]);
                if (A.length === lim) return A;
              }
              q = p = e;
            }
          }
          A.push(S.slice(p));
          return A;
        }
      ];
    }, !SUPPORTS_Y);
  
    var nativePropertyIsEnumerable = {}.propertyIsEnumerable;
    var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
  
    // Nashorn ~ JDK8 bug
    var NASHORN_BUG = getOwnPropertyDescriptor && !nativePropertyIsEnumerable.call({ 1: 2 }, 1);
  
    var f$1 = NASHORN_BUG ? function propertyIsEnumerable(V) {
      var descriptor = getOwnPropertyDescriptor(this, V);
      return !!descriptor && descriptor.enumerable;
    } : nativePropertyIsEnumerable;
  
    var objectPropertyIsEnumerable = {
    	f: f$1
    };
  
    // fallback for non-array-like ES3 and non-enumerable old V8 strings
  
  
  
    var split = ''.split;
  
    var indexedObject = fails(function () {
      // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346
      // eslint-disable-next-line no-prototype-builtins
      return !Object('z').propertyIsEnumerable(0);
    }) ? function (it) {
      return classofRaw(it) == 'String' ? split.call(it, '') : Object(it);
    } : Object;
  
    // toObject with fallback for non-array-like ES3 strings
  
  
  
    var toIndexedObject = function (it) {
      return indexedObject(requireObjectCoercible(it));
    };
  
    var nativeGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
  
    var f$2 = descriptors ? nativeGetOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {
      O = toIndexedObject(O);
      P = toPrimitive(P, true);
      if (ie8DomDefine) try {
        return nativeGetOwnPropertyDescriptor(O, P);
      } catch (error) { /* empty */ }
      if (has(O, P)) return createPropertyDescriptor(!objectPropertyIsEnumerable.f.call(O, P), O[P]);
    };
  
    var objectGetOwnPropertyDescriptor = {
    	f: f$2
    };
  
    var max = Math.max;
    var min$2 = Math.min;
  
    // Helper for a popular repeating case of the spec:
    // Let integer be ? ToInteger(index).
    // If integer < 0, let result be max((length + integer), 0); else let result be min(length, length).
    var toAbsoluteIndex = function (index, length) {
      var integer = toInteger(index);
      return integer < 0 ? max(integer + length, 0) : min$2(integer, length);
    };
  
    // `Array.prototype.{ indexOf, includes }` methods implementation
    // false -> Array#indexOf
    // https://tc39.github.io/ecma262/#sec-array.prototype.indexof
    // true  -> Array#includes
    // https://tc39.github.io/ecma262/#sec-array.prototype.includes
    var arrayIncludes = function (IS_INCLUDES) {
      return function ($this, el, fromIndex) {
        var O = toIndexedObject($this);
        var length = toLength(O.length);
        var index = toAbsoluteIndex(fromIndex, length);
        var value;
        // Array#includes uses SameValueZero equality algorithm
        // eslint-disable-next-line no-self-compare
        if (IS_INCLUDES && el != el) while (length > index) {
          value = O[index++];
          // eslint-disable-next-line no-self-compare
          if (value != value) return true;
        // Array#indexOf ignores holes, Array#includes - not
        } else for (;length > index; index++) if (IS_INCLUDES || index in O) {
          if (O[index] === el) return IS_INCLUDES || index || 0;
        } return !IS_INCLUDES && -1;
      };
    };
  
    var arrayIndexOf = arrayIncludes(false);
  
    var objectKeysInternal = function (object, names) {
      var O = toIndexedObject(object);
      var i = 0;
      var result = [];
      var key;
      for (key in O) !has(hiddenKeys, key) && has(O, key) && result.push(key);
      // Don't enum bug & hidden keys
      while (names.length > i) if (has(O, key = names[i++])) {
        ~arrayIndexOf(result, key) || result.push(key);
      }
      return result;
    };
  
    // IE8- don't enum bug keys
    var enumBugKeys = [
      'constructor',
      'hasOwnProperty',
      'isPrototypeOf',
      'propertyIsEnumerable',
      'toLocaleString',
      'toString',
      'valueOf'
    ];
  
    // 19.1.2.7 / 15.2.3.4 Object.getOwnPropertyNames(O)
  
  
  
    var hiddenKeys$1 = enumBugKeys.concat('length', 'prototype');
  
    var f$3 = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
      return objectKeysInternal(O, hiddenKeys$1);
    };
  
    var objectGetOwnPropertyNames = {
    	f: f$3
    };
  
    var f$4 = Object.getOwnPropertySymbols;
  
    var objectGetOwnPropertySymbols = {
    	f: f$4
    };
  
    var Reflect = global_1.Reflect;
  
    // all object keys, includes non-enumerable and symbols
    var ownKeys = Reflect && Reflect.ownKeys || function ownKeys(it) {
      var keys = objectGetOwnPropertyNames.f(anObject(it));
      var getOwnPropertySymbols = objectGetOwnPropertySymbols.f;
      return getOwnPropertySymbols ? keys.concat(getOwnPropertySymbols(it)) : keys;
    };
  
    var copyConstructorProperties = function (target, source) {
      var keys = ownKeys(source);
      var defineProperty = objectDefineProperty.f;
      var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f;
      for (var i = 0; i < keys.length; i++) {
        var key = keys[i];
        if (!has(target, key)) defineProperty(target, key, getOwnPropertyDescriptor(source, key));
      }
    };
  
    var replacement = /#|\.prototype\./;
  
    var isForced = function (feature, detection) {
      var value = data[normalize(feature)];
      return value == POLYFILL ? true
        : value == NATIVE ? false
        : typeof detection == 'function' ? 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';
  
    var isForced_1 = isForced;
  
    var getOwnPropertyDescriptor$1 = objectGetOwnPropertyDescriptor.f;
  
  
  
  
  
  
    /*
      options.target      - name of the target object
      options.global      - target is the global object
      options.stat        - export as static methods of target
      options.proto       - export as prototype methods of target
      options.real        - real prototype method for the `pure` version
      options.forced      - export even if the native feature is available
      options.bind        - bind methods to the target, required for the `pure` version
      options.wrap        - wrap constructors to preventing global pollution, required for the `pure` version
      options.unsafe      - use the simple assignment of property instead of delete + defineProperty
      options.sham        - add a flag to not completely full polyfills
      options.enumerable  - export as enumerable property
      options.noTargetGet - prevent calling a getter on target
    */
    var _export = 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_1;
      } else if (STATIC) {
        target = global_1[TARGET] || setGlobal(TARGET, {});
      } else {
        target = (global_1[TARGET] || {}).prototype;
      }
      if (target) for (key in source) {
        sourceProperty = source[key];
        if (options.noTargetGet) {
          descriptor = getOwnPropertyDescriptor$1(target, key);
          targetProperty = descriptor && descriptor.value;
        } else targetProperty = target[key];
        FORCED = isForced_1(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);
        // contained in target
        if (!FORCED && targetProperty !== undefined) {
          if (typeof sourceProperty === typeof targetProperty) continue;
          copyConstructorProperties(sourceProperty, targetProperty);
        }
        // add a flag to not completely full polyfills
        if (options.sham || (targetProperty && targetProperty.sham)) {
          hide(sourceProperty, 'sham', true);
        }
        // extend global
        redefine(target, key, sourceProperty, options);
      }
    };
  
    // optional / simple context binding
    var bindContext = function (fn, that, length) {
      aFunction(fn);
      if (that === undefined) return fn;
      switch (length) {
        case 0: return function () {
          return fn.call(that);
        };
        case 1: return function (a) {
          return fn.call(that, a);
        };
        case 2: return function (a, b) {
          return fn.call(that, a, b);
        };
        case 3: return function (a, b, c) {
          return fn.call(that, a, b, c);
        };
      }
      return function (/* ...args */) {
        return fn.apply(that, arguments);
      };
    };
  
    // `ToObject` abstract operation
    // https://tc39.github.io/ecma262/#sec-toobject
    var toObject = function (argument) {
      return Object(requireObjectCoercible(argument));
    };
  
    // call something on iterator step with safe closing on error
    var callWithSafeIterationClosing = function (iterator, fn, value, ENTRIES) {
      try {
        return ENTRIES ? fn(anObject(value)[0], value[1]) : fn(value);
      // 7.4.6 IteratorClose(iterator, completion)
      } catch (error) {
        var returnMethod = iterator['return'];
        if (returnMethod !== undefined) anObject(returnMethod.call(iterator));
        throw error;
      }
    };
  
    var iterators = {};
  
    var ITERATOR = wellKnownSymbol('iterator');
    var ArrayPrototype = Array.prototype;
  
    // check on default Array iterator
    var isArrayIteratorMethod = function (it) {
      return it !== undefined && (iterators.Array === it || ArrayPrototype[ITERATOR] === it);
    };
  
    var createProperty = function (object, key, value) {
      var propertyKey = toPrimitive(key);
      if (propertyKey in object) objectDefineProperty.f(object, propertyKey, createPropertyDescriptor(0, value));
      else object[propertyKey] = value;
    };
  
    var TO_STRING_TAG = wellKnownSymbol('toStringTag');
    // ES3 wrong here
    var CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) == 'Arguments';
  
    // fallback for IE11 Script Access Denied error
    var tryGet = function (it, key) {
      try {
        return it[key];
      } catch (error) { /* empty */ }
    };
  
    // getting tag from ES6+ `Object.prototype.toString`
    var classof = function (it) {
      var O, tag, result;
      return it === undefined ? 'Undefined' : it === null ? 'Null'
        // @@toStringTag case
        : typeof (tag = tryGet(O = Object(it), TO_STRING_TAG)) == 'string' ? tag
        // builtinTag case
        : CORRECT_ARGUMENTS ? classofRaw(O)
        // ES3 arguments fallback
        : (result = classofRaw(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : result;
    };
  
    var ITERATOR$1 = wellKnownSymbol('iterator');
  
    var getIteratorMethod = function (it) {
      if (it != undefined) return it[ITERATOR$1]
        || it['@@iterator']
        || iterators[classof(it)];
    };
  
    // `Array.from` method
    // https://tc39.github.io/ecma262/#sec-array.from
    var arrayFrom = function from(arrayLike /* , mapfn = undefined, thisArg = undefined */) {
      var O = toObject(arrayLike);
      var C = typeof this == 'function' ? this : Array;
      var argumentsLength = arguments.length;
      var mapfn = argumentsLength > 1 ? arguments[1] : undefined;
      var mapping = mapfn !== undefined;
      var index = 0;
      var iteratorMethod = getIteratorMethod(O);
      var length, result, step, iterator;
      if (mapping) mapfn = bindContext(mapfn, argumentsLength > 2 ? arguments[2] : undefined, 2);
      // if the target is not iterable or it's an array with the default iterator - use a simple case
      if (iteratorMethod != undefined && !(C == Array && isArrayIteratorMethod(iteratorMethod))) {
        iterator = iteratorMethod.call(O);
        result = new C();
        for (;!(step = iterator.next()).done; index++) {
          createProperty(result, index, mapping
            ? callWithSafeIterationClosing(iterator, mapfn, [step.value, index], true)
            : step.value
          );
        }
      } else {
        length = toLength(O.length);
        result = new C(length);
        for (;length > index; index++) {
          createProperty(result, index, mapping ? mapfn(O[index], index) : O[index]);
        }
      }
      result.length = index;
      return result;
    };
  
    var ITERATOR$2 = wellKnownSymbol('iterator');
    var SAFE_CLOSING = false;
  
    try {
      var called = 0;
      var iteratorWithReturn = {
        next: function () {
          return { done: !!called++ };
        },
        'return': function () {
          SAFE_CLOSING = true;
        }
      };
      iteratorWithReturn[ITERATOR$2] = function () {
        return this;
      };
      // eslint-disable-next-line no-throw-literal
      Array.from(iteratorWithReturn, function () { throw 2; });
    } catch (error) { /* empty */ }
  
    var checkCorrectnessOfIteration = function (exec, SKIP_CLOSING) {
      if (!SKIP_CLOSING && !SAFE_CLOSING) return false;
      var ITERATION_SUPPORT = false;
      try {
        var object = {};
        object[ITERATOR$2] = function () {
          return {
            next: function () {
              return { done: ITERATION_SUPPORT = true };
            }
          };
        };
        exec(object);
      } catch (error) { /* empty */ }
      return ITERATION_SUPPORT;
    };
  
    var INCORRECT_ITERATION = !checkCorrectnessOfIteration(function (iterable) {
      Array.from(iterable);
    });
  
    // `Array.from` method
    // https://tc39.github.io/ecma262/#sec-array.from
    _export({ target: 'Array', stat: true, forced: INCORRECT_ITERATION }, {
      from: arrayFrom
    });
  
    // `IsArray` abstract operation
    // https://tc39.github.io/ecma262/#sec-isarray
    var isArray = Array.isArray || function isArray(arg) {
      return classofRaw(arg) == 'Array';
    };
  
    var SPECIES$2 = wellKnownSymbol('species');
  
    // `ArraySpeciesCreate` abstract operation
    // https://tc39.github.io/ecma262/#sec-arrayspeciescreate
    var arraySpeciesCreate = function (originalArray, length) {
      var C;
      if (isArray(originalArray)) {
        C = originalArray.constructor;
        // cross-realm fallback
        if (typeof C == 'function' && (C === Array || isArray(C.prototype))) C = undefined;
        else if (isObject(C)) {
          C = C[SPECIES$2];
          if (C === null) C = undefined;
        }
      } return new (C === undefined ? Array : C)(length === 0 ? 0 : length);
    };
  
    // `Array.prototype.{ forEach, map, filter, some, every, find, findIndex }` methods implementation
    // 0 -> Array#forEach
    // https://tc39.github.io/ecma262/#sec-array.prototype.foreach
    // 1 -> Array#map
    // https://tc39.github.io/ecma262/#sec-array.prototype.map
    // 2 -> Array#filter
    // https://tc39.github.io/ecma262/#sec-array.prototype.filter
    // 3 -> Array#some
    // https://tc39.github.io/ecma262/#sec-array.prototype.some
    // 4 -> Array#every
    // https://tc39.github.io/ecma262/#sec-array.prototype.every
    // 5 -> Array#find
    // https://tc39.github.io/ecma262/#sec-array.prototype.find
    // 6 -> Array#findIndex
    // https://tc39.github.io/ecma262/#sec-array.prototype.findIndex
    var arrayMethods = function (TYPE, specificCreate) {
      var IS_MAP = TYPE == 1;
      var IS_FILTER = TYPE == 2;
      var IS_SOME = TYPE == 3;
      var IS_EVERY = TYPE == 4;
      var IS_FIND_INDEX = TYPE == 6;
      var NO_HOLES = TYPE == 5 || IS_FIND_INDEX;
      var create = specificCreate || arraySpeciesCreate;
      return function ($this, callbackfn, that) {
        var O = toObject($this);
        var self = indexedObject(O);
        var boundFunction = bindContext(callbackfn, that, 3);
        var length = toLength(self.length);
        var index = 0;
        var target = IS_MAP ? create($this, length) : IS_FILTER ? create($this, 0) : undefined;
        var value, result;
        for (;length > index; index++) if (NO_HOLES || index in self) {
          value = self[index];
          result = boundFunction(value, index, O);
          if (TYPE) {
            if (IS_MAP) target[index] = result; // map
            else if (result) switch (TYPE) {
              case 3: return true;              // some
              case 5: return value;             // find
              case 6: return index;             // findIndex
              case 2: target.push(value);       // filter
            } else if (IS_EVERY) return false;  // every
          }
        }
        return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target;
      };
    };
  
    var SPECIES$3 = wellKnownSymbol('species');
  
    var arrayMethodHasSpeciesSupport = function (METHOD_NAME) {
      return !fails(function () {
        var array = [];
        var constructor = array.constructor = {};
        constructor[SPECIES$3] = function () {
          return { foo: 1 };
        };
        return array[METHOD_NAME](Boolean).foo !== 1;
      });
    };
  
    var internalMap = arrayMethods(1);
    var SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('map');
  
    // `Array.prototype.map` method
    // https://tc39.github.io/ecma262/#sec-array.prototype.map
    // with adding support of @@species
    _export({ target: 'Array', proto: true, forced: !SPECIES_SUPPORT }, {
      map: function map(callbackfn /* , thisArg */) {
        return internalMap(this, callbackfn, arguments[1]);
      }
    });
  
    // 19.1.2.14 / 15.2.3.14 Object.keys(O)
    var objectKeys = Object.keys || function keys(O) {
      return objectKeysInternal(O, enumBugKeys);
    };
  
    var nativeAssign = Object.assign;
  
    // 19.1.2.1 Object.assign(target, source, ...)
    // should work with symbols and should have deterministic property order (V8 bug)
    var objectAssign = !nativeAssign || fails(function () {
      var A = {};
      var B = {};
      // eslint-disable-next-line no-undef
      var symbol = Symbol();
      var alphabet = 'abcdefghijklmnopqrst';
      A[symbol] = 7;
      alphabet.split('').forEach(function (chr) { B[chr] = chr; });
      return nativeAssign({}, A)[symbol] != 7 || objectKeys(nativeAssign({}, B)).join('') != alphabet;
    }) ? function assign(target, source) { // eslint-disable-line no-unused-vars
      var T = toObject(target);
      var argumentsLength = arguments.length;
      var index = 1;
      var getOwnPropertySymbols = objectGetOwnPropertySymbols.f;
      var propertyIsEnumerable = objectPropertyIsEnumerable.f;
      while (argumentsLength > index) {
        var S = indexedObject(arguments[index++]);
        var keys = getOwnPropertySymbols ? objectKeys(S).concat(getOwnPropertySymbols(S)) : objectKeys(S);
        var length = keys.length;
        var j = 0;
        var key;
        while (length > j) {
          key = keys[j++];
          if (!descriptors || propertyIsEnumerable.call(S, key)) T[key] = S[key];
        }
      } return T;
    } : nativeAssign;
  
    // `Object.assign` method
    // https://tc39.github.io/ecma262/#sec-object.assign
    _export({ target: 'Object', stat: true, forced: Object.assign !== objectAssign }, {
      assign: objectAssign
    });
  
    var correctPrototypeGetter = !fails(function () {
      function F() { /* empty */ }
      F.prototype.constructor = null;
      return Object.getPrototypeOf(new F()) !== F.prototype;
    });
  
    var IE_PROTO = sharedKey('IE_PROTO');
    var ObjectPrototype = Object.prototype;
  
    // 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O)
    var objectGetPrototypeOf = correctPrototypeGetter ? Object.getPrototypeOf : function (O) {
      O = toObject(O);
      if (has(O, IE_PROTO)) return O[IE_PROTO];
      if (typeof O.constructor == 'function' && O instanceof O.constructor) {
        return O.constructor.prototype;
      } return O instanceof Object ? ObjectPrototype : null;
    };
  
    var ITERATOR$3 = wellKnownSymbol('iterator');
    var BUGGY_SAFARI_ITERATORS = false;
  
    var returnThis = function () { return this; };
  
    // `%IteratorPrototype%` object
    // https://tc39.github.io/ecma262/#sec-%iteratorprototype%-object
    var IteratorPrototype, PrototypeOfArrayIteratorPrototype, arrayIterator;
  
    if ([].keys) {
      arrayIterator = [].keys();
      // Safari 8 has buggy iterators w/o `next`
      if (!('next' in arrayIterator)) BUGGY_SAFARI_ITERATORS = true;
      else {
        PrototypeOfArrayIteratorPrototype = objectGetPrototypeOf(objectGetPrototypeOf(arrayIterator));
        if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype = PrototypeOfArrayIteratorPrototype;
      }
    }
  
    if (IteratorPrototype == undefined) IteratorPrototype = {};
  
    // 25.1.2.1.1 %IteratorPrototype%[@@iterator]()
    if (!has(IteratorPrototype, ITERATOR$3)) hide(IteratorPrototype, ITERATOR$3, returnThis);
  
    var iteratorsCore = {
      IteratorPrototype: IteratorPrototype,
      BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS
    };
  
    var objectDefineProperties = descriptors ? Object.defineProperties : function defineProperties(O, Properties) {
      anObject(O);
      var keys = objectKeys(Properties);
      var length = keys.length;
      var i = 0;
      var key;
      while (length > i) objectDefineProperty.f(O, key = keys[i++], Properties[key]);
      return O;
    };
  
    var document$2 = global_1.document;
  
    var html = document$2 && document$2.documentElement;
  
    var IE_PROTO$1 = sharedKey('IE_PROTO');
  
    var PROTOTYPE = 'prototype';
    var Empty = function () { /* empty */ };
  
    // Create object with fake `null` prototype: use iframe Object with cleared prototype
    var createDict = function () {
      // Thrash, waste and sodomy: IE GC bug
      var iframe = documentCreateElement('iframe');
      var length = enumBugKeys.length;
      var lt = '<';
      var script = 'script';
      var gt = '>';
      var js = 'java' + script + ':';
      var iframeDocument;
      iframe.style.display = 'none';
      html.appendChild(iframe);
      iframe.src = String(js);
      iframeDocument = iframe.contentWindow.document;
      iframeDocument.open();
      iframeDocument.write(lt + script + gt + 'document.F=Object' + lt + '/' + script + gt);
      iframeDocument.close();
      createDict = iframeDocument.F;
      while (length--) delete createDict[PROTOTYPE][enumBugKeys[length]];
      return createDict();
    };
  
    // 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])
    var objectCreate = Object.create || function create(O, Properties) {
      var result;
      if (O !== null) {
        Empty[PROTOTYPE] = anObject(O);
        result = new Empty();
        Empty[PROTOTYPE] = null;
        // add "__proto__" for Object.getPrototypeOf polyfill
        result[IE_PROTO$1] = O;
      } else result = createDict();
      return Properties === undefined ? result : objectDefineProperties(result, Properties);
    };
  
    hiddenKeys[IE_PROTO$1] = true;
  
    var defineProperty = objectDefineProperty.f;
  
  
  
    var TO_STRING_TAG$1 = wellKnownSymbol('toStringTag');
  
    var setToStringTag = function (it, TAG, STATIC) {
      if (it && !has(it = STATIC ? it : it.prototype, TO_STRING_TAG$1)) {
        defineProperty(it, TO_STRING_TAG$1, { configurable: true, value: TAG });
      }
    };
  
    var IteratorPrototype$1 = iteratorsCore.IteratorPrototype;
  
  
  
  
  
    var returnThis$1 = function () { return this; };
  
    var createIteratorConstructor = function (IteratorConstructor, NAME, next) {
      var TO_STRING_TAG = NAME + ' Iterator';
      IteratorConstructor.prototype = objectCreate(IteratorPrototype$1, { next: createPropertyDescriptor(1, next) });
      setToStringTag(IteratorConstructor, TO_STRING_TAG, false);
      iterators[TO_STRING_TAG] = returnThis$1;
      return IteratorConstructor;
    };
  
    var validateSetPrototypeOfArguments = function (O, proto) {
      anObject(O);
      if (!isObject(proto) && proto !== null) {
        throw TypeError("Can't set " + String(proto) + ' as a prototype');
      }
    };
  
    // Works with __proto__ only. Old v8 can't work with null proto objects.
    /* eslint-disable no-proto */
    var objectSetPrototypeOf = Object.setPrototypeOf || ('__proto__' in {} ? function () {
      var correctSetter = false;
      var test = {};
      var setter;
      try {
        setter = Object.getOwnPropertyDescriptor(Object.prototype, '__proto__').set;
        setter.call(test, []);
        correctSetter = test instanceof Array;
      } catch (error) { /* empty */ }
      return function setPrototypeOf(O, proto) {
        validateSetPrototypeOfArguments(O, proto);
        if (correctSetter) setter.call(O, proto);
        else O.__proto__ = proto;
        return O;
      };
    }() : undefined);
  
    var IteratorPrototype$2 = iteratorsCore.IteratorPrototype;
    var BUGGY_SAFARI_ITERATORS$1 = iteratorsCore.BUGGY_SAFARI_ITERATORS;
    var ITERATOR$4 = wellKnownSymbol('iterator');
    var KEYS = 'keys';
    var VALUES = 'values';
    var ENTRIES = 'entries';
  
    var returnThis$2 = function () { return this; };
  
    var defineIterator = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) {
      createIteratorConstructor(IteratorConstructor, NAME, next);
  
      var getIterationMethod = function (KIND) {
        if (KIND === DEFAULT && defaultIterator) return defaultIterator;
        if (!BUGGY_SAFARI_ITERATORS$1 && KIND in IterablePrototype) return IterablePrototype[KIND];
        switch (KIND) {
          case KEYS: return function keys() { return new IteratorConstructor(this, KIND); };
          case VALUES: return function values() { return new IteratorConstructor(this, KIND); };
          case ENTRIES: return function entries() { return new IteratorConstructor(this, KIND); };
        } return function () { return new IteratorConstructor(this); };
      };
  
      var TO_STRING_TAG = NAME + ' Iterator';
      var INCORRECT_VALUES_NAME = false;
      var IterablePrototype = Iterable.prototype;
      var nativeIterator = IterablePrototype[ITERATOR$4]
        || IterablePrototype['@@iterator']
        || DEFAULT && IterablePrototype[DEFAULT];
      var defaultIterator = !BUGGY_SAFARI_ITERATORS$1 && nativeIterator || getIterationMethod(DEFAULT);
      var anyNativeIterator = NAME == 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator;
      var CurrentIteratorPrototype, methods, KEY;
  
      // fix native
      if (anyNativeIterator) {
        CurrentIteratorPrototype = objectGetPrototypeOf(anyNativeIterator.call(new Iterable()));
        if (IteratorPrototype$2 !== Object.prototype && CurrentIteratorPrototype.next) {
          if (objectGetPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype$2) {
            if (objectSetPrototypeOf) {
              objectSetPrototypeOf(CurrentIteratorPrototype, IteratorPrototype$2);
            } else if (typeof CurrentIteratorPrototype[ITERATOR$4] != 'function') {
              hide(CurrentIteratorPrototype, ITERATOR$4, returnThis$2);
            }
          }
          // Set @@toStringTag to native iterators
          setToStringTag(CurrentIteratorPrototype, TO_STRING_TAG, true);
        }
      }
  
      // fix Array#{values, @@iterator}.name in V8 / FF
      if (DEFAULT == VALUES && nativeIterator && nativeIterator.name !== VALUES) {
        INCORRECT_VALUES_NAME = true;
        defaultIterator = function values() { return nativeIterator.call(this); };
      }
  
      // define iterator
      if (IterablePrototype[ITERATOR$4] !== defaultIterator) {
        hide(IterablePrototype, ITERATOR$4, defaultIterator);
      }
      iterators[NAME] = defaultIterator;
  
      // export additional methods
      if (DEFAULT) {
        methods = {
          values: getIterationMethod(VALUES),
          keys: IS_SET ? defaultIterator : getIterationMethod(KEYS),
          entries: getIterationMethod(ENTRIES)
        };
        if (FORCED) for (KEY in methods) {
          if (BUGGY_SAFARI_ITERATORS$1 || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) {
            redefine(IterablePrototype, KEY, methods[KEY]);
          }
        } else _export({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS$1 || INCORRECT_VALUES_NAME }, methods);
      }
  
      return methods;
    };
  
    var STRING_ITERATOR = 'String Iterator';
    var setInternalState = internalState.set;
    var getInternalState = internalState.getterFor(STRING_ITERATOR);
  
    // `String.prototype[@@iterator]` method
    // https://tc39.github.io/ecma262/#sec-string.prototype-@@iterator
    defineIterator(String, 'String', function (iterated) {
      setInternalState(this, {
        type: STRING_ITERATOR,
        string: String(iterated),
        index: 0
      });
    // `%StringIteratorPrototype%.next` method
    // https://tc39.github.io/ecma262/#sec-%stringiteratorprototype%.next
    }, function next() {
      var state = getInternalState(this);
      var string = state.string;
      var index = state.index;
      var point;
      if (index >= string.length) return { value: undefined, done: true };
      point = stringAt(string, index, true);
      state.index += point.length;
      return { value: point, done: false };
    });
  
    var max$1 = Math.max;
    var min$3 = Math.min;
    var floor$1 = Math.floor;
    var SUBSTITUTION_SYMBOLS = /\$([$&'`]|\d\d?|<[^>]*>)/g;
    var SUBSTITUTION_SYMBOLS_NO_NAMED = /\$([$&'`]|\d\d?)/g;
  
    var maybeToString = function (it) {
      return it === undefined ? it : String(it);
    };
  
    // @@replace logic
    fixRegexpWellKnownSymbolLogic('replace', 2, function (REPLACE, nativeReplace, maybeCallNative) {
      return [
        // `String.prototype.replace` method
        // https://tc39.github.io/ecma262/#sec-string.prototype.replace
        function replace(searchValue, replaceValue) {
          var O = requireObjectCoercible(this);
          var replacer = searchValue == undefined ? undefined : searchValue[REPLACE];
          return replacer !== undefined
            ? replacer.call(searchValue, O, replaceValue)
            : nativeReplace.call(String(O), searchValue, replaceValue);
        },
        // `RegExp.prototype[@@replace]` method
        // https://tc39.github.io/ecma262/#sec-regexp.prototype-@@replace
        function (regexp, replaceValue) {
          var res = maybeCallNative(nativeReplace, regexp, this, replaceValue);
          if (res.done) return res.value;
  
          var rx = anObject(regexp);
          var S = String(this);
  
          var functionalReplace = typeof replaceValue === 'function';
          if (!functionalReplace) replaceValue = String(replaceValue);
  
          var global = rx.global;
          if (global) {
            var fullUnicode = rx.unicode;
            rx.lastIndex = 0;
          }
          var results = [];
          while (true) {
            var result = regexpExecAbstract(rx, S);
            if (result === null) break;
  
            results.push(result);
            if (!global) break;
  
            var matchStr = String(result[0]);
            if (matchStr === '') rx.lastIndex = advanceStringIndex(S, toLength(rx.lastIndex), fullUnicode);
          }
  
          var accumulatedResult = '';
          var nextSourcePosition = 0;
          for (var i = 0; i < results.length; i++) {
            result = results[i];
  
            var matched = String(result[0]);
            var position = max$1(min$3(toInteger(result.index), S.length), 0);
            var captures = [];
            // NOTE: This is equivalent to
            //   captures = result.slice(1).map(maybeToString)
            // but for some reason `nativeSlice.call(result, 1, result.length)` (called in
            // the slice polyfill when slicing native arrays) "doesn't work" in safari 9 and
            // causes a crash (https://pastebin.com/N21QzeQA) when trying to debug it.
            for (var j = 1; j < result.length; j++) captures.push(maybeToString(result[j]));
            var namedCaptures = result.groups;
            if (functionalReplace) {
              var replacerArgs = [matched].concat(captures, position, S);
              if (namedCaptures !== undefined) replacerArgs.push(namedCaptures);
              var replacement = String(replaceValue.apply(undefined, replacerArgs));
            } else {
              replacement = getSubstitution(matched, S, position, captures, namedCaptures, replaceValue);
            }
            if (position >= nextSourcePosition) {
              accumulatedResult += S.slice(nextSourcePosition, position) + replacement;
              nextSourcePosition = position + matched.length;
            }
          }
          return accumulatedResult + S.slice(nextSourcePosition);
        }
      ];
  
      // https://tc39.github.io/ecma262/#sec-getsubstitution
      function getSubstitution(matched, str, position, captures, namedCaptures, replacement) {
        var tailPos = position + matched.length;
        var m = captures.length;
        var symbols = SUBSTITUTION_SYMBOLS_NO_NAMED;
        if (namedCaptures !== undefined) {
          namedCaptures = toObject(namedCaptures);
          symbols = SUBSTITUTION_SYMBOLS;
        }
        return nativeReplace.call(replacement, symbols, function (match, ch) {
          var capture;
          switch (ch.charAt(0)) {
            case '$': return '$';
            case '&': return matched;
            case '`': return str.slice(0, position);
            case "'": return str.slice(tailPos);
            case '<':
              capture = namedCaptures[ch.slice(1, -1)];
              break;
            default: // \d\d?
              var n = +ch;
              if (n === 0) return match;
              if (n > m) {
                var f = floor$1(n / 10);
                if (f === 0) return match;
                if (f <= m) return captures[f - 1] === undefined ? ch.charAt(1) : captures[f - 1] + ch.charAt(1);
                return match;
              }
              capture = captures[n - 1];
          }
          return capture === undefined ? '' : capture;
        });
      }
    });
  
    // iterable DOM collections
    // flag - `iterable` interface - 'entries', 'keys', 'values', 'forEach' methods
    var domIterables = {
      CSSRuleList: 0,
      CSSStyleDeclaration: 0,
      CSSValueList: 0,
      ClientRectList: 0,
      DOMRectList: 0,
      DOMStringList: 0,
      DOMTokenList: 1,
      DataTransferItemList: 0,
      FileList: 0,
      HTMLAllCollection: 0,
      HTMLCollection: 0,
      HTMLFormElement: 0,
      HTMLSelectElement: 0,
      MediaList: 0,
      MimeTypeArray: 0,
      NamedNodeMap: 0,
      NodeList: 1,
      PaintRequestList: 0,
      Plugin: 0,
      PluginArray: 0,
      SVGLengthList: 0,
      SVGNumberList: 0,
      SVGPathSegList: 0,
      SVGPointList: 0,
      SVGStringList: 0,
      SVGTransformList: 0,
      SourceBufferList: 0,
      StyleSheetList: 0,
      TextTrackCueList: 0,
      TextTrackList: 0,
      TouchList: 0
    };
  
    var sloppyArrayMethod = function (METHOD_NAME, argument) {
      var method = [][METHOD_NAME];
      return !method || !fails(function () {
        // eslint-disable-next-line no-useless-call,no-throw-literal
        method.call(null, argument || function () { throw 1; }, 1);
      });
    };
  
    var internalForEach = arrayMethods(0);
    var SLOPPY_METHOD = sloppyArrayMethod('forEach');
  
    // `Array.prototype.forEach` method implementation
    // https://tc39.github.io/ecma262/#sec-array.prototype.foreach
    var arrayForEach = SLOPPY_METHOD ? function forEach(callbackfn /* , thisArg */) {
      return internalForEach(this, callbackfn, arguments[1]);
    } : [].forEach;
  
    for (var COLLECTION_NAME in domIterables) {
      var Collection = global_1[COLLECTION_NAME];
      var CollectionPrototype = Collection && Collection.prototype;
      // some Chrome versions have non-configurable methods on DOMTokenList
      if (CollectionPrototype && CollectionPrototype.forEach !== arrayForEach) try {
        hide(CollectionPrototype, 'forEach', arrayForEach);
      } catch (error) {
        CollectionPrototype.forEach = arrayForEach;
      }
    }
  
    function _defineProperties(target, props) {
      for (var i = 0; i < props.length; i++) {
        var descriptor = props[i];
        descriptor.enumerable = descriptor.enumerable || false;
        descriptor.configurable = true;
        if ("value" in descriptor) descriptor.writable = true;
        Object.defineProperty(target, descriptor.key, descriptor);
      }
    }
  
    function _createClass(Constructor, protoProps, staticProps) {
      if (protoProps) _defineProperties(Constructor.prototype, protoProps);
      if (staticProps) _defineProperties(Constructor, staticProps);
      return Constructor;
    }
  
    /**
     * --------------------------------------------------------------------------
     * CoreUI (v2.1.12): ajax-load.js
     * Licensed under MIT (https://coreui.io/license)
     * --------------------------------------------------------------------------
     */
  
    var AjaxLoad = function ($) {
      /**
       * ------------------------------------------------------------------------
       * Constants
       * ------------------------------------------------------------------------
       */
      var NAME = 'ajaxLoad';
      var VERSION = '2.1.12';
      var DATA_KEY = 'coreui.ajaxLoad';
      var JQUERY_NO_CONFLICT = $.fn[NAME];
      var ClassName = {
        ACTIVE: 'active',
        NAV_PILLS: 'nav-pills',
        NAV_TABS: 'nav-tabs',
        OPEN: 'open',
        VIEW_SCRIPT: 'view-script'
      };
      var Event = {
        CLICK: 'click'
      };
      var Selector = {
        HEAD: 'head',
        NAV_DROPDOWN: '.sidebar-nav .nav-dropdown',
        NAV_LINK: '.sidebar-nav .nav-link',
        NAV_ITEM: '.sidebar-nav .nav-item',
        VIEW_SCRIPT: '.view-script'
      };
      var Default = {
        defaultPage: 'main.html',
        errorPage: '404.html',
        subpagesDirectory: 'views/'
      };
  
      var AjaxLoad =
      /*#__PURE__*/
      function () {
        function AjaxLoad(element, config) {
          this._config = this._getConfig(config);
          this._element = element;
          var url = location.hash.replace(/^#/, '');
  
          if (url !== '') {
            this.setUpUrl(url);
          } else {
            this.setUpUrl(this._config.defaultPage);
          }
  
          this._addEventListeners();
        } // Getters
  
  
        var _proto = AjaxLoad.prototype;
  
        // Public
        _proto.loadPage = function loadPage(url) {
          var element = this._element;
          var config = this._config;
  
          var loadScripts = function loadScripts(src, element) {
            if (element === void 0) {
              element = 0;
            }
  
            var script = document.createElement('script');
            script.type = 'text/javascript';
            script.src = src[element];
            script.className = ClassName.VIEW_SCRIPT; // eslint-disable-next-line no-multi-assign
  
            script.onload = script.onreadystatechange = function () {
              if (!this.readyState || this.readyState === 'complete') {
                if (src.length > element + 1) {
                  loadScripts(src, element + 1);
                }
              }
            };
  
            var body = document.getElementsByTagName('body')[0];
            body.appendChild(script);
          };
  
          $.ajax({
            type: 'GET',
            url: config.subpagesDirectory + url,
            dataType: 'html',
            beforeSend: function beforeSend() {
              $(Selector.VIEW_SCRIPT).remove();
            },
            success: function success(result) {
              var wrapper = document.createElement('div');
              wrapper.innerHTML = result;
              var scripts = Array.from(wrapper.querySelectorAll('script')).map(function (script) {
                return script.attributes.getNamedItem('src').nodeValue;
              });
              wrapper.querySelectorAll('script').forEach(function (script) {
                return script.parentNode.removeChild(script);
              });
              $('body').animate({
                scrollTop: 0
              }, 0);
              $(element).html(wrapper);
  
              if (scripts.length) {
                loadScripts(scripts);
              }
  
              window.location.hash = url;
            },
            error: function error() {
              window.location.href = config.errorPage;
            }
          });
        };
  
        _proto.setUpUrl = function setUpUrl(url) {
          $(Selector.NAV_LINK).removeClass(ClassName.ACTIVE);
          $(Selector.NAV_DROPDOWN).removeClass(ClassName.OPEN);
          $(Selector.NAV_DROPDOWN + ":has(a[href=\"" + url.replace(/^\//, '').split('?')[0] + "\"])").addClass(ClassName.OPEN);
          $(Selector.NAV_ITEM + " a[href=\"" + url.replace(/^\//, '').split('?')[0] + "\"]").addClass(ClassName.ACTIVE);
          this.loadPage(url);
        };
  
        _proto.loadBlank = function loadBlank(url) {
          window.open(url);
        };
  
        _proto.loadTop = function loadTop(url) {
          window.location = url;
        } // Private
        ;
  
        _proto._getConfig = function _getConfig(config) {
          config = Object.assign({}, Default, config);
          return config;
        };
  
        _proto._addEventListeners = function _addEventListeners() {
          var _this = this;
  
          $(document).on(Event.CLICK, Selector.NAV_LINK + "[href!=\"#\"]", function (event) {
            event.preventDefault();
            event.stopPropagation();
  
            if (event.currentTarget.target === '_top') {
              _this.loadTop(event.currentTarget.href);
            } else if (event.currentTarget.target === '_blank') {
              _this.loadBlank(event.currentTarget.href);
            } else {
              _this.setUpUrl(event.currentTarget.getAttribute('href'));
            }
          });
        } // Static
        ;
  
        AjaxLoad._jQueryInterface = function _jQueryInterface(config) {
          return this.each(function () {
            var data = $(this).data(DATA_KEY);
  
            var _config = typeof config === 'object' && config;
  
            if (!data) {
              data = new AjaxLoad(this, _config);
              $(this).data(DATA_KEY, data);
            }
          });
        };
  
        _createClass(AjaxLoad, null, [{
          key: "VERSION",
          get: function get() {
            return VERSION;
          }
        }, {
          key: "Default",
          get: function get() {
            return Default;
          }
        }]);
  
        return AjaxLoad;
      }();
      /**
       * ------------------------------------------------------------------------
       * jQuery
       * ------------------------------------------------------------------------
       */
  
  
      $.fn[NAME] = AjaxLoad._jQueryInterface;
      $.fn[NAME].Constructor = AjaxLoad;
  
      $.fn[NAME].noConflict = function () {
        $.fn[NAME] = JQUERY_NO_CONFLICT;
        return AjaxLoad._jQueryInterface;
      };
  
      return AjaxLoad;
    }($);
  
    var SPECIES$4 = wellKnownSymbol('species');
    var nativeSlice = [].slice;
    var max$2 = Math.max;
  
    var SPECIES_SUPPORT$1 = arrayMethodHasSpeciesSupport('slice');
  
    // `Array.prototype.slice` method
    // https://tc39.github.io/ecma262/#sec-array.prototype.slice
    // fallback for not array-like ES3 strings and DOM objects
    _export({ target: 'Array', proto: true, forced: !SPECIES_SUPPORT$1 }, {
      slice: function slice(start, end) {
        var O = toIndexedObject(this);
        var length = toLength(O.length);
        var k = toAbsoluteIndex(start, length);
        var fin = toAbsoluteIndex(end === undefined ? length : end, length);
        // inline `ArraySpeciesCreate` for usage native `Array#slice` where it's possible
        var Constructor, result, n;
        if (isArray(O)) {
          Constructor = O.constructor;
          // cross-realm fallback
          if (typeof Constructor == 'function' && (Constructor === Array || isArray(Constructor.prototype))) {
            Constructor = undefined;
          } else if (isObject(Constructor)) {
            Constructor = Constructor[SPECIES$4];
            if (Constructor === null) Constructor = undefined;
          }
          if (Constructor === Array || Constructor === undefined) {
            return nativeSlice.call(O, k, fin);
          }
        }
        result = new (Constructor === undefined ? Array : Constructor)(max$2(fin - k, 0));
        for (n = 0; k < fin; k++, n++) if (k in O) createProperty(result, n, O[k]);
        result.length = n;
        return result;
      }
    });
  
    /**
     * --------------------------------------------------------------------------
     * CoreUI (v2.1.12): toggle-classes.js
     * Licensed under MIT (https://coreui.io/license)
     * --------------------------------------------------------------------------
     */
    var removeClasses = function removeClasses(classNames) {
      return classNames.map(function (className) {
        return document.body.classList.contains(className);
      }).indexOf(true) !== -1;
    };
  
    var toggleClasses = function toggleClasses(toggleClass, classNames) {
      var breakpoint = classNames.indexOf(toggleClass);
      var newClassNames = classNames.slice(0, breakpoint + 1);
  
      if (removeClasses(newClassNames)) {
        newClassNames.map(function (className) {
          return document.body.classList.remove(className);
        });
      } else {
        document.body.classList.add(toggleClass);
      }
    };
  
    /**
     * --------------------------------------------------------------------------
     * CoreUI (v2.1.12): aside-menu.js
     * Licensed under MIT (https://coreui.io/license)
     * --------------------------------------------------------------------------
     */
  
    var AsideMenu = function ($) {
      /**
       * ------------------------------------------------------------------------
       * Constants
       * ------------------------------------------------------------------------
       */
      var NAME = 'aside-menu';
      var VERSION = '2.1.12';
      var DATA_KEY = 'coreui.aside-menu';
      var EVENT_KEY = "." + DATA_KEY;
      var DATA_API_KEY = '.data-api';
      var JQUERY_NO_CONFLICT = $.fn[NAME];
      var Event = {
        CLICK: 'click',
        LOAD_DATA_API: "load" + EVENT_KEY + DATA_API_KEY,
        TOGGLE: 'toggle'
      };
      var Selector = {
        BODY: 'body',
        ASIDE_MENU: '.aside-menu',
        ASIDE_MENU_TOGGLER: '.aside-menu-toggler'
      };
      var ShowClassNames = ['aside-menu-show', 'aside-menu-sm-show', 'aside-menu-md-show', 'aside-menu-lg-show', 'aside-menu-xl-show'];
      /**
       * ------------------------------------------------------------------------
       * Class Definition
       * ------------------------------------------------------------------------
       */
  
      var AsideMenu =
      /*#__PURE__*/
      function () {
        function AsideMenu(element) {
          this._element = element;
  
          this._addEventListeners();
        } // Getters
  
  
        var _proto = AsideMenu.prototype;
  
        // Private
        _proto._addEventListeners = function _addEventListeners() {
          $(document).on(Event.CLICK, Selector.ASIDE_MENU_TOGGLER, function (event) {
            event.preventDefault();
            event.stopPropagation();
            var toggle = event.currentTarget.dataset ? event.currentTarget.dataset.toggle : $(event.currentTarget).data('toggle');
            toggleClasses(toggle, ShowClassNames);
          });
        } // Static
        ;
  
        AsideMenu._jQueryInterface = function _jQueryInterface() {
          return this.each(function () {
            var $element = $(this);
            var data = $element.data(DATA_KEY);
  
            if (!data) {
              data = new AsideMenu(this);
              $element.data(DATA_KEY, data);
            }
          });
        };
  
        _createClass(AsideMenu, null, [{
          key: "VERSION",
          get: function get() {
            return VERSION;
          }
        }]);
  
        return AsideMenu;
      }();
      /**
       * ------------------------------------------------------------------------
       * Data Api implementation
       * ------------------------------------------------------------------------
       */
  
  
      $(window).on(Event.LOAD_DATA_API, function () {
        var asideMenu = $(Selector.ASIDE_MENU);
  
        AsideMenu._jQueryInterface.call(asideMenu);
      });
      /**
       * ------------------------------------------------------------------------
       * jQuery
       * ------------------------------------------------------------------------
       */
  
      $.fn[NAME] = AsideMenu._jQueryInterface;
      $.fn[NAME].Constructor = AsideMenu;
  
      $.fn[NAME].noConflict = function () {
        $.fn[NAME] = JQUERY_NO_CONFLICT;
        return AsideMenu._jQueryInterface;
      };
  
      return AsideMenu;
    }($);
  
    var UNSCOPABLES = wellKnownSymbol('unscopables');
    var ArrayPrototype$1 = Array.prototype;
  
    // Array.prototype[@@unscopables]
    // https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables
    if (ArrayPrototype$1[UNSCOPABLES] == undefined) {
      hide(ArrayPrototype$1, UNSCOPABLES, objectCreate(null));
    }
  
    // add a key to Array.prototype[@@unscopables]
    var addToUnscopables = function (key) {
      ArrayPrototype$1[UNSCOPABLES][key] = true;
    };
  
    var internalFind = arrayMethods(5);
    var FIND = 'find';
    var SKIPS_HOLES = true;
  
    // Shouldn't skip holes
    if (FIND in []) Array(1)[FIND](function () { SKIPS_HOLES = false; });
  
    // `Array.prototype.find` method
    // https://tc39.github.io/ecma262/#sec-array.prototype.find
    _export({ target: 'Array', proto: true, forced: SKIPS_HOLES }, {
      find: function find(callbackfn /* , that = undefined */) {
        return internalFind(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
      }
    });
  
    // https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables
    addToUnscopables(FIND);
  
    // @@match logic
    fixRegexpWellKnownSymbolLogic('match', 1, function (MATCH, nativeMatch, maybeCallNative) {
      return [
        // `String.prototype.match` method
        // https://tc39.github.io/ecma262/#sec-string.prototype.match
        function match(regexp) {
          var O = requireObjectCoercible(this);
          var matcher = regexp == undefined ? undefined : regexp[MATCH];
          return matcher !== undefined ? matcher.call(regexp, O) : new RegExp(regexp)[MATCH](String(O));
        },
        // `RegExp.prototype[@@match]` method
        // https://tc39.github.io/ecma262/#sec-regexp.prototype-@@match
        function (regexp) {
          var res = maybeCallNative(nativeMatch, regexp, this);
          if (res.done) return res.value;
  
          var rx = anObject(regexp);
          var S = String(this);
  
          if (!rx.global) return regexpExecAbstract(rx, S);
  
          var fullUnicode = rx.unicode;
          rx.lastIndex = 0;
          var A = [];
          var n = 0;
          var result;
          while ((result = regexpExecAbstract(rx, S)) !== null) {
            var matchStr = String(result[0]);
            A[n] = matchStr;
            if (matchStr === '') rx.lastIndex = advanceStringIndex(S, toLength(rx.lastIndex), fullUnicode);
            n++;
          }
          return n === 0 ? null : A;
        }
      ];
    });
  
    // a string of all valid unicode whitespaces
    // eslint-disable-next-line max-len
    var whitespaces = '\u0009\u000A\u000B\u000C\u000D\u0020\u00A0\u1680\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF';
  
    var whitespace = '[' + whitespaces + ']';
    var ltrim = RegExp('^' + whitespace + whitespace + '*');
    var rtrim = RegExp(whitespace + whitespace + '*$');
  
    // 1 -> String#trimStart
    // 2 -> String#trimEnd
    // 3 -> String#trim
    var stringTrim = function (string, TYPE) {
      string = String(requireObjectCoercible(string));
      if (TYPE & 1) string = string.replace(ltrim, '');
      if (TYPE & 2) string = string.replace(rtrim, '');
      return string;
    };
  
    var non = '\u200B\u0085\u180E';
  
    // check that a method works with the correct list
    // of whitespaces and has a correct name
    var forcedStringTrimMethod = function (METHOD_NAME) {
      return fails(function () {
        return !!whitespaces[METHOD_NAME]() || non[METHOD_NAME]() != non || whitespaces[METHOD_NAME].name !== METHOD_NAME;
      });
    };
  
    var FORCED = forcedStringTrimMethod('trim');
  
    // `String.prototype.trim` method
    // https://tc39.github.io/ecma262/#sec-string.prototype.trim
    _export({ target: 'String', proto: true, forced: FORCED }, {
      trim: function trim() {
        return stringTrim(this, 3);
      }
    });
  
    /**
     * --------------------------------------------------------------------------
     * CoreUI Utilities (v2.1.12): get-css-custom-properties.js
     * Licensed under MIT (https://coreui.io/license)
     * @returns {string} css custom property name
     * --------------------------------------------------------------------------
     */
    var getCssCustomProperties = function getCssCustomProperties() {
      var cssCustomProperties = {};
      var sheets = document.styleSheets;
      var cssText = '';
  
      for (var i = sheets.length - 1; i > -1; i--) {
        var rules = sheets[i].cssRules;
  
        for (var j = rules.length - 1; j > -1; j--) {
          if (rules[j].selectorText === '.ie-custom-properties') {
            cssText = rules[j].cssText;
            break;
          }
        }
  
        if (cssText) {
          break;
        }
      }
  
      cssText = cssText.substring(cssText.lastIndexOf('{') + 1, cssText.lastIndexOf('}'));
      cssText.split(';').forEach(function (property) {
        if (property) {
          var name = property.split(': ')[0];
          var value = property.split(': ')[1];
  
          if (name && value) {
            cssCustomProperties["--" + name.trim()] = value.trim();
          }
        }
      });
      return cssCustomProperties;
    };
  
    var minIEVersion = 10;
  
    var isIE1x = function isIE1x() {
      return Boolean(document.documentMode) && document.documentMode >= minIEVersion;
    };
  
    var isCustomProperty = function isCustomProperty(property) {
      return property.match(/^--.*/i);
    };
  
    var getStyle = function getStyle(property, element) {
      if (element === void 0) {
        element = document.body;
      }
  
      var style;
  
      if (isCustomProperty(property) && isIE1x()) {
        var cssCustomProperties = getCssCustomProperties();
        style = cssCustomProperties[property];
      } else {
        style = window.getComputedStyle(element, null).getPropertyValue(property).replace(/^\s/, '');
      }
  
      return style;
    };
  
    /**
     * --------------------------------------------------------------------------
     * CoreUI (v2.1.12): sidebar.js
     * Licensed under MIT (https://coreui.io/license)
     * --------------------------------------------------------------------------
     */
  
    var Sidebar = function ($) {
      /**
       * ------------------------------------------------------------------------
       * Constants
       * ------------------------------------------------------------------------
       */
      var NAME = 'sidebar';
      var VERSION = '2.1.12';
      var DATA_KEY = 'coreui.sidebar';
      var EVENT_KEY = "." + DATA_KEY;
      var DATA_API_KEY = '.data-api';
      var JQUERY_NO_CONFLICT = $.fn[NAME];
      var Default = {
        transition: 400
      };
      var ClassName = {
        ACTIVE: 'active',
        BRAND_MINIMIZED: 'brand-minimized',
        NAV_DROPDOWN_TOGGLE: 'nav-dropdown-toggle',
        OPEN: 'open',
        SIDEBAR_FIXED: 'sidebar-fixed',
        SIDEBAR_MINIMIZED: 'sidebar-minimized',
        SIDEBAR_OFF_CANVAS: 'sidebar-off-canvas'
      };
      var Event = {
        CLICK: 'click',
        DESTROY: 'destroy',
        INIT: 'init',
        LOAD_DATA_API: "load" + EVENT_KEY + DATA_API_KEY,
        TOGGLE: 'toggle',
        UPDATE: 'update'
      };
      var Selector = {
        BODY: 'body',
        BRAND_MINIMIZER: '.brand-minimizer',
        NAV_DROPDOWN_TOGGLE: '.nav-dropdown-toggle',
        NAV_DROPDOWN_ITEMS: '.nav-dropdown-items',
        NAV_ITEM: '.nav-item',
        NAV_LINK: '.nav-link',
        NAV_LINK_QUERIED: '.nav-link-queried',
        NAVIGATION_CONTAINER: '.sidebar-nav',
        NAVIGATION: '.sidebar-nav > .nav',
        SIDEBAR: '.sidebar',
        SIDEBAR_MINIMIZER: '.sidebar-minimizer',
        SIDEBAR_TOGGLER: '.sidebar-toggler',
        SIDEBAR_SCROLL: '.sidebar-scroll'
      };
      var ShowClassNames = ['sidebar-show', 'sidebar-sm-show', 'sidebar-md-show', 'sidebar-lg-show', 'sidebar-xl-show'];
      /**
       * ------------------------------------------------------------------------
       * Class Definition
       * ------------------------------------------------------------------------
       */
  
      var Sidebar =
      /*#__PURE__*/
      function () {
        function Sidebar(element) {
          this._element = element;
          this.mobile = false;
          this.ps = null;
          this.perfectScrollbar(Event.INIT);
          this.setActiveLink();
          this._breakpointTest = this._breakpointTest.bind(this);
          this._clickOutListener = this._clickOutListener.bind(this);
  
          this._addEventListeners();
  
          this._addMediaQuery();
        } // Getters
  
  
        var _proto = Sidebar.prototype;
  
        // Public
        _proto.perfectScrollbar = function perfectScrollbar(event) {
          var _this = this;
  
          if (typeof PerfectScrollbar !== 'undefined') {
            var classList = document.body.classList;
  
            if (event === Event.INIT && !classList.contains(ClassName.SIDEBAR_MINIMIZED)) {
              this.ps = this.makeScrollbar();
            }
  
            if (event === Event.DESTROY) {
              this.destroyScrollbar();
            }
  
            if (event === Event.TOGGLE) {
              if (classList.contains(ClassName.SIDEBAR_MINIMIZED)) {
                this.destroyScrollbar();
              } else {
                this.destroyScrollbar();
                this.ps = this.makeScrollbar();
              }
            }
  
            if (event === Event.UPDATE && !classList.contains(ClassName.SIDEBAR_MINIMIZED)) {
              // ToDo: Add smooth transition
              setTimeout(function () {
                _this.destroyScrollbar();
  
                _this.ps = _this.makeScrollbar();
              }, Default.transition);
            }
          }
        };
  
        _proto.makeScrollbar = function makeScrollbar() {
          var container = Selector.SIDEBAR_SCROLL;
  
          if (document.querySelector(container) === null) {
            container = Selector.NAVIGATION_CONTAINER;
  
            if (document.querySelector(container) === null) {
              return null;
            }
          }
  
          var ps = new PerfectScrollbar(document.querySelector(container), {
            suppressScrollX: true
          }); // ToDo: find real fix for ps rtl
  
          ps.isRtl = false;
          return ps;
        };
  
        _proto.destroyScrollbar = function destroyScrollbar() {
          if (this.ps) {
            this.ps.destroy();
            this.ps = null;
          }
        };
  
        _proto.setActiveLink = function setActiveLink() {
          $(Selector.NAVIGATION).find(Selector.NAV_LINK).each(function (key, value) {
            var link = value;
            var cUrl;
  
            if (link.classList.contains(Selector.NAV_LINK_QUERIED)) {
              cUrl = String(window.location);
            } else {
              cUrl = String(window.location).split('?')[0];
            }
  
            if (cUrl.substr(cUrl.length - 1) === '#') {
              cUrl = cUrl.slice(0, -1);
            }
  
            if ($($(link))[0].href === cUrl) {
              $(link).addClass(ClassName.ACTIVE).parents(Selector.NAV_DROPDOWN_ITEMS).add(link).each(function (key, value) {
                link = value;
                $(link).parent().addClass(ClassName.OPEN);
              });
            }
          });
        } // Private
        ;
  
        _proto._addMediaQuery = function _addMediaQuery() {
          var sm = getStyle('--breakpoint-sm');
  
          if (!sm) {
            return;
          }
  
          var smVal = parseInt(sm, 10) - 1;
          var mediaQueryList = window.matchMedia("(max-width: " + smVal + "px)");
  
          this._breakpointTest(mediaQueryList);
  
          mediaQueryList.addListener(this._breakpointTest);
        };
  
        _proto._breakpointTest = function _breakpointTest(e) {
          this.mobile = Boolean(e.matches);
  
          this._toggleClickOut();
        };
  
        _proto._clickOutListener = function _clickOutListener(event) {
          if (!this._element.contains(event.target)) {
            // or use: event.target.closest(Selector.SIDEBAR) === null
            event.preventDefault();
            event.stopPropagation();
  
            this._removeClickOut();
  
            document.body.classList.remove('sidebar-show');
          }
        };
  
        _proto._addClickOut = function _addClickOut() {
          document.addEventListener(Event.CLICK, this._clickOutListener, true);
        };
  
        _proto._removeClickOut = function _removeClickOut() {
          document.removeEventListener(Event.CLICK, this._clickOutListener, true);
        };
  
        _proto._toggleClickOut = function _toggleClickOut() {
          if (this.mobile && document.body.classList.contains('sidebar-show')) {
            document.body.classList.remove('aside-menu-show');
  
            this._addClickOut();
          } else {
            this._removeClickOut();
          }
        };
  
        _proto._addEventListeners = function _addEventListeners() {
          var _this2 = this;
  
          $(document).on(Event.CLICK, Selector.BRAND_MINIMIZER, function (event) {
            event.preventDefault();
            event.stopPropagation();
            $(Selector.BODY).toggleClass(ClassName.BRAND_MINIMIZED);
          });
          $(document).on(Event.CLICK, Selector.NAV_DROPDOWN_TOGGLE, function (event) {
            event.preventDefault();
            event.stopPropagation();
            var dropdown = event.target;
            $(dropdown).parent().toggleClass(ClassName.OPEN);
  
            _this2.perfectScrollbar(Event.UPDATE);
          });
          $(document).on(Event.CLICK, Selector.SIDEBAR_MINIMIZER, function (event) {
            event.preventDefault();
            event.stopPropagation();
            $(Selector.BODY).toggleClass(ClassName.SIDEBAR_MINIMIZED);
  
            _this2.perfectScrollbar(Event.TOGGLE);
          });
          $(document).on(Event.CLICK, Selector.SIDEBAR_TOGGLER, function (event) {
            event.preventDefault();
            event.stopPropagation();
            var toggle = event.currentTarget.dataset ? event.currentTarget.dataset.toggle : $(event.currentTarget).data('toggle');
            toggleClasses(toggle, ShowClassNames);
  
            _this2._toggleClickOut();
          });
          $(Selector.NAVIGATION + " > " + Selector.NAV_ITEM + " " + Selector.NAV_LINK + ":not(" + Selector.NAV_DROPDOWN_TOGGLE + ")").on(Event.CLICK, function () {
            _this2._removeClickOut();
  
            document.body.classList.remove('sidebar-show');
          });
        } // Static
        ;
  
        Sidebar._jQueryInterface = function _jQueryInterface() {
          return this.each(function () {
            var $element = $(this);
            var data = $element.data(DATA_KEY);
  
            if (!data) {
              data = new Sidebar(this);
              $element.data(DATA_KEY, data);
            }
          });
        };
  
        _createClass(Sidebar, null, [{
          key: "VERSION",
          get: function get() {
            return VERSION;
          }
        }]);
  
        return Sidebar;
      }();
      /**
       * ------------------------------------------------------------------------
       * Data Api implementation
       * ------------------------------------------------------------------------
       */
  
  
      $(window).on(Event.LOAD_DATA_API, function () {
        var sidebar = $(Selector.SIDEBAR);
  
        Sidebar._jQueryInterface.call(sidebar);
      });
      /**
       * ------------------------------------------------------------------------
       * jQuery
       * ------------------------------------------------------------------------
       */
  
      $.fn[NAME] = Sidebar._jQueryInterface;
      $.fn[NAME].Constructor = Sidebar;
  
      $.fn[NAME].noConflict = function () {
        $.fn[NAME] = JQUERY_NO_CONFLICT;
        return Sidebar._jQueryInterface;
      };
  
      return Sidebar;
    }($);
  
    /**
     * --------------------------------------------------------------------------
     * CoreUI Utilities (v2.1.12): hex-to-rgb.js
     * Licensed under MIT (https://coreui.io/license)
     * --------------------------------------------------------------------------
     */
  
    /* eslint-disable no-magic-numbers */
    var hexToRgb = function hexToRgb(color) {
      if (typeof color === 'undefined') {
        throw new Error('Hex color is not defined');
      }
  
      var hex = color.match(/^#(?:[0-9a-f]{3}){1,2}$/i);
  
      if (!hex) {
        throw new Error(color + " is not a valid hex color");
      }
  
      var r;
      var g;
      var b;
  
      if (color.length === 7) {
        r = parseInt(color.substring(1, 3), 16);
        g = parseInt(color.substring(3, 5), 16);
        b = parseInt(color.substring(5, 7), 16);
      } else {
        r = parseInt(color.substring(1, 2), 16);
        g = parseInt(color.substring(2, 3), 16);
        b = parseInt(color.substring(3, 5), 16);
      }
  
      return "rgba(" + r + ", " + g + ", " + b + ")";
    };
  
    /**
     * --------------------------------------------------------------------------
     * CoreUI Utilities (v2.1.12): hex-to-rgba.js
     * Licensed under MIT (https://coreui.io/license)
     * --------------------------------------------------------------------------
     */
  
    /* eslint-disable no-magic-numbers */
    var hexToRgba = function hexToRgba(color, opacity) {
      if (opacity === void 0) {
        opacity = 100;
      }
  
      if (typeof color === 'undefined') {
        throw new Error('Hex color is not defined');
      }
  
      var hex = color.match(/^#(?:[0-9a-f]{3}){1,2}$/i);
  
      if (!hex) {
        throw new Error(color + " is not a valid hex color");
      }
  
      var r;
      var g;
      var b;
  
      if (color.length === 7) {
        r = parseInt(color.substring(1, 3), 16);
        g = parseInt(color.substring(3, 5), 16);
        b = parseInt(color.substring(5, 7), 16);
      } else {
        r = parseInt(color.substring(1, 2), 16);
        g = parseInt(color.substring(2, 3), 16);
        b = parseInt(color.substring(3, 5), 16);
      }
  
      return "rgba(" + r + ", " + g + ", " + b + ", " + opacity / 100 + ")";
    };
  
    var TO_STRING_TAG$2 = wellKnownSymbol('toStringTag');
    var test = {};
  
    test[TO_STRING_TAG$2] = 'z';
  
    // `Object.prototype.toString` method implementation
    // https://tc39.github.io/ecma262/#sec-object.prototype.tostring
    var objectToString = String(test) !== '[object z]' ? function toString() {
      return '[object ' + classof(this) + ']';
    } : test.toString;
  
    var ObjectPrototype$1 = Object.prototype;
  
    // `Object.prototype.toString` method
    // https://tc39.github.io/ecma262/#sec-object.prototype.tostring
    if (objectToString !== ObjectPrototype$1.toString) {
      redefine(ObjectPrototype$1, 'toString', objectToString, { unsafe: true });
    }
  
    var TO_STRING = 'toString';
    var nativeToString = /./[TO_STRING];
    var RegExpPrototype = RegExp.prototype;
  
    var NOT_GENERIC = fails(function () { return nativeToString.call({ source: 'a', flags: 'b' }) != '/a/b'; });
    // FF44- RegExp#toString has a wrong name
    var INCORRECT_NAME = nativeToString.name != TO_STRING;
  
    // `RegExp.prototype.toString` method
    // https://tc39.github.io/ecma262/#sec-regexp.prototype.tostring
    if (NOT_GENERIC || INCORRECT_NAME) {
      redefine(RegExp.prototype, TO_STRING, function toString() {
        var R = anObject(this);
        var p = String(R.source);
        var rf = R.flags;
        var f = String(rf === undefined && R instanceof RegExp && !('flags' in RegExpPrototype) ? regexpFlags.call(R) : rf);
        return '/' + p + '/' + f;
      }, { unsafe: true });
    }
  
    /**
     * --------------------------------------------------------------------------
     * CoreUI (v2.1.12): rgb-to-hex.js
     * Licensed under MIT (https://coreui.io/license)
     * --------------------------------------------------------------------------
     */
  
    /* eslint-disable no-magic-numbers */
    var rgbToHex = function rgbToHex(color) {
      if (typeof color === 'undefined') {
        throw new Error('Hex color is not defined');
      }
  
      if (color === 'transparent') {
        return '#00000000';
      }
  
      var rgb = color.match(/^rgba?[\s+]?\([\s+]?(\d+)[\s+]?,[\s+]?(\d+)[\s+]?,[\s+]?(\d+)[\s+]?/i);
  
      if (!rgb) {
        throw new Error(color + " is not a valid rgb color");
      }
  
      var r = "0" + parseInt(rgb[1], 10).toString(16);
      var g = "0" + parseInt(rgb[2], 10).toString(16);
      var b = "0" + parseInt(rgb[3], 10).toString(16);
      return "#" + r.slice(-2) + g.slice(-2) + b.slice(-2);
    };
  
    /**
     * --------------------------------------------------------------------------
     * CoreUI (v2.1.12): index.js
     * Licensed under MIT (https://coreui.io/license)
     * --------------------------------------------------------------------------
     */
  
    (function ($) {
      if (typeof $ === 'undefined') {
        throw new TypeError('CoreUI\'s JavaScript requires jQuery. jQuery must be included before CoreUI\'s JavaScript.');
      }
  
      var version = $.fn.jquery.split(' ')[0].split('.');
      var minMajor = 1;
      var ltMajor = 2;
      var minMinor = 9;
      var minPatch = 1;
      var maxMajor = 4;
  
      if (version[0] < ltMajor && version[1] < minMinor || version[0] === minMajor && version[1] === minMinor && version[2] < minPatch || version[0] >= maxMajor) {
        throw new Error('CoreUI\'s JavaScript requires at least jQuery v1.9.1 but less than v4.0.0');
      }
    })($);
    window.getStyle = getStyle;
    window.hexToRgb = hexToRgb;
    window.hexToRgba = hexToRgba;
    window.rgbToHex = rgbToHex;
  
    exports.AjaxLoad = AjaxLoad;
    exports.AsideMenu = AsideMenu;
    exports.Sidebar = Sidebar;
  
    Object.defineProperty(exports, '__esModule', { value: true });
  
  }));
  //# sourceMappingURL=coreui.js.map
  