@startlibs/utils 1.0.3 → 1.1.0

package/lib/index.cjs

@@ -0,0 +1,1811 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _awaitAsyncGenerator = require('@babel/runtime/helpers/awaitAsyncGenerator');
+var _wrapAsyncGenerator = require('@babel/runtime/helpers/wrapAsyncGenerator');
+var _times = require('lodash/fp/times');
+var _identity = require('lodash/fp/identity');
+var React = require('react');
+var _slicedToArray = require('@babel/runtime/helpers/slicedToArray');
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var _isPlainObject = require('lodash/fp/isPlainObject');
+var _fromPairs = require('lodash/fp/fromPairs');
+var _isFinite = require('lodash/fp/isFinite');
+var _taggedTemplateLiteral = require('@babel/runtime/helpers/taggedTemplateLiteral');
+var _objectWithoutProperties = require('@babel/runtime/helpers/objectWithoutProperties');
+var _find = require('lodash/fp/find');
+var _reverse = require('lodash/fp/reverse');
+var _isEqual = require('lodash/fp/isEqual');
+var _isFunction = require('lodash/fp/isFunction');
+var _get = require('lodash/fp/get');
+var _unset = require('lodash/fp/unset');
+var polished = require('polished');
+var styled = require('styled-components');
+var createEmotion = require('create-emotion');
+var _flow = require('lodash/fp/flow');
+var _without = require('lodash/fp/without');
+var _flatMap = require('lodash/fp/flatMap');
+var _mapValues = require('lodash/fp/mapValues');
+var _map = require('lodash/fp/map');
+var _filter = require('lodash/fp/filter');
+var _each = require('lodash/fp/each');
+var _concat = require('lodash/fp/concat');
+var _assign = require('lodash/fp/assign');
+var _2 = require('lodash/fp/__');
+var _set = require('lodash/fp/set');
+var _update = require('lodash/fp/update');
+var _toPath = require('lodash/fp/toPath');
+var _pullAt = require('lodash/fp/pullAt');
+var _curry = require('lodash/fp/curry');
+var _last = require('lodash/fp/last');
+var _isString = require('lodash/fp/isString');
+var _isNumber = require('lodash/fp/isNumber');
+var _padCharsEnd = require('lodash/fp/padCharsEnd');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
+
+var _awaitAsyncGenerator__default = /*#__PURE__*/_interopDefault(_awaitAsyncGenerator);
+var _wrapAsyncGenerator__default = /*#__PURE__*/_interopDefault(_wrapAsyncGenerator);
+var _times__default = /*#__PURE__*/_interopDefault(_times);
+var _identity__default = /*#__PURE__*/_interopDefault(_identity);
+var React__default = /*#__PURE__*/_interopDefault(React);
+var _slicedToArray__default = /*#__PURE__*/_interopDefault(_slicedToArray);
+var _defineProperty__default = /*#__PURE__*/_interopDefault(_defineProperty);
+var _isPlainObject__default = /*#__PURE__*/_interopDefault(_isPlainObject);
+var _fromPairs__default = /*#__PURE__*/_interopDefault(_fromPairs);
+var _isFinite__default = /*#__PURE__*/_interopDefault(_isFinite);
+var _taggedTemplateLiteral__default = /*#__PURE__*/_interopDefault(_taggedTemplateLiteral);
+var _objectWithoutProperties__default = /*#__PURE__*/_interopDefault(_objectWithoutProperties);
+var _find__default = /*#__PURE__*/_interopDefault(_find);
+var _reverse__default = /*#__PURE__*/_interopDefault(_reverse);
+var _isEqual__default = /*#__PURE__*/_interopDefault(_isEqual);
+var _isFunction__default = /*#__PURE__*/_interopDefault(_isFunction);
+var _get__default = /*#__PURE__*/_interopDefault(_get);
+var _unset__default = /*#__PURE__*/_interopDefault(_unset);
+var styled__default = /*#__PURE__*/_interopDefault(styled);
+var createEmotion__default = /*#__PURE__*/_interopDefault(createEmotion);
+var _flow__default = /*#__PURE__*/_interopDefault(_flow);
+var _without__default = /*#__PURE__*/_interopDefault(_without);
+var _flatMap__default = /*#__PURE__*/_interopDefault(_flatMap);
+var _mapValues__default = /*#__PURE__*/_interopDefault(_mapValues);
+var _map__default = /*#__PURE__*/_interopDefault(_map);
+var _filter__default = /*#__PURE__*/_interopDefault(_filter);
+var _each__default = /*#__PURE__*/_interopDefault(_each);
+var _concat__default = /*#__PURE__*/_interopDefault(_concat);
+var _assign__default = /*#__PURE__*/_interopDefault(_assign);
+var _2__default = /*#__PURE__*/_interopDefault(_2);
+var _set__default = /*#__PURE__*/_interopDefault(_set);
+var _update__default = /*#__PURE__*/_interopDefault(_update);
+var _toPath__default = /*#__PURE__*/_interopDefault(_toPath);
+var _pullAt__default = /*#__PURE__*/_interopDefault(_pullAt);
+var _curry__default = /*#__PURE__*/_interopDefault(_curry);
+var _last__default = /*#__PURE__*/_interopDefault(_last);
+var _isString__default = /*#__PURE__*/_interopDefault(_isString);
+var _isNumber__default = /*#__PURE__*/_interopDefault(_isNumber);
+var _padCharsEnd__default = /*#__PURE__*/_interopDefault(_padCharsEnd);
+
+const createPromiseResolverPair = () => {
+  let res, rej;
+  const promise = new Promise((res2, rej2) => {
+    res = res2;
+    rej = rej2;
+  });
+  return [promise, [res, rej]];
+};
+const createSimplePromiseLock = () => {
+  let promiseQueue = Promise.resolve();
+  return () => {
+    let resolve = _identity__default["default"];
+    const nextPromise = new Promise(res => {
+      resolve = res;
+    });
+    const prevPromise = promiseQueue;
+    promiseQueue = nextPromise;
+    return prevPromise.then(() => resolve);
+  };
+};
+function createSinglePromiseQueue() {
+  return _createSinglePromiseQueue.apply(this, arguments);
+}
+function _createSinglePromiseQueue() {
+  _createSinglePromiseQueue = _wrapAsyncGenerator__default["default"](function* () {
+    let lastPromise = Promise.resolve();
+    /* eslint-disable no-await-in-loop */
+    while (true) {
+      yield _awaitAsyncGenerator__default["default"](lastPromise);
+      let resolve = _identity__default["default"];
+      lastPromise = new Promise(res => {
+        resolve = res;
+      });
+      yield resolve;
+    }
+  });
+  return _createSinglePromiseQueue.apply(this, arguments);
+}
+function createPromiseQueue() {
+  return _createPromiseQueue.apply(this, arguments);
+}
+function _createPromiseQueue() {
+  _createPromiseQueue = _wrapAsyncGenerator__default["default"](function () {
+    let parallel = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
+    return function* () {
+      const queues = _times__default["default"](createSinglePromiseQueue, parallel);
+      const promises = queues.map(q => q.next());
+      const locks = yield _awaitAsyncGenerator__default["default"](Promise.all(promises));
+      const getNextAvailableLock = async () => {
+        const index = locks.findIndex(Boolean);
+        if (index >= 0) {
+          const lock = locks[index];
+          locks[index] = null;
+          promises[index] = queues[index].next().then(result => {
+            locks[index] = result;
+          });
+          return [lock.value, locks.filter(Boolean).length];
+        }
+        await Promise.race(promises);
+        return getNextAvailableLock();
+      };
+      while (true) {
+        const lock = yield _awaitAsyncGenerator__default["default"](getNextAvailableLock());
+        yield lock;
+      }
+    }();
+  });
+  return _createPromiseQueue.apply(this, arguments);
+}
+const promiseMapReduce = (arr, callback) => arr.reduce((acc, item) => acc.then(seq => callback(item).then(res => [...seq, res])), Promise.resolve([]));
+const asyncDebounce = function (fn) {
+  let delay = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 200;
+  let timeout;
+  return function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    clearTimeout(timeout);
+    return new Promise(res => {
+      timeout = setTimeout(() => res(fn(...args)), delay);
+    });
+  };
+};
+
+const getClosestOffsetScroll = node => {
+  if (!node) {
+    return document.body;
+  }
+  const overflowY = window.getComputedStyle(node).overflowY;
+  const isScrollable = overflowY !== 'visible' && overflowY !== 'hidden';
+  if (isScrollable && node.scrollHeight > node.clientHeight) {
+    return node;
+  } else {
+    return getClosestOffsetScroll(node.offsetParent);
+  }
+};
+
+// Get the top position of an element in the document
+const getTop = function (element, start) {
+  // return value of html.getBoundingClientRect().top ... IE : 0, other browsers : -pageYOffset
+  if (!element || element.nodeName === 'HTML') return -start;
+  return element.getBoundingClientRect().top + start;
+};
+// ease in out function thanks to:
+// http://blog.greweb.fr/2012/02/bezier-curve-based-easing-functions-from-concept-to-implementation/
+const easeInOutCubic = function (t) {
+  return t < .5 ? 4 * t * t * t : (t - 1) * (2 * t - 2) * (2 * t - 2) + 1;
+};
+
+// calculate the scroll position we should be in
+// given the start and end point of the scroll
+// the time elapsed from the beginning of the scroll
+// and the total duration of the scroll (default 500ms)
+const position = function (start, end, elapsed, duration) {
+  if (elapsed > duration) return end;
+  return start + (end - start) * easeInOutCubic(elapsed / duration); // <-- you can change the easing funtion there
+  // return start + (end - start) * (elapsed / duration); // <-- this would give a linear scroll
+};
+
+// we use requestAnimationFrame to be called by the browser before every repaint
+// if the first argument is an element then scroll to the top of this element
+// if the first argument is numeric then scroll to this location
+// if the callback exist, it is called when the scrolling is finished
+// if context is set then scroll that element, else scroll window
+const smoothScroll = function (el) {
+  let duration = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 500;
+  let callback = arguments.length > 2 ? arguments[2] : undefined;
+  let ctx = arguments.length > 3 ? arguments[3] : undefined;
+  const context = ctx || window;
+  const start = context.scrollTop || window.pageYOffset;
+  const offset = el instanceof HTMLElement ? 0 : el.offset || 0;
+  const end = offset + (typeof el === 'number' ? Math.round(el) : el instanceof HTMLElement ? getTop(el, start) : getTop(el.target, start));
+  const clock = Date.now();
+  const requestAnimationFrame = window.requestAnimationFrame || window.mozRequestAnimationFrame || window.webkitRequestAnimationFrame || function (fn) {
+    window.setTimeout(fn, 15);
+  };
+  const step = () => {
+    const elapsed = Date.now() - clock;
+    if (context !== window) {
+      context.scrollTop = position(start, end, elapsed, duration);
+    } else {
+      window.scroll(window.pageXOffset, position(start, end, elapsed, duration));
+    }
+    if (elapsed > duration) {
+      if (typeof callback === 'function') {
+        callback(el);
+      }
+    } else {
+      requestAnimationFrame(step);
+    }
+  };
+  step();
+};
+
+let fixed = false;
+const scrollWidth = function () {
+  if (!window.document) return 0;
+  const html = document.documentElement;
+  const oldOverflow = html.style.overflowY;
+  html.style.overflowY = 'scroll';
+  const width = window.innerWidth - html.clientWidth;
+  html.style.overflowY = oldOverflow;
+  return width;
+}();
+const fixMediaQueryFn = function () {
+  const fontSize = parseFloat(window.getComputedStyle(document.body).getPropertyValue('font-size'));
+  if (scrollWidth > 0) {
+    [].slice.call(document.styleSheets).filter(styleSheet => isValidExternal(styleSheet) || isInline(styleSheet)).forEach(stylesheet => {
+      try {
+        [].slice.call(stylesheet.cssRules || stylesheet.media).filter(rule => rule.constructor === window.CSSMediaRule).forEach(rule => {
+          rule.media.mediaText = rule.media.mediaText.replace(/m(in|ax)-width:\s*(\d|\.)+(px|em)/gi, function (strA) {
+            if (strA.match('px')) {
+              return strA.replace(/\d+px/gi, function (strB) {
+                return parseInt(strB, 10) + scrollWidth + 'px';
+              });
+            } else {
+              return strA.replace(/\d.+?em/gi, function (strB) {
+                return (parseFloat(strB) * fontSize + scrollWidth) / fontSize + 'em';
+              });
+            }
+          });
+        });
+      } catch (e) {}
+    });
+  }
+  fixed = true;
+  function sameOrigin(url) {
+    const loc = window.location,
+      a = document.createElement('a');
+    a.href = url;
+    return a.hostname === loc.hostname && a.protocol === loc.protocol;
+  }
+  function isInline(stylesheet) {
+    try {
+      return stylesheet.ownerNode.constructor === HTMLStyleElement && stylesheet.ownerNode.getAttribute("data-styled") === null;
+    } catch (e) {
+      return stylesheet.ownerNode.constructor === HTMLStyleElement;
+    }
+  }
+  function isValidExternal(stylesheet) {
+    var _stylesheet$ownerNode;
+    return stylesheet.href && (sameOrigin(stylesheet.href) || ((_stylesheet$ownerNode = stylesheet.ownerNode) === null || _stylesheet$ownerNode === void 0 ? void 0 : _stylesheet$ownerNode.crossOrigin) === "anonymous");
+  }
+};
+function fixMediaQuery() {
+  if (fixed || !document || !document.readyState) return;
+  if (process.env.NODE_ENV === 'test') {
+    return;
+  }
+  if (document.readyState !== 'loading') {
+    fixMediaQueryFn();
+  } else {
+    document.addEventListener('DOMContentLoaded', fixMediaQueryFn);
+  }
+}
+
+const formatPath = function () {
+  for (var _len = arguments.length, paths = new Array(_len), _key = 0; _key < _len; _key++) {
+    paths[_key] = arguments[_key];
+  }
+  return paths.map(path => Array.isArray(path) ? path.join('.') : path ? path.toString().replace(/\[/g, '.').replace(/^\./, '').replace(/]/g, '') : '').filter(_ => _).join('.');
+};
+const identityFn = function () {
+  let n = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+  return function () {
+    for (var _len2 = arguments.length, e = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      e[_key2] = arguments[_key2];
+    }
+    return e[n];
+  };
+};
+const will = function (fn) {
+  for (var _len3 = arguments.length, props = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
+    props[_key3 - 1] = arguments[_key3];
+  }
+  return function () {
+    for (var _len4 = arguments.length, more = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+      more[_key4] = arguments[_key4];
+    }
+    return fn(...props, ...more);
+  };
+};
+const lazyValue = v => () => v;
+const callIfFunction = function (prop) {
+  for (var _len5 = arguments.length, args = new Array(_len5 > 1 ? _len5 - 1 : 0), _key5 = 1; _key5 < _len5; _key5++) {
+    args[_key5 - 1] = arguments[_key5];
+  }
+  return typeof prop === "function" ? prop(...args) : prop;
+};
+const callIfFunctions = function (prop) {
+  for (var _len6 = arguments.length, args = new Array(_len6 > 1 ? _len6 - 1 : 0), _key6 = 1; _key6 < _len6; _key6++) {
+    args[_key6 - 1] = arguments[_key6];
+  }
+  return typeof prop === "function" ? prop(...args.map(e => callIfFunction(e))) : prop;
+};
+const callMany = function () {
+  for (var _len7 = arguments.length, many = new Array(_len7), _key7 = 0; _key7 < _len7; _key7++) {
+    many[_key7] = arguments[_key7];
+  }
+  return function () {
+    for (var _len8 = arguments.length, args = new Array(_len8), _key8 = 0; _key8 < _len8; _key8++) {
+      args[_key8] = arguments[_key8];
+    }
+    return many.map(_ => callIfFunction(_, ...args));
+  };
+};
+const ifUndefined = function (v) {
+  for (var _len9 = arguments.length, or = new Array(_len9 > 1 ? _len9 - 1 : 0), _key9 = 1; _key9 < _len9; _key9++) {
+    or[_key9 - 1] = arguments[_key9];
+  }
+  return v !== undefined ? v : or.length === 1 ? or[0] : ifUndefined(or[0], ...or.slice(1));
+};
+const using = function () {
+  for (var _len0 = arguments.length, v = new Array(_len0), _key0 = 0; _key0 < _len0; _key0++) {
+    v[_key0] = arguments[_key0];
+  }
+  return fn => fn(...v.map(v => callIfFunction(v)));
+};
+const stopPropagation = cb => e => {
+  e && e.stopPropagation && e.stopPropagation();
+  callIfFunction(cb, e);
+};
+const preventDefault = cb => e => {
+  e && e.preventDefault && e.preventDefault();
+  callIfFunction(cb, e);
+};
+const constrainEvent = cb => e => {
+  e === null || e === void 0 || e.preventDefault();
+  e.stopPropagation();
+  callIfFunction(cb, e);
+};
+const mapGetOrSet = (map, key, value) => (map.has(key) ? map : map.set(key, value)).get(key);
+const intToHour = function (hour) {
+  let autoFill = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+  if (hour === undefined || hour === null) return '';
+  if (hour === 0) {
+    return "00:00";
+  }
+
+  //const [h,m] = ('000' + hour.toString().replace(":","")).slice(-4).replace(/(\d\d)(\d\d)/, '$1:$2').split(":")
+
+  const h = hour.toString().replace(":", "").slice(-4, -2);
+  const m = hour.toString().replace(":", "").slice(-2);
+  if (callIfFunction(autoFill, hour)) {
+    return ('000' + (h ? parseInt(h, 10) % 24 : '') + m).slice(-4).replace(/(\d\d)(\d\d)/, '$1:$2');
+  }
+  if (h) return (parseInt(h, 10) > 23 ? h.slice(1) : h) + ':' + m;
+  return m;
+};
+const formatHour = function () {
+  let hour = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "";
+  if (!hour) {
+    return "";
+  }
+  const h = hour.toString().replace(":", "").slice(-4, -2);
+  const m = hour.toString().replace(":", "").slice(-2);
+  if (!h && parseInt(m) < 24 && !_isFinite__default["default"](hour)) {
+    return m + ":00";
+  } else if (h) {
+    return (parseInt(h, 10) > 23 ? h.slice(1) : h) + ':' + m;
+  }
+  return ('000' + hour.toString().replace(":", "")).slice(-4).replace(/(\d\d)(\d\d)/, '$1:$2');
+};
+const willRafThrottle = () => {
+  let ticking = false;
+  return fn => {
+    if (!ticking) {
+      window.requestAnimationFrame(() => {
+        fn();
+        ticking = false;
+      });
+      ticking = true;
+    }
+  };
+};
+const rafThrottle = fn => {
+  const throttle = willRafThrottle();
+  return () => {
+    throttle(fn);
+  };
+};
+const intsToHour = _ref => {
+  let open = _ref.open,
+    close = _ref.close;
+  return intToHour(open) + ' - ' + intToHour(close);
+};
+function isSmallDevice() {
+  let width = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 600;
+  const smallDeviceQuery = window.matchMedia ? window.matchMedia("(max-width: ".concat(width + scrollWidth, "px)")) : {
+    matches: false
+  };
+  return smallDeviceQuery.matches;
+}
+function isHighDensity() {
+  return window.matchMedia && (window.matchMedia('only screen and (min-resolution: 124dpi), only screen and (min-resolution: 1.3dppx), only screen and (min-resolution: 48.8dpcm)').matches || window.matchMedia('only screen and (-webkit-min-device-pixel-ratio: 1.3), only screen and (-o-min-device-pixel-ratio: 2.6/2), only screen and (min--moz-device-pixel-ratio: 1.3), only screen and (min-device-pixel-ratio: 1.3)').matches) || window.devicePixelRatio && window.devicePixelRatio > 1.3;
+}
+function isRetina() {
+  return (window.matchMedia && (window.matchMedia('only screen and (min-resolution: 192dpi), only screen and (min-resolution: 2dppx), only screen and (min-resolution: 75.6dpcm)').matches || window.matchMedia('only screen and (-webkit-min-device-pixel-ratio: 2), only screen and (-o-min-device-pixel-ratio: 2/1), only screen and (min--moz-device-pixel-ratio: 2), only screen and (min-device-pixel-ratio: 2)').matches) || window.devicePixelRatio && window.devicePixelRatio >= 2) && /(iPad|iPhone|iPod)/g.test(navigator.userAgent);
+}
+function isMobile() {
+  if (typeof navigator === 'undefined') return false;
+  const ua = navigator.userAgent;
+  const isAndroid = /android/i.test(ua);
+  const isiOS = /iphone|ipod|ipad/i.test(ua);
+
+  // iPadOS 13+ reports "Macintosh" but has touch
+  const isIPadOS = navigator.platform === 'MacIntel' && navigator.maxTouchPoints > 1;
+  return isAndroid || isiOS || isIPadOS;
+}
+function isAndroid() {
+  if (navigator.userAgentData) {
+    return navigator.userAgentData.platform === "Android";
+  }
+  return /Android/i.test(navigator.userAgent);
+}
+const isPWA = () => {
+  return window.matchMedia && window.matchMedia("(display-mode: standalone)").matches || !!window.hasWebviewBridge;
+};
+function isTouchDevice() {
+  return window.document && 'ontouchstart' in window.document.documentElement;
+}
+const isIOS = () => {
+  return /iPad|iPhone|iPod/.test(navigator.platform) || navigator.platform === 'MacIntel' && navigator.maxTouchPoints > 1;
+};
+const isIPad = () => {
+  return navigator.userAgent.match(/iPad/i) != null;
+};
+const getNumberInputType2 = () => {
+  const isIOS = /iPad|iPhone|iPod/.test(navigator.platform) || navigator.platform === 'MacIntel' && navigator.maxTouchPoints > 1;
+  return isMobile() ? isIOS ? "tel" : "number" : "text";
+};
+const getNumberInputType = () => {
+  return "tel";
+};
+function addHttp(s, secure) {
+  s = (s || '').trim();
+  if (s.indexOf('http://') === 0 || s.indexOf('https://') === 0) {
+    return s;
+  } else {
+    return "http".concat(secure ? 's' : '', "://") + s;
+  }
+}
+const protocols = '(^|\\s|\u00a0)(https?://)?(www\\.)?';
+const subdomains = '([a-zA-Z0-9][a-zA-Z0-9-_]*[a-zA-Z0-9]?\\.)*';
+const domain = '(([a-zA-Z]{1})|([a-zA-Z]{1}[a-zA-Z]{1})|([a-zA-Z]{1}[0-9]{1})|([0-9]{1}[a-zA-Z]{1})|([a-zA-Z0-9][a-zA-Z0-9-_]{1,61}[a-zA-Z0-9]))\\.([a-zA-Z]{2,6}|[a-zA-Z0-9-]{2,30}\\.[a-zA-Z]{2,3})';
+const resource = '[\u00A1-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEFa-zA-Z0-9-._~:/?#%[\\]@!$&\'()*+,;=]*';
+const linkRegex = new RegExp(protocols + subdomains + domain + resource);
+function isUrl(url) {
+  return linkRegex.test(addHttp(url));
+}
+function ellipsis() {
+  let str = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "";
+  let length = arguments.length > 1 ? arguments[1] : undefined;
+  if (str.length > length) {
+    let words = str.slice(0, length).split(' ');
+    if (str.split(' ').indexOf(words[words.length - 1]) < 0) words = words.slice(0, words.length - 1);
+    return words.join(' ') + '...';
+  } else return str;
+}
+function safeNewLineToBr(str, keepMany) {
+  const result = (str || "").replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+  if (keepMany === true) {
+    return result.replace(/\n/g, '<br/>');
+  }
+  return result.replace(/\n+/g, '<br/>');
+}
+function padGroups(pattern, value) {
+  return pattern.split('').reduce((_ref2, char, i) => {
+    let _ref3 = _slicedToArray__default["default"](_ref2, 2),
+      acc = _ref3[0],
+      value = _ref3[1];
+    if (char === '0') {
+      const shouldHave = pattern.slice(i).search(/[^0#?*]/);
+      const has = value.slice(i).search(/\D/);
+      if (has > 0 && shouldHave > has) {
+        return [acc.concat('0'), acc.join('') + '0' + value.slice(i)];
+      } else {
+        return [acc.concat(value[i]), value];
+      }
+    } else {
+      return [acc.concat(value[i]), value];
+    }
+  }, [[], value])[0].join('');
+}
+const digitsToPattern = (patternWithLimit, optValue) => {
+  const value = optValue || "";
+  if (patternWithLimit[0] === '>' && Number(patternWithLimit.replace(/^>(\d*).*/g, "$1")) > value.length) return value;
+  const pattern = patternWithLimit.replace(/^>\d+/, '');
+  const digits = padGroups(pattern, value).replace(/\D/g, '');
+  const totalRequired = pattern.split(/[0#]/).length - 1;
+  const totalOptional = pattern.split(/[?*]/).length - 1;
+  const available = digits.length - totalRequired;
+  if (available > 0 && totalOptional > 0) {
+    let i = 0;
+    return digitsToPattern(pattern.replace(/\?/g, () => i++ < available ? '#' : '').replace('*', new Array(Math.max(0, available - i + 1)).join("#")), value);
+  }
+  let i = 0;
+  return pattern.replace(/^>\d*/, '').split('').reduce((acc, char) => {
+    if (!digits[Math.max(i - 1, 0)] || char === '?' || char === '*') return acc;
+    if (char === '#' || char === '0') {
+      return acc + (digits[i++] || '');
+    } else {
+      return acc + char;
+    }
+  }, '');
+};
+const normalizeTouch = (fn, endFn) => e => {
+  const touch = e.touches[0];
+  if (e.touches.length > 1 && e.type !== 'touchend') {
+    callIfFunction(endFn, e, touch);
+  } else {
+    callIfFunction(fn, e, touch);
+  }
+};
+const normalizeMouse = (fn, endFn) => e => {
+  if (e.buttons > 1 && e.type !== 'mouseup') {
+    callIfFunction(endFn, e, e);
+  } else {
+    callIfFunction(fn, e, e);
+  }
+};
+const normalizePress = (fn, endFn) => e => {
+  if (e.touches) {
+    normalizeTouch(fn, endFn)(e);
+  } else {
+    normalizeMouse(fn, endFn)(e);
+  }
+};
+const touchClick = function (cb) {
+  let sensibility = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 5;
+  return e => {
+    var _e$touches;
+    if (((_e$touches = e.touches) === null || _e$touches === void 0 ? void 0 : _e$touches.length) !== 1) {
+      return;
+    }
+    const target = e.target;
+    const originalX = e.touches[0].screenX;
+    const originalY = e.touches[0].screenY;
+    const isInsideBounds = touch => Math.sqrt(Math.pow(originalX - touch.screenX, 2) + Math.pow(originalY - touch.screenY, 2)) < sensibility;
+    const checkBounds = e => {
+      if (e.touches.length !== 1) {
+        return;
+      }
+      if (!isInsideBounds(e.changedTouches[0])) {
+        maybeClick();
+      }
+    };
+    const maybeClick = e => {
+      var _e$changedTouches;
+      target.removeEventListener('touchend', maybeClick);
+      target.removeEventListener('touchmove', checkBounds);
+      if ((e === null || e === void 0 || (_e$changedTouches = e.changedTouches) === null || _e$changedTouches === void 0 ? void 0 : _e$changedTouches.length) !== 1) {
+        return;
+      }
+      if (isInsideBounds(e.changedTouches[0])) {
+        e.preventDefault();
+        cb(e);
+      }
+    };
+    target.addEventListener('touchend', maybeClick);
+    target.addEventListener('touchmove', checkBounds);
+  };
+};
+const isEmptyHtml = function () {
+  let __html = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "";
+  const a = document.createElement('span');
+  a.innerHTML = __html;
+  return a.textContent.replace(/\s/g, '').length === 0;
+};
+const getScrollParent = node => {
+  if (!node) {
+    return window;
+  }
+  const overflowY = window.getComputedStyle(node).overflowY;
+  const isScrollable = overflowY !== 'visible' && overflowY !== 'hidden';
+  if (isScrollable && (node.scrollHeight > node.clientHeight || overflowY === 'scroll')) {
+    return node;
+  } else {
+    return getScrollParent(node.offsetParent);
+  }
+};
+const scrollIntoViewWithOffset = (el, offset) => {
+  const scrollOffset = getScrollParent(el);
+  const scrollY = scrollOffset === window ? window.pageYOffset : scrollOffset.scrollTop;
+  const elTop = el.getBoundingClientRect().top;
+  const computedOffset = callIfFunction(offset, elTop > 0);
+  const y = el.getBoundingClientRect().top + scrollY + computedOffset;
+  scrollOffset.scrollTo({
+    top: y,
+    behavior: 'smooth'
+  });
+};
+const isElementInView = async element => {
+  if (!element) return false;
+  if (1 !== element.nodeType) return false;
+  var html = document.documentElement;
+  var rect = element.getBoundingClientRect();
+  if (IntersectionObserver) {
+    return new Promise(resolve => {
+      const o = new IntersectionObserver(_ref4 => {
+        let _ref5 = _slicedToArray__default["default"](_ref4, 1),
+          entry = _ref5[0];
+        resolve(entry.intersectionRatio === 1);
+        o.disconnect();
+      });
+      o.observe(element);
+    });
+  }
+  return !!rect && rect.bottom >= 0 && rect.right >= 0 && rect.left <= html.clientWidth && rect.top <= html.clientHeight;
+};
+let i = 0;
+const getUID = () => Date.now().toString(36) + Math.random().toString(36).slice(2) + (i++).toString(36);
+const getUrlParams = () => _fromPairs__default["default"](Array.from(new URLSearchParams(location.search).entries()));
+const isShallowEqualSameKeys = (a, b) => {
+  for (var key in a) {
+    if (a[key] !== b[key]) {
+      return false;
+    }
+  }
+  return true;
+};
+const isShallowEqual = (a, b) => {
+  for (var key in a) {
+    if (!(key in b) || a[key] !== b[key]) {
+      return false;
+    }
+  }
+  for (var key in b) {
+    if (!(key in a) || a[key] !== b[key]) {
+      return false;
+    }
+  }
+  return true;
+};
+
+function ownKeys$3(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread$3(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys$3(Object(t), !0).forEach(function (r) { _defineProperty__default["default"](e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys$3(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+const resolveFetch = async (url, fetchOptions) => {
+  try {
+    const response = await fetch(url, _objectSpread$3({
+      credentials: 'same-origin'
+    }, fetchOptions));
+    const text = await response.text();
+    try {
+      const json = JSON.parse(text);
+      return [json, response];
+    } catch (eror) {
+      return [text, response];
+    }
+  } catch (error) {
+    return [error, false];
+  }
+};
+const innerFetcher = async (url, fetchOptions) => {
+  const _await$resolveFetch = await resolveFetch(url, fetchOptions),
+    _await$resolveFetch2 = _slicedToArray__default["default"](_await$resolveFetch, 2),
+    data = _await$resolveFetch2[0],
+    response = _await$resolveFetch2[1];
+  if (!response || response.status >= 400) {
+    throw [data, response];
+  } else {
+    return [data, response];
+  }
+};
+const queryStringToObj = function () {
+  let str = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : window.location.search;
+  return Object.fromEntries(new URLSearchParams(str).entries());
+};
+const addQueryString = function () {
+  let existingUrl = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  let obj = arguments.length > 1 ? arguments[1] : undefined;
+  const _existingUrl$split = existingUrl.split('?'),
+    _existingUrl$split2 = _slicedToArray__default["default"](_existingUrl$split, 2),
+    onlyUrl = _existingUrl$split2[0],
+    otherQueryString = _existingUrl$split2[1];
+  const params = new URLSearchParams(otherQueryString);
+  for (let key in obj) {
+    const value = obj[key];
+    if (value === null) {
+      params.delete(key);
+    } else {
+      params.set(key, obj[key]);
+    }
+  }
+  const paramsStr = params.toString();
+  if (!paramsStr) {
+    return onlyUrl;
+  }
+  return onlyUrl + '?' + paramsStr;
+};
+const cleanNulls = str => str.replace(/\0/g, '');
+
+// Cross-origin o X-Requested-With só custa: dispara preflight e impede o reuso do
+// <link rel=preload as=fetch>, cujo request vai sem ele. Quem lê o header é servidor nosso.
+const isSameOrigin = url => new URL(url, window.location.href).origin === window.location.origin;
+let postFetcherWithResponse = async function (url, jsonOrForm) {
+  let fetchOptions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  return innerFetcher(url, _objectSpread$3(_objectSpread$3({
+    method: 'POST',
+    body: typeof jsonOrForm === 'string' ? jsonOrForm : !jsonOrForm || jsonOrForm.constructor === window.FormData || jsonOrForm.constructor === window.File ? jsonOrForm : cleanNulls(JSON.stringify(jsonOrForm))
+  }, fetchOptions), {}, {
+    headers: _isPlainObject__default["default"](fetchOptions.headers) || !fetchOptions.headers ? _objectSpread$3(_objectSpread$3(_objectSpread$3({}, jsonOrForm && (typeof jsonOrForm === 'string' || jsonOrForm.constructor === window.FormData) ? {} : {
+      'Content-Type': 'application/json; charset=UTF-8'
+    }), isSameOrigin(url) ? {
+      'X-Requested-With': 'XMLHttpRequest'
+    } : {}), fetchOptions.headers) : fetchOptions.headers
+  }));
+};
+let getFetcherWithResponse = async (url, jsonParams, fetchOptions) => innerFetcher(addQueryString(url, jsonParams), _objectSpread$3(_objectSpread$3({
+  method: 'GET'
+}, fetchOptions), {}, {
+  headers: _objectSpread$3(_objectSpread$3({}, isSameOrigin(url) ? {
+    'X-Requested-With': 'XMLHttpRequest'
+  } : {}), fetchOptions === null || fetchOptions === void 0 ? void 0 : fetchOptions.headers)
+}));
+let postFetcher = async (url, json, options) => postFetcherWithResponse(url, json, options).then(_ref => {
+  let _ref2 = _slicedToArray__default["default"](_ref, 1),
+    json = _ref2[0];
+  return json;
+});
+let getFetcher = async (url, json, options) => getFetcherWithResponse(url, json, options).then(_ref3 => {
+  let _ref4 = _slicedToArray__default["default"](_ref3, 1),
+    json = _ref4[0];
+  return json;
+});
+const formFetchWithResponse = (url, options) => (values, meta) => postFetcherWithResponse(callIfFunction(url, meta, values), values, callIfFunction(options, meta, values));
+const formFetch = (url, options) => (values, meta) => postFetcher(callIfFunction(url, meta, values), values, callIfFunction(options, meta, values));
+
+const moveElement = _curry__default["default"]((from, to, list) => {
+  const el = list[from];
+  const without = _pullAt__default["default"](from, list);
+  without.splice(to, 0, el);
+  return without;
+});
+const unsetOrRemoveAt = _curry__default["default"]((path, value) => {
+  const pathArr = toPath(path);
+  const _pathArr$slice = pathArr.slice(-1),
+    _pathArr$slice2 = _slicedToArray__default["default"](_pathArr$slice, 1),
+    lastKey = _pathArr$slice2[0];
+  return update(pathArr.slice(0, -1), v => Array.isArray(v) ? removeAt(lastKey, v) : unset(lastKey, v), value);
+});
+const pathToString = path => toPath(path).join(".");
+const sanitizePath = path => Array.isArray(path) ? path.map(sanitizePath) : typeof path === 'number' ? path.toString() : path === undefined ? [] : path;
+const toPath = path => _toPath__default["default"](sanitizePath(path));
+const isEmptyPath = path => path && !path.length;
+const update = _curry__default["default"]((path, updater, state) => {
+  const sanitizedPath = sanitizePath(path);
+  if (isEmptyPath(sanitizedPath)) {
+    return updater(state);
+  } else {
+    return _update__default["default"](sanitizedPath, updater, state);
+  }
+});
+const get = _curry__default["default"]((path, state) => {
+  const sanitizedPath = sanitizePath(path);
+  if (isEmptyPath(sanitizedPath)) {
+    return state;
+  } else {
+    return _get__default["default"](sanitizedPath, state);
+  }
+});
+const set = _curry__default["default"]((path, value, state) => {
+  const sanitizedPath = sanitizePath(path);
+  if (isEmptyPath(sanitizedPath)) {
+    return value;
+  } else {
+    return _set__default["default"](sanitizedPath, value, state);
+  }
+});
+const unset = _curry__default["default"]((path, state) => {
+  const sanitizedPath = sanitizePath(path);
+  if (isEmptyPath(sanitizedPath)) {
+    return undefined;
+  } else {
+    return _unset__default["default"](sanitizedPath, state);
+  }
+});
+const removeNAt = _curry__default["default"]((pos, n, value) => [...value.slice(0, Number(pos)), ...value.slice(Number(pos) + n)]);
+const removeAt = removeNAt(_2__default["default"], 1);
+const when = _curry__default["default"]((cond, fn, value) => callIfFunction(cond, value) ? fn(value) : value);
+const assign = _curry__default["default"]((a, b) => _assign__default["default"](b, a));
+const concat = _curry__default["default"]((a, b) => _concat__default["default"](b, a));
+const each = _each__default["default"].convert({
+  cap: false
+});
+const find = _find__default["default"].convert({
+  cap: false
+});
+const filter = _filter__default["default"].convert({
+  cap: false
+});
+const map = _map__default["default"].convert({
+  cap: false
+});
+const mapValues = _mapValues__default["default"].convert({
+  cap: false
+});
+const flatMap = _flatMap__default["default"].convert({
+  cap: false
+});
+const insertAt = _curry__default["default"]((pos, newElements, value) => [...value.slice(0, pos).concat(newElements), ...value.slice(pos)]);
+const select = _curry__default["default"]((selector, value) => (_isFunction__default["default"](selector) ? selector : selector ? _get__default["default"](selector) : _identity__default["default"])(value));
+const itemToggle = _curry__default["default"]((item, list) => (list || []).indexOf(item) >= 0 ? _without__default["default"]([item], list) : [...(list || []), item]);
+const _s = {
+  moveElement,
+  unsetOrRemoveAt,
+  pathToString,
+  toPath,
+  update,
+  get,
+  set,
+  select,
+  unset,
+  removeNAt,
+  removeAt,
+  itemToggle,
+  when,
+  assign,
+  concat,
+  each,
+  find,
+  filter,
+  map,
+  flatMap,
+  mapValues,
+  insertAt,
+  flowEach: function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    return _flow__default["default"](...args.filter(Boolean));
+  }
+};
+
+var _templateObject;
+const _excluded = ["theme"];
+function ownKeys$2(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread$2(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys$2(Object(t), !0).forEach(function (r) { _defineProperty__default["default"](e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys$2(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+const getColor = (propsOrColor, hover) => {
+  if (propsOrColor === undefined) {
+    return _ref => {
+      let theme = _ref.theme;
+      return theme.colors.gray150;
+    };
+  }
+  if (typeof propsOrColor === 'string') {
+    return _ref2 => {
+      let theme = _ref2.theme;
+      return theme.colors[propsOrColor] || propsOrColor;
+    };
+  }
+  const theme = propsOrColor.theme,
+    props = _objectWithoutProperties__default["default"](propsOrColor, _excluded);
+  if (props.dark) {
+    return polished.darken(0.1, getColor(_objectSpread$2({
+      theme
+    }, _unset__default["default"]('dark', props))));
+  } else if (hover && props.hover) {
+    return getColor({
+      theme,
+      color: props.hover
+    });
+  } else if (props.color) {
+    return theme.colors[props.color] || props.color;
+  } else if (props.highlight) {
+    return theme.colors.main;
+  } else if (props.alert) {
+    return theme.colors.alert;
+  } else if (props.success) {
+    return theme.colors.success;
+  } else {
+    return theme.colors.gray150;
+  }
+};
+const getMargin = enumeratedMargins => props => enumeratedMargins[props.margin] || props.margin || enumeratedMargins['default'] || 0;
+
+/**
+ * Returns the value of `props[path]` or `defaultValue`
+ * @example
+ * const Button = styled.button`
+ *  color: ${prop('color', 'red')};
+ * `
+ */
+const prop = (path, defaultValue) => function () {
+  let props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return _get__default["default"](path.trim(), props) || defaultValue;
+};
+const customTheme = type => function () {
+  let props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return _get__default["default"](["theme", "startlibs", type], props) || '';
+};
+
+/**
+ * Returns `pass` if prop is truthy. Otherwise returns `fail`
+ * @example
+ * // usage with styled-theme
+ * import styled from 'styled-components'
+ * import { ifProp } from 'styled-tools'
+ * import { palette } from 'styled-theme'
+ *
+ * const Button = styled.button`
+ *  background-color: ${ifProp('transparent', 'transparent', palette(0))};
+ *  color: ${ifProp(['transparent', 'accent'], palette('secondary', 0))};
+ *  font-size: ${ifProp({ size: 'large' }, '20px', ifProp({ size: 'medium' }, '16px', '12px'))};
+ *`
+ */
+const ifProp = (path, pass, fail) => {
+  if (pass && !_isFunction__default["default"](pass)) {
+    // old version
+    return function () {
+      let props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      let result = false;
+      if (Array.isArray(path)) {
+        result = path.every(p => testSinglePath(props, p));
+      } else if (typeof path === 'object') {
+        result = !Object.entries(path).find(_ref3 => {
+          let _ref4 = _slicedToArray__default["default"](_ref3, 2),
+            k = _ref4[0],
+            v = _ref4[1];
+          return props[k] !== v;
+        });
+      } else {
+        result = testSinglePath(props, path);
+      }
+      return result ? pass : fail;
+    };
+  } else {
+    return function () {
+      for (var _len = arguments.length, argsTrue = new Array(_len), _key = 0; _key < _len; _key++) {
+        argsTrue[_key] = arguments[_key];
+      }
+      const check = pass || _identity__default["default"];
+      const fn = props => check(_get__default["default"](path, props)) ? styled.css(...argsTrue) : '';
+      fn.orElse = function () {
+        for (var _len2 = arguments.length, argsFalse = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+          argsFalse[_key2] = arguments[_key2];
+        }
+        return props => check(_get__default["default"](path, props)) ? styled.css(...argsTrue) : styled.css(...argsFalse);
+      };
+      return fn;
+    };
+  }
+};
+const ifPropEquals = (path, str) => ifProp(path, _isEqual__default["default"](str));
+const ifNotProp = path => ifProp(path, v => !v);
+const checkCustomScreenWidth = (sizeParis, customWidth) => {
+  const currentWidth = callIfFunction(customWidth);
+  return !sizeParis.find(_ref5 => {
+    let _ref6 = _slicedToArray__default["default"](_ref5, 2),
+      size = _ref6[0],
+      type = _ref6[1];
+    if (type === "min-width") {
+      return currentWidth < size;
+    }
+    if (type === "max-width") {
+      return currentWidth > size;
+    }
+  });
+};
+const media = function () {
+  for (var _len3 = arguments.length, sizePairs = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+    sizePairs[_key3] = arguments[_key3];
+  }
+  return function () {
+    for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+      args[_key4] = arguments[_key4];
+    }
+    return styled.css(["", ""], props => {
+      var _props$theme, _props$theme2;
+      return (_props$theme = props.theme) !== null && _props$theme !== void 0 && _props$theme.overrideMediaWidth ? checkCustomScreenWidth(sizePairs, (_props$theme2 = props.theme) === null || _props$theme2 === void 0 ? void 0 : _props$theme2.overrideMediaWidth) ? styled.css(...args) : "" : styled.css(["@media ", "{", "}"], sizePairs.map(_ref7 => {
+        let _ref8 = _slicedToArray__default["default"](_ref7, 2),
+          size = _ref8[0],
+          type = _ref8[1];
+        return "(".concat(type, ": ").concat(size + scrollWidth, "px)");
+      }).join(' and '), styled.css(...args));
+    });
+  };
+};
+media.mobile = media([600, 'max-width']);
+media.between = (min, max) => media([min, 'min-width'], [max, 'max-width']);
+media.max = n => media([n, 'max-width']);
+media.min = n => media([n, 'min-width']);
+media.desktop = media([601, 'min-width']);
+const vheight = (strings, size) => {
+  const propType = strings[0];
+  const calc = (strings[1] || "").replace(";", "").trim();
+  return "\n  ".concat(propType, " ").concat(calc ? "calc(".concat(size, "vh ").concat(calc, ")") : "".concat(size, "vh"), ";\n  ").concat(propType, " ").concat(calc ? "calc(calc(var(--vh, 1vh) * ".concat(size, ") ").concat(calc, ")") : "calc(var(--vh, 1vh) * ".concat(size, ")"), ";\n  ");
+};
+function testSinglePath(props, path) {
+  if (typeof path === 'string') {
+    return !!_s.get(path, props);
+  } else if (typeof path === 'number') {
+    return !!props[path];
+  } else {
+    return false;
+  }
+}
+const getFrameOffset = (i, total) => Math.round(i * 100 / (total - 1));
+const emotion = createEmotion__default["default"]({
+  nonce: typeof document !== 'undefined' && (document.querySelector('meta[property="csp-nonce"]') || {}).content || 'animation_nonce'
+});
+const oneWayAnimation = function () {
+  for (var _len5 = arguments.length, frames = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
+    frames[_key5] = arguments[_key5];
+  }
+  return emotion.keyframes(_templateObject || (_templateObject = _taggedTemplateLiteral__default["default"](["\n  ", ""])), frames.map((frame, i) => !frame ? '' : "".concat(getFrameOffset(i, frames.length), "% {\n      ").concat(frame, "\n    }")));
+};
+const twoWayAnimation = function () {
+  for (var _len6 = arguments.length, frames = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
+    frames[_key6] = arguments[_key6];
+  }
+  return [frames, _reverse__default["default"](frames)].map(frames => oneWayAnimation(...frames));
+};
+const animationTiming = props => function () {
+  for (var _len7 = arguments.length, animations = new Array(_len7), _key7 = 0; _key7 < _len7; _key7++) {
+    animations[_key7] = arguments[_key7];
+  }
+  return animations.filter(_ => _).map(_ => _ + ' ' + props).join(',');
+};
+const identityTranslateFrames = oneWayAnimation('transform: translateY(0);', 'transform: translateY(0);');
+const identityOpacityFrames = oneWayAnimation('opacity: 1;', 'opacity:1;');
+const styledExtend = _ref9 => {
+  let target = _ref9.target,
+    componentStyle = _ref9.componentStyle;
+  return function () {
+    const wasStatic = !_find__default["default"](_isFunction__default["default"], componentStyle.rules);
+    for (var _len8 = arguments.length, template = new Array(_len8), _key8 = 0; _key8 < _len8; _key8++) {
+      template[_key8] = arguments[_key8];
+    }
+    const v = /*#__PURE__*/styled__default["default"](target)(...template, ...(wasStatic ? [] : [() => ""]));
+    v.componentStyle.rules = [...componentStyle.rules, ...v.componentStyle.rules];
+    return v;
+  };
+};
+const printerMedia = function () {
+  for (var _len9 = arguments.length, args = new Array(_len9), _key9 = 0; _key9 < _len9; _key9++) {
+    args[_key9] = arguments[_key9];
+  }
+  return props => props.theme.printMode ? styled.css(...args) : styled.css(["@media print{", "}"], styled.css(...args));
+};
+const notPrinterMedia = function () {
+  for (var _len0 = arguments.length, args = new Array(_len0), _key0 = 0; _key0 < _len0; _key0++) {
+    args[_key0] = arguments[_key0];
+  }
+  return props => props.theme.printMode ? '' : styled.css(["@media screen{", "}"], styled.css(...args));
+};
+
+const escapedValidParts = /(^|[^\\])(dd?|DD?|mm?|LL?|hh?|MM?|ss|SSS|yy(?:yy)?)/g;
+const validParts = /(dd?|DD?|mm?|LL?|hh?|MM?|yy(?:yy)|yy|ss|SSS)$/;
+const addZero = v => (v < 10 ? '0' : '') + v;
+const getSet = function (index, ttype) {
+  let plus = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+  let format = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : v => v;
+  let parse = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : (v, defaultDate) => v === '0' ? '' : v;
+  return [(date, _, noUTC) => format((typeof date === 'number' ? new Date(date) : date)['get' + (noUTC ? '' : 'UTC') + ttype]() + plus), (unformatedStr, date, _, failOnFormat, noUTC) => {
+    const str = parse(unformatedStr, date, failOnFormat);
+    if (str === '' || isNaN(date.getTime())) return date;
+    if (str === '\0') return date.setTime(NaN);
+    const utcSTR = noUTC ? '' : 'UTC';
+    const v = parseInt(str, 10) - plus;
+    const prevDay = date['get' + utcSTR + 'Date']();
+    if (ttype !== 'Date') {
+      date['set' + utcSTR + 'Date'](1);
+    }
+    date['set' + utcSTR + ttype](v);
+    if (date['get' + utcSTR + ttype]() !== v) {
+      date['set' + utcSTR + ttype](NaN);
+      return date;
+    }
+    if (ttype !== 'Date') {
+      date['set' + utcSTR + 'Date'](prevDay);
+      if (date['get' + utcSTR + ttype]() !== v) {
+        date['set' + utcSTR + 'Date'](0);
+        return date;
+      }
+    }
+    return date;
+  }, index];
+};
+const getText = function (type, total) {
+  let slice = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 99;
+  return [(date, messages, noUTC) => messages(type.toLowerCase(), date['get' + (noUTC ? '' : 'UTC') + type]()).slice(0, slice)];
+};
+const yearParse = (y, date, failOnFormat) => {
+  const formattedY = y.length === 2 && y !== '20' ? '20' + y : y.length === 4 ? y : '';
+  if (formattedY === '') {
+    if (failOnFormat) {
+      const found = date.getUTCFullYear().toString().indexOf(y);
+      return found === 0 || found === 2 ? date.getUTCFullYear() : '\0';
+    } else {
+      return date.getUTCFullYear();
+    }
+  } else {
+    return formattedY;
+  }
+};
+const val = {
+  yyyy: getSet(0, 'FullYear', 0, v => v, yearParse),
+  yy: getSet(0, 'FullYear', 0, v => (v + "").slice(2, 4), yearParse),
+  M: getSet(1, 'Month', 1),
+  MM: getSet(1, 'Month', 1, addZero),
+  L: getText('Month', 12, 3),
+  LL: getText('Month', 12),
+  d: getSet(2, 'Date'),
+  dd: getSet(2, 'Date', 0, addZero),
+  D: getText('Day', 7, 3),
+  DD: getText('Day', 7),
+  m: getSet(4, 'Minutes'),
+  mm: getSet(4, 'Minutes', 0, addZero),
+  h: getSet(5, 'Hours'),
+  hh: getSet(5, 'Hours', 0, addZero),
+  ss: getSet(6, 'Seconds', 0, addZero),
+  SSS: getSet(7, 'Milliseconds', 0, addZero)
+};
+function formatDateToPattern(format) {
+  return format.replace(escapedValidParts, (_, _1, _2) => _1 + (_2 === 'yy' ? '##' : _2 === 'yyyy' ? '####' : '0#'));
+}
+function formatDate(date, format, messages, noUTC) {
+  if (!date) return '';
+  const separators = format.replace(escapedValidParts, '\0').split('\0');
+  const parts = format.match(escapedValidParts);
+  const formattedDate = parts.reduce((acc, part) => acc.concat(separators.length ? [separators.shift()] : [], part.replace(validParts, ''), val[part.match(validParts)[0]][0](date, messages, noUTC)), []);
+  return formattedDate.join('').replace(/\\([dDmLhMy])/g, '$1');
+}
+const now = () => new Date();
+function parseDate(str, possibleDate, format, messages, failOnFormat, noUTC) {
+  if (!str) return possibleDate;
+  const separators = format.replace(escapedValidParts, '\0').split('\0');
+  const parts = format.match(escapedValidParts);
+  const mutations = [];
+  parts.reduce((rest, part, i) => {
+    const separator = (separators.length ? separators.shift() : '') + part.replace(validParts, '');
+    const current = rest.slice(separator.length);
+    if (current && separator === rest.slice(0, separator.length)) {
+      const setType = part.match(validParts)[0];
+      const nextSeparator = separators[0];
+      const nextStrIndex = current.indexOf(nextSeparator + (parts[i + 1] || '').replace(validParts, ''));
+      mutations[val[setType][2]] = [val[setType][1], nextStrIndex ? current.slice(0, nextStrIndex) : current];
+      return current.slice(nextStrIndex);
+    } else {
+      return '';
+    }
+  }, str);
+  const date = possibleDate && possibleDate.getTime() !== -1 ? new Date(possibleDate) : now();
+  mutations.forEach(_ref => {
+    let _ref2 = _slicedToArray__default["default"](_ref, 2),
+      setter = _ref2[0],
+      text = _ref2[1];
+    return setter(text, date, messages, failOnFormat, noUTC);
+  });
+  return date;
+}
+
+function ownKeys$1(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread$1(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys$1(Object(t), !0).forEach(function (r) { _defineProperty__default["default"](e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys$1(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+const isNotSelector = v => typeof v !== 'function' || v.length === 0;
+const toSelector = v => isNotSelector(v) ? s => _s.get(callIfFunction(v), s) : v;
+const mergeSelectors = (prev, next) => v => next(prev(v));
+const concatSelectors = function () {
+  for (var _len = arguments.length, paths = new Array(_len), _key = 0; _key < _len; _key++) {
+    paths[_key] = arguments[_key];
+  }
+  return paths.reduce((_ref, path) => {
+    let _ref2 = _slicedToArray__default["default"](_ref, 2),
+      selector = _ref2[0],
+      isSelector = _ref2[1];
+    return isNotSelector(path) && !isSelector ? [selector.concat(path), false] : [mergeSelectors(toSelector(selector), path), true];
+  }, [[], false]);
+};
+const COMPLETE_ACTION = {};
+const REDUCE = {};
+const FETCH = {};
+const SKIP_FETCH = {};
+const SKIP_DISPATCH = {};
+const SKIPPED_ACTION = {};
+const selectPath = function (useState) {
+  for (var _len2 = arguments.length, paths = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+    paths[_key2 - 1] = arguments[_key2];
+  }
+  const _useMemo = React.useMemo(() => concatSelectors(...paths), paths),
+    _useMemo2 = _slicedToArray__default["default"](_useMemo, 1),
+    selector = _useMemo2[0];
+  const _useState = useState(selector),
+    _useState2 = _slicedToArray__default["default"](_useState, 1),
+    value = _useState2[0];
+  return value;
+};
+const Action = function (fnOrArray) {
+  let prevArgs = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  const isArray = Array.isArray(fnOrArray);
+  if (isArray) {
+    // excessive paramaeters called on the action, used for options.
+    const actionType = _last__default["default"](prevArgs);
+    const _fnOrArray = _slicedToArray__default["default"](fnOrArray, 3),
+      fetcher = _fnOrArray[0],
+      reducer = _fnOrArray[1],
+      rollbacker = _fnOrArray[2];
+    if (actionType === REDUCE) {
+      return reducer(null, prevArgs);
+    } else if (actionType === FETCH) {
+      return fetcher();
+    } else {
+      return _set__default["default"]('extra', fnOrArray.extra, [actionType === SKIP_FETCH ? () => Promise.resolve() : fetcher, actionType === SKIP_DISPATCH ? undefined : reducer].concat(rollbacker || []));
+    }
+  } else {
+    return prevArgs.length < fnOrArray.length ? function () {
+      for (var _len3 = arguments.length, moreArgs = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+        moreArgs[_key3] = arguments[_key3];
+      }
+      return Action(fnOrArray, [...prevArgs, ...moreArgs]);
+    } : Action(fnOrArray(...prevArgs), prevArgs);
+  }
+};
+const mapAction = (get, dispatcher, firstRun) => action => {
+  if (Array.isArray(action)) {
+    if (firstRun) {
+      return () => mapAction(get, dispatcher)(action);
+    }
+    const _action = _slicedToArray__default["default"](action, 3),
+      fetcher = _action[0],
+      reducer = _action[1],
+      rollbacker = _action[2];
+    const _ref3 = action.extra || {},
+      skip = _ref3.skip;
+    if (skip && skip(get())) {
+      return Promise.resolve(SKIPPED_ACTION);
+    }
+    const fetched = fetcher();
+    if (rollbacker) {
+      dispatcher(prevState => {
+        const nextState = reducer(null)(prevState);
+        fetched.catch(response => {
+          dispatcher(rollbacker(prevState, nextState, response));
+        });
+        return nextState;
+      });
+    }
+    if (reducer !== undefined) {
+      fetched.then(response => dispatcher(reducer(response)));
+    }
+    return fetched;
+  } else {
+    return function () {
+      return mapAction(get, dispatcher)(action(...arguments));
+    };
+  }
+};
+const activateActions = function (get, dispatcher) {
+  for (var _len4 = arguments.length, actions = new Array(_len4 > 2 ? _len4 - 2 : 0), _key4 = 2; _key4 < _len4; _key4++) {
+    actions[_key4 - 2] = arguments[_key4];
+  }
+  return actions.map(mapAction(get, dispatcher, true));
+};
+const SkipAction = (skip, action) => {
+  action.extra = _objectSpread$1(_objectSpread$1({}, action.extra), {}, {
+    skip
+  });
+  return action;
+};
+
+const compareBest = compare => (best, next) => best ? compare(best, next) ? next : best : next;
+const toLowest = function () {
+  let getValue = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _identity__default["default"];
+  return compareBest((best, next) => getValue(next) < getValue(best));
+};
+const toHighest = function () {
+  let getValue = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _identity__default["default"];
+  return compareBest((best, next) => getValue(next) > getValue(best));
+};
+
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty__default["default"](e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+const addExtraProp = function (element, extra) {
+  let override = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+  return /*#__PURE__*/React__default["default"].cloneElement(element, override ? _objectSpread(_objectSpread({}, element.props), extra) : _objectSpread(_objectSpread({}, extra), element.props), element.props.children);
+};
+
+const useEventListener = function (eventName, callback) {
+  let deps = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+  React.useEffect(() => {
+    window.addEventListener(eventName, callback);
+    return () => window.removeEventListener(eventName, callback);
+  }, deps);
+};
+const useEventListenerIf = function (check, eventName, callback) {
+  let deps = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
+  React.useEffect(() => {
+    if (!check()) return;
+    window.addEventListener(eventName, callback);
+    return () => window.removeEventListener(eventName, callback);
+  }, deps);
+};
+const useEventListenerFor = function (element, eventName, callback) {
+  let deps = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
+  React.useEffect(() => {
+    element.addEventListener(eventName, callback);
+    return () => element.removeEventListener(eventName, callback);
+  }, deps.concat(element));
+};
+
+const disableSelect = e => {
+  e.preventDefault();
+};
+const createPressEvent = onStart => normalizePress((startEvent, info) => {
+  const onEnd = onStart(startEvent, info);
+  const finish = normalizePress((e, info) => {
+    callIfFunction(onEnd, e, info);
+    window.removeEventListener('selectstart', disableSelect);
+    window.removeEventListener('touchend', finish);
+    window.removeEventListener('mouseup', finish);
+  });
+  window.addEventListener('selectstart', disableSelect);
+  if (startEvent.touches) {
+    window.addEventListener('touchend', finish);
+  } else {
+    window.addEventListener("mouseup", finish);
+  }
+});
+const createPressAndHoldEvent = (onStart, interval) => createPressEvent((startEvent, info) => {
+  const _concat = [].concat(onStart(startEvent, info)),
+    _concat2 = _slicedToArray__default["default"](_concat, 2),
+    onInterval = _concat2[0],
+    onEnd = _concat2[1];
+  let i = 0;
+  if (interval) {
+    const intervalId = setInterval(() => {
+      onInterval(i++);
+    }, interval);
+    return normalizePress((e, info) => {
+      callIfFunction(onEnd, e, info);
+      clearInterval(intervalId);
+    });
+  } else {
+    let running = true;
+    const run = () => window.requestAnimationFrame(() => {
+      if (running) {
+        onInterval(i++);
+        run();
+      }
+    });
+    run();
+    return normalizePress((e, info) => {
+      callIfFunction(onEnd, e, info);
+      running = false;
+    });
+  }
+});
+const createPressAndMoveEvent = onStart => createPressEvent((startEvent, info) => {
+  const _concat3 = [].concat(onStart(startEvent, info)),
+    _concat4 = _slicedToArray__default["default"](_concat3, 2),
+    onMove = _concat4[0],
+    onEnd = _concat4[1];
+  const finish = normalizePress((e, info) => {
+    callIfFunction(onEnd, e, info);
+    window.removeEventListener('touchmove', move);
+    window.removeEventListener('mousemove', move);
+  });
+  const move = normalizePress(onMove, finish);
+  if (startEvent.touches) {
+    window.addEventListener('touchmove', move, {
+      passive: false
+    });
+  } else {
+    window.addEventListener("mousemove", move);
+  }
+  return finish;
+});
+
+// Suspense integrations like Relay implement
+// a contract like this to integrate with React.
+// Real implementations can be significantly more complex.
+// Don't copy-paste this into your project!
+const EMPTY_ARGS = [];
+const UNDEFINED_CURRENT_VALUE = {};
+const innerWrapLazy = refreshCallback => function (maybePromise) {
+  for (var _len = arguments.length, rootArgs = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    rootArgs[_key - 1] = arguments[_key];
+  }
+  let status;
+  let awaitReadResolver;
+  let checker = _isEqual__default["default"];
+  let lazyArgs = EMPTY_ARGS;
+  let uid = Math.random().toString() + Date.now();
+  let result;
+  let currentValue = UNDEFINED_CURRENT_VALUE;
+  const promisify = (maybePromise, resolveNow) => {
+    return (_isFunction__default["default"](maybePromise) && !resolveNow ? new Promise(res => awaitReadResolver = res) : Promise.resolve()).then(function () {
+      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        args[_key2] = arguments[_key2];
+      }
+      return callIfFunction(maybePromise, ...rootArgs, ...lazyArgs, ...args);
+    });
+  };
+  const onPromiseSuccess = returnedPromise => r => {
+    if (returnedPromise !== suspender) {
+      return suspender;
+    }
+    status = "success";
+    currentValue = r;
+    result = r;
+    return r;
+  };
+  const onPromiseError = returnedPromise => e => {
+    if (returnedPromise !== suspender) {
+      return suspender;
+    }
+    status = "error";
+    result = e;
+    return Promise.reject(e);
+  };
+  const suspend = maybePromise => {
+    status = "pending";
+    awaitReadResolver = _identity__default["default"];
+    const returnedPromise = promisify(maybePromise);
+    returnedPromise.then(onPromiseSuccess(returnedPromise), onPromiseError(returnedPromise));
+    return returnedPromise;
+  };
+  let suspender = suspend(maybePromise);
+  return {
+    read() {
+      awaitReadResolver();
+      if (status === "pending") {
+        throw suspender;
+      } else if (status === "error") {
+        throw result;
+      } else if (status === "success") {
+        return currentValue;
+      }
+    },
+    promise() {
+      awaitReadResolver();
+      return suspender;
+    },
+    refresh(force) {
+      if (status !== "pending" || force) {
+        suspender = suspend(maybePromise);
+        uid = Math.random().toString() + Date.now();
+        callIfFunction(refreshCallback, this);
+      }
+      return this;
+    },
+    next() {
+      for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+        args[_key3] = arguments[_key3];
+      }
+      return wrapLazy(maybePromise, ...rootArgs, ...args).checkWith(checker);
+    },
+    use() {
+      for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+        args[_key4] = arguments[_key4];
+      }
+      if (!checker(args, lazyArgs)) {
+        if (lazyArgs !== EMPTY_ARGS) {
+          uid = Math.random().toString() + Date.now();
+        }
+        lazyArgs = args;
+        suspender = suspend(maybePromise);
+      }
+      return this;
+    },
+    _getCurrentValue() {
+      return currentValue;
+    },
+    silentRefresh() {
+      const currentSuspender = suspender;
+      const suspended = promisify(maybePromise, true).then(v => {
+        if (currentSuspender === suspender) {
+          suspender = suspended;
+        }
+        return v;
+      });
+      suspended.then(onPromiseSuccess(suspended), onPromiseError(suspended));
+      uid = Math.random().toString() + Date.now();
+      callIfFunction(refreshCallback, this);
+      return suspended;
+    },
+    and(lazy) {},
+    checkWith(isEqual) {
+      checker = isEqual;
+      return this;
+    },
+    localUpdate(updater) {
+      currentValue = callIfFunction(updater, currentValue);
+      return this;
+    },
+    uid() {
+      return uid;
+    }
+  };
+};
+const wrapLazy = innerWrapLazy();
+
+const SECOND = 1000;
+const MINUTE = SECOND * 60;
+const HOUR = MINUTE * 60;
+const DAY = HOUR * 24;
+const WEEK = DAY * 7;
+const MONTH = DAY * 31;
+const YEAR = DAY * 366;
+const getStartOfDay = function (d) {
+  let utc = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  const date = new Date(d);
+  if (utc) {
+    date.setUTCHours(0, 0, 0, 0);
+  } else {
+    date.setHours(0, 0, 0, 0);
+  }
+  return date;
+};
+const isSameDay = function (a, b) {
+  let utc = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  return getStartOfDay(a, utc).getTime() === getStartOfDay(b, utc).getTime();
+};
+const intervalsIntersect = (_ref, _ref2) => {
+  let _ref3 = _slicedToArray__default["default"](_ref, 2),
+    a1 = _ref3[0],
+    a2 = _ref3[1];
+  let _ref4 = _slicedToArray__default["default"](_ref2, 2),
+    b1 = _ref4[0],
+    b2 = _ref4[1];
+  return b2 >= a1 && b1 <= a2;
+};
+const intervalsIntersectExclusive = (_ref5, _ref6) => {
+  let _ref7 = _slicedToArray__default["default"](_ref5, 2),
+    a1 = _ref7[0],
+    a2 = _ref7[1];
+  let _ref8 = _slicedToArray__default["default"](_ref6, 2),
+    b1 = _ref8[0],
+    b2 = _ref8[1];
+  return b2 > a1 && b1 < a2;
+};
+const intervalsIntersection = (a, b) => {
+  if (!intervalsIntersect(a, b)) {
+    return [];
+  }
+  return [[Math.max(a[0], b[0]), Math.min(a[1], b[1])]];
+};
+const diffIntervals = (_ref9, _ref0) => {
+  let _ref1 = _slicedToArray__default["default"](_ref9, 2),
+    a1 = _ref1[0],
+    a2 = _ref1[1];
+  let _ref10 = _slicedToArray__default["default"](_ref0, 2),
+    b1 = _ref10[0],
+    b2 = _ref10[1];
+  if (a1 >= b2 ||
+  // a after b
+  b1 >= a2 // a before b
+  ) {
+    return [[a1, a2]];
+  } else if (a1 > b1 && a2 < b2) {
+    // a inside b
+    return [];
+  }
+  if (b1 > a1 && b2 < a2) {
+    // b inside a
+    return [[a1, b1], [b2, a2]];
+  }
+  if (b1 <= a1) {
+    // b intersecting left of a
+    return [[b2, a2]];
+  } else {
+    // b intersecting right of a
+    return [[a1, b1]];
+  }
+};
+const blockDiffIntervals = (a, b) => intervalsIntersect(a, b) ? [] : [a];
+const startBlockDiffIntervals = (a, b) => intervalsIntersectExclusive(a, b) && a[0] >= b[0] ? [] : [a];
+
+const timerPromise = time => new Promise(res => setTimeout(res, time));
+const cancelableTimer = (res, time) => {
+  const v = setTimeout(res, time);
+  return () => clearTimeout(v);
+};
+
+const formatJoin = function (arr) {
+  let separator = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ', ';
+  let lastSeparator = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : ' e ';
+  return [arr.slice(0, -1).join(separator), arr.slice(-1)].join(lastSeparator);
+};
+const formatJoinArr = (arr, separator, lastSeparator) => arr.flatMap((v, i) => i < arr.length - 2 ? [v, separator] : i < arr.length - 1 ? [v, lastSeparator] : [v]);
+const removeAccents = str => (str || "").normalize('NFD').replace(/\p{Diacritic}/gu, "");
+const asciify = str => removeAccents(str || "").replace(/[^\x00-\x7F]/g, "");
+const normalizeText = str => removeAccents(str).toLowerCase();
+const normalizeTextUrl = str => removeAccents(str).replace(/[\s.\u0022&/]/g, '-').replace(/-{2,}/g, '-').toLowerCase();
+const willFormatDecimal = function () {
+  let digits = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 2;
+  let _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+    max = _ref.max,
+    min = _ref.min,
+    padTo = _ref.padTo,
+    zeroless = _ref.zeroless,
+    clean = _ref.clean;
+  const splitRegex = new RegExp("(\\d+)(\\d{".concat(digits, "})"));
+  const singleRegex = new RegExp("/^([^,]*,\\d{0,".concat(digits, ").*/"));
+  const pad = str => padTo ? str.indexOf(",") >= 0 ? _padCharsEnd__default["default"]("0", str.indexOf(",") + padTo + 1, str) : _padCharsEnd__default["default"]("0", str.length + 1 + padTo, str + ",") : str;
+  const constrain = val => {
+    if (_isNumber__default["default"](max) && parseFloat(val.replace(",", ".")) > max) return max.toString();
+    if (_isNumber__default["default"](min) && parseFloat(val.replace(",", ".")) < min) return min.toString();
+    return val;
+  };
+  const cleaned = val => clean ? val.replace(/,$/, '').replace(/^0*,/, '0,') || "0" : val;
+  return v => {
+    const skipZero = finalV => v !== '0' && zeroless && finalV === '0' ? '' : finalV.replace(/^0+([^,])/, '$1');
+    const formatted = _flow__default["default"](constrain, pad, skipZero, cleaned);
+    if (_isNumber__default["default"](v)) {
+      return formatted(v.toString().replace(".", ","));
+    }
+    const fixComma = v => v.replace(/,/g, '').replace(splitRegex, "$1,$2");
+    const format = () => {
+      const allowedChars = (v || "").replace(/[^\d,]/g, "");
+      const commaIndex = allowedChars.indexOf(',');
+      if (commaIndex >= 0 && commaIndex < allowedChars.length - 1 - digits) {
+        const alteredComma = fixComma(allowedChars);
+        if (_isNumber__default["default"](max) && parseFloat(alteredComma.replace(",", ".")) > max) {
+          return fixComma(allowedChars.slice(0, commaIndex + 1 + digits));
+        }
+        return alteredComma;
+      }
+      const simpleNumber = allowedChars.replace(singleRegex, "$1");
+      if (_isNumber__default["default"](max) && parseInt(simpleNumber) > max) {
+        return simpleNumber.slice(0, -1);
+      }
+      return simpleNumber;
+    };
+    const result = format();
+    return formatted(result);
+  };
+};
+const parseDecimalToNumber = v => _isString__default["default"](v) ? Number(v.replace(/\./g, '').replace(',', ".")) : v || 0;
+
+exports.Action = Action;
+exports.COMPLETE_ACTION = COMPLETE_ACTION;
+exports.DAY = DAY;
+exports.FETCH = FETCH;
+exports.HOUR = HOUR;
+exports.MINUTE = MINUTE;
+exports.MONTH = MONTH;
+exports.REDUCE = REDUCE;
+exports.SECOND = SECOND;
+exports.SKIPPED_ACTION = SKIPPED_ACTION;
+exports.SKIP_DISPATCH = SKIP_DISPATCH;
+exports.SKIP_FETCH = SKIP_FETCH;
+exports.SkipAction = SkipAction;
+exports.WEEK = WEEK;
+exports.YEAR = YEAR;
+exports._s = _s;
+exports.activateActions = activateActions;
+exports.addExtraProp = addExtraProp;
+exports.addHttp = addHttp;
+exports.addQueryString = addQueryString;
+exports.addZero = addZero;
+exports.animationTiming = animationTiming;
+exports.asciify = asciify;
+exports.asyncDebounce = asyncDebounce;
+exports.blockDiffIntervals = blockDiffIntervals;
+exports.callIfFunction = callIfFunction;
+exports.callIfFunctions = callIfFunctions;
+exports.callMany = callMany;
+exports.cancelableTimer = cancelableTimer;
+exports.compareBest = compareBest;
+exports.concatSelectors = concatSelectors;
+exports.constrainEvent = constrainEvent;
+exports.createPressAndHoldEvent = createPressAndHoldEvent;
+exports.createPressAndMoveEvent = createPressAndMoveEvent;
+exports.createPressEvent = createPressEvent;
+exports.createPromiseQueue = createPromiseQueue;
+exports.createPromiseResolverPair = createPromiseResolverPair;
+exports.createSimplePromiseLock = createSimplePromiseLock;
+exports.customTheme = customTheme;
+exports.diffIntervals = diffIntervals;
+exports.digitsToPattern = digitsToPattern;
+exports.ellipsis = ellipsis;
+exports.fixMediaQuery = fixMediaQuery;
+exports.formFetch = formFetch;
+exports.formFetchWithResponse = formFetchWithResponse;
+exports.formatDate = formatDate;
+exports.formatDateToPattern = formatDateToPattern;
+exports.formatHour = formatHour;
+exports.formatJoin = formatJoin;
+exports.formatJoinArr = formatJoinArr;
+exports.formatPath = formatPath;
+exports.getClosestOffsetScroll = getClosestOffsetScroll;
+exports.getColor = getColor;
+exports.getFetcher = getFetcher;
+exports.getFetcherWithResponse = getFetcherWithResponse;
+exports.getMargin = getMargin;
+exports.getNumberInputType = getNumberInputType;
+exports.getNumberInputType2 = getNumberInputType2;
+exports.getScrollParent = getScrollParent;
+exports.getStartOfDay = getStartOfDay;
+exports.getUID = getUID;
+exports.getUrlParams = getUrlParams;
+exports.identityFn = identityFn;
+exports.identityOpacityFrames = identityOpacityFrames;
+exports.identityTranslateFrames = identityTranslateFrames;
+exports.ifNotProp = ifNotProp;
+exports.ifProp = ifProp;
+exports.ifPropEquals = ifPropEquals;
+exports.ifUndefined = ifUndefined;
+exports.intToHour = intToHour;
+exports.intervalsIntersect = intervalsIntersect;
+exports.intervalsIntersectExclusive = intervalsIntersectExclusive;
+exports.intervalsIntersection = intervalsIntersection;
+exports.intsToHour = intsToHour;
+exports.isAndroid = isAndroid;
+exports.isElementInView = isElementInView;
+exports.isEmptyHtml = isEmptyHtml;
+exports.isHighDensity = isHighDensity;
+exports.isIOS = isIOS;
+exports.isIPad = isIPad;
+exports.isMobile = isMobile;
+exports.isPWA = isPWA;
+exports.isRetina = isRetina;
+exports.isSameDay = isSameDay;
+exports.isShallowEqual = isShallowEqual;
+exports.isShallowEqualSameKeys = isShallowEqualSameKeys;
+exports.isSmallDevice = isSmallDevice;
+exports.isTouchDevice = isTouchDevice;
+exports.isUrl = isUrl;
+exports.lazyValue = lazyValue;
+exports.linkRegex = linkRegex;
+exports.mapGetOrSet = mapGetOrSet;
+exports.media = media;
+exports.normalizeMouse = normalizeMouse;
+exports.normalizePress = normalizePress;
+exports.normalizeText = normalizeText;
+exports.normalizeTextUrl = normalizeTextUrl;
+exports.normalizeTouch = normalizeTouch;
+exports.notPrinterMedia = notPrinterMedia;
+exports.oneWayAnimation = oneWayAnimation;
+exports.parseDate = parseDate;
+exports.parseDecimalToNumber = parseDecimalToNumber;
+exports.postFetcher = postFetcher;
+exports.postFetcherWithResponse = postFetcherWithResponse;
+exports.preventDefault = preventDefault;
+exports.printerMedia = printerMedia;
+exports.promiseMapReduce = promiseMapReduce;
+exports.prop = prop;
+exports.queryStringToObj = queryStringToObj;
+exports.rafThrottle = rafThrottle;
+exports.removeAccents = removeAccents;
+exports.safeNewLineToBr = safeNewLineToBr;
+exports.scrollIntoViewWithOffset = scrollIntoViewWithOffset;
+exports.scrollWidth = scrollWidth;
+exports.selectPath = selectPath;
+exports.smoothScroll = smoothScroll;
+exports.startBlockDiffIntervals = startBlockDiffIntervals;
+exports.stopPropagation = stopPropagation;
+exports.styledExtend = styledExtend;
+exports.timerPromise = timerPromise;
+exports.toHighest = toHighest;
+exports.toLowest = toLowest;
+exports.touchClick = touchClick;
+exports.twoWayAnimation = twoWayAnimation;
+exports.useEventListener = useEventListener;
+exports.useEventListenerFor = useEventListenerFor;
+exports.useEventListenerIf = useEventListenerIf;
+exports.using = using;
+exports.vheight = vheight;
+exports.will = will;
+exports.willFormatDecimal = willFormatDecimal;
+exports.willRafThrottle = willRafThrottle;
+exports.wrapLazy = wrapLazy;
+//# sourceMappingURL=index.cjs.map