Security upgrades

node_modules/dom-helpers/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Jason Quense
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

node_modules/dom-helpers/README.md

@@ -0,0 +1,70 @@
+# dom-helpers
+
+tiny modular DOM lib for ie9+
+
+## Install
+
+```sh
+npm i -S dom-helpers
+```
+
+Mostly just naive wrappers around common DOM API inconsistencies, Cross browser work is minimal and mostly taken from jQuery. This library doesn't do a lot to normalize behavior across browsers, it mostly seeks to provide a common interface, and eliminate the need to write the same damn `if (ie9)` statements in every project.
+
+For example `on()` works in all browsers ie9+ but it uses the native event system so actual event oddities will continue to exist. If you need **robust** cross-browser support, use jQuery. If you are just tired of rewriting:
+
+```js
+if (document.addEventListener)
+  return (node, eventName, handler, capture) =>
+    node.addEventListener(eventName, handler, capture || false)
+else if (document.attachEvent)
+  return (node, eventName, handler) =>
+    node.attachEvent('on' + eventName, handler)
+```
+
+over and over again, or you need a ok `getComputedStyle` polyfill but don't want to include all of jQuery, use this.
+
+dom-helpers does expect certain, polyfillable, es5 features to be present for which you can use `es5-shim` where needed
+
+The real advantage to this collection is that any method can be required individually, meaning bundlers like webpack will only include the exact methods you use. This is great for environments where jQuery doesn't make sense, such as `React` where you only occasionally need to do direct DOM manipulation.
+
+All methods are exported as a flat namesapce
+
+```js
+var helpers = require('dom-helpers')
+var offset = require('dom-helpers/offset')
+
+// style is a function
+require('dom-helpers/css')(node, { width: '40px' })
+```
+
+- dom-helpers
+  - `ownerDocument(element)`: returns the element's document owner
+  - `ownerWindow(element)`: returns the element's document window
+  - `activeElement`: return focused element safely
+  - `querySelectorAll(element, selector)`: optimized qsa, uses `getElementBy{Id|TagName|ClassName}` if it can.
+  - `contains(container, element)`
+  - `height(element, useClientHeight)`
+  - `width(element, useClientWidth)`
+  - `matches(element, selector)`
+  - `offset(element)` -> `{ top: Number, left: Number, height: Number, width: Number}`
+  - `offsetParent(element)`: return the parent node that the element is offset from
+  - `position(element, [offsetParent]`: return "offset" of the node to its offsetParent, optionally you can specify the offset parent if different than the "real" one
+  - `scrollTop(element, [value])`
+  - `scrollLeft(element, [value])`
+  - `scrollParent(element)`
+  - `addClass(element, className)`
+  - `removeClass(element, className)`
+  - `hasClass(element, className)`
+  - `toggleClass(element, className)`
+  - `style(element, propName)` or `style(element, objectOfPropValues)`
+  - `getComputedStyle(element)` -> `getPropertyValue(name)`
+  - `animate(node, properties, duration, easing, callback)` programmatically start css transitions
+  - `transitionEnd(node, handler, [duration])` listens for transition end, and ensures that the handler if called even if the transition fails to fire its end event. Will attempt to read duration from the element, otherwise one can be provided
+  - `addEventListener(node, eventName, handler, [options])`:
+  - `removeEventListener(node, eventName, handler, [options])`:
+  - `listen(node, eventName, handler, [options])`: wraps `addEventlistener` and returns a function that calls `removeEventListener` for you
+  - `filter(selector, fn)`: returns a function handler that only fires when the target matches or is contained in the selector ex: `on(list, 'click', filter('li > a', handler))`
+  - `requestAnimationFrame(cb)` returns an ID for canceling
+  - `cancelAnimationFrame(id)`
+  - `scrollbarSize([recalc])` returns the scrollbar's width size in pixels
+  - `scrollTo(element, [scrollParent])`

node_modules/dom-helpers/activeElement/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "dom-helpers/activeElement",
+  "private": true,
+  "main": "../cjs/activeElement.js",
+  "module": "../esm/activeElement.js",
+  "types": "../esm/activeElement.d.ts"
+}

node_modules/dom-helpers/addClass/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "dom-helpers/addClass",
+  "private": true,
+  "main": "../cjs/addClass.js",
+  "module": "../esm/addClass.js",
+  "types": "../esm/addClass.d.ts"
+}

node_modules/dom-helpers/addEventListener/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "dom-helpers/addEventListener",
+  "private": true,
+  "main": "../cjs/addEventListener.js",
+  "module": "../esm/addEventListener.js",
+  "types": "../esm/addEventListener.d.ts"
+}

node_modules/dom-helpers/animate/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "dom-helpers/animate",
+  "private": true,
+  "main": "../cjs/animate.js",
+  "module": "../esm/animate.js",
+  "types": "../esm/animate.d.ts"
+}

node_modules/dom-helpers/animationFrame/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "dom-helpers/animationFrame",
+  "private": true,
+  "main": "../cjs/animationFrame.js",
+  "module": "../esm/animationFrame.js",
+  "types": "../esm/animationFrame.d.ts"
+}

node_modules/dom-helpers/camelize/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "dom-helpers/camelize",
+  "private": true,
+  "main": "../cjs/camelize.js",
+  "module": "../esm/camelize.js",
+  "types": "../esm/camelize.d.ts"
+}

node_modules/dom-helpers/camelizeStyle/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "dom-helpers/camelizeStyle",
+  "private": true,
+  "main": "../cjs/camelizeStyle.js",
+  "module": "../esm/camelizeStyle.js",
+  "types": "../esm/camelizeStyle.d.ts"
+}

node_modules/dom-helpers/canUseDOM/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "dom-helpers/canUseDOM",
+  "private": true,
+  "main": "../cjs/canUseDOM.js",
+  "module": "../esm/canUseDOM.js",
+  "types": "../esm/canUseDOM.d.ts"
+}

node_modules/dom-helpers/cjs/activeElement.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Return the actively focused element safely.
+ *
+ * @param doc the document to checl
+ */
+export default function activeElement(doc?: Document): Element | null;

node_modules/dom-helpers/cjs/activeElement.js

@@ -0,0 +1,34 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = activeElement;
+
+var _ownerDocument = _interopRequireDefault(require("./ownerDocument"));
+
+/**
+ * Return the actively focused element safely.
+ *
+ * @param doc the document to checl
+ */
+function activeElement(doc) {
+  if (doc === void 0) {
+    doc = (0, _ownerDocument.default)();
+  }
+
+  // Support: IE 9 only
+  // IE9 throws an "Unspecified error" accessing document.activeElement from an <iframe>
+  try {
+    var active = doc.activeElement; // IE11 returns a seemingly empty object in some cases when accessing
+    // document.activeElement from an <iframe>
+
+    if (!active || !active.nodeName) return null;
+    return active;
+  } catch (e) {
+    /* ie throws if no active element */
+    return doc.body;
+  }
+}
+
+module.exports = exports["default"];

node_modules/dom-helpers/cjs/addClass.d.ts

@@ -0,0 +1 @@
+export default function addClass(element: Element | SVGElement, className: string): void;

node_modules/dom-helpers/cjs/addClass.js

@@ -0,0 +1,14 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = addClass;
+
+var _hasClass = _interopRequireDefault(require("./hasClass"));
+
+function addClass(element, className) {
+  if (element.classList) element.classList.add(className);else if (!(0, _hasClass.default)(element, className)) if (typeof element.className === 'string') element.className = element.className + " " + className;else element.setAttribute('class', (element.className && element.className.baseVal || '') + " " + className);
+}
+
+module.exports = exports["default"];

