(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ? factory() :
  typeof define === 'function' && define.amd ? define(factory) :
  (factory());
}(this, (function () { 'use strict';

  function _typeof(obj) {
    if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
      _typeof = function (obj) {
        return typeof obj;
      };
    } else {
      _typeof = function (obj) {
        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
      };
    }

    return _typeof(obj);
  }

  function _defineProperty(obj, key, value) {
    if (key in obj) {
      Object.defineProperty(obj, key, {
        value: value,
        enumerable: true,
        configurable: true,
        writable: true
      });
    } else {
      obj[key] = value;
    }

    return obj;
  }

  function _objectSpread(target) {
    for (var i = 1; i < arguments.length; i++) {
      var source = arguments[i] != null ? arguments[i] : {};
      var ownKeys = Object.keys(source);

      if (typeof Object.getOwnPropertySymbols === 'function') {
        ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) {
          return Object.getOwnPropertyDescriptor(source, sym).enumerable;
        }));
      }

      ownKeys.forEach(function (key) {
        _defineProperty(target, key, source[key]);
      });
    }

    return target;
  }

  function _slicedToArray(arr, i) {
    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest();
  }

  function _toArray(arr) {
    return _arrayWithHoles(arr) || _iterableToArray(arr) || _nonIterableRest();
  }

  function _toConsumableArray(arr) {
    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread();
  }

  function _arrayWithoutHoles(arr) {
    if (Array.isArray(arr)) {
      for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];

      return arr2;
    }
  }

  function _arrayWithHoles(arr) {
    if (Array.isArray(arr)) return arr;
  }

  function _iterableToArray(iter) {
    if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter);
  }

  function _iterableToArrayLimit(arr, i) {
    var _arr = [];
    var _n = true;
    var _d = false;
    var _e = undefined;

    try {
      for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
        _arr.push(_s.value);

        if (i && _arr.length === i) break;
      }
    } catch (err) {
      _d = true;
      _e = err;
    } finally {
      try {
        if (!_n && _i["return"] != null) _i["return"]();
      } finally {
        if (_d) throw _e;
      }
    }

    return _arr;
  }

  function _nonIterableSpread() {
    throw new TypeError("Invalid attempt to spread non-iterable instance");
  }

  function _nonIterableRest() {
    throw new TypeError("Invalid attempt to destructure non-iterable instance");
  }

  var fs = typeof require !== "undefined" && require('fs');

  var crypto = typeof require !== "undefined" && require('crypto');

  var CSVToArray = function CSVToArray(data) {
    var delimiter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ',';
    var omitFirstRow = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
    return data.slice(omitFirstRow ? data.indexOf('\n') + 1 : 0).split('\n').map(function (v) {
      return v.split(delimiter);
    });
  };

  var CSVToJSON = function CSVToJSON(data) {
    var delimiter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ',';
    var titles = data.slice(0, data.indexOf('\n')).split(delimiter);
    return data.slice(data.indexOf('\n') + 1).split('\n').map(function (v) {
      var values = v.split(delimiter);
      return titles.reduce(function (obj, title, index) {
        return obj[title] = values[index], obj;
      }, {});
    });
  };

  var JSONToFile = function JSONToFile(obj, filename) {
    return fs.writeFile("".concat(filename, ".json"), JSON.stringify(obj, null, 2));
  };

  var JSONtoCSV = function JSONtoCSV(arr, columns) {
    var delimiter = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : ',';
    return [columns.join(delimiter)].concat(_toConsumableArray(arr.map(function (obj) {
      return columns.reduce(function (acc, key) {
        return "".concat(acc).concat(!acc.length ? '' : delimiter, "\"").concat(!obj[key] ? '' : obj[key], "\"");
      }, '');
    }))).join('\n');
  };

  var RGBToHex = function RGBToHex(r, g, b) {
    return ((r << 16) + (g << 8) + b).toString(16).padStart(6, '0');
  };

  var URLJoin = function URLJoin() {
    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }

    return args.join('/').replace(/[\/]+/g, '/').replace(/^(.+):\//, '$1://').replace(/^file:/, 'file:/').replace(/\/(\?|&|#[^!])/g, '$1').replace(/\?/g, '&').replace('&', '?');
  };

  var UUIDGeneratorBrowser = function UUIDGeneratorBrowser() {
    return ([1e7] + -1e3 + -4e3 + -8e3 + -1e11).replace(/[018]/g, function (c) {
      return (c ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> c / 4).toString(16);
    });
  };

  var UUIDGeneratorNode = function UUIDGeneratorNode() {
    return ([1e7] + -1e3 + -4e3 + -8e3 + -1e11).replace(/[018]/g, function (c) {
      return (c ^ crypto.randomBytes(1)[0] & 15 >> c / 4).toString(16);
    });
  };

  var all = function all(arr) {
    var fn = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Boolean;
    return arr.every(fn);
  };

  var allEqual = function allEqual(arr) {
    return arr.every(function (val) {
      return val === arr[0];
    });
  };

  var any = function any(arr) {
    var fn = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Boolean;
    return arr.some(fn);
  };

  var approximatelyEqual = function approximatelyEqual(v1, v2) {
    var epsilon = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0.001;
    return Math.abs(v1 - v2) < epsilon;
  };

  var arrayToCSV = function arrayToCSV(arr) {
    var delimiter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ',';
    return arr.map(function (v) {
      return v.map(function (x) {
        return "\"".concat(x, "\"");
      }).join(delimiter);
    }).join('\n');
  };

  var arrayToHtmlList = function arrayToHtmlList(arr, listID) {
    return function (el) {
      return el = document.querySelector('#' + listID), el.innerHTML += arr.map(function (item) {
        return "<li>".concat(item, "</li>");
      }).join('');
    }();
  };

  var ary = function ary(fn, n) {
    return function () {
      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
        args[_key2] = arguments[_key2];
      }

      return fn.apply(void 0, _toConsumableArray(args.slice(0, n)));
    };
  };

  var atob = function atob(str) {
    return Buffer.from(str, 'base64').toString('binary');
  };

  var attempt = function attempt(fn) {
    try {
      for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
        args[_key3 - 1] = arguments[_key3];
      }

      return fn.apply(void 0, args);
    } catch (e) {
      return e instanceof Error ? e : new Error(e);
    }
  };

  var average = function average() {
    for (var _len4 = arguments.length, nums = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
      nums[_key4] = arguments[_key4];
    }

    return nums.reduce(function (acc, val) {
      return acc + val;
    }, 0) / nums.length;
  };

  var averageBy = function averageBy(arr, fn) {
    return arr.map(typeof fn === 'function' ? fn : function (val) {
      return val[fn];
    }).reduce(function (acc, val) {
      return acc + val;
    }, 0) / arr.length;
  };

  var bifurcate = function bifurcate(arr, filter) {
    return arr.reduce(function (acc, val, i) {
      return acc[filter[i] ? 0 : 1].push(val), acc;
    }, [[], []]);
  };

  var bifurcateBy = function bifurcateBy(arr, fn) {
    return arr.reduce(function (acc, val, i) {
      return acc[fn(val, i) ? 0 : 1].push(val), acc;
    }, [[], []]);
  };

  var bind = function bind(fn, context) {
    for (var _len5 = arguments.length, boundArgs = new Array(_len5 > 2 ? _len5 - 2 : 0), _key5 = 2; _key5 < _len5; _key5++) {
      boundArgs[_key5 - 2] = arguments[_key5];
    }

    return function () {
      for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
        args[_key6] = arguments[_key6];
      }

      return fn.apply(context, boundArgs.concat(args));
    };
  };

  var bindAll = function bindAll(obj) {
    for (var _len7 = arguments.length, fns = new Array(_len7 > 1 ? _len7 - 1 : 0), _key7 = 1; _key7 < _len7; _key7++) {
      fns[_key7 - 1] = arguments[_key7];
    }

    return fns.forEach(function (fn) {
      return f = obj[fn], obj[fn] = function () {
        return f.apply(obj);
      };
    });
  };

  var bindKey = function bindKey(context, fn) {
    for (var _len8 = arguments.length, boundArgs = new Array(_len8 > 2 ? _len8 - 2 : 0), _key8 = 2; _key8 < _len8; _key8++) {
      boundArgs[_key8 - 2] = arguments[_key8];
    }

    return function () {
      for (var _len9 = arguments.length, args = new Array(_len9), _key9 = 0; _key9 < _len9; _key9++) {
        args[_key9] = arguments[_key9];
      }

      return context[fn].apply(context, boundArgs.concat(args));
    };
  };

  var binomialCoefficient = function binomialCoefficient(n, k) {
    if (Number.isNaN(n) || Number.isNaN(k)) return NaN;
    if (k < 0 || k > n) return 0;
    if (k === 0 || k === n) return 1;
    if (k === 1 || k === n - 1) return n;
    if (n - k < k) k = n - k;
    var res = n;

    for (var j = 2; j <= k; j++) {
      res *= (n - j + 1) / j;
    }

    return Math.round(res);
  };

  var bottomVisible = function bottomVisible() {
    return document.documentElement.clientHeight + window.scrollY >= (document.documentElement.scrollHeight || document.documentElement.clientHeight);
  };

  var btoa = function btoa(str) {
    return Buffer.from(str, 'binary').toString('base64');
  };

  var byteSize = function byteSize(str) {
    return new Blob([str]).size;
  };

  var call = function call(key) {
    for (var _len10 = arguments.length, args = new Array(_len10 > 1 ? _len10 - 1 : 0), _key10 = 1; _key10 < _len10; _key10++) {
      args[_key10 - 1] = arguments[_key10];
    }

    return function (context) {
      return context[key].apply(context, args);
    };
  };

  var capitalize = function capitalize(_ref) {
    var _ref2 = _toArray(_ref),
        first = _ref2[0],
        rest = _ref2.slice(1);

    var lowerRest = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
    return first.toUpperCase() + (lowerRest ? rest.join('').toLowerCase() : rest.join(''));
  };

  var capitalizeEveryWord = function capitalizeEveryWord(str) {
    return str.replace(/\b[a-z]/g, function (char) {
      return char.toUpperCase();
    });
  };

  var castArray = function castArray(val) {
    return Array.isArray(val) ? val : [val];
  };

  var chainAsync = function chainAsync(fns) {
    var curr = 0;

    var next = function next() {
      return fns[curr++](next);
    };

    next();
  };

  var chunk = function chunk(arr, size) {
    return Array.from({
      length: Math.ceil(arr.length / size)
    }, function (v, i) {
      return arr.slice(i * size, i * size + size);
    });
  };

  var clampNumber = function clampNumber(num, a, b) {
    return Math.max(Math.min(num, Math.max(a, b)), Math.min(a, b));
  };

  var cloneRegExp = function cloneRegExp(regExp) {
    return new RegExp(regExp.source, regExp.flags);
  };

  var coalesce = function coalesce() {
    for (var _len11 = arguments.length, args = new Array(_len11), _key11 = 0; _key11 < _len11; _key11++) {
      args[_key11] = arguments[_key11];
    }

    return args.find(function (_) {
      return ![undefined, null].includes(_);
    });
  };

  var coalesceFactory = function coalesceFactory(valid) {
    return function () {
      for (var _len12 = arguments.length, args = new Array(_len12), _key12 = 0; _key12 < _len12; _key12++) {
        args[_key12] = arguments[_key12];
      }

      return args.find(valid);
    };
  };

  var collectInto = function collectInto(fn) {
    return function () {
      for (var _len13 = arguments.length, args = new Array(_len13), _key13 = 0; _key13 < _len13; _key13++) {
        args[_key13] = arguments[_key13];
      }

      return fn(args);
    };
  };

  var colorize = function colorize() {
    for (var _len14 = arguments.length, args = new Array(_len14), _key14 = 0; _key14 < _len14; _key14++) {
      args[_key14] = arguments[_key14];
    }

    return {
      black: "\x1B[30m".concat(args.join(' ')),
      red: "\x1B[31m".concat(args.join(' ')),
      green: "\x1B[32m".concat(args.join(' ')),
      yellow: "\x1B[33m".concat(args.join(' ')),
      blue: "\x1B[34m".concat(args.join(' ')),
      magenta: "\x1B[35m".concat(args.join(' ')),
      cyan: "\x1B[36m".concat(args.join(' ')),
      white: "\x1B[37m".concat(args.join(' ')),
      bgBlack: "\x1B[40m".concat(args.join(' '), "\x1B[0m"),
      bgRed: "\x1B[41m".concat(args.join(' '), "\x1B[0m"),
      bgGreen: "\x1B[42m".concat(args.join(' '), "\x1B[0m"),
      bgYellow: "\x1B[43m".concat(args.join(' '), "\x1B[0m"),
      bgBlue: "\x1B[44m".concat(args.join(' '), "\x1B[0m"),
      bgMagenta: "\x1B[45m".concat(args.join(' '), "\x1B[0m"),
      bgCyan: "\x1B[46m".concat(args.join(' '), "\x1B[0m"),
      bgWhite: "\x1B[47m".concat(args.join(' '), "\x1B[0m")
    };
  };

  var compact = function compact(arr) {
    return arr.filter(Boolean);
  };

  var compose = function compose() {
    for (var _len15 = arguments.length, fns = new Array(_len15), _key15 = 0; _key15 < _len15; _key15++) {
      fns[_key15] = arguments[_key15];
    }

    return fns.reduce(function (f, g) {
      return function () {
        return f(g.apply(void 0, arguments));
      };
    });
  };

  var composeRight = function composeRight() {
    for (var _len16 = arguments.length, fns = new Array(_len16), _key16 = 0; _key16 < _len16; _key16++) {
      fns[_key16] = arguments[_key16];
    }

    return fns.reduce(function (f, g) {
      return function () {
        return g(f.apply(void 0, arguments));
      };
    });
  };

  var converge = function converge(converger, fns) {
    return function () {
      for (var _len17 = arguments.length, args = new Array(_len17), _key17 = 0; _key17 < _len17; _key17++) {
        args[_key17] = arguments[_key17];
      }

      return converger.apply(void 0, _toConsumableArray(fns.map(function (fn) {
        return fn.apply(null, args);
      })));
    };
  };

  var copyToClipboard = function copyToClipboard(str) {
    var el = document.createElement('textarea');
    el.value = str;
    el.setAttribute('readonly', '');
    el.style.position = 'absolute';
    el.style.left = '-9999px';
    document.body.appendChild(el);
    var selected = document.getSelection().rangeCount > 0 ? document.getSelection().getRangeAt(0) : false;
    el.select();
    document.execCommand('copy');
    document.body.removeChild(el);

    if (selected) {
      document.getSelection().removeAllRanges();
      document.getSelection().addRange(selected);
    }
  };

  var countBy = function countBy(arr, fn) {
    return arr.map(typeof fn === 'function' ? fn : function (val) {
      return val[fn];
    }).reduce(function (acc, val) {
      acc[val] = (acc[val] || 0) + 1;
      return acc;
    }, {});
  };

  var countOccurrences = function countOccurrences(arr, val) {
    return arr.reduce(function (a, v) {
      return v === val ? a + 1 : a;
    }, 0);
  };

  var counter = function counter(selector, start, end) {
    var step = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 1;
    var duration = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 2000;

    var current = start,
        _step = (end - start) * step < 0 ? -step : step,
        timer = setInterval(function () {
      current += _step;
      document.querySelector(selector).innerHTML = current;
      if (current >= end) document.querySelector(selector).innerHTML = end;
      if (current >= end) clearInterval(timer);
    }, Math.abs(Math.floor(duration / (end - start))));

    return timer;
  };

  var createElement = function createElement(str) {
    var el = document.createElement('div');
    el.innerHTML = str;
    return el.firstElementChild;
  };

  var createEventHub = function createEventHub() {
    return {
      hub: Object.create(null),
      emit: function emit(event, data) {
        (this.hub[event] || []).forEach(function (handler) {
          return handler(data);
        });
      },
      on: function on(event, handler) {
        if (!this.hub[event]) this.hub[event] = [];
        this.hub[event].push(handler);
      },
      off: function off(event, handler) {
        var i = (this.hub[event] || []).findIndex(function (h) {
          return h === handler;
        });
        if (i > -1) this.hub[event].splice(i, 1);
      }
    };
  };

  var currentURL = function currentURL() {
    return window.location.href;
  };

  var curry = function curry(fn) {
    var arity = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : fn.length;

    for (var _len18 = arguments.length, args = new Array(_len18 > 2 ? _len18 - 2 : 0), _key18 = 2; _key18 < _len18; _key18++) {
      args[_key18 - 2] = arguments[_key18];
    }

    return arity <= args.length ? fn.apply(void 0, args) : curry.bind.apply(curry, [null, fn, arity].concat(args));
  };

  var dayOfYear = function dayOfYear(date) {
    return Math.floor((date - new Date(date.getFullYear(), 0, 0)) / 1000 / 60 / 60 / 24);
  };

  var debounce = function debounce(fn) {
    var ms = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
    var timeoutId;
    return function () {
      var _this = this;

      for (var _len19 = arguments.length, args = new Array(_len19), _key19 = 0; _key19 < _len19; _key19++) {
        args[_key19] = arguments[_key19];
      }

      clearTimeout(timeoutId);
      timeoutId = setTimeout(function () {
        return fn.apply(_this, args);
      }, ms);
    };
  };

  var decapitalize = function decapitalize(_ref3) {
    var _ref4 = _toArray(_ref3),
        first = _ref4[0],
        rest = _ref4.slice(1);

    var upperRest = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
    return first.toLowerCase() + (upperRest ? rest.join('').toUpperCase() : rest.join(''));
  };

  var deepClone = function deepClone(obj) {
    var clone = Object.assign({}, obj);
    Object.keys(clone).forEach(function (key) {
      return clone[key] = _typeof(obj[key]) === 'object' ? deepClone(obj[key]) : obj[key];
    });
    return Array.isArray(obj) ? (clone.length = obj.length) && Array.from(clone) : clone;
  };

  var deepFlatten = function deepFlatten(arr) {
    var _ref5;

    return (_ref5 = []).concat.apply(_ref5, _toConsumableArray(arr.map(function (v) {
      return Array.isArray(v) ? deepFlatten(v) : v;
    })));
  };

  var deepFreeze = function deepFreeze(obj) {
    return Object.keys(obj).forEach(function (prop) {
      return !(obj[prop] instanceof Object) || Object.isFrozen(obj[prop]) ? null : deepFreeze(obj[prop]);
    }) || Object.freeze(obj);
  };

  var defaults = function defaults(obj) {
    for (var _len20 = arguments.length, defs = new Array(_len20 > 1 ? _len20 - 1 : 0), _key20 = 1; _key20 < _len20; _key20++) {
      defs[_key20 - 1] = arguments[_key20];
    }

    return Object.assign.apply(Object, [{}, obj].concat(_toConsumableArray(defs.reverse()), [obj]));
  };

  var defer = function defer(fn) {
    for (var _len21 = arguments.length, args = new Array(_len21 > 1 ? _len21 - 1 : 0), _key21 = 1; _key21 < _len21; _key21++) {
      args[_key21 - 1] = arguments[_key21];
    }

    return setTimeout.apply(void 0, [fn, 1].concat(args));
  };

  var degreesToRads = function degreesToRads(deg) {
    return deg * Math.PI / 180.0;
  };

  var delay = function delay(fn, wait) {
    for (var _len22 = arguments.length, args = new Array(_len22 > 2 ? _len22 - 2 : 0), _key22 = 2; _key22 < _len22; _key22++) {
      args[_key22 - 2] = arguments[_key22];
    }

    return setTimeout.apply(void 0, [fn, wait].concat(args));
  };

  var detectDeviceType = function detectDeviceType() {
    return /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent) ? 'Mobile' : 'Desktop';
  };

  var difference = function difference(a, b) {
    var s = new Set(b);
    return a.filter(function (x) {
      return !s.has(x);
    });
  };

  var differenceBy = function differenceBy(a, b, fn) {
    var s = new Set(b.map(fn));
    return a.filter(function (x) {
      return !s.has(fn(x));
    });
  };

  var differenceWith = function differenceWith(arr, val, comp) {
    return arr.filter(function (a) {
      return val.findIndex(function (b) {
        return comp(a, b);
      }) === -1;
    });
  };

  var dig = function dig(obj, target) {
    return target in obj ? obj[target] : Object.values(obj).reduce(function (acc, val) {
      if (acc !== undefined) return acc;
      if (_typeof(val) === 'object') return dig(val, target);
    }, undefined);
  };

  var digitize = function digitize(n) {
    return _toConsumableArray("".concat(n)).map(function (i) {
      return parseInt(i);
    });
  };

  var distance = function distance(x0, y0, x1, y1) {
    return Math.hypot(x1 - x0, y1 - y0);
  };

  var drop = function drop(arr) {
    var n = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
    return arr.slice(n);
  };

  var dropRight = function dropRight(arr) {
    var n = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
    return arr.slice(0, -n);
  };

  var dropRightWhile = function dropRightWhile(arr, func) {
    while (arr.length > 0 && !func(arr[arr.length - 1])) {
      arr = arr.slice(0, -1);
    }

    return arr;
  };

  var dropWhile = function dropWhile(arr, func) {
    while (arr.length > 0 && !func(arr[0])) {
      arr = arr.slice(1);
    }

    return arr;
  };

  var elementContains = function elementContains(parent, child) {
    return parent !== child && parent.contains(child);
  };

  var elementIsVisibleInViewport = function elementIsVisibleInViewport(el) {
    var partiallyVisible = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;

    var _el$getBoundingClient = el.getBoundingClientRect(),
        top = _el$getBoundingClient.top,
        left = _el$getBoundingClient.left,
        bottom = _el$getBoundingClient.bottom,
        right = _el$getBoundingClient.right;

    var _window = window,
        innerHeight = _window.innerHeight,
        innerWidth = _window.innerWidth;
    return partiallyVisible ? (top > 0 && top < innerHeight || bottom > 0 && bottom < innerHeight) && (left > 0 && left < innerWidth || right > 0 && right < innerWidth) : top >= 0 && left >= 0 && bottom <= innerHeight && right <= innerWidth;
  };

  var elo = function elo(_ref6) {
    var _ref7 = _toArray(_ref6),
        ratings = _ref7.slice(0);

    var kFactor = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 32;
    var selfRating = arguments.length > 2 ? arguments[2] : undefined;

    var _ratings = _slicedToArray(ratings, 2),
        a = _ratings[0],
        b = _ratings[1];

    var expectedScore = function expectedScore(self, opponent) {
      return 1 / (1 + Math.pow(10, (opponent - self) / 400));
    };

    var newRating = function newRating(rating, i) {
      return (selfRating || rating) + kFactor * (i - expectedScore(i ? a : b, i ? b : a));
    };

    if (ratings.length === 2) return [newRating(a, 1), newRating(b, 0)];

    for (var i = 0, len = ratings.length; i < len; i++) {
      var j = i;

      while (j < len - 1) {
        j++;

        var _elo = elo([ratings[i], ratings[j]], kFactor);

        var _elo2 = _slicedToArray(_elo, 2);

        ratings[i] = _elo2[0];
        ratings[j] = _elo2[1];
      }
    }

    return ratings;
  };

  var equals = function equals(a, b) {
    if (a === b) return true;
    if (a instanceof Date && b instanceof Date) return a.getTime() === b.getTime();
    if (!a || !b || _typeof(a) !== 'object' && _typeof(b) !== 'object') return a === b;
    if (a === null || a === undefined || b === null || b === undefined) return false;
    if (a.prototype !== b.prototype) return false;
    var keys = Object.keys(a);
    if (keys.length !== Object.keys(b).length) return false;
    return keys.every(function (k) {
      return equals(a[k], b[k]);
    });
  };

  var escapeHTML = function escapeHTML(str) {
    return str.replace(/[&<>'"]/g, function (tag) {
      return {
        '&': '&amp;',
        '<': '&lt;',
        '>': '&gt;',
        "'": '&#39;',
        '"': '&quot;'
      }[tag] || tag;
    });
  };

  var escapeRegExp = function escapeRegExp(str) {
    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
  };

  var everyNth = function everyNth(arr, nth) {
    return arr.filter(function (e, i) {
      return i % nth === nth - 1;
    });
  };

  var extendHex = function extendHex(shortHex) {
    return '#' + shortHex.slice(shortHex.startsWith('#') ? 1 : 0).split('').map(function (x) {
      return x + x;
    }).join('');
  };

  var factorial = function factorial(n) {
    return n < 0 ? function () {
      throw new TypeError('Negative numbers are not allowed!');
    }() : n <= 1 ? 1 : n * factorial(n - 1);
  };

  var fibonacci = function fibonacci(n) {
    return Array.from({
      length: n
    }).reduce(function (acc, val, i) {
      return acc.concat(i > 1 ? acc[i - 1] + acc[i - 2] : i);
    }, []);
  };

  var filterNonUnique = function filterNonUnique(arr) {
    return arr.filter(function (i) {
      return arr.indexOf(i) === arr.lastIndexOf(i);
    });
  };

  var filterNonUniqueBy = function filterNonUniqueBy(arr, fn) {
    return arr.filter(function (v, i) {
      return arr.every(function (x, j) {
        return i === j === fn(v, x, i, j);
      });
    });
  };

  var findKey = function findKey(obj, fn) {
    return Object.keys(obj).find(function (key) {
      return fn(obj[key], key, obj);
    });
  };

  var findLast = function findLast(arr, fn) {
    return arr.filter(fn).pop();
  };

  var findLastIndex = function findLastIndex(arr, fn) {
    return arr.map(function (val, i) {
      return [i, val];
    }).filter(function (_ref8) {
      var _ref9 = _slicedToArray(_ref8, 2),
          i = _ref9[0],
          val = _ref9[1];

      return fn(val, i, arr);
    }).pop()[0];
  };

  var findLastKey = function findLastKey(obj, fn) {
    return Object.keys(obj).reverse().find(function (key) {
      return fn(obj[key], key, obj);
    });
  };

  var flatten = function flatten(arr) {
    var depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
    return arr.reduce(function (a, v) {
      return a.concat(depth > 1 && Array.isArray(v) ? flatten(v, depth - 1) : v);
    }, []);
  };

  var flattenObject = function flattenObject(obj) {
    var prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
    return Object.keys(obj).reduce(function (acc, k) {
      var pre = prefix.length ? prefix + '.' : '';
      if (_typeof(obj[k]) === 'object') Object.assign(acc, flattenObject(obj[k], pre + k));else acc[pre + k] = obj[k];
      return acc;
    }, {});
  };

  var flip = function flip(fn) {
    return function (first) {
      for (var _len23 = arguments.length, rest = new Array(_len23 > 1 ? _len23 - 1 : 0), _key23 = 1; _key23 < _len23; _key23++) {
        rest[_key23 - 1] = arguments[_key23];
      }

      return fn.apply(void 0, rest.concat([first]));
    };
  };

  var forEachRight = function forEachRight(arr, callback) {
    return arr.slice(0).reverse().forEach(callback);
  };

  var forOwn = function forOwn(obj, fn) {
    return Object.keys(obj).forEach(function (key) {
      return fn(obj[key], key, obj);
    });
  };

  var forOwnRight = function forOwnRight(obj, fn) {
    return Object.keys(obj).reverse().forEach(function (key) {
      return fn(obj[key], key, obj);
    });
  };

  var formatDuration = function formatDuration(ms) {
    if (ms < 0) ms = -ms;
    var time = {
      day: Math.floor(ms / 86400000),
      hour: Math.floor(ms / 3600000) % 24,
      minute: Math.floor(ms / 60000) % 60,
      second: Math.floor(ms / 1000) % 60,
      millisecond: Math.floor(ms) % 1000
    };
    return Object.entries(time).filter(function (val) {
      return val[1] !== 0;
    }).map(function (_ref10) {
      var _ref11 = _slicedToArray(_ref10, 2),
          key = _ref11[0],
          val = _ref11[1];

      return "".concat(val, " ").concat(key).concat(val !== 1 ? 's' : '');
    }).join(', ');
  };

  var fromCamelCase = function fromCamelCase(str) {
    var separator = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '_';
    return str.replace(/([a-z\d])([A-Z])/g, '$1' + separator + '$2').replace(/([A-Z]+)([A-Z][a-z\d]+)/g, '$1' + separator + '$2').toLowerCase();
  };

  var functionName = function functionName(fn) {
    return console.debug(fn.name), fn;
  };

  var functions = function functions(obj) {
    var inherited = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
    return (inherited ? _toConsumableArray(Object.keys(obj)).concat(_toConsumableArray(Object.keys(Object.getPrototypeOf(obj)))) : Object.keys(obj)).filter(function (key) {
      return typeof obj[key] === 'function';
    });
  };

  var gcd = function gcd() {
    var _gcd = function _gcd(x, y) {
      return !y ? x : gcd(y, x % y);
    };

    for (var _len24 = arguments.length, arr = new Array(_len24), _key24 = 0; _key24 < _len24; _key24++) {
      arr[_key24] = arguments[_key24];
    }

    return arr.concat().reduce(function (a, b) {
      return _gcd(a, b);
    });
  };

  var geometricProgression = function geometricProgression(end) {
    var start = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
    var step = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 2;
    return Array.from({
      length: Math.floor(Math.log(end / start) / Math.log(step)) + 1
    }).map(function (v, i) {
      return start * Math.pow(step, i);
    });
  };

  var get = function get(from) {
    for (var _len25 = arguments.length, selectors = new Array(_len25 > 1 ? _len25 - 1 : 0), _key25 = 1; _key25 < _len25; _key25++) {
      selectors[_key25 - 1] = arguments[_key25];
    }

    return selectors.concat().map(function (s) {
      return s.replace(/\[([^\[\]]*)\]/g, '.$1.').split('.').filter(function (t) {
        return t !== '';
      }).reduce(function (prev, cur) {
        return prev && prev[cur];
      }, from);
    });
  };

  var getColonTimeFromDate = function getColonTimeFromDate(date) {
    return date.toTimeString().slice(0, 8);
  };

  var getDaysDiffBetweenDates = function getDaysDiffBetweenDates(dateInitial, dateFinal) {
    return (dateFinal - dateInitial) / (1000 * 3600 * 24);
  };

  var getImages = function getImages(el) {
    var includeDuplicates = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;

    var images = _toConsumableArray(el.getElementsByTagName('img')).map(function (img) {
      return img.getAttribute('src');
    });

    return includeDuplicates ? images : _toConsumableArray(new Set(images));
  };

  var getMeridiemSuffixOfInteger = function getMeridiemSuffixOfInteger(num) {
    return num === 0 || num === 24 ? 12 + 'am' : num === 12 ? 12 + 'pm' : num < 12 ? num % 12 + 'am' : num % 12 + 'pm';
  };

  var getScrollPosition = function getScrollPosition() {
    var el = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : window;
    return {
      x: el.pageXOffset !== undefined ? el.pageXOffset : el.scrollLeft,
      y: el.pageYOffset !== undefined ? el.pageYOffset : el.scrollTop
    };
  };

  var getStyle = function getStyle(el, ruleName) {
    return getComputedStyle(el)[ruleName];
  };

  var getType = function getType(v) {
    return v === undefined ? 'undefined' : v === null ? 'null' : v.constructor.name.toLowerCase();
  };

  var getURLParameters = function getURLParameters(url) {
    return (url.match(/([^?=&]+)(=([^&]*))/g) || []).reduce(function (a, v) {
      return a[v.slice(0, v.indexOf('='))] = v.slice(v.indexOf('=') + 1), a;
    }, {});
  };

  var groupBy = function groupBy(arr, fn) {
    return arr.map(typeof fn === 'function' ? fn : function (val) {
      return val[fn];
    }).reduce(function (acc, val, i) {
      acc[val] = (acc[val] || []).concat(arr[i]);
      return acc;
    }, {});
  };

  var hammingDistance = function hammingDistance(num1, num2) {
    return ((num1 ^ num2).toString(2).match(/1/g) || '').length;
  };

  var hasClass = function hasClass(el, className) {
    return el.classList.contains(className);
  };

  var hasFlags = function hasFlags() {
    for (var _len26 = arguments.length, flags = new Array(_len26), _key26 = 0; _key26 < _len26; _key26++) {
      flags[_key26] = arguments[_key26];
    }

    return flags.every(function (flag) {
      return process.argv.includes(/^-{1,2}/.test(flag) ? flag : '--' + flag);
    });
  };

  var hashBrowser = function hashBrowser(val) {
    return crypto.subtle.digest('SHA-256', new TextEncoder('utf-8').encode(val)).then(function (h) {
      var hexes = [],
          view = new DataView(h);

      for (var i = 0; i < view.byteLength; i += 4) {
        hexes.push(('00000000' + view.getUint32(i).toString(16)).slice(-8));
      }

      return hexes.join('');
    });
  };

  var hashNode = function hashNode(val) {
    return new Promise(function (resolve) {
      return setTimeout(function () {
        return resolve(crypto.createHash('sha256').update(val).digest('hex'));
      }, 0);
    });
  };

  var head = function head(arr) {
    return arr[0];
  };

  var hexToRGB = function hexToRGB(hex) {
    var alpha = false,
        h = hex.slice(hex.startsWith('#') ? 1 : 0);
    if (h.length === 3) h = _toConsumableArray(h).map(function (x) {
      return x + x;
    }).join('');else if (h.length === 8) alpha = true;
    h = parseInt(h, 16);
    return 'rgb' + (alpha ? 'a' : '') + '(' + (h >>> (alpha ? 24 : 16)) + ', ' + ((h & (alpha ? 0x00ff0000 : 0x00ff00)) >>> (alpha ? 16 : 8)) + ', ' + ((h & (alpha ? 0x0000ff00 : 0x0000ff)) >>> (alpha ? 8 : 0)) + (alpha ? ", ".concat(h & 0x000000ff) : '') + ')';
  };

  var hide = function hide() {
    for (var _len27 = arguments.length, el = new Array(_len27), _key27 = 0; _key27 < _len27; _key27++) {
      el[_key27] = arguments[_key27];
    }

    return el.concat().forEach(function (e) {
      return e.style.display = 'none';
    });
  };

  var httpGet = function httpGet(url, callback) {
    var err = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : console.error;
    var request = new XMLHttpRequest();
    request.open('GET', url, true);

    request.onload = function () {
      return callback(request.responseText);
    };

    request.onerror = function () {
      return err(request);
    };

    request.send();
  };

  var httpPost = function httpPost(url, data, callback) {
    var err = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : console.error;
    var request = new XMLHttpRequest();
    request.open('POST', url, true);
    request.setRequestHeader('Content-type', 'application/json; charset=utf-8');

    request.onload = function () {
      return callback(request.responseText);
    };

    request.onerror = function () {
      return err(request);
    };

    request.send(data);
  };

  var httpsRedirect = function httpsRedirect() {
    if (location.protocol !== 'https:') location.replace('https://' + location.href.split('//')[1]);
  };

  var hz = function hz(fn) {
    var iterations = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 100;
    var before = performance.now();

    for (var i = 0; i < iterations; i++) {
      fn();
    }

    return 1000 * iterations / (performance.now() - before);
  };

  var inRange = function inRange(n, start) {
    var end = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;

    if (end && start > end) {
      var _ref12 = [start, end];
      end = _ref12[0];
      start = _ref12[1];
    }

    return end == null ? n >= 0 && n < start : n >= start && n < end;
  };

  var indentString = function indentString(str, count) {
    var indent = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : ' ';
    return str.replace(/^/gm, indent.repeat(count));
  };

  var indexOfAll = function indexOfAll(arr, val) {
    return arr.reduce(function (acc, el, i) {
      return el === val ? _toConsumableArray(acc).concat([i]) : acc;
    }, []);
  };

  var initial = function initial(arr) {
    return arr.slice(0, -1);
  };

  var initialize2DArray = function initialize2DArray(w, h) {
    var val = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
    return Array.from({
      length: h
    }).map(function () {
      return Array.from({
        length: w
      }).fill(val);
    });
  };

  var initializeArrayWithRange = function initializeArrayWithRange(end) {
    var start = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
    var step = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
    return Array.from({
      length: Math.ceil((end - start + 1) / step)
    }, function (v, i) {
      return i * step + start;
    });
  };

  var initializeArrayWithRangeRight = function initializeArrayWithRangeRight(end) {
    var start = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
    var step = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
    return Array.from({
      length: Math.ceil((end + 1 - start) / step)
    }).map(function (v, i, arr) {
      return (arr.length - i - 1) * step + start;
    });
  };

  var initializeArrayWithValues = function initializeArrayWithValues(n) {
    var val = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
    return Array(n).fill(val);
  };

  var initializeNDArray = function initializeNDArray(val) {
    for (var _len28 = arguments.length, args = new Array(_len28 > 1 ? _len28 - 1 : 0), _key28 = 1; _key28 < _len28; _key28++) {
      args[_key28 - 1] = arguments[_key28];
    }

    return args.length === 0 ? val : Array.from({
      length: args[0]
    }).map(function () {
      return initializeNDArray.apply(void 0, [val].concat(_toConsumableArray(args.slice(1))));
    });
  };

  var insertAfter = function insertAfter(el, htmlString) {
    return el.insertAdjacentHTML('afterend', htmlString);
  };

  var insertBefore = function insertBefore(el, htmlString) {
    return el.insertAdjacentHTML('beforebegin', htmlString);
  };

  var intersection = function intersection(a, b) {
    var s = new Set(b);
    return a.filter(function (x) {
      return s.has(x);
    });
  };

  var intersectionBy = function intersectionBy(a, b, fn) {
    var s = new Set(b.map(fn));
    return a.filter(function (x) {
      return s.has(fn(x));
    });
  };

  var intersectionWith = function intersectionWith(a, b, comp) {
    return a.filter(function (x) {
      return b.findIndex(function (y) {
        return comp(x, y);
      }) !== -1;
    });
  };

  var invertKeyValues = function invertKeyValues(obj, fn) {
    return Object.keys(obj).reduce(function (acc, key) {
      var val = fn ? fn(obj[key]) : obj[key];
      acc[val] = acc[val] || [];
      acc[val].push(key);
      return acc;
    }, {});
  };

  var is = function is(type, val) {
    return ![, null].includes(val) && val.constructor === type;
  };

  var isAbsoluteURL = function isAbsoluteURL(str) {
    return /^[a-z][a-z0-9+.-]*:/.test(str);
  };

  var isAfterDate = function isAfterDate(dateA, dateB) {
    return dateA > dateB;
  };

  var isAnagram = function isAnagram(str1, str2) {
    var normalize = function normalize(str) {
      return str.toLowerCase().replace(/[^a-z0-9]/gi, '').split('').sort().join('');
    };

    return normalize(str1) === normalize(str2);
  };

  var isArrayLike = function isArrayLike(obj) {
    return obj != null && typeof obj[Symbol.iterator] === 'function';
  };

  var isBeforeDate = function isBeforeDate(dateA, dateB) {
    return dateA < dateB;
  };

  var isBoolean = function isBoolean(val) {
    return typeof val === 'boolean';
  };

  var isBrowser = function isBrowser() {
    return ![typeof window === "undefined" ? "undefined" : _typeof(window), typeof document === "undefined" ? "undefined" : _typeof(document)].includes('undefined');
  };

  var isBrowserTabFocused = function isBrowserTabFocused() {
    return !document.hidden;
  };

  var isDivisible = function isDivisible(dividend, divisor) {
    return dividend % divisor === 0;
  };

  var isDuplexStream = function isDuplexStream(val) {
    return val !== null && _typeof(val) === 'object' && typeof val.pipe === 'function' && typeof val._read === 'function' && _typeof(val._readableState) === 'object' && typeof val._write === 'function' && _typeof(val._writableState) === 'object';
  };

  var isEmpty = function isEmpty(val) {
    return val == null || !(Object.keys(val) || val).length;
  };

  var isEven = function isEven(num) {
    return num % 2 === 0;
  };

  var isFunction = function isFunction(val) {
    return typeof val === 'function';
  };

  var isLowerCase = function isLowerCase(str) {
    return str === str.toLowerCase();
  };

  var isNil = function isNil(val) {
    return val === undefined || val === null;
  };

  var isNull = function isNull(val) {
    return val === null;
  };

  var isNumber = function isNumber(val) {
    return typeof val === 'number';
  };

  var isObject = function isObject(obj) {
    return obj === Object(obj);
  };

  var isObjectLike = function isObjectLike(val) {
    return val !== null && _typeof(val) === 'object';
  };

  var isPlainObject = function isPlainObject(val) {
    return !!val && _typeof(val) === 'object' && val.constructor === Object;
  };

  var isPrime = function isPrime(num) {
    var boundary = Math.floor(Math.sqrt(num));

    for (var i = 2; i <= boundary; i++) {
      if (num % i === 0) return false;
    }

    return num >= 2;
  };

  var isPrimitive = function isPrimitive(val) {
    return Object(val) !== val;
  };

  var isPromiseLike = function isPromiseLike(obj) {
    return obj !== null && (_typeof(obj) === 'object' || typeof obj === 'function') && typeof obj.then === 'function';
  };

  var isReadableStream = function isReadableStream(val) {
    return val !== null && _typeof(val) === 'object' && typeof val.pipe === 'function' && typeof val._read === 'function' && _typeof(val._readableState) === 'object';
  };

  var isSameDate = function isSameDate(dateA, dateB) {
    return dateA.toISOString() === dateB.toISOString();
  };

  var isSorted = function isSorted(arr) {
    var direction = -(arr[0] - arr[1]);
    var _iteratorNormalCompletion = true;
    var _didIteratorError = false;
    var _iteratorError = undefined;

    try {
      for (var _iterator = arr.entries()[Symbol.iterator](), _step2; !(_iteratorNormalCompletion = (_step2 = _iterator.next()).done); _iteratorNormalCompletion = true) {
        var _step2$value = _slicedToArray(_step2.value, 2),
            i = _step2$value[0],
            val = _step2$value[1];

        direction = !direction ? -(arr[i - 1] - arr[i]) : direction;
        if (i === arr.length - 1) return !direction ? 0 : direction;else if ((val - arr[i + 1]) * direction > 0) return 0;
      }
    } catch (err) {
      _didIteratorError = true;
      _iteratorError = err;
    } finally {
      try {
        if (!_iteratorNormalCompletion && _iterator.return != null) {
          _iterator.return();
        }
      } finally {
        if (_didIteratorError) {
          throw _iteratorError;
        }
      }
    }
  };

  var isStream = function isStream(val) {
    return val !== null && _typeof(val) === 'object' && typeof val.pipe === 'function';
  };

  var isString = function isString(val) {
    return typeof val === 'string';
  };

  var isSymbol = function isSymbol(val) {
    return _typeof(val) === 'symbol';
  };

  var isTravisCI = function isTravisCI() {
    return 'TRAVIS' in process.env && 'CI' in process.env;
  };

  var isUndefined = function isUndefined(val) {
    return val === undefined;
  };

  var isUpperCase = function isUpperCase(str) {
    return str === str.toUpperCase();
  };

  var isValidJSON = function isValidJSON(obj) {
    try {
      JSON.parse(obj);
      return true;
    } catch (e) {
      return false;
    }
  };

  var isWritableStream = function isWritableStream(val) {
    return val !== null && _typeof(val) === 'object' && typeof val.pipe === 'function' && typeof val._write === 'function' && _typeof(val._writableState) === 'object';
  };

  var join = function join(arr) {
    var separator = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ',';
    var end = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : separator;
    return arr.reduce(function (acc, val, i) {
      return i === arr.length - 2 ? acc + val + end : i === arr.length - 1 ? acc + val : acc + val + separator;
    }, '');
  };

  var last = function last(arr) {
    return arr[arr.length - 1];
  };

  var lcm = function lcm() {
    var gcd = function gcd(x, y) {
      return !y ? x : gcd(y, x % y);
    };

    var _lcm = function _lcm(x, y) {
      return x * y / gcd(x, y);
    };

    for (var _len29 = arguments.length, arr = new Array(_len29), _key29 = 0; _key29 < _len29; _key29++) {
      arr[_key29] = arguments[_key29];
    }

    return arr.concat().reduce(function (a, b) {
      return _lcm(a, b);
    });
  };

  var longestItem = function longestItem() {
    for (var _len30 = arguments.length, vals = new Array(_len30), _key30 = 0; _key30 < _len30; _key30++) {
      vals[_key30] = arguments[_key30];
    }

    return vals.reduce(function (a, x) {
      return x.length > a.length ? x : a;
    });
  };

  var lowercaseKeys = function lowercaseKeys(obj) {
    return Object.keys(obj).reduce(function (acc, key) {
      acc[key.toLowerCase()] = obj[key];
      return acc;
    }, {});
  };

  var luhnCheck = function luhnCheck(num) {
    var arr = (num + '').split('').reverse().map(function (x) {
      return parseInt(x);
    });
    var lastDigit = arr.splice(0, 1)[0];
    var sum = arr.reduce(function (acc, val, i) {
      return i % 2 !== 0 ? acc + val : acc + val * 2 % 9 || 9;
    }, 0);
    sum += lastDigit;
    return sum % 10 === 0;
  };

  var mapKeys = function mapKeys(obj, fn) {
    return Object.keys(obj).reduce(function (acc, k) {
      acc[fn(obj[k], k, obj)] = obj[k];
      return acc;
    }, {});
  };

  var mapObject = function mapObject(arr, fn) {
    return function (a) {
      return a = [arr, arr.map(fn)], a[0].reduce(function (acc, val, ind) {
        return acc[val] = a[1][ind], acc;
      }, {});
    }();
  };

  var mapString = function mapString(str, fn) {
    return str.split('').map(function (c, i) {
      return fn(c, i, str);
    }).join('');
  };

  var mapValues = function mapValues(obj, fn) {
    return Object.keys(obj).reduce(function (acc, k) {
      acc[k] = fn(obj[k], k, obj);
      return acc;
    }, {});
  };

  var mask = function mask(cc) {
    var num = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 4;
    var mask = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '*';
    return "".concat(cc).slice(-num).padStart("".concat(cc).length, mask);
  };

  var matches = function matches(obj, source) {
    return Object.keys(source).every(function (key) {
      return obj.hasOwnProperty(key) && obj[key] === source[key];
    });
  };

  var matchesWith = function matchesWith(obj, source, fn) {
    return Object.keys(source).every(function (key) {
      return obj.hasOwnProperty(key) && fn ? fn(obj[key], source[key], key, obj, source) : obj[key] == source[key];
    });
  };

  var maxBy = function maxBy(arr, fn) {
    return Math.max.apply(Math, _toConsumableArray(arr.map(typeof fn === 'function' ? fn : function (val) {
      return val[fn];
    })));
  };

  var maxDate = function maxDate() {
    var _Math$max;

    for (var _len31 = arguments.length, dates = new Array(_len31), _key31 = 0; _key31 < _len31; _key31++) {
      dates[_key31] = arguments[_key31];
    }

    return new Date((_Math$max = Math.max).apply.apply(_Math$max, [null].concat(dates)));
  };

  var maxN = function maxN(arr) {
    var n = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
    return _toConsumableArray(arr).sort(function (a, b) {
      return b - a;
    }).slice(0, n);
  };

  var median = function median(arr) {
    var mid = Math.floor(arr.length / 2),
        nums = _toConsumableArray(arr).sort(function (a, b) {
      return a - b;
    });

    return arr.length % 2 !== 0 ? nums[mid] : (nums[mid - 1] + nums[mid]) / 2;
  };

  var memoize = function memoize(fn) {
    var cache = new Map();

    var cached = function cached(val) {
      return cache.has(val) ? cache.get(val) : cache.set(val, fn.call(this, val)) && cache.get(val);
    };

    cached.cache = cache;
    return cached;
  };

  var merge = function merge() {
    for (var _len32 = arguments.length, objs = new Array(_len32), _key32 = 0; _key32 < _len32; _key32++) {
      objs[_key32] = arguments[_key32];
    }

    return objs.concat().reduce(function (acc, obj) {
      return Object.keys(obj).reduce(function (a, k) {
        acc[k] = acc.hasOwnProperty(k) ? [].concat(acc[k]).concat(obj[k]) : obj[k];
        return acc;
      }, {});
    }, {});
  };

  var minBy = function minBy(arr, fn) {
    return Math.min.apply(Math, _toConsumableArray(arr.map(typeof fn === 'function' ? fn : function (val) {
      return val[fn];
    })));
  };

  var minDate = function minDate() {
    var _Math$min;

    for (var _len33 = arguments.length, dates = new Array(_len33), _key33 = 0; _key33 < _len33; _key33++) {
      dates[_key33] = arguments[_key33];
    }

    return new Date((_Math$min = Math.min).apply.apply(_Math$min, [null].concat(dates)));
  };

  var minN = function minN(arr) {
    var n = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
    return _toConsumableArray(arr).sort(function (a, b) {
      return a - b;
    }).slice(0, n);
  };

  var mostPerformant = function mostPerformant(fns) {
    var iterations = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 10000;
    var times = fns.map(function (fn) {
      var before = performance.now();

      for (var i = 0; i < iterations; i++) {
        fn();
      }

      return performance.now() - before;
    });
    return times.indexOf(Math.min.apply(Math, _toConsumableArray(times)));
  };

  var negate = function negate(func) {
    return function () {
      return !func.apply(void 0, arguments);
    };
  };

  var nest = function nest(items) {
    var id = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
    var link = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'parent_id';
    return items.filter(function (item) {
      return item[link] === id;
    }).map(function (item) {
      return _objectSpread({}, item, {
        children: nest(items, item.id)
      });
    });
  };

  var nodeListToArray = function nodeListToArray(nodeList) {
    return _toConsumableArray(nodeList);
  };

  var none = function none(arr) {
    var fn = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Boolean;
    return !arr.some(fn);
  };

  var nthArg = function nthArg(n) {
    return function () {
      for (var _len34 = arguments.length, args = new Array(_len34), _key34 = 0; _key34 < _len34; _key34++) {
        args[_key34] = arguments[_key34];
      }

      return args.slice(n)[0];
    };
  };

  var nthElement = function nthElement(arr) {
    var n = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
    return (n === -1 ? arr.slice(n) : arr.slice(n, n + 1))[0];
  };

  var objectFromPairs = function objectFromPairs(arr) {
    return arr.reduce(function (a, _ref13) {
      var _ref14 = _slicedToArray(_ref13, 2),
          key = _ref14[0],
          val = _ref14[1];

      return a[key] = val, a;
    }, {});
  };

  var objectToPairs = function objectToPairs(obj) {
    return Object.keys(obj).map(function (k) {
      return [k, obj[k]];
    });
  };

  var observeMutations = function observeMutations(element, callback, options) {
    var observer = new MutationObserver(function (mutations) {
      return mutations.forEach(function (m) {
        return callback(m);
      });
    });
    observer.observe(element, Object.assign({
      childList: true,
      attributes: true,
      attributeOldValue: true,
      characterData: true,
      characterDataOldValue: true,
      subtree: true
    }, options));
    return observer;
  };

  var off = function off(el, evt, fn) {
    var opts = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
    return el.removeEventListener(evt, fn, opts);
  };

  var offset = function offset(arr, _offset) {
    return _toConsumableArray(arr.slice(_offset)).concat(_toConsumableArray(arr.slice(0, _offset)));
  };

  var omit = function omit(obj, arr) {
    return Object.keys(obj).filter(function (k) {
      return !arr.includes(k);
    }).reduce(function (acc, key) {
      return acc[key] = obj[key], acc;
    }, {});
  };

  var omitBy = function omitBy(obj, fn) {
    return Object.keys(obj).filter(function (k) {
      return !fn(obj[k], k);
    }).reduce(function (acc, key) {
      return acc[key] = obj[key], acc;
    }, {});
  };

  var on = function on(el, evt, fn) {
    var opts = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};

    var delegatorFn = function delegatorFn(e) {
      return e.target.matches(opts.target) && fn.call(e.target, e);
    };

    el.addEventListener(evt, opts.target ? delegatorFn : fn, opts.options || false);
    if (opts.target) return delegatorFn;
  };

  var onUserInputChange = function onUserInputChange(callback) {
    var type = 'mouse',
        lastTime = 0;

    var mousemoveHandler = function mousemoveHandler() {
      var now = performance.now();
      if (now - lastTime < 20) type = 'mouse', callback(type), document.removeEventListener('mousemove', mousemoveHandler);
      lastTime = now;
    };

    document.addEventListener('touchstart', function () {
      if (type === 'touch') return;
      type = 'touch', callback(type), document.addEventListener('mousemove', mousemoveHandler);
    });
  };

  var once = function once(fn) {
    var called = false;
    return function () {
      if (called) return;
      called = true;

      for (var _len35 = arguments.length, args = new Array(_len35), _key35 = 0; _key35 < _len35; _key35++) {
        args[_key35] = arguments[_key35];
      }

      return fn.apply(this, args);
    };
  };

  var orderBy = function orderBy(arr, props, orders) {
    return _toConsumableArray(arr).sort(function (a, b) {
      return props.reduce(function (acc, prop, i) {
        if (acc === 0) {
          var _ref15 = orders && orders[i] === 'desc' ? [b[prop], a[prop]] : [a[prop], b[prop]],
              _ref16 = _slicedToArray(_ref15, 2),
              p1 = _ref16[0],
              p2 = _ref16[1];

          acc = p1 > p2 ? 1 : p1 < p2 ? -1 : 0;
        }

        return acc;
      }, 0);
    });
  };

  var over = function over() {
    for (var _len36 = arguments.length, fns = new Array(_len36), _key36 = 0; _key36 < _len36; _key36++) {
      fns[_key36] = arguments[_key36];
    }

    return function () {
      for (var _len37 = arguments.length, args = new Array(_len37), _key37 = 0; _key37 < _len37; _key37++) {
        args[_key37] = arguments[_key37];
      }

      return fns.map(function (fn) {
        return fn.apply(null, args);
      });
    };
  };

  var overArgs = function overArgs(fn, transforms) {
    return function () {
      for (var _len38 = arguments.length, args = new Array(_len38), _key38 = 0; _key38 < _len38; _key38++) {
        args[_key38] = arguments[_key38];
      }

      return fn.apply(void 0, _toConsumableArray(args.map(function (val, i) {
        return transforms[i](val);
      })));
    };
  };

  var pad = function pad(str, length) {
    var char = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : ' ';
    return str.padStart((str.length + length) / 2, char).padEnd(length, char);
  };

  var palindrome = function palindrome(str) {
    var s = str.toLowerCase().replace(/[\W_]/g, '');
    return s === _toConsumableArray(s).reverse().join('');
  };

  var parseCookie = function parseCookie(str) {
    return str.split(';').map(function (v) {
      return v.split('=');
    }).reduce(function (acc, v) {
      acc[decodeURIComponent(v[0].trim())] = decodeURIComponent(v[1].trim());
      return acc;
    }, {});
  };

  var partial = function partial(fn) {
    for (var _len39 = arguments.length, partials = new Array(_len39 > 1 ? _len39 - 1 : 0), _key39 = 1; _key39 < _len39; _key39++) {
      partials[_key39 - 1] = arguments[_key39];
    }

    return function () {
      for (var _len40 = arguments.length, args = new Array(_len40), _key40 = 0; _key40 < _len40; _key40++) {
        args[_key40] = arguments[_key40];
      }

      return fn.apply(void 0, partials.concat(args));
    };
  };

  var partialRight = function partialRight(fn) {
    for (var _len41 = arguments.length, partials = new Array(_len41 > 1 ? _len41 - 1 : 0), _key41 = 1; _key41 < _len41; _key41++) {
      partials[_key41 - 1] = arguments[_key41];
    }

    return function () {
      for (var _len42 = arguments.length, args = new Array(_len42), _key42 = 0; _key42 < _len42; _key42++) {
        args[_key42] = arguments[_key42];
      }

      return fn.apply(void 0, args.concat(partials));
    };
  };

  var partition = function partition(arr, fn) {
    return arr.reduce(function (acc, val, i, arr) {
      acc[fn(val, i, arr) ? 0 : 1].push(val);
      return acc;
    }, [[], []]);
  };

  var percentile = function percentile(arr, val) {
    return 100 * arr.reduce(function (acc, v) {
      return acc + (v < val ? 1 : 0) + (v === val ? 0.5 : 0);
    }, 0) / arr.length;
  };

  var permutations = function permutations(arr) {
    if (arr.length <= 2) return arr.length === 2 ? [arr, [arr[1], arr[0]]] : arr;
    return arr.reduce(function (acc, item, i) {
      return acc.concat(permutations(_toConsumableArray(arr.slice(0, i)).concat(_toConsumableArray(arr.slice(i + 1)))).map(function (val) {
        return [item].concat(_toConsumableArray(val));
      }));
    }, []);
  };

  var pick = function pick(obj, arr) {
    return arr.reduce(function (acc, curr) {
      return curr in obj && (acc[curr] = obj[curr]), acc;
    }, {});
  };

  var pickBy = function pickBy(obj, fn) {
    return Object.keys(obj).filter(function (k) {
      return fn(obj[k], k);
    }).reduce(function (acc, key) {
      return acc[key] = obj[key], acc;
    }, {});
  };

  var pipeAsyncFunctions = function pipeAsyncFunctions() {
    for (var _len43 = arguments.length, fns = new Array(_len43), _key43 = 0; _key43 < _len43; _key43++) {
      fns[_key43] = arguments[_key43];
    }

    return function (arg) {
      return fns.reduce(function (p, f) {
        return p.then(f);
      }, Promise.resolve(arg));
    };
  };

  var pipeFunctions = function pipeFunctions() {
    for (var _len44 = arguments.length, fns = new Array(_len44), _key44 = 0; _key44 < _len44; _key44++) {
      fns[_key44] = arguments[_key44];
    }

    return fns.reduce(function (f, g) {
      return function () {
        return g(f.apply(void 0, arguments));
      };
    });
  };

  var pluralize = function pluralize(val, word) {
    var plural = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : word + 's';

    var _pluralize = function _pluralize(num, word) {
      var plural = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : word + 's';
      return [1, -1].includes(Number(num)) ? word : plural;
    };

    if (_typeof(val) === 'object') return function (num, word) {
      return _pluralize(num, word, val[word]);
    };
    return _pluralize(val, word, plural);
  };

  var powerset = function powerset(arr) {
    return arr.reduce(function (a, v) {
      return a.concat(a.map(function (r) {
        return [v].concat(r);
      }));
    }, [[]]);
  };

  var prefix = function prefix(prop) {
    var capitalizedProp = prop.charAt(0).toUpperCase() + prop.slice(1);
    var prefixes = ['', 'webkit', 'moz', 'ms', 'o'];
    var i = prefixes.findIndex(function (prefix) {
      return typeof document.body.style[prefix ? prefix + capitalizedProp : prop] !== 'undefined';
    });
    return i !== -1 ? i === 0 ? prop : prefixes[i] + capitalizedProp : null;
  };

  var prettyBytes = function prettyBytes(num) {
    var precision = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 3;
    var addSpace = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
    var UNITS = ['B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
    if (Math.abs(num) < 1) return num + (addSpace ? ' ' : '') + UNITS[0];
    var exponent = Math.min(Math.floor(Math.log10(num < 0 ? -num : num) / 3), UNITS.length - 1);
    var n = Number(((num < 0 ? -num : num) / Math.pow(1000, exponent)).toPrecision(precision));
    return (num < 0 ? '-' : '') + n + (addSpace ? ' ' : '') + UNITS[exponent];
  };

  var primes = function primes(num) {
    var arr = Array.from({
      length: num - 1
    }).map(function (x, i) {
      return i + 2;
    }),
        sqroot = Math.floor(Math.sqrt(num)),
        numsTillSqroot = Array.from({
      length: sqroot - 1
    }).map(function (x, i) {
      return i + 2;
    });
    numsTillSqroot.forEach(function (x) {
      return arr = arr.filter(function (y) {
        return y % x !== 0 || y === x;
      });
    });
    return arr;
  };

  var promisify = function promisify(func) {
    return function () {
      for (var _len45 = arguments.length, args = new Array(_len45), _key45 = 0; _key45 < _len45; _key45++) {
        args[_key45] = arguments[_key45];
      }

      return new Promise(function (resolve, reject) {
        return func.apply(void 0, args.concat([function (err, result) {
          return err ? reject(err) : resolve(result);
        }]));
      });
    };
  };

  var pull = function pull(arr) {
    for (var _len46 = arguments.length, args = new Array(_len46 > 1 ? _len46 - 1 : 0), _key46 = 1; _key46 < _len46; _key46++) {
      args[_key46 - 1] = arguments[_key46];
    }

    var argState = Array.isArray(args[0]) ? args[0] : args;
    var pulled = arr.filter(function (v, i) {
      return !argState.includes(v);
    });
    arr.length = 0;
    pulled.forEach(function (v) {
      return arr.push(v);
    });
  };

  var pullAtIndex = function pullAtIndex(arr, pullArr) {
    var removed = [];
    var pulled = arr.map(function (v, i) {
      return pullArr.includes(i) ? removed.push(v) : v;
    }).filter(function (v, i) {
      return !pullArr.includes(i);
    });
    arr.length = 0;
    pulled.forEach(function (v) {
      return arr.push(v);
    });
    return removed;
  };

  var pullAtValue = function pullAtValue(arr, pullArr) {
    var removed = [],
        pushToRemove = arr.forEach(function (v, i) {
      return pullArr.includes(v) ? removed.push(v) : v;
    }),
        mutateTo = arr.filter(function (v, i) {
      return !pullArr.includes(v);
    });
    arr.length = 0;
    mutateTo.forEach(function (v) {
      return arr.push(v);
    });
    return removed;
  };

  var pullBy = function pullBy(arr) {
    for (var _len47 = arguments.length, args = new Array(_len47 > 1 ? _len47 - 1 : 0), _key47 = 1; _key47 < _len47; _key47++) {
      args[_key47 - 1] = arguments[_key47];
    }

    var length = args.length;
    var fn = length > 1 ? args[length - 1] : undefined;
    fn = typeof fn == 'function' ? (args.pop(), fn) : undefined;
    var argState = (Array.isArray(args[0]) ? args[0] : args).map(function (val) {
      return fn(val);
    });
    var pulled = arr.filter(function (v, i) {
      return !argState.includes(fn(v));
    });
    arr.length = 0;
    pulled.forEach(function (v) {
      return arr.push(v);
    });
  };

  var radsToDegrees = function radsToDegrees(rad) {
    return rad * 180.0 / Math.PI;
  };

  var randomHexColorCode = function randomHexColorCode() {
    var n = (Math.random() * 0xfffff * 1000000).toString(16);
    return '#' + n.slice(0, 6);
  };

  var randomIntArrayInRange = function randomIntArrayInRange(min, max) {
    var n = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
    return Array.from({
      length: n
    }, function () {
      return Math.floor(Math.random() * (max - min + 1)) + min;
    });
  };

  var randomIntegerInRange = function randomIntegerInRange(min, max) {
    return Math.floor(Math.random() * (max - min + 1)) + min;
  };

  var randomNumberInRange = function randomNumberInRange(min, max) {
    return Math.random() * (max - min) + min;
  };

  var readFileLines = function readFileLines(filename) {
    return fs.readFileSync(filename).toString('UTF8').split('\n');
  };

  var rearg = function rearg(fn, indexes) {
    return function () {
      for (var _len48 = arguments.length, args = new Array(_len48), _key48 = 0; _key48 < _len48; _key48++) {
        args[_key48] = arguments[_key48];
      }

      return fn.apply(void 0, _toConsumableArray(indexes.map(function (i) {
        return args[i];
      })));
    };
  };

  var recordAnimationFrames = function recordAnimationFrames(callback) {
    var autoStart = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
    var running = true,
        raf;

    var stop = function stop() {
      running = false;
      cancelAnimationFrame(raf);
    };

    var start = function start() {
      running = true;
      run();
    };

    var run = function run() {
      raf = requestAnimationFrame(function () {
        callback();
        if (running) run();
      });
    };

    if (autoStart) start();
    return {
      start: start,
      stop: stop
    };
  };

  var redirect = function redirect(url) {
    var asLink = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
    return asLink ? window.location.href = url : window.location.replace(url);
  };

  var reduceSuccessive = function reduceSuccessive(arr, fn, acc) {
    return arr.reduce(function (res, val, i, arr) {
      return res.push(fn(res.slice(-1)[0], val, i, arr)), res;
    }, [acc]);
  };

  var reduceWhich = function reduceWhich(arr) {
    var comparator = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function (a, b) {
      return a - b;
    };
    return arr.reduce(function (a, b) {
      return comparator(a, b) >= 0 ? b : a;
    });
  };

  var reducedFilter = function reducedFilter(data, keys, fn) {
    return data.filter(fn).map(function (el) {
      return keys.reduce(function (acc, key) {
        acc[key] = el[key];
        return acc;
      }, {});
    });
  };

  var reject = function reject(pred, array) {
    return array.filter(function () {
      return !pred.apply(void 0, arguments);
    });
  };

  var remove = function remove(arr, func) {
    return Array.isArray(arr) ? arr.filter(func).reduce(function (acc, val) {
      arr.splice(arr.indexOf(val), 1);
      return acc.concat(val);
    }, []) : [];
  };

  var removeNonASCII = function removeNonASCII(str) {
    return str.replace(/[^\x20-\x7E]/g, '');
  };

  var renameKeys = function renameKeys(keysMap, obj) {
    return Object.keys(obj).reduce(function (acc, key) {
      return _objectSpread({}, acc, _defineProperty({}, keysMap[key] || key, obj[key]));
    }, {});
  };

  var reverseString = function reverseString(str) {
    return _toConsumableArray(str).reverse().join('');
  };

  var round = function round(n) {
    var decimals = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
    return Number("".concat(Math.round("".concat(n, "e").concat(decimals)), "e-").concat(decimals));
  };

  var runAsync = function runAsync(fn) {
    var worker = new Worker(URL.createObjectURL(new Blob(["postMessage((".concat(fn, ")());")]), {
      type: 'application/javascript; charset=utf-8'
    }));
    return new Promise(function (res, rej) {
      worker.onmessage = function (_ref17) {
        var data = _ref17.data;
        res(data), worker.terminate();
      };

      worker.onerror = function (err) {
        rej(err), worker.terminate();
      };
    });
  };

  var runPromisesInSeries = function runPromisesInSeries(ps) {
    return ps.reduce(function (p, next) {
      return p.then(next);
    }, Promise.resolve());
  };

  var sample = function sample(arr) {
    return arr[Math.floor(Math.random() * arr.length)];
  };

  var sampleSize = function sampleSize(_ref18) {
    var _ref19 = _toArray(_ref18),
        arr = _ref19.slice(0);

    var n = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
    var m = arr.length;

    while (m) {
      var i = Math.floor(Math.random() * m--);
      var _ref20 = [arr[i], arr[m]];
      arr[m] = _ref20[0];
      arr[i] = _ref20[1];
    }

    return arr.slice(0, n);
  };

  var scrollToTop = function scrollToTop() {
    var c = document.documentElement.scrollTop || document.body.scrollTop;

    if (c > 0) {
      window.requestAnimationFrame(scrollToTop);
      window.scrollTo(0, c - c / 8);
    }
  };

  var sdbm = function sdbm(str) {
    var arr = str.split('');
    return arr.reduce(function (hashCode, currentVal) {
      return hashCode = currentVal.charCodeAt(0) + (hashCode << 6) + (hashCode << 16) - hashCode;
    }, 0);
  };

  var serializeCookie = function serializeCookie(name, val) {
    return "".concat(encodeURIComponent(name), "=").concat(encodeURIComponent(val));
  };

  var setStyle = function setStyle(el, ruleName, val) {
    return el.style[ruleName] = val;
  };

  var shallowClone = function shallowClone(obj) {
    return Object.assign({}, obj);
  };

  var shank = function shank(arr) {
    var index = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
    var delCount = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;

    for (var _len49 = arguments.length, elements = new Array(_len49 > 3 ? _len49 - 3 : 0), _key49 = 3; _key49 < _len49; _key49++) {
      elements[_key49 - 3] = arguments[_key49];
    }

    return arr.slice(0, index).concat(elements).concat(arr.slice(index + delCount));
  };

  var show = function show() {
    for (var _len50 = arguments.length, el = new Array(_len50), _key50 = 0; _key50 < _len50; _key50++) {
      el[_key50] = arguments[_key50];
    }

    return el.concat().forEach(function (e) {
      return e.style.display = '';
    });
  };

  var shuffle = function shuffle(_ref21) {
    var _ref22 = _toArray(_ref21),
        arr = _ref22.slice(0);

    var m = arr.length;

    while (m) {
      var i = Math.floor(Math.random() * m--);
      var _ref23 = [arr[i], arr[m]];
      arr[m] = _ref23[0];
      arr[i] = _ref23[1];
    }

    return arr;
  };

  var similarity = function similarity(arr, values) {
    return arr.filter(function (v) {
      return values.includes(v);
    });
  };

  var size = function size(val) {
    return Array.isArray(val) ? val.length : val && _typeof(val) === 'object' ? val.size || val.length || Object.keys(val).length : typeof val === 'string' ? new Blob([val]).size : 0;
  };

  var sleep = function sleep(ms) {
    return new Promise(function (resolve) {
      return setTimeout(resolve, ms);
    });
  };

  var smoothScroll = function smoothScroll(element) {
    return document.querySelector(element).scrollIntoView({
      behavior: 'smooth'
    });
  };

  var sortCharactersInString = function sortCharactersInString(str) {
    return _toConsumableArray(str).sort(function (a, b) {
      return a.localeCompare(b);
    }).join('');
  };

  var sortedIndex = function sortedIndex(arr, n) {
    var isDescending = arr[0] > arr[arr.length - 1];
    var index = arr.findIndex(function (el) {
      return isDescending ? n >= el : n <= el;
    });
    return index === -1 ? arr.length : index;
  };

  var sortedIndexBy = function sortedIndexBy(arr, n, fn) {
    var isDescending = fn(arr[0]) > fn(arr[arr.length - 1]);
    var val = fn(n);
    var index = arr.findIndex(function (el) {
      return isDescending ? val >= fn(el) : val <= fn(el);
    });
    return index === -1 ? arr.length : index;
  };

  var sortedLastIndex = function sortedLastIndex(arr, n) {
    var isDescending = arr[0] > arr[arr.length - 1];
    var index = arr.reverse().findIndex(function (el) {
      return isDescending ? n <= el : n >= el;
    });
    return index === -1 ? 0 : arr.length - index;
  };

  var sortedLastIndexBy = function sortedLastIndexBy(arr, n, fn) {
    var isDescending = fn(arr[0]) > fn(arr[arr.length - 1]);
    var val = fn(n);
    var index = arr.map(fn).reverse().findIndex(function (el) {
      return isDescending ? val <= el : val >= el;
    });
    return index === -1 ? 0 : arr.length - index;
  };

  var splitLines = function splitLines(str) {
    return str.split(/\r?\n/);
  };

  var spreadOver = function spreadOver(fn) {
    return function (argsArr) {
      return fn.apply(void 0, _toConsumableArray(argsArr));
    };
  };

  var stableSort = function stableSort(arr, compare) {
    return arr.map(function (item, index) {
      return {
        item: item,
        index: index
      };
    }).sort(function (a, b) {
      return compare(a.item, b.item) || a.index - b.index;
    }).map(function (_ref24) {
      var item = _ref24.item;
      return item;
    });
  };

  var standardDeviation = function standardDeviation(arr) {
    var usePopulation = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
    var mean = arr.reduce(function (acc, val) {
      return acc + val;
    }, 0) / arr.length;
    return Math.sqrt(arr.reduce(function (acc, val) {
      return acc.concat(Math.pow(val - mean, 2));
    }, []).reduce(function (acc, val) {
      return acc + val;
    }, 0) / (arr.length - (usePopulation ? 0 : 1)));
  };

  var stringPermutations = function stringPermutations(str) {
    if (str.length <= 2) return str.length === 2 ? [str, str[1] + str[0]] : [str];
    return str.split('').reduce(function (acc, letter, i) {
      return acc.concat(stringPermutations(str.slice(0, i) + str.slice(i + 1)).map(function (val) {
        return letter + val;
      }));
    }, []);
  };

  var stripHTMLTags = function stripHTMLTags(str) {
    return str.replace(/<[^>]*>/g, '');
  };

  var sum = function sum() {
    for (var _len51 = arguments.length, arr = new Array(_len51), _key51 = 0; _key51 < _len51; _key51++) {
      arr[_key51] = arguments[_key51];
    }

    return arr.concat().reduce(function (acc, val) {
      return acc + val;
    }, 0);
  };

  var sumBy = function sumBy(arr, fn) {
    return arr.map(typeof fn === 'function' ? fn : function (val) {
      return val[fn];
    }).reduce(function (acc, val) {
      return acc + val;
    }, 0);
  };

  var sumPower = function sumPower(end) {
    var power = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 2;
    var start = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
    return Array(end + 1 - start).fill(0).map(function (x, i) {
      return Math.pow(i + start, power);
    }).reduce(function (a, b) {
      return a + b;
    }, 0);
  };

  var symmetricDifference = function symmetricDifference(a, b) {
    var sA = new Set(a),
        sB = new Set(b);
    return _toConsumableArray(a.filter(function (x) {
      return !sB.has(x);
    })).concat(_toConsumableArray(b.filter(function (x) {
      return !sA.has(x);
    })));
  };

  var symmetricDifferenceBy = function symmetricDifferenceBy(a, b, fn) {
    var sA = new Set(a.map(function (v) {
      return fn(v);
    })),
        sB = new Set(b.map(function (v) {
      return fn(v);
    }));
    return _toConsumableArray(a.filter(function (x) {
      return !sB.has(fn(x));
    })).concat(_toConsumableArray(b.filter(function (x) {
      return !sA.has(fn(x));
    })));
  };

  var symmetricDifferenceWith = function symmetricDifferenceWith(arr, val, comp) {
    return _toConsumableArray(arr.filter(function (a) {
      return val.findIndex(function (b) {
        return comp(a, b);
      }) === -1;
    })).concat(_toConsumableArray(val.filter(function (a) {
      return arr.findIndex(function (b) {
        return comp(a, b);
      }) === -1;
    })));
  };

  var tail = function tail(arr) {
    return arr.length > 1 ? arr.slice(1) : arr;
  };

  var take = function take(arr) {
    var n = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
    return arr.slice(0, n);
  };

  var takeRight = function takeRight(arr) {
    var n = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
    return arr.slice(arr.length - n, arr.length);
  };

  var takeRightWhile = function takeRightWhile(arr, func) {
    return arr.reduceRight(function (acc, el) {
      return func(el) ? acc : [el].concat(_toConsumableArray(acc));
    }, []);
  };

  var takeWhile = function takeWhile(arr, func) {
    var _iteratorNormalCompletion2 = true;
    var _didIteratorError2 = false;
    var _iteratorError2 = undefined;

    try {
      for (var _iterator2 = arr.entries()[Symbol.iterator](), _step3; !(_iteratorNormalCompletion2 = (_step3 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
        var _step3$value = _slicedToArray(_step3.value, 2),
            i = _step3$value[0],
            val = _step3$value[1];

        if (func(val)) return arr.slice(0, i);
      }
    } catch (err) {
      _didIteratorError2 = true;
      _iteratorError2 = err;
    } finally {
      try {
        if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
          _iterator2.return();
        }
      } finally {
        if (_didIteratorError2) {
          throw _iteratorError2;
        }
      }
    }

    return arr;
  };

  var throttle = function throttle(fn, wait) {
    var inThrottle, lastFn, lastTime;
    return function () {
      var context = this,
          args = arguments;

      if (!inThrottle) {
        fn.apply(context, args);
        lastTime = Date.now();
        inThrottle = true;
      } else {
        clearTimeout(lastFn);
        lastFn = setTimeout(function () {
          if (Date.now() - lastTime >= wait) {
            fn.apply(context, args);
            lastTime = Date.now();
          }
        }, Math.max(wait - (Date.now() - lastTime), 0));
      }
    };
  };

  var timeTaken = function timeTaken(callback) {
    console.time('timeTaken');
    var r = callback();
    console.timeEnd('timeTaken');
    return r;
  };

  var times = function times(n, fn) {
    var context = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : undefined;
    var i = 0;

    while (fn.call(context, i) !== false && ++i < n) {}
  };

  var toCamelCase = function toCamelCase(str) {
    var s = str && str.match(/[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/g).map(function (x) {
      return x.slice(0, 1).toUpperCase() + x.slice(1).toLowerCase();
    }).join('');
    return s.slice(0, 1).toLowerCase() + s.slice(1);
  };

  var toCurrency = function toCurrency(n, curr) {
    var LanguageFormat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : undefined;
    return Intl.NumberFormat(LanguageFormat, {
      style: 'currency',
      currency: curr
    }).format(n);
  };

  var toDecimalMark = function toDecimalMark(num) {
    return num.toLocaleString('en-US');
  };

  var toHash = function toHash(object, key) {
    return Array.prototype.reduce.call(object, function (acc, data, index) {
      return acc[!key ? index : data[key]] = data, acc;
    }, {});
  };

  var toKebabCase = function toKebabCase(str) {
    return str && str.match(/[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/g).map(function (x) {
      return x.toLowerCase();
    }).join('-');
  };

  var toOrdinalSuffix = function toOrdinalSuffix(num) {
    var int = parseInt(num),
        digits = [int % 10, int % 100],
        ordinals = ['st', 'nd', 'rd', 'th'],
        oPattern = [1, 2, 3, 4],
        tPattern = [11, 12, 13, 14, 15, 16, 17, 18, 19];
    return oPattern.includes(digits[0]) && !tPattern.includes(digits[1]) ? int + ordinals[digits[0] - 1] : int + ordinals[3];
  };

  var toSafeInteger = function toSafeInteger(num) {
    return Math.round(Math.max(Math.min(num, Number.MAX_SAFE_INTEGER), Number.MIN_SAFE_INTEGER));
  };

  var toSnakeCase = function toSnakeCase(str) {
    return str && str.match(/[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/g).map(function (x) {
      return x.toLowerCase();
    }).join('_');
  };

  var toTitleCase = function toTitleCase(str) {
    return str.match(/[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/g).map(function (x) {
      return x.charAt(0).toUpperCase() + x.slice(1);
    }).join(' ');
  };

  var toggleClass = function toggleClass(el, className) {
    return el.classList.toggle(className);
  };

  var tomorrow = function tomorrow() {
    var long = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
    var t = new Date();
    t.setDate(t.getDate() + 1);
    var ret = "".concat(t.getFullYear(), "-").concat(String(t.getMonth() + 1).padStart(2, '0'), "-").concat(String(t.getDate()).padStart(2, '0'));
    return !long ? ret : "".concat(ret, "T00:00:00");
  };

  var transform = function transform(obj, fn, acc) {
    return Object.keys(obj).reduce(function (a, k) {
      return fn(a, obj[k], k, obj);
    }, acc);
  };

  var triggerEvent = function triggerEvent(el, eventType, detail) {
    return el.dispatchEvent(new CustomEvent(eventType, {
      detail: detail
    }));
  };

  var truncateString = function truncateString(str, num) {
    return str.length > num ? str.slice(0, num > 3 ? num - 3 : num) + '...' : str;
  };

  var truthCheckCollection = function truthCheckCollection(collection, pre) {
    return collection.every(function (obj) {
      return obj[pre];
    });
  };

  var unary = function unary(fn) {
    return function (val) {
      return fn(val);
    };
  };

  var uncurry = function uncurry(fn) {
    var n = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
    return function () {
      var next = function next(acc) {
        return function (args) {
          return args.reduce(function (x, y) {
            return x(y);
          }, acc);
        };
      };

      for (var _len52 = arguments.length, args = new Array(_len52), _key52 = 0; _key52 < _len52; _key52++) {
        args[_key52] = arguments[_key52];
      }

      if (n > args.length) throw new RangeError('Arguments too few!');
      return next(fn)(args.slice(0, n));
    };
  };

  var unescapeHTML = function unescapeHTML(str) {
    return str.replace(/&amp;|&lt;|&gt;|&#39;|&quot;/g, function (tag) {
      return {
        '&amp;': '&',
        '&lt;': '<',
        '&gt;': '>',
        '&#39;': "'",
        '&quot;': '"'
      }[tag] || tag;
    });
  };

  var unflattenObject = function unflattenObject(obj) {
    return Object.keys(obj).reduce(function (acc, k) {
      if (k.indexOf('.') !== -1) {
        var keys = k.split('.');
        Object.assign(acc, JSON.parse('{' + keys.map(function (v, i) {
          return i !== keys.length - 1 ? "\"".concat(v, "\":{") : "\"".concat(v, "\":");
        }).join('') + obj[k] + '}'.repeat(keys.length)));
      } else acc[k] = obj[k];

      return acc;
    }, {});
  };

  var unfold = function unfold(fn, seed) {
    var result = [],
        val = [null, seed];

    while (val = fn(val[1])) {
      result.push(val[0]);
    }

    return result;
  };

  var union = function union(a, b) {
    return Array.from(new Set(_toConsumableArray(a).concat(_toConsumableArray(b))));
  };

  var unionBy = function unionBy(a, b, fn) {
    var s = new Set(a.map(fn));
    return Array.from(new Set(_toConsumableArray(a).concat(_toConsumableArray(b.filter(function (x) {
      return !s.has(fn(x));
    })))));
  };

  var unionWith = function unionWith(a, b, comp) {
    return Array.from(new Set(_toConsumableArray(a).concat(_toConsumableArray(b.filter(function (x) {
      return a.findIndex(function (y) {
        return comp(x, y);
      }) === -1;
    })))));
  };

  var uniqueElements = function uniqueElements(arr) {
    return _toConsumableArray(new Set(arr));
  };

  var uniqueElementsBy = function uniqueElementsBy(arr, fn) {
    return arr.reduce(function (acc, v) {
      if (!acc.some(function (x) {
        return fn(v, x);
      })) acc.push(v);
      return acc;
    }, []);
  };

  var uniqueElementsByRight = function uniqueElementsByRight(arr, fn) {
    return arr.reduceRight(function (acc, v) {
      if (!acc.some(function (x) {
        return fn(v, x);
      })) acc.push(v);
      return acc;
    }, []);
  };

  var uniqueSymmetricDifference = function uniqueSymmetricDifference(a, b) {
    return _toConsumableArray(new Set(_toConsumableArray(a.filter(function (v) {
      return !b.includes(v);
    })).concat(_toConsumableArray(b.filter(function (v) {
      return !a.includes(v);
    })))));
  };

  var untildify = function untildify(str) {
    return str.replace(/^~($|\/|\\)/, "".concat(require('os').homedir(), "$1"));
  };

  var unzip = function unzip(arr) {
    return arr.reduce(function (acc, val) {
      return val.forEach(function (v, i) {
        return acc[i].push(v);
      }), acc;
    }, Array.from({
      length: Math.max.apply(Math, _toConsumableArray(arr.map(function (x) {
        return x.length;
      })))
    }).map(function (x) {
      return [];
    }));
  };

  var unzipWith = function unzipWith(arr, fn) {
    return arr.reduce(function (acc, val) {
      return val.forEach(function (v, i) {
        return acc[i].push(v);
      }), acc;
    }, Array.from({
      length: Math.max.apply(Math, _toConsumableArray(arr.map(function (x) {
        return x.length;
      })))
    }).map(function (x) {
      return [];
    })).map(function (val) {
      return fn.apply(void 0, _toConsumableArray(val));
    });
  };

  var validateNumber = function validateNumber(n) {
    return !isNaN(parseFloat(n)) && isFinite(n) && Number(n) == n;
  };

  var when = function when(pred, whenTrue) {
    return function (x) {
      return pred(x) ? whenTrue(x) : x;
    };
  };

  var without = function without(arr) {
    for (var _len53 = arguments.length, args = new Array(_len53 > 1 ? _len53 - 1 : 0), _key53 = 1; _key53 < _len53; _key53++) {
      args[_key53 - 1] = arguments[_key53];
    }

    return arr.filter(function (v) {
      return !args.includes(v);
    });
  };

  var words = function words(str) {
    var pattern = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : /[^a-zA-Z-]+/;
    return str.split(pattern).filter(Boolean);
  };

  var xProd = function xProd(a, b) {
    return a.reduce(function (acc, x) {
      return acc.concat(b.map(function (y) {
        return [x, y];
      }));
    }, []);
  };

  var yesNo = function yesNo(val) {
    var def = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
    return /^(y|yes)$/i.test(val) ? true : /^(n|no)$/i.test(val) ? false : def;
  };

  var zip = function zip() {
    for (var _len54 = arguments.length, arrays = new Array(_len54), _key54 = 0; _key54 < _len54; _key54++) {
      arrays[_key54] = arguments[_key54];
    }

    var maxLength = Math.max.apply(Math, _toConsumableArray(arrays.map(function (x) {
      return x.length;
    })));
    return Array.from({
      length: maxLength
    }).map(function (_, i) {
      return Array.from({
        length: arrays.length
      }, function (_, k) {
        return arrays[k][i];
      });
    });
  };

  var zipObject = function zipObject(props, values) {
    return props.reduce(function (obj, prop, index) {
      return obj[prop] = values[index], obj;
    }, {});
  };

  var zipWith = function zipWith() {
    for (var _len55 = arguments.length, array = new Array(_len55), _key55 = 0; _key55 < _len55; _key55++) {
      array[_key55] = arguments[_key55];
    }

    var fn = typeof array[array.length - 1] === 'function' ? array.pop() : undefined;
    return Array.from({
      length: Math.max.apply(Math, _toConsumableArray(array.map(function (a) {
        return a.length;
      })))
    }, function (_, i) {
      return fn ? fn.apply(void 0, _toConsumableArray(array.map(function (a) {
        return a[i];
      }))) : array.map(function (a) {
        return a[i];
      });
    });
  };

  module.exports = {
    CSVToArray: CSVToArray,
    CSVToJSON: CSVToJSON,
    JSONToFile: JSONToFile,
    JSONtoCSV: JSONtoCSV,
    RGBToHex: RGBToHex,
    URLJoin: URLJoin,
    UUIDGeneratorBrowser: UUIDGeneratorBrowser,
    UUIDGeneratorNode: UUIDGeneratorNode,
    all: all,
    allEqual: allEqual,
    any: any,
    approximatelyEqual: approximatelyEqual,
    arrayToCSV: arrayToCSV,
    arrayToHtmlList: arrayToHtmlList,
    ary: ary,
    atob: atob,
    attempt: attempt,
    average: average,
    averageBy: averageBy,
    bifurcate: bifurcate,
    bifurcateBy: bifurcateBy,
    bind: bind,
    bindAll: bindAll,
    bindKey: bindKey,
    binomialCoefficient: binomialCoefficient,
    bottomVisible: bottomVisible,
    btoa: btoa,
    byteSize: byteSize,
    call: call,
    capitalize: capitalize,
    capitalizeEveryWord: capitalizeEveryWord,
    castArray: castArray,
    chainAsync: chainAsync,
    chunk: chunk,
    clampNumber: clampNumber,
    cloneRegExp: cloneRegExp,
    coalesce: coalesce,
    coalesceFactory: coalesceFactory,
    collectInto: collectInto,
    colorize: colorize,
    compact: compact,
    compose: compose,
    composeRight: composeRight,
    converge: converge,
    copyToClipboard: copyToClipboard,
    countBy: countBy,
    countOccurrences: countOccurrences,
    counter: counter,
    createElement: createElement,
    createEventHub: createEventHub,
    currentURL: currentURL,
    curry: curry,
    dayOfYear: dayOfYear,
    debounce: debounce,
    decapitalize: decapitalize,
    deepClone: deepClone,
    deepFlatten: deepFlatten,
    deepFreeze: deepFreeze,
    defaults: defaults,
    defer: defer,
    degreesToRads: degreesToRads,
    delay: delay,
    detectDeviceType: detectDeviceType,
    difference: difference,
    differenceBy: differenceBy,
    differenceWith: differenceWith,
    dig: dig,
    digitize: digitize,
    distance: distance,
    drop: drop,
    dropRight: dropRight,
    dropRightWhile: dropRightWhile,
    dropWhile: dropWhile,
    elementContains: elementContains,
    elementIsVisibleInViewport: elementIsVisibleInViewport,
    elo: elo,
    equals: equals,
    escapeHTML: escapeHTML,
    escapeRegExp: escapeRegExp,
    everyNth: everyNth,
    extendHex: extendHex,
    factorial: factorial,
    fibonacci: fibonacci,
    filterNonUnique: filterNonUnique,
    filterNonUniqueBy: filterNonUniqueBy,
    findKey: findKey,
    findLast: findLast,
    findLastIndex: findLastIndex,
    findLastKey: findLastKey,
    flatten: flatten,
    flattenObject: flattenObject,
    flip: flip,
    forEachRight: forEachRight,
    forOwn: forOwn,
    forOwnRight: forOwnRight,
    formatDuration: formatDuration,
    fromCamelCase: fromCamelCase,
    functionName: functionName,
    functions: functions,
    gcd: gcd,
    geometricProgression: geometricProgression,
    get: get,
    getColonTimeFromDate: getColonTimeFromDate,
    getDaysDiffBetweenDates: getDaysDiffBetweenDates,
    getImages: getImages,
    getMeridiemSuffixOfInteger: getMeridiemSuffixOfInteger,
    getScrollPosition: getScrollPosition,
    getStyle: getStyle,
    getType: getType,
    getURLParameters: getURLParameters,
    groupBy: groupBy,
    hammingDistance: hammingDistance,
    hasClass: hasClass,
    hasFlags: hasFlags,
    hashBrowser: hashBrowser,
    hashNode: hashNode,
    head: head,
    hexToRGB: hexToRGB,
    hide: hide,
    httpGet: httpGet,
    httpPost: httpPost,
    httpsRedirect: httpsRedirect,
    hz: hz,
    inRange: inRange,
    indentString: indentString,
    indexOfAll: indexOfAll,
    initial: initial,
    initialize2DArray: initialize2DArray,
    initializeArrayWithRange: initializeArrayWithRange,
    initializeArrayWithRangeRight: initializeArrayWithRangeRight,
    initializeArrayWithValues: initializeArrayWithValues,
    initializeNDArray: initializeNDArray,
    insertAfter: insertAfter,
    insertBefore: insertBefore,
    intersection: intersection,
    intersectionBy: intersectionBy,
    intersectionWith: intersectionWith,
    invertKeyValues: invertKeyValues,
    is: is,
    isAbsoluteURL: isAbsoluteURL,
    isAfterDate: isAfterDate,
    isAnagram: isAnagram,
    isArrayLike: isArrayLike,
    isBeforeDate: isBeforeDate,
    isBoolean: isBoolean,
    isBrowser: isBrowser,
    isBrowserTabFocused: isBrowserTabFocused,
    isDivisible: isDivisible,
    isDuplexStream: isDuplexStream,
    isEmpty: isEmpty,
    isEven: isEven,
    isFunction: isFunction,
    isLowerCase: isLowerCase,
    isNil: isNil,
    isNull: isNull,
    isNumber: isNumber,
    isObject: isObject,
    isObjectLike: isObjectLike,
    isPlainObject: isPlainObject,
    isPrime: isPrime,
    isPrimitive: isPrimitive,
    isPromiseLike: isPromiseLike,
    isReadableStream: isReadableStream,
    isSameDate: isSameDate,
    isSorted: isSorted,
    isStream: isStream,
    isString: isString,
    isSymbol: isSymbol,
    isTravisCI: isTravisCI,
    isUndefined: isUndefined,
    isUpperCase: isUpperCase,
    isValidJSON: isValidJSON,
    isWritableStream: isWritableStream,
    join: join,
    last: last,
    lcm: lcm,
    longestItem: longestItem,
    lowercaseKeys: lowercaseKeys,
    luhnCheck: luhnCheck,
    mapKeys: mapKeys,
    mapObject: mapObject,
    mapString: mapString,
    mapValues: mapValues,
    mask: mask,
    matches: matches,
    matchesWith: matchesWith,
    maxBy: maxBy,
    maxDate: maxDate,
    maxN: maxN,
    median: median,
    memoize: memoize,
    merge: merge,
    minBy: minBy,
    minDate: minDate,
    minN: minN,
    mostPerformant: mostPerformant,
    negate: negate,
    nest: nest,
    nodeListToArray: nodeListToArray,
    none: none,
    nthArg: nthArg,
    nthElement: nthElement,
    objectFromPairs: objectFromPairs,
    objectToPairs: objectToPairs,
    observeMutations: observeMutations,
    off: off,
    offset: offset,
    omit: omit,
    omitBy: omitBy,
    on: on,
    onUserInputChange: onUserInputChange,
    once: once,
    orderBy: orderBy,
    over: over,
    overArgs: overArgs,
    pad: pad,
    palindrome: palindrome,
    parseCookie: parseCookie,
    partial: partial,
    partialRight: partialRight,
    partition: partition,
    percentile: percentile,
    permutations: permutations,
    pick: pick,
    pickBy: pickBy,
    pipeAsyncFunctions: pipeAsyncFunctions,
    pipeFunctions: pipeFunctions,
    pluralize: pluralize,
    powerset: powerset,
    prefix: prefix,
    prettyBytes: prettyBytes,
    primes: primes,
    promisify: promisify,
    pull: pull,
    pullAtIndex: pullAtIndex,
    pullAtValue: pullAtValue,
    pullBy: pullBy,
    radsToDegrees: radsToDegrees,
    randomHexColorCode: randomHexColorCode,
    randomIntArrayInRange: randomIntArrayInRange,
    randomIntegerInRange: randomIntegerInRange,
    randomNumberInRange: randomNumberInRange,
    readFileLines: readFileLines,
    rearg: rearg,
    recordAnimationFrames: recordAnimationFrames,
    redirect: redirect,
    reduceSuccessive: reduceSuccessive,
    reduceWhich: reduceWhich,
    reducedFilter: reducedFilter,
    reject: reject,
    remove: remove,
    removeNonASCII: removeNonASCII,
    renameKeys: renameKeys,
    reverseString: reverseString,
    round: round,
    runAsync: runAsync,
    runPromisesInSeries: runPromisesInSeries,
    sample: sample,
    sampleSize: sampleSize,
    scrollToTop: scrollToTop,
    sdbm: sdbm,
    serializeCookie: serializeCookie,
    setStyle: setStyle,
    shallowClone: shallowClone,
    shank: shank,
    show: show,
    shuffle: shuffle,
    similarity: similarity,
    size: size,
    sleep: sleep,
    smoothScroll: smoothScroll,
    sortCharactersInString: sortCharactersInString,
    sortedIndex: sortedIndex,
    sortedIndexBy: sortedIndexBy,
    sortedLastIndex: sortedLastIndex,
    sortedLastIndexBy: sortedLastIndexBy,
    splitLines: splitLines,
    spreadOver: spreadOver,
    stableSort: stableSort,
    standardDeviation: standardDeviation,
    stringPermutations: stringPermutations,
    stripHTMLTags: stripHTMLTags,
    sum: sum,
    sumBy: sumBy,
    sumPower: sumPower,
    symmetricDifference: symmetricDifference,
    symmetricDifferenceBy: symmetricDifferenceBy,
    symmetricDifferenceWith: symmetricDifferenceWith,
    tail: tail,
    take: take,
    takeRight: takeRight,
    takeRightWhile: takeRightWhile,
    takeWhile: takeWhile,
    throttle: throttle,
    timeTaken: timeTaken,
    times: times,
    toCamelCase: toCamelCase,
    toCurrency: toCurrency,
    toDecimalMark: toDecimalMark,
    toHash: toHash,
    toKebabCase: toKebabCase,
    toOrdinalSuffix: toOrdinalSuffix,
    toSafeInteger: toSafeInteger,
    toSnakeCase: toSnakeCase,
    toTitleCase: toTitleCase,
    toggleClass: toggleClass,
    tomorrow: tomorrow,
    transform: transform,
    triggerEvent: triggerEvent,
    truncateString: truncateString,
    truthCheckCollection: truthCheckCollection,
    unary: unary,
    uncurry: uncurry,
    unescapeHTML: unescapeHTML,
    unflattenObject: unflattenObject,
    unfold: unfold,
    union: union,
    unionBy: unionBy,
    unionWith: unionWith,
    uniqueElements: uniqueElements,
    uniqueElementsBy: uniqueElementsBy,
    uniqueElementsByRight: uniqueElementsByRight,
    uniqueSymmetricDifference: uniqueSymmetricDifference,
    untildify: untildify,
    unzip: unzip,
    unzipWith: unzipWith,
    validateNumber: validateNumber,
    when: when,
    without: without,
    words: words,
    xProd: xProd,
    yesNo: yesNo,
    zip: zip,
    zipObject: zipObject,
    zipWith: zipWith
  };

})));