node_modules/dom-helpers/cjs/addEventListener.d.ts

@@ -0,0 +1,11 @@
+export declare let optionsSupported: boolean;
+export declare let onceSupported: boolean;
+export declare type EventHandler<K extends keyof HTMLElementEventMap> = (this: HTMLElement, event: HTMLElementEventMap[K]) => any;
+export declare type TaggedEventHandler<K extends keyof HTMLElementEventMap> = EventHandler<K> & {
+    __once?: EventHandler<K>;
+};
+/**
+ * An `addEventListener` ponyfill, supports the `once` option
+ */
+declare function addEventListener<K extends keyof HTMLElementEventMap>(node: HTMLElement, eventName: K, handler: TaggedEventHandler<K>, options?: boolean | AddEventListenerOptions): void;
+export default addEventListener;

node_modules/dom-helpers/cjs/addEventListener.js

@@ -0,0 +1,62 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = exports.onceSupported = exports.optionsSupported = void 0;
+
+var _canUseDOM = _interopRequireDefault(require("./canUseDOM"));
+
+/* eslint-disable no-return-assign */
+var optionsSupported = false;
+exports.optionsSupported = optionsSupported;
+var onceSupported = false;
+exports.onceSupported = onceSupported;
+
+try {
+  var options = {
+    get passive() {
+      return exports.optionsSupported = optionsSupported = true;
+    },
+
+    get once() {
+      // eslint-disable-next-line no-multi-assign
+      return exports.onceSupported = onceSupported = exports.optionsSupported = optionsSupported = true;
+    }
+
+  };
+
+  if (_canUseDOM.default) {
+    window.addEventListener('test', options, options);
+    window.removeEventListener('test', options, true);
+  }
+} catch (e) {
+  /* */
+}
+
+/**
+ * An `addEventListener` ponyfill, supports the `once` option
+ */
+function addEventListener(node, eventName, handler, options) {
+  if (options && typeof options !== 'boolean' && !onceSupported) {
+    var once = options.once,
+        capture = options.capture;
+    var wrappedHandler = handler;
+
+    if (!onceSupported && once) {
+      wrappedHandler = handler.__once || function onceHandler(event) {
+        this.removeEventListener(eventName, onceHandler, capture);
+        handler.call(this, event);
+      };
+
+      handler.__once = wrappedHandler;
+    }
+
+    node.addEventListener(eventName, wrappedHandler, optionsSupported ? options : capture);
+  }
+
+  node.addEventListener(eventName, handler, options);
+}
+
+var _default = addEventListener;
+exports.default = _default;

node_modules/dom-helpers/cjs/animate.d.ts

@@ -0,0 +1,19 @@
+import { EventHandler } from './addEventListener';
+import { TransformValue } from './isTransform';
+import { Property } from './types';
+declare type AnimateProperties = Record<Property | TransformValue, string>;
+interface Options {
+    node: HTMLElement;
+    properties: AnimateProperties;
+    duration?: number;
+    easing?: string;
+    callback?: EventHandler<'transitionend'>;
+}
+interface Cancel {
+    cancel(): void;
+}
+declare function animate(options: Options): Cancel;
+declare function animate(node: HTMLElement, properties: AnimateProperties, duration: number): Cancel;
+declare function animate(node: HTMLElement, properties: AnimateProperties, duration: number, callback: EventHandler<'transitionend'>): Cancel;
+declare function animate(node: HTMLElement, properties: AnimateProperties, duration: number, easing: string, callback: EventHandler<'transitionend'>): Cancel;
+export default animate;

node_modules/dom-helpers/cjs/animate.js

@@ -0,0 +1,103 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _css = _interopRequireDefault(require("./css"));
+
+var _hyphenate = _interopRequireDefault(require("./hyphenate"));
+
+var _isTransform = _interopRequireDefault(require("./isTransform"));
+
+var _transitionEnd = _interopRequireDefault(require("./transitionEnd"));
+
+var reset = {
+  transition: '',
+  'transition-duration': '',
+  'transition-delay': '',
+  'transition-timing-function': ''
+};
+
+// super lean animate function for transitions
+// doesn't support all translations to keep it matching the jquery API
+
+/**
+ * code in part from: Zepto 1.1.4 | zeptojs.com/license
+ */
+function _animate(_ref) {
+  var node = _ref.node,
+      properties = _ref.properties,
+      _ref$duration = _ref.duration,
+      duration = _ref$duration === void 0 ? 200 : _ref$duration,
+      easing = _ref.easing,
+      callback = _ref.callback;
+  var cssProperties = [];
+  var cssValues = {};
+  var transforms = '';
+  Object.keys(properties).forEach(function (key) {
+    var value = properties[key];
+    if ((0, _isTransform.default)(key)) transforms += key + "(" + value + ") ";else {
+      cssValues[key] = value;
+      cssProperties.push((0, _hyphenate.default)(key));
+    }
+  });
+
+  if (transforms) {
+    cssValues.transform = transforms;
+    cssProperties.push('transform');
+  }
+
+  function done(event) {
+    if (event.target !== event.currentTarget) return;
+    (0, _css.default)(node, reset);
+    if (callback) callback.call(this, event);
+  }
+
+  if (duration > 0) {
+    cssValues.transition = cssProperties.join(', ');
+    cssValues['transition-duration'] = duration / 1000 + "s";
+    cssValues['transition-delay'] = '0s';
+    cssValues['transition-timing-function'] = easing || 'linear';
+  }
+
+  var removeListener = (0, _transitionEnd.default)(node, done, duration); // eslint-disable-next-line no-unused-expressions
+
+  node.clientLeft; // trigger page reflow
+
+  (0, _css.default)(node, cssValues);
+  return {
+    cancel: function cancel() {
+      removeListener();
+      (0, _css.default)(node, reset);
+    }
+  };
+}
+
+function animate(nodeOrOptions, properties, duration, easing, callback) {
+  if (!('nodeType' in nodeOrOptions)) {
+    return _animate(nodeOrOptions);
+  }
+
+  if (!properties) {
+    throw new Error('must include properties to animate');
+  }
+
+  if (typeof easing === 'function') {
+    callback = easing;
+    easing = '';
+  }
+
+  return _animate({
+    node: nodeOrOptions,
+    properties: properties,
+    duration: duration,
+    easing: easing,
+    callback: callback
+  });
+}
+
+var _default = animate;
+exports.default = _default;
+module.exports = exports["default"];

node_modules/dom-helpers/cjs/animationFrame.d.ts

@@ -0,0 +1,2 @@
+export declare const cancel: (id: number) => void;
+export declare const request: typeof requestAnimationFrame;

node_modules/dom-helpers/cjs/animationFrame.js

@@ -0,0 +1,52 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.request = exports.cancel = void 0;
+
+var _canUseDOM = _interopRequireDefault(require("./canUseDOM"));
+
+/* https://github.com/component/raf */
+var prev = new Date().getTime();
+
+function fallback(fn) {
+  var curr = new Date().getTime();
+  var ms = Math.max(0, 16 - (curr - prev));
+  var handle = setTimeout(fn, ms);
+  prev = curr;
+  return handle;
+}
+
+var vendors = ['', 'webkit', 'moz', 'o', 'ms'];
+var cancelMethod = 'clearTimeout';
+var rafImpl = fallback; // eslint-disable-next-line import/no-mutable-exports
+
+var getKey = function getKey(vendor, k) {
+  return vendor + (!vendor ? k : k[0].toUpperCase() + k.substr(1)) + "AnimationFrame";
+};
+
+if (_canUseDOM.default) {
+  vendors.some(function (vendor) {
+    var rafMethod = getKey(vendor, 'request');
+
+    if (rafMethod in window) {
+      cancelMethod = getKey(vendor, 'cancel'); // @ts-ignore
+
+      rafImpl = function rafImpl(cb) {
+        return window[rafMethod](cb);
+      };
+    }
+
+    return !!rafImpl;
+  });
+}
+
+var cancel = function cancel(id) {
+  // @ts-ignore
+  if (typeof window[cancelMethod] === 'function') window[cancelMethod](id);
+};
+
+exports.cancel = cancel;
+var request = rafImpl;
+exports.request = request;

node_modules/dom-helpers/cjs/camelize.d.ts

@@ -0,0 +1 @@
+export default function camelize(string: string): string;

node_modules/dom-helpers/cjs/camelize.js

@@ -0,0 +1,13 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = camelize;
+var rHyphen = /-(.)/g;
+
+function camelize(string) {
+  return string.replace(rHyphen, function (_, chr) {
+    return chr.toUpperCase();
+  });
+}
+
+module.exports = exports["default"];

node_modules/dom-helpers/cjs/camelizeStyle.d.ts

@@ -0,0 +1,2 @@
+import { CamelProperty, Property } from './types';
+export default function camelizeStyleName<T extends string = Property>(string: T): CamelProperty;

node_modules/dom-helpers/cjs/camelizeStyle.js

@@ -0,0 +1,21 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = camelizeStyleName;
+
+var _camelize = _interopRequireDefault(require("./camelize"));
+
+/**
+ * Copyright 2014-2015, Facebook, Inc.
+ * All rights reserved.
+ * https://github.com/facebook/react/blob/2aeb8a2a6beb00617a4217f7f8284924fa2ad819/src/vendor/core/camelizeStyleName.js
+ */
+var msPattern = /^-ms-/;
+
+function camelizeStyleName(string) {
+  return (0, _camelize.default)(string.replace(msPattern, 'ms-'));
+}
+
+module.exports = exports["default"];

node_modules/dom-helpers/cjs/canUseDOM.d.ts

@@ -0,0 +1,2 @@
+declare const _default: boolean;
+export default _default;

node_modules/dom-helpers/cjs/canUseDOM.js

@@ -0,0 +1,9 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _default = !!(typeof window !== 'undefined' && window.document && window.document.createElement);
+
+exports.default = _default;
+module.exports = exports["default"];

node_modules/dom-helpers/cjs/closest.d.ts

@@ -0,0 +1 @@
+export default function closest(node: Element, selector: string, stopAt?: Element): Element | null;

node_modules/dom-helpers/cjs/closest.js

@@ -0,0 +1,22 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = closest;
+
+var _matches = _interopRequireDefault(require("./matches"));
+
+function closest(node, selector, stopAt) {
+  if (node.closest && !stopAt) node.closest(selector);
+  var nextNode = node;
+
+  do {
+    if ((0, _matches.default)(nextNode, selector)) return nextNode;
+    nextNode = nextNode.parentElement;
+  } while (nextNode && nextNode !== stopAt && nextNode.nodeType === document.ELEMENT_NODE);
+
+  return null;
+}
+
+module.exports = exports["default"];

node_modules/dom-helpers/cjs/contains.d.ts

@@ -0,0 +1 @@
+export default function contains(context: Element, node: Element): boolean | undefined;

node_modules/dom-helpers/cjs/contains.js

@@ -0,0 +1,14 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = contains;
+
+/* eslint-disable no-bitwise, no-cond-assign */
+// HTML DOM and SVG DOM may have different support levels,
+// so we need to check on context instead of a document root element.
+function contains(context, node) {
+  if (context.contains) return context.contains(node);
+  if (context.compareDocumentPosition) return context === node || !!(context.compareDocumentPosition(node) & 16);
+}
+
+module.exports = exports["default"];

node_modules/dom-helpers/cjs/css.d.ts

@@ -0,0 +1,6 @@
+import * as CSS from 'csstype';
+import { CamelProperty, HyphenProperty, Property } from './types';
+declare function style(node: HTMLElement, property: Partial<Record<Property, string>>): void;
+declare function style<T extends HyphenProperty>(node: HTMLElement, property: T): CSS.PropertiesHyphen[T];
+declare function style<T extends CamelProperty>(node: HTMLElement, property: T): CSS.Properties[T];
+export default style;

node_modules/dom-helpers/cjs/css.js

@@ -0,0 +1,43 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _getComputedStyle = _interopRequireDefault(require("./getComputedStyle"));
+
+var _hyphenateStyle = _interopRequireDefault(require("./hyphenateStyle"));
+
+var _isTransform = _interopRequireDefault(require("./isTransform"));
+
+function style(node, property) {
+  var css = '';
+  var transforms = '';
+
+  if (typeof property === 'string') {
+    return node.style.getPropertyValue((0, _hyphenateStyle.default)(property)) || (0, _getComputedStyle.default)(node).getPropertyValue((0, _hyphenateStyle.default)(property));
+  }
+
+  Object.keys(property).forEach(function (key) {
+    var value = property[key];
+
+    if (!value && value !== 0) {
+      node.style.removeProperty((0, _hyphenateStyle.default)(key));
+    } else if ((0, _isTransform.default)(key)) {
+      transforms += key + "(" + value + ") ";
+    } else {
+      css += (0, _hyphenateStyle.default)(key) + ": " + value + ";";
+    }
+  });
+
+  if (transforms) {
+    css += "transform: " + transforms + ";";
+  }
+
+  node.style.cssText += ";" + css;
+}
+
+var _default = style;
+exports.default = _default;
+module.exports = exports["default"];

node_modules/dom-helpers/cjs/filterEventHandler.d.ts

@@ -0,0 +1,2 @@
+import { EventHandler } from './addEventListener';
+export default function filterEvents<K extends keyof HTMLElementEventMap>(selector: string, handler: EventHandler<K>): EventHandler<K>;

node_modules/dom-helpers/cjs/filterEventHandler.js

@@ -0,0 +1,23 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = filterEvents;
+
+var _contains = _interopRequireDefault(require("./contains"));
+
+var _querySelectorAll = _interopRequireDefault(require("./querySelectorAll"));
+
+function filterEvents(selector, handler) {
+  return function filterHandler(e) {
+    var top = e.currentTarget;
+    var target = e.target;
+    var matches = (0, _querySelectorAll.default)(top, selector);
+    if (matches.some(function (match) {
+      return (0, _contains.default)(match, target);
+    })) handler.call(this, e);
+  };
+}
+
+module.exports = exports["default"];

node_modules/dom-helpers/cjs/getComputedStyle.d.ts

@@ -0,0 +1 @@
+export default function getComputedStyle(node: HTMLElement, psuedoElement?: string): CSSStyleDeclaration;

node_modules/dom-helpers/cjs/getComputedStyle.js

@@ -0,0 +1,14 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = getComputedStyle;
+
+var _ownerWindow = _interopRequireDefault(require("./ownerWindow"));
+
+function getComputedStyle(node, psuedoElement) {
+  return (0, _ownerWindow.default)(node).getComputedStyle(node, psuedoElement);
+}
+
+module.exports = exports["default"];

node_modules/dom-helpers/cjs/getScrollAccessor.d.ts

@@ -0,0 +1,4 @@
+export default function getscrollAccessor(offset: 'pageXOffset' | 'pageYOffset'): {
+    (node: Element): number;
+    (node: Element, val: number): undefined;
+};

node_modules/dom-helpers/cjs/getScrollAccessor.js

@@ -0,0 +1,30 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = getscrollAccessor;
+
+var _isWindow = _interopRequireDefault(require("./isWindow"));
+
+function getscrollAccessor(offset) {
+  var prop = offset === 'pageXOffset' ? 'scrollLeft' : 'scrollTop';
+
+  function scrollAccessor(node, val) {
+    var win = (0, _isWindow.default)(node);
+
+    if (val === undefined) {
+      return win ? win[offset] : node[prop];
+    }
+
+    if (win) {
+      win.scrollTo(win[offset], val);
+    } else {
+      node[prop] = val;
+    }
+  }
+
+  return scrollAccessor;
+}
+
+module.exports = exports["default"];

node_modules/dom-helpers/cjs/hasClass.d.ts

@@ -0,0 +1 @@
+export default function hasClass(element: Element | SVGElement, className: string): boolean;

node_modules/dom-helpers/cjs/hasClass.js

@@ -0,0 +1,11 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = hasClass;
+
+function hasClass(element, className) {
+  if (element.classList) return !!className && element.classList.contains(className);
+  return (" " + (element.className.baseVal || element.className) + " ").indexOf(" " + className + " ") !== -1;
+}
+
+module.exports = exports["default"];

node_modules/dom-helpers/cjs/height.d.ts

@@ -0,0 +1 @@
+export default function height(node: HTMLElement, client?: boolean): number;

node_modules/dom-helpers/cjs/height.js

@@ -0,0 +1,17 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = height;
+
+var _isWindow = _interopRequireDefault(require("./isWindow"));
+
+var _offset = _interopRequireDefault(require("./offset"));
+
+function height(node, client) {
+  var win = (0, _isWindow.default)(node);
+  return win ? win.innerHeight : client ? node.clientHeight : (0, _offset.default)(node).height;
+}
+
+module.exports = exports["default"];

node_modules/dom-helpers/cjs/hyphenate.d.ts

@@ -0,0 +1 @@
+export default function hyphenate(string: string): string;

node_modules/dom-helpers/cjs/hyphenate.js

@@ -0,0 +1,11 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = hyphenate;
+var rUpper = /([A-Z])/g;
+
+function hyphenate(string) {
+  return string.replace(rUpper, '-$1').toLowerCase();
+}
+
+module.exports = exports["default"];

node_modules/dom-helpers/cjs/hyphenateStyle.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Copyright 2013-2014, Facebook, Inc.
+ * All rights reserved.
+ * https://github.com/facebook/react/blob/2aeb8a2a6beb00617a4217f7f8284924fa2ad819/src/vendor/core/hyphenateStyleName.js
+ */
+import { Property } from './types';
+export default function hyphenateStyleName(string: Property): Property;

node_modules/dom-helpers/cjs/hyphenateStyle.js

@@ -0,0 +1,21 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = hyphenateStyleName;
+
+var _hyphenate = _interopRequireDefault(require("./hyphenate"));
+
+/**
+ * Copyright 2013-2014, Facebook, Inc.
+ * All rights reserved.
+ * https://github.com/facebook/react/blob/2aeb8a2a6beb00617a4217f7f8284924fa2ad819/src/vendor/core/hyphenateStyleName.js
+ */
+var msPattern = /^ms-/;
+
+function hyphenateStyleName(string) {
+  return (0, _hyphenate.default)(string).replace(msPattern, '-ms-');
+}
+
+module.exports = exports["default"];

node_modules/dom-helpers/cjs/index.d.ts

@@ -0,0 +1,71 @@
+import activeElement from './activeElement';
+import addClass from './addClass';
+import addEventListener from './addEventListener';
+import animate from './animate';
+import { cancel as cancelAnimationFrame, request as requestAnimationFrame } from './animationFrame';
+import closest from './closest';
+import contains from './contains';
+import style from './css';
+import filter from './filterEventHandler';
+import getComputedStyle from './getComputedStyle';
+import hasClass from './hasClass';
+import height from './height';
+import listen from './listen';
+import matches from './matches';
+import offset from './offset';
+import offsetParent from './offsetParent';
+import ownerDocument from './ownerDocument';
+import ownerWindow from './ownerWindow';
+import position from './position';
+import querySelectorAll from './querySelectorAll';
+import removeClass from './removeClass';
+import removeEventListener from './removeEventListener';
+import scrollbarSize from './scrollbarSize';
+import scrollLeft from './scrollLeft';
+import scrollParent from './scrollParent';
+import scrollTo from './scrollTo';
+import scrollTop from './scrollTop';
+import toggleClass from './toggleClass';
+import transitionEnd from './transitionEnd';
+import width from './width';
+export { addEventListener, removeEventListener, animate, filter, listen, style, getComputedStyle, activeElement, ownerDocument, ownerWindow, requestAnimationFrame, cancelAnimationFrame, matches, height, width, offset, offsetParent, position, contains, scrollbarSize, scrollLeft, scrollParent, scrollTo, scrollTop, querySelectorAll, closest, addClass, removeClass, hasClass, toggleClass, transitionEnd, };
+declare const _default: {
+    addEventListener: typeof addEventListener;
+    removeEventListener: typeof removeEventListener;
+    animate: typeof animate;
+    filter: typeof filter;
+    listen: typeof listen;
+    style: typeof style;
+    getComputedStyle: typeof getComputedStyle;
+    activeElement: typeof activeElement;
+    ownerDocument: typeof ownerDocument;
+    ownerWindow: typeof ownerWindow;
+    requestAnimationFrame: typeof globalThis.requestAnimationFrame;
+    cancelAnimationFrame: (id: number) => void;
+    matches: typeof matches;
+    height: typeof height;
+    width: typeof width;
+    offset: typeof offset;
+    offsetParent: typeof offsetParent;
+    position: typeof position;
+    contains: typeof contains;
+    scrollbarSize: typeof scrollbarSize;
+    scrollLeft: {
+        (node: Element): number;
+        (node: Element, val: number): undefined;
+    };
+    scrollParent: typeof scrollParent;
+    scrollTo: typeof scrollTo;
+    scrollTop: {
+        (node: Element): number;
+        (node: Element, val: number): undefined;
+    };
+    querySelectorAll: typeof querySelectorAll;
+    closest: typeof closest;
+    addClass: typeof addClass;
+    removeClass: typeof removeClass;
+    hasClass: typeof hasClass;
+    toggleClass: typeof toggleClass;
+    transitionEnd: typeof transitionEnd;
+};
+export default _default;

node_modules/dom-helpers/cjs/index.js

@@ -0,0 +1,161 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _activeElement = _interopRequireDefault(require("./activeElement"));
+
+exports.activeElement = _activeElement.default;
+
+var _addClass = _interopRequireDefault(require("./addClass"));
+
+exports.addClass = _addClass.default;
+
+var _addEventListener = _interopRequireDefault(require("./addEventListener"));
+
+exports.addEventListener = _addEventListener.default;
+
+var _animate = _interopRequireDefault(require("./animate"));
+
+exports.animate = _animate.default;
+
+var _animationFrame = require("./animationFrame");
+
+exports.cancelAnimationFrame = _animationFrame.cancel;
+exports.requestAnimationFrame = _animationFrame.request;
+
+var _closest = _interopRequireDefault(require("./closest"));
+
+exports.closest = _closest.default;
+
+var _contains = _interopRequireDefault(require("./contains"));
+
+exports.contains = _contains.default;
+
+var _css = _interopRequireDefault(require("./css"));
+
+exports.style = _css.default;
+
+var _filterEventHandler = _interopRequireDefault(require("./filterEventHandler"));
+
+exports.filter = _filterEventHandler.default;
+
+var _getComputedStyle = _interopRequireDefault(require("./getComputedStyle"));
+
+exports.getComputedStyle = _getComputedStyle.default;
+
+var _hasClass = _interopRequireDefault(require("./hasClass"));
+
+exports.hasClass = _hasClass.default;
+
+var _height = _interopRequireDefault(require("./height"));
+
+exports.height = _height.default;
+
+var _listen = _interopRequireDefault(require("./listen"));
+
+exports.listen = _listen.default;
+
+var _matches = _interopRequireDefault(require("./matches"));
+
+exports.matches = _matches.default;
+
+var _offset = _interopRequireDefault(require("./offset"));
+
+exports.offset = _offset.default;
+
+var _offsetParent = _interopRequireDefault(require("./offsetParent"));
+
+exports.offsetParent = _offsetParent.default;
+
+var _ownerDocument = _interopRequireDefault(require("./ownerDocument"));
+
+exports.ownerDocument = _ownerDocument.default;
+
+var _ownerWindow = _interopRequireDefault(require("./ownerWindow"));
+
+exports.ownerWindow = _ownerWindow.default;
+
+var _position = _interopRequireDefault(require("./position"));
+
+exports.position = _position.default;
+
+var _querySelectorAll = _interopRequireDefault(require("./querySelectorAll"));
+
+exports.querySelectorAll = _querySelectorAll.default;
+
+var _removeClass = _interopRequireDefault(require("./removeClass"));
+
+exports.removeClass = _removeClass.default;
+
+var _removeEventListener = _interopRequireDefault(require("./removeEventListener"));
+
+exports.removeEventListener = _removeEventListener.default;
+
+var _scrollbarSize = _interopRequireDefault(require("./scrollbarSize"));
+
+exports.scrollbarSize = _scrollbarSize.default;
+
+var _scrollLeft = _interopRequireDefault(require("./scrollLeft"));
+
+exports.scrollLeft = _scrollLeft.default;
+
+var _scrollParent = _interopRequireDefault(require("./scrollParent"));
+
+exports.scrollParent = _scrollParent.default;
+
+var _scrollTo = _interopRequireDefault(require("./scrollTo"));
+
+exports.scrollTo = _scrollTo.default;
+
+var _scrollTop = _interopRequireDefault(require("./scrollTop"));
+
+exports.scrollTop = _scrollTop.default;
+
+var _toggleClass = _interopRequireDefault(require("./toggleClass"));
+
+exports.toggleClass = _toggleClass.default;
+
+var _transitionEnd = _interopRequireDefault(require("./transitionEnd"));
+
+exports.transitionEnd = _transitionEnd.default;
+
+var _width = _interopRequireDefault(require("./width"));
+
+exports.width = _width.default;
+var _default = {
+  addEventListener: _addEventListener.default,
+  removeEventListener: _removeEventListener.default,
+  animate: _animate.default,
+  filter: _filterEventHandler.default,
+  listen: _listen.default,
+  style: _css.default,
+  getComputedStyle: _getComputedStyle.default,
+  activeElement: _activeElement.default,
+  ownerDocument: _ownerDocument.default,
+  ownerWindow: _ownerWindow.default,
+  requestAnimationFrame: _animationFrame.request,
+  cancelAnimationFrame: _animationFrame.cancel,
+  matches: _matches.default,
+  height: _height.default,
+  width: _width.default,
+  offset: _offset.default,
+  offsetParent: _offsetParent.default,
+  position: _position.default,
+  contains: _contains.default,
+  scrollbarSize: _scrollbarSize.default,
+  scrollLeft: _scrollLeft.default,
+  scrollParent: _scrollParent.default,
+  scrollTo: _scrollTo.default,
+  scrollTop: _scrollTop.default,
+  querySelectorAll: _querySelectorAll.default,
+  closest: _closest.default,
+  addClass: _addClass.default,
+  removeClass: _removeClass.default,
+  hasClass: _hasClass.default,
+  toggleClass: _toggleClass.default,
+  transitionEnd: _transitionEnd.default
+};
+exports.default = _default;

node_modules/dom-helpers/cjs/isDocument.d.ts

@@ -0,0 +1 @@
+export default function isDocument(element: Element | Document | Window): element is Document;

node_modules/dom-helpers/cjs/isDocument.js

@@ -0,0 +1,10 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = isDocument;
+
+function isDocument(element) {
+  return 'nodeType' in element && element.nodeType === document.DOCUMENT_NODE;
+}
+
+module.exports = exports["default"];

node_modules/dom-helpers/cjs/isTransform.d.ts

@@ -0,0 +1,2 @@
+export declare type TransformValue = 'translate' | 'translateY' | 'translateX' | 'translateZ' | 'translate3d' | 'rotate' | 'rotateY' | 'rotateX' | 'rotateZ' | 'rotate3d' | 'scale' | 'scaleY' | 'scaleX' | 'scaleZ' | 'scale3d' | 'matrix' | 'matrix3d' | 'perspective' | 'skew' | 'skewY' | 'skewX';
+export default function isTransform(value: string): value is TransformValue;

node_modules/dom-helpers/cjs/isTransform.js

@@ -0,0 +1,11 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = isTransform;
+var supportedTransforms = /^((translate|rotate|scale)(X|Y|Z|3d)?|matrix(3d)?|perspective|skew(X|Y)?)$/i;
+
+function isTransform(value) {
+  return !!(value && supportedTransforms.test(value));
+}
+
+module.exports = exports["default"];

node_modules/dom-helpers/cjs/isWindow.d.ts

@@ -0,0 +1 @@
+export default function isWindow(node: Element | Document | Window): Window | false;

node_modules/dom-helpers/cjs/isWindow.js

@@ -0,0 +1,16 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = isWindow;
+
+var _isDocument = _interopRequireDefault(require("./isDocument"));
+
+function isWindow(node) {
+  if ('window' in node && node.window === node) return node;
+  if ((0, _isDocument.default)(node)) return node.defaultView || false;
+  return false;
+}
+
+module.exports = exports["default"];

node_modules/dom-helpers/cjs/listen.d.ts

@@ -0,0 +1,3 @@
+import { EventHandler } from './addEventListener';
+declare function listen<K extends keyof HTMLElementEventMap>(node: HTMLElement, eventName: K, handler: EventHandler<K>, options?: boolean | AddEventListenerOptions): () => void;
+export default listen;

node_modules/dom-helpers/cjs/listen.js

@@ -0,0 +1,21 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _addEventListener = _interopRequireDefault(require("./addEventListener"));
+
+var _removeEventListener = _interopRequireDefault(require("./removeEventListener"));
+
+function listen(node, eventName, handler, options) {
+  (0, _addEventListener.default)(node, eventName, handler, options);
+  return function () {
+    (0, _removeEventListener.default)(node, eventName, handler, options);
+  };
+}
+
+var _default = listen;
+exports.default = _default;
+module.exports = exports["default"];

node_modules/dom-helpers/cjs/matches.d.ts

@@ -0,0 +1 @@
+export default function matches(node: Element, selector: string): boolean;

node_modules/dom-helpers/cjs/matches.js

@@ -0,0 +1,20 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = matches;
+var matchesImpl;
+
+function matches(node, selector) {
+  if (!matchesImpl) {
+    var body = document.body;
+    var nativeMatch = body.matches || body.matchesSelector || body.webkitMatchesSelector || body.mozMatchesSelector || body.msMatchesSelector;
+
+    matchesImpl = function matchesImpl(n, s) {
+      return nativeMatch.call(n, s);
+    };
+  }
+
+  return matchesImpl(node, selector);
+}
+
+module.exports = exports["default"];

node_modules/dom-helpers/cjs/offset.d.ts

@@ -0,0 +1,6 @@
+export default function offset(node: HTMLElement): {
+    top: number;
+    left: number;
+    height: number;
+    width: number;
+};

node_modules/dom-helpers/cjs/offset.js

@@ -0,0 +1,37 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = offset;
+
+var _contains = _interopRequireDefault(require("./contains"));
+
+var _ownerDocument = _interopRequireDefault(require("./ownerDocument"));
+
+var _scrollLeft = _interopRequireDefault(require("./scrollLeft"));
+
+var _scrollTop = _interopRequireDefault(require("./scrollTop"));
+
+function offset(node) {
+  var doc = (0, _ownerDocument.default)(node);
+  var box = {
+    top: 0,
+    left: 0,
+    height: 0,
+    width: 0
+  };
+  var docElem = doc && doc.documentElement; // Make sure it's not a disconnected DOM node
+
+  if (!docElem || !(0, _contains.default)(docElem, node)) return box;
+  if (node.getBoundingClientRect !== undefined) box = node.getBoundingClientRect();
+  box = {
+    top: box.top + (0, _scrollTop.default)(docElem) - (docElem.clientTop || 0),
+    left: box.left + (0, _scrollLeft.default)(docElem) - (docElem.clientLeft || 0),
+    width: box.width,
+    height: box.height
+  };
+  return box;
+}
+
+module.exports = exports["default"];

node_modules/dom-helpers/cjs/offsetParent.d.ts

@@ -0,0 +1 @@
+export default function offsetParent(node: HTMLElement): HTMLElement;

node_modules/dom-helpers/cjs/offsetParent.js

@@ -0,0 +1,27 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = offsetParent;
+
+var _css = _interopRequireDefault(require("./css"));
+
+var _ownerDocument = _interopRequireDefault(require("./ownerDocument"));
+
+var isHTMLElement = function isHTMLElement(e) {
+  return !!e && 'offsetParent' in e;
+};
+
+function offsetParent(node) {
+  var doc = (0, _ownerDocument.default)(node);
+  var parent = node && node.offsetParent;
+
+  while (isHTMLElement(parent) && parent.nodeName !== 'HTML' && (0, _css.default)(parent, 'position') === 'static') {
+    parent = parent.offsetParent;
+  }
+
+  return parent || doc.documentElement;
+}
+
+module.exports = exports["default"];

node_modules/dom-helpers/cjs/ownerDocument.d.ts

@@ -0,0 +1 @@
+export default function ownerDocument(node?: Element): Document;

node_modules/dom-helpers/cjs/ownerDocument.js

@@ -0,0 +1,10 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = ownerDocument;
+
+function ownerDocument(node) {
+  return node && node.ownerDocument || document;
+}
+
+module.exports = exports["default"];

node_modules/dom-helpers/cjs/ownerWindow.d.ts

@@ -0,0 +1 @@
+export default function ownerWindow(node?: Element): Window;

node_modules/dom-helpers/cjs/ownerWindow.js

@@ -0,0 +1,15 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = ownerWindow;
+
+var _ownerDocument = _interopRequireDefault(require("./ownerDocument"));
+
+function ownerWindow(node) {
+  var doc = (0, _ownerDocument.default)(node);
+  return doc && doc.defaultView || window;
+}
+
+module.exports = exports["default"];

node_modules/dom-helpers/cjs/position.d.ts

@@ -0,0 +1,6 @@
+export default function position(node: HTMLElement, offsetParent?: HTMLElement): {
+    top: number;
+    left: number;
+    height: number;
+    width: number;
+};

node_modules/dom-helpers/cjs/position.js

@@ -0,0 +1,53 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = position;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _css = _interopRequireDefault(require("./css"));
+
+var _offset = _interopRequireDefault(require("./offset"));
+
+var _offsetParent = _interopRequireDefault(require("./offsetParent"));
+
+var _scrollLeft = _interopRequireDefault(require("./scrollLeft"));
+
+var _scrollTop = _interopRequireDefault(require("./scrollTop"));
+
+var nodeName = function nodeName(node) {
+  return node.nodeName && node.nodeName.toLowerCase();
+};
+
+function position(node, offsetParent) {
+  var parentOffset = {
+    top: 0,
+    left: 0
+  };
+  var offset; // Fixed elements are offset from window (parentOffset = {top:0, left: 0},
+  // because it is its only offset parent
+
+  if ((0, _css.default)(node, 'position') === 'fixed') {
+    offset = node.getBoundingClientRect();
+  } else {
+    var parent = offsetParent || (0, _offsetParent.default)(node);
+    offset = (0, _offset.default)(node);
+    if (nodeName(parent) !== 'html') parentOffset = (0, _offset.default)(parent);
+    var borderTop = String((0, _css.default)(parent, 'borderTopWidth') || 0);
+    parentOffset.top += parseInt(borderTop, 10) - (0, _scrollTop.default)(parent) || 0;
+    var borderLeft = String((0, _css.default)(parent, 'borderLeftWidth') || 0);
+    parentOffset.left += parseInt(borderLeft, 10) - (0, _scrollLeft.default)(parent) || 0;
+  }
+
+  var marginTop = String((0, _css.default)(node, 'marginTop') || 0);
+  var marginLeft = String((0, _css.default)(node, 'marginLeft') || 0); // Subtract parent offsets and node margins
+
+  return (0, _extends2.default)({}, offset, {
+    top: offset.top - parentOffset.top - (parseInt(marginTop, 10) || 0),
+    left: offset.left - parentOffset.left - (parseInt(marginLeft, 10) || 0)
+  });
+}
+
+module.exports = exports["default"];

node_modules/dom-helpers/cjs/querySelectorAll.d.ts

@@ -0,0 +1 @@
+export default function qsa(element: HTMLElement | Document, selector: string): HTMLElement[];

node_modules/dom-helpers/cjs/querySelectorAll.js

@@ -0,0 +1,11 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = qsa;
+var toArray = Function.prototype.bind.call(Function.prototype.call, [].slice);
+
+function qsa(element, selector) {
+  return toArray(element.querySelectorAll(selector));
+}
+
+module.exports = exports["default"];

node_modules/dom-helpers/cjs/removeClass.d.ts

@@ -0,0 +1 @@
+export default function removeClass(element: Element | SVGElement, className: string): void;

node_modules/dom-helpers/cjs/removeClass.js

@@ -0,0 +1,21 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = removeClass;
+
+function replaceClassName(origClass, classToRemove) {
+  return origClass.replace(new RegExp("(^|\\s)" + classToRemove + "(?:\\s|$)", 'g'), '$1').replace(/\s+/g, ' ').replace(/^\s*|\s*$/g, '');
+}
+
+function removeClass(element, className) {
+  if (element.classList) {
+    element.classList.remove(className);
+  } else if (typeof element.className === 'string') {
+    ;
+    element.className = replaceClassName(element.className, className);
+  } else {
+    element.setAttribute('class', replaceClassName(element.className && element.className.baseVal || '', className));
+  }
+}
+
+module.exports = exports["default"];

node_modules/dom-helpers/cjs/removeEventListener.d.ts

@@ -0,0 +1,3 @@
+import { TaggedEventHandler } from './addEventListener';
+declare function removeEventListener<K extends keyof HTMLElementEventMap>(node: HTMLElement, eventName: K, handler: TaggedEventHandler<K>, options?: boolean | EventListenerOptions): void;
+export default removeEventListener;

node_modules/dom-helpers/cjs/removeEventListener.js

@@ -0,0 +1,17 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+function removeEventListener(node, eventName, handler, options) {
+  var capture = options && typeof options !== 'boolean' ? options.capture : options;
+  node.removeEventListener(eventName, handler, capture);
+
+  if (handler.__once) {
+    node.removeEventListener(eventName, handler.__once, capture);
+  }
+}
+
+var _default = removeEventListener;
+exports.default = _default;
+module.exports = exports["default"];

node_modules/dom-helpers/cjs/scrollLeft.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    (node: Element): number;
+    (node: Element, val: number): undefined;
+};
+export default _default;

node_modules/dom-helpers/cjs/scrollLeft.js

@@ -0,0 +1,13 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _getScrollAccessor = _interopRequireDefault(require("./getScrollAccessor"));
+
+var _default = (0, _getScrollAccessor.default)('pageXOffset');
+
+exports.default = _default;
+module.exports = exports["default"];

node_modules/dom-helpers/cjs/scrollParent.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Find the first scrollable parent of an element.
+ *
+ * @param element Starting element
+ * @param firstPossible Stop at the first scrollable parent, even if it's not currently scrollable
+ */
+export default function scrollParent(element: HTMLElement, firstPossible?: boolean): Document | HTMLElement;

node_modules/dom-helpers/cjs/scrollParent.js

@@ -0,0 +1,41 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = scrollParent;
+
+var _css = _interopRequireDefault(require("./css"));
+
+var _height = _interopRequireDefault(require("./height"));
+
+var _isDocument = _interopRequireDefault(require("./isDocument"));
+
+/* eslint-disable no-cond-assign, no-continue */
+
+/**
+ * Find the first scrollable parent of an element.
+ *
+ * @param element Starting element
+ * @param firstPossible Stop at the first scrollable parent, even if it's not currently scrollable
+ */
+function scrollParent(element, firstPossible) {
+  var position = (0, _css.default)(element, 'position');
+  var excludeStatic = position === 'absolute';
+  var ownerDoc = element.ownerDocument;
+  if (position === 'fixed') return ownerDoc || document; // @ts-ignore
+
+  while ((element = element.parentNode) && !(0, _isDocument.default)(element)) {
+    var isStatic = excludeStatic && (0, _css.default)(element, 'position') === 'static';
+    var style = ((0, _css.default)(element, 'overflow') || '') + ((0, _css.default)(element, 'overflow-y') || '') + (0, _css.default)(element, 'overflow-x');
+    if (isStatic) continue;
+
+    if (/(auto|scroll)/.test(style) && (firstPossible || (0, _height.default)(element) < element.scrollHeight)) {
+      return element;
+    }
+  }
+
+  return ownerDoc || document;
+}
+
+module.exports = exports["default"];

node_modules/dom-helpers/cjs/scrollTo.d.ts

@@ -0,0 +1 @@
+export default function scrollTo(selected: HTMLElement, scrollParent?: HTMLElement): (() => void) | undefined;

node_modules/dom-helpers/cjs/scrollTo.js

@@ -0,0 +1,51 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = scrollTo;
+
+var _animationFrame = require("./animationFrame");
+
+var _height = _interopRequireDefault(require("./height"));
+
+var _isWindow = _interopRequireDefault(require("./isWindow"));
+
+var _offset = _interopRequireDefault(require("./offset"));
+
+var _scrollParent = _interopRequireDefault(require("./scrollParent"));
+
+var _scrollTop = _interopRequireDefault(require("./scrollTop"));
+
+/* eslint-disable no-nested-ternary */
+function scrollTo(selected, scrollParent) {
+  var offset = (0, _offset.default)(selected);
+  var poff = {
+    top: 0,
+    left: 0
+  };
+  if (!selected) return undefined;
+  var list = scrollParent || (0, _scrollParent.default)(selected);
+  var isWin = (0, _isWindow.default)(list);
+  var listScrollTop = (0, _scrollTop.default)(list);
+  var listHeight = (0, _height.default)(list, true);
+  if (!isWin) poff = (0, _offset.default)(list);
+  offset = {
+    top: offset.top - poff.top,
+    left: offset.left - poff.left,
+    height: offset.height,
+    width: offset.width
+  };
+  var selectedHeight = offset.height;
+  var selectedTop = offset.top + (isWin ? 0 : listScrollTop);
+  var bottom = selectedTop + selectedHeight;
+  listScrollTop = listScrollTop > selectedTop ? selectedTop : bottom > listScrollTop + listHeight ? bottom - listHeight : listScrollTop;
+  var id = (0, _animationFrame.request)(function () {
+    return (0, _scrollTop.default)(list, listScrollTop);
+  });
+  return function () {
+    return (0, _animationFrame.cancel)(id);
+  };
+}
+
+module.exports = exports["default"];

node_modules/dom-helpers/cjs/scrollTop.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    (node: Element): number;
+    (node: Element, val: number): undefined;
+};
+export default _default;

node_modules/dom-helpers/cjs/scrollTop.js

@@ -0,0 +1,13 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _getScrollAccessor = _interopRequireDefault(require("./getScrollAccessor"));
+
+var _default = (0, _getScrollAccessor.default)('pageYOffset');
+
+exports.default = _default;
+module.exports = exports["default"];

node_modules/dom-helpers/cjs/scrollbarSize.d.ts

@@ -0,0 +1 @@
+export default function scrollbarSize(recalc?: boolean): number;

node_modules/dom-helpers/cjs/scrollbarSize.js

@@ -0,0 +1,30 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = scrollbarSize;
+
+var _canUseDOM = _interopRequireDefault(require("./canUseDOM"));
+
+var size;
+
+function scrollbarSize(recalc) {
+  if (!size && size !== 0 || recalc) {
+    if (_canUseDOM.default) {
+      var scrollDiv = document.createElement('div');
+      scrollDiv.style.position = 'absolute';
+      scrollDiv.style.top = '-9999px';
+      scrollDiv.style.width = '50px';
+      scrollDiv.style.height = '50px';
+      scrollDiv.style.overflow = 'scroll';
+      document.body.appendChild(scrollDiv);
+      size = scrollDiv.offsetWidth - scrollDiv.clientWidth;
+      document.body.removeChild(scrollDiv);
+    }
+  }
+
+  return size;
+}
+
+module.exports = exports["default"];

node_modules/dom-helpers/cjs/toggleClass.d.ts

@@ -0,0 +1 @@
+export default function toggleClass(element: Element | SVGElement, className: string): void;

node_modules/dom-helpers/cjs/toggleClass.js

@@ -0,0 +1,18 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = toggleClass;
+
+var _addClass = _interopRequireDefault(require("./addClass"));
+
+var _hasClass = _interopRequireDefault(require("./hasClass"));
+
+var _removeClass = _interopRequireDefault(require("./removeClass"));
+
+function toggleClass(element, className) {
+  if (element.classList) element.classList.toggle(className);else if ((0, _hasClass.default)(element, className)) (0, _removeClass.default)(element, className);else (0, _addClass.default)(element, className);
+}
+
+module.exports = exports["default"];

node_modules/dom-helpers/cjs/transitionEnd.d.ts

@@ -0,0 +1,5 @@
+export declare type Listener = (this: HTMLElement, ev: TransitionEvent) => any;
+export declare const TRANSITION_SUPPORTED: boolean;
+export declare function parseDuration(node: HTMLElement): number;
+declare function transitionEnd(element: HTMLElement, handler: Listener, duration?: number): () => void;
+export default transitionEnd;

node_modules/dom-helpers/cjs/transitionEnd.js

@@ -0,0 +1,61 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.parseDuration = parseDuration;
+exports.default = exports.TRANSITION_SUPPORTED = void 0;
+
+var _canUseDOM = _interopRequireDefault(require("./canUseDOM"));
+
+var _css = _interopRequireDefault(require("./css"));
+
+var _listen = _interopRequireDefault(require("./listen"));
+
+var TRANSITION_SUPPORTED = _canUseDOM.default && 'ontransitionend' in window;
+exports.TRANSITION_SUPPORTED = TRANSITION_SUPPORTED;
+
+function parseDuration(node) {
+  var str = (0, _css.default)(node, 'transitionDuration') || '';
+  var mult = str.indexOf('ms') === -1 ? 1000 : 1;
+  return parseFloat(str) * mult;
+}
+
+function triggerTransitionEnd(element) {
+  var evt = document.createEvent('HTMLEvents');
+  evt.initEvent('transitionend', true, true);
+  element.dispatchEvent(evt);
+}
+
+function emulateTransitionEnd(element, duration, padding) {
+  if (padding === void 0) {
+    padding = 5;
+  }
+
+  var called = false;
+  var handle = setTimeout(function () {
+    if (!called) triggerTransitionEnd(element);
+  }, duration + padding);
+  var remove = (0, _listen.default)(element, 'transitionend', function () {
+    called = true;
+  }, {
+    once: true
+  });
+  return function () {
+    clearTimeout(handle);
+    remove();
+  };
+}
+
+function transitionEnd(element, handler, duration) {
+  if (duration == null) duration = parseDuration(element) || 0;
+  var removeEmulate = emulateTransitionEnd(element, duration);
+  var remove = (0, _listen.default)(element, 'transitionend', handler);
+  return function () {
+    removeEmulate();
+    remove();
+  };
+}
+
+var _default = transitionEnd;
+exports.default = _default;

node_modules/dom-helpers/cjs/types.d.ts

@@ -0,0 +1,8 @@
+import * as CSS from 'csstype'
+
+type Styles = keyof CSSStyleDeclaration
+
+export type HyphenProperty = keyof CSS.PropertiesHyphen
+export type CamelProperty = keyof CSS.Properties
+
+export type Property = HyphenProperty | CamelProperty

node_modules/dom-helpers/cjs/width.d.ts

@@ -0,0 +1 @@
+export default function getWidth(node: HTMLElement, client?: boolean): number;

node_modules/dom-helpers/cjs/width.js

@@ -0,0 +1,17 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = getWidth;
+
+var _isWindow = _interopRequireDefault(require("./isWindow"));
+
+var _offset = _interopRequireDefault(require("./offset"));
+
+function getWidth(node, client) {
+  var win = (0, _isWindow.default)(node);
+  return win ? win.innerWidth : client ? node.clientWidth : (0, _offset.default)(node).width;
+}
+
+module.exports = exports["default"];

node_modules/dom-helpers/closest/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "dom-helpers/closest",
+  "private": true,
+  "main": "../cjs/closest.js",
+  "module": "../esm/closest.js",
+  "types": "../esm/closest.d.ts"
+}

node_modules/dom-helpers/contains/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "dom-helpers/contains",
+  "private": true,
+  "main": "../cjs/contains.js",
+  "module": "../esm/contains.js",
+  "types": "../esm/contains.d.ts"
+}

node_modules/dom-helpers/css/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "dom-helpers/css",
+  "private": true,
+  "main": "../cjs/css.js",
+  "module": "../esm/css.js",
+  "types": "../esm/css.d.ts"
+}

node_modules/dom-helpers/esm/activeElement.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Return the actively focused element safely.
+ *
+ * @param doc the document to checl
+ */
+export default function activeElement(doc?: Document): Element | null;

node_modules/dom-helpers/esm/activeElement.js

@@ -0,0 +1,25 @@
+import ownerDocument from './ownerDocument';
+/**
+ * Return the actively focused element safely.
+ *
+ * @param doc the document to checl
+ */
+
+export default function activeElement(doc) {
+  if (doc === void 0) {
+    doc = ownerDocument();
+  }
+
+  // Support: IE 9 only
+  // IE9 throws an "Unspecified error" accessing document.activeElement from an <iframe>
+  try {
+    var active = doc.activeElement; // IE11 returns a seemingly empty object in some cases when accessing
+    // document.activeElement from an <iframe>
+
+    if (!active || !active.nodeName) return null;
+    return active;
+  } catch (e) {
+    /* ie throws if no active element */
+    return doc.body;
+  }
+}

node_modules/dom-helpers/esm/addClass.d.ts

@@ -0,0 +1 @@
+export default function addClass(element: Element | SVGElement, className: string): void;

node_modules/dom-helpers/esm/addClass.js

@@ -0,0 +1,4 @@
+import hasClass from './hasClass';
+export default function addClass(element, className) {
+  if (element.classList) element.classList.add(className);else if (!hasClass(element, className)) if (typeof element.className === 'string') element.className = element.className + " " + className;else element.setAttribute('class', (element.className && element.className.baseVal || '') + " " + className);
+}

node_modules/dom-helpers/esm/addEventListener.d.ts

@@ -0,0 +1,11 @@
+export declare let optionsSupported: boolean;
+export declare let onceSupported: boolean;
+export declare type EventHandler<K extends keyof HTMLElementEventMap> = (this: HTMLElement, event: HTMLElementEventMap[K]) => any;
+export declare type TaggedEventHandler<K extends keyof HTMLElementEventMap> = EventHandler<K> & {
+    __once?: EventHandler<K>;
+};
+/**
+ * An `addEventListener` ponyfill, supports the `once` option
+ */
+declare function addEventListener<K extends keyof HTMLElementEventMap>(node: HTMLElement, eventName: K, handler: TaggedEventHandler<K>, options?: boolean | AddEventListenerOptions): void;
+export default addEventListener;

node_modules/dom-helpers/esm/addEventListener.js

@@ -0,0 +1,51 @@
+/* eslint-disable no-return-assign */
+import canUseDOM from './canUseDOM';
+export var optionsSupported = false;
+export var onceSupported = false;
+
+try {
+  var options = {
+    get passive() {
+      return optionsSupported = true;
+    },
+
+    get once() {
+      // eslint-disable-next-line no-multi-assign
+      return onceSupported = optionsSupported = true;
+    }
+
+  };
+
+  if (canUseDOM) {
+    window.addEventListener('test', options, options);
+    window.removeEventListener('test', options, true);
+  }
+} catch (e) {
+  /* */
+}
+
+/**
+ * An `addEventListener` ponyfill, supports the `once` option
+ */
+function addEventListener(node, eventName, handler, options) {
+  if (options && typeof options !== 'boolean' && !onceSupported) {
+    var once = options.once,
+        capture = options.capture;
+    var wrappedHandler = handler;
+
+    if (!onceSupported && once) {
+      wrappedHandler = handler.__once || function onceHandler(event) {
+        this.removeEventListener(eventName, onceHandler, capture);
+        handler.call(this, event);
+      };
+
+      handler.__once = wrappedHandler;
+    }
+
+    node.addEventListener(eventName, wrappedHandler, optionsSupported ? options : capture);
+  }
+
+  node.addEventListener(eventName, handler, options);
+}
+
+export default addEventListener;