@mjhls/mjh-framework 1.0.879 → 1.0.880-beta.0

package/dist/cjs/Auth.js

@@ -2,33 +2,28 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var asyncToGenerator = require('./asyncToGenerator-77821af0.js');
-var stringify = require('./stringify-f7a37a8d.js');
-var slicedToArray = require('./slicedToArray-067dd3bc.js');
+function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
+
+var _commonjsHelpers = require('./_commonjsHelpers-06173234.js');
+require('./core.get-iterator-method-f3c44602.js');
+require('./_library-dd23b178.js');
+require('./_iter-detect-05795553.js');
+require('./_object-pie-68c5bcbc.js');
+var _extends$1 = require('./extends-eed4f016.js');
+require('./web.dom.iterable-e34bf324.js');
 var React = require('react');
+var React__default = _interopDefault(React);
 var Router = require('next/router');
-var _extends = require('./extends-7c86182f.js');
+var Router__default = _interopDefault(Router);
+var slicedToArray = require('./slicedToArray-f6d4eaa8.js');
+var stringify = require('./stringify-bbc68047.js');
+var asyncToGenerator = require('./asyncToGenerator-df19209d.js');
 var reactBootstrap = require('react-bootstrap');
-var useSWR = require('swr');
-var index = require('./index-bd6c9f56.js');
-var Local = require('passport-local');
-var mysql = require('mysql');
-var util = require('./util-6f784d85.js');
-var _commonjsHelpers = require('./_commonjsHelpers-06173234.js');
-var md5 = require('./md5-e1ca5797.js');
-require('./core.get-iterator-method-5643aa10.js');
-require('./web.dom.iterable-d98303e0.js');
-require('./_library-dd23b178.js');
-require('./_iter-detect-b1df62f0.js');
-require('./_object-pie-083f2dd6.js');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
-var Router__default = /*#__PURE__*/_interopDefaultLegacy(Router);
-var useSWR__default = /*#__PURE__*/_interopDefaultLegacy(useSWR);
-var Local__default = /*#__PURE__*/_interopDefaultLegacy(Local);
-var mysql__default = /*#__PURE__*/_interopDefaultLegacy(mysql);
+var util = require('./util-f2c1b65b.js');
+var index$5 = require('./index-bd6c9f56.js');
+var Local = _interopDefault(require('passport-local'));
+var mysql = _interopDefault(require('mysql'));
+var md5 = require('./md5-5039b1a6.js');
 
 var returnFormField = function returnFormField(_ref) {
   var name = _ref.name,
@@ -67,21 +62,21 @@ var returnFormField = function returnFormField(_ref) {
   }
 
   if (type == 'text' || type == 'email' || type == 'password' || type == 'number') {
-    return React__default['default'].createElement(
+    return React__default.createElement(
       reactBootstrap.Form.Group,
-      _extends._extends({}, opts, { controlId: name }),
-      React__default['default'].createElement(
+      _extends$1._extends({}, opts, { controlId: name }),
+      React__default.createElement(
         reactBootstrap.Form.Label,
         { kye: name + '_label' },
         label,
-        required && React__default['default'].createElement(
+        required && React__default.createElement(
           'span',
           { style: { color: 'red' } },
           '*'
         )
       ),
-      React__default['default'].createElement(reactBootstrap.Form.Control, { key: name + '_' + type, type: type, readOnly: readonly, name: name, placeholder: '', defaultValue: default_value, required: required }),
-      React__default['default'].createElement(
+      React__default.createElement(reactBootstrap.Form.Control, { key: name + '_' + type, type: type, readOnly: readonly, name: name, placeholder: '', defaultValue: default_value, required: required }),
+      React__default.createElement(
         reactBootstrap.Form.Control.Feedback,
         { key: name + '_feedback', type: 'invalid' },
         errors[name]
@@ -89,28 +84,28 @@ var returnFormField = function returnFormField(_ref) {
     );
   }
   if (type == 'select') {
-    return React__default['default'].createElement(
+    return React__default.createElement(
       reactBootstrap.Form.Group,
-      _extends._extends({}, opts, { key: name, controlId: name }),
-      React__default['default'].createElement(
+      _extends$1._extends({}, opts, { key: name, controlId: name }),
+      React__default.createElement(
         reactBootstrap.Form.Label,
         { key: name + '_' + label },
         label,
-        required && React__default['default'].createElement(
+        required && React__default.createElement(
           'span',
           { key: name + '_required_span', style: { color: 'red' } },
           '*'
         )
       ),
-      React__default['default'].createElement(
+      React__default.createElement(
         reactBootstrap.Form.Control,
         { key: name + '_select', as: 'select', name: name, required: required, defaultValue: default_value },
-        React__default['default'].createElement('option', { value: '', key: name + '_options_empty' }),
+        React__default.createElement('option', { value: '', key: name + '_options_empty' }),
         options.map(function (option, index) {
           var value = option.value ? option.value : option;
           var label = option.label ? option.label : option;
           var key = name + '_options_' + index;
-          return React__default['default'].createElement(
+          return React__default.createElement(
             'option',
             { key: key, value: value },
             label
@@ -121,32 +116,1081 @@ var returnFormField = function returnFormField(_ref) {
   }
 
   if (type == 'radio' || type == 'checkbox') {
-    return React__default['default'].createElement(
+    return React__default.createElement(
       reactBootstrap.Form.Group,
       opts,
-      React__default['default'].createElement(
+      React__default.createElement(
         reactBootstrap.Form.Label,
         null,
         label,
-        required && React__default['default'].createElement(
+        required && React__default.createElement(
           'span',
           { style: { color: 'red' } },
           '*'
         )
       ),
       options.map(function (option, index) {
-        return React__default['default'].createElement(
+        return React__default.createElement(
           reactBootstrap.Form.Check,
           { type: type, key: index, required: required },
-          React__default['default'].createElement(reactBootstrap.Form.Check.Input, { type: type, key: type + '_' + index + '_input', defaultChecked: default_value ? default_value === option.value : false, name: name, id: name + '_' + index, value: option.value, required: required }),
-          React__default['default'].createElement(reactBootstrap.Form.Check.Label, { style: { cursor: 'pointer' }, 'for': name + '_' + index, key: type + '_' + index + '_label', dangerouslySetInnerHTML: { __html: option.label } })
+          React__default.createElement(reactBootstrap.Form.Check.Input, { type: type, key: type + '_' + index + '_input', defaultChecked: default_value ? default_value === option.value : false, name: name, id: name + '_' + index, value: option.value, required: required }),
+          React__default.createElement(reactBootstrap.Form.Check.Label, { style: { cursor: 'pointer' }, 'for': name + '_' + index, key: type + '_' + index + '_label', dangerouslySetInnerHTML: { __html: option.label } })
         );
       })
     );
   }
 };
 
-var _this$4 = undefined;
+var has = Object.prototype.hasOwnProperty;
+
+function dequal(foo, bar) {
+	var ctor, len;
+	if (foo === bar) return true;
+
+	if (foo && bar && (ctor=foo.constructor) === bar.constructor) {
+		if (ctor === Date) return foo.getTime() === bar.getTime();
+		if (ctor === RegExp) return foo.toString() === bar.toString();
+
+		if (ctor === Array) {
+			if ((len=foo.length) === bar.length) {
+				while (len-- && dequal(foo[len], bar[len]));
+			}
+			return len === -1;
+		}
+
+		if (!ctor || typeof foo === 'object') {
+			len = 0;
+			for (ctor in foo) {
+				if (has.call(foo, ctor) && ++len && !has.call(bar, ctor)) return false;
+				if (!(ctor in bar) || !dequal(foo[ctor], bar[ctor])) return false;
+			}
+			return Object.keys(bar).length === len;
+		}
+	}
+
+	return foo !== foo && bar !== bar;
+}
+
+// use WeakMap to store the object->key mapping
+// so the objects can be garbage collected.
+// WeakMap uses a hashtable under the hood, so the lookup
+// complexity is almost O(1).
+var table = new WeakMap();
+// counter of the key
+var counter = 0;
+// hashes an array of objects and returns a string
+function hash(args) {
+    if (!args.length)
+        return '';
+    var key = 'arg';
+    for (var i = 0; i < args.length; ++i) {
+        if (args[i] === null) {
+            key += '@null';
+            continue;
+        }
+        var _hash = void 0;
+        if (typeof args[i] !== 'object' && typeof args[i] !== 'function') {
+            // need to consider the case that args[i] is a string:
+            // args[i]        _hash
+            // "undefined" -> '"undefined"'
+            // undefined   -> 'undefined'
+            // 123         -> '123'
+            // "null"      -> '"null"'
+            if (typeof args[i] === 'string') {
+                _hash = '"' + args[i] + '"';
+            }
+            else {
+                _hash = String(args[i]);
+            }
+        }
+        else {
+            if (!table.has(args[i])) {
+                _hash = counter;
+                table.set(args[i], counter++);
+            }
+            else {
+                _hash = table.get(args[i]);
+            }
+        }
+        key += '@' + _hash;
+    }
+    return key;
+}
+
+var Cache = /** @class */ (function () {
+    function Cache(initialData) {
+        if (initialData === void 0) { initialData = {}; }
+        this.cache = new Map(Object.entries(initialData));
+        this.subs = [];
+    }
+    Cache.prototype.get = function (key) {
+        var _key = this.serializeKey(key)[0];
+        return this.cache.get(_key);
+    };
+    Cache.prototype.set = function (key, value) {
+        var _key = this.serializeKey(key)[0];
+        this.cache.set(_key, value);
+        this.notify();
+    };
+    Cache.prototype.keys = function () {
+        return Array.from(this.cache.keys());
+    };
+    Cache.prototype.has = function (key) {
+        var _key = this.serializeKey(key)[0];
+        return this.cache.has(_key);
+    };
+    Cache.prototype.clear = function () {
+        this.cache.clear();
+        this.notify();
+    };
+    Cache.prototype.delete = function (key) {
+        var _key = this.serializeKey(key)[0];
+        this.cache.delete(_key);
+        this.notify();
+    };
+    // TODO: introduce namespace for the cache
+    Cache.prototype.serializeKey = function (key) {
+        var args = null;
+        if (typeof key === 'function') {
+            try {
+                key = key();
+            }
+            catch (err) {
+                // dependencies not ready
+                key = '';
+            }
+        }
+        if (Array.isArray(key)) {
+            // args array
+            args = key;
+            key = hash(key);
+        }
+        else {
+            // convert null to ''
+            key = String(key || '');
+        }
+        var errorKey = key ? 'err@' + key : '';
+        var isValidatingKey = key ? 'validating@' + key : '';
+        return [key, args, errorKey, isValidatingKey];
+    };
+    Cache.prototype.subscribe = function (listener) {
+        var _this = this;
+        if (typeof listener !== 'function') {
+            throw new Error('Expected the listener to be a function.');
+        }
+        var isSubscribed = true;
+        this.subs.push(listener);
+        return function () {
+            if (!isSubscribed)
+                return;
+            isSubscribed = false;
+            var index = _this.subs.indexOf(listener);
+            if (index > -1) {
+                _this.subs[index] = _this.subs[_this.subs.length - 1];
+                _this.subs.length--;
+            }
+        };
+    };
+    // Notify Cache subscribers about a change in the cache
+    Cache.prototype.notify = function () {
+        for (var _i = 0, _a = this.subs; _i < _a.length; _i++) {
+            var listener = _a[_i];
+            listener();
+        }
+    };
+    return Cache;
+}());
+
+/**
+ * Due to bug https://bugs.chromium.org/p/chromium/issues/detail?id=678075,
+ * it's not reliable to detect if the browser is currently online or offline
+ * based on `navigator.onLine`.
+ * As a work around, we always assume it's online on first load, and change
+ * the status upon `online` or `offline` events.
+ */
+var online = true;
+var isOnline = function () { return online; };
+var isDocumentVisible = function () {
+    if (typeof document !== 'undefined' &&
+        document.visibilityState !== undefined) {
+        return document.visibilityState !== 'hidden';
+    }
+    // always assume it's visible
+    return true;
+};
+var fetcher = function (url) { return fetch(url).then(function (res) { return res.json(); }); };
+var registerOnFocus = function (cb) {
+    if (typeof window !== 'undefined' &&
+        window.addEventListener !== undefined &&
+        typeof document !== 'undefined' &&
+        document.addEventListener !== undefined) {
+        // focus revalidate
+        document.addEventListener('visibilitychange', function () { return cb(); }, false);
+        window.addEventListener('focus', function () { return cb(); }, false);
+    }
+};
+var registerOnReconnect = function (cb) {
+    if (typeof window !== 'undefined' && window.addEventListener !== undefined) {
+        // reconnect revalidate
+        window.addEventListener('online', function () {
+            online = true;
+            cb();
+        }, false);
+        // nothing to revalidate, just update the status
+        window.addEventListener('offline', function () { return (online = false); }, false);
+    }
+};
+var webPreset = {
+    isOnline: isOnline,
+    isDocumentVisible: isDocumentVisible,
+    fetcher: fetcher,
+    registerOnFocus: registerOnFocus,
+    registerOnReconnect: registerOnReconnect
+};
+
+var __assign = (undefined && undefined.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+// cache
+var cache = new Cache();
+// error retry
+function onErrorRetry(_, __, config, revalidate, opts) {
+    if (!config.isDocumentVisible()) {
+        // if it's hidden, stop
+        // it will auto revalidate when focus
+        return;
+    }
+    if (typeof config.errorRetryCount === 'number' &&
+        opts.retryCount > config.errorRetryCount) {
+        return;
+    }
+    // exponential backoff
+    var count = Math.min(opts.retryCount, 8);
+    var timeout = ~~((Math.random() + 0.5) * (1 << count)) * config.errorRetryInterval;
+    setTimeout(revalidate, timeout, opts);
+}
+// client side: need to adjust the config
+// based on the browser status
+// slow connection (<= 70Kbps)
+var slowConnection = typeof window !== 'undefined' &&
+    // @ts-ignore
+    navigator['connection'] &&
+    // @ts-ignore
+    ['slow-2g', '2g'].indexOf(navigator['connection'].effectiveType) !== -1;
+// config
+var defaultConfig = __assign({ 
+    // events
+    onLoadingSlow: function () { }, onSuccess: function () { }, onError: function () { }, onErrorRetry: onErrorRetry, errorRetryInterval: (slowConnection ? 10 : 5) * 1000, focusThrottleInterval: 5 * 1000, dedupingInterval: 2 * 1000, loadingTimeout: (slowConnection ? 5 : 3) * 1000, refreshInterval: 0, revalidateOnFocus: true, revalidateOnReconnect: true, refreshWhenHidden: false, refreshWhenOffline: false, shouldRetryOnError: true, suspense: false, compare: dequal, isPaused: function () { return false; } }, webPreset);
+
+var IS_SERVER = typeof window === 'undefined' ||
+    // @ts-ignore
+    !!(typeof Deno !== 'undefined' && Deno && Deno.version && Deno.version.deno);
+// polyfill for requestAnimationFrame
+var rAF = IS_SERVER
+    ? null
+    : window['requestAnimationFrame']
+        ? function (f) { return window['requestAnimationFrame'](f); }
+        : function (f) { return setTimeout(f, 1); };
+// React currently throws a warning when using useLayoutEffect on the server.
+// To get around it, we can conditionally useEffect on the server (no-op) and
+// useLayoutEffect in the browser.
+var useIsomorphicLayoutEffect = IS_SERVER ? React.useEffect : React.useLayoutEffect;
+
+var SWRConfigContext = React.createContext({});
+SWRConfigContext.displayName = 'SWRConfigContext';
+
+var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (undefined && undefined.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+// global state managers
+var CONCURRENT_PROMISES = {};
+var CONCURRENT_PROMISES_TS = {};
+var FOCUS_REVALIDATORS = {};
+var RECONNECT_REVALIDATORS = {};
+var CACHE_REVALIDATORS = {};
+var MUTATION_TS = {};
+var MUTATION_END_TS = {};
+// generate strictly increasing timestamps
+var now = (function () {
+    var ts = 0;
+    return function () { return ++ts; };
+})();
+// setup DOM events listeners for `focus` and `reconnect` actions
+if (!IS_SERVER) {
+    var revalidate_1 = function (revalidators) {
+        if (!defaultConfig.isDocumentVisible() || !defaultConfig.isOnline())
+            return;
+        for (var key in revalidators) {
+            if (revalidators[key][0])
+                revalidators[key][0]();
+        }
+    };
+    if (typeof defaultConfig.registerOnFocus === 'function') {
+        defaultConfig.registerOnFocus(function () { return revalidate_1(FOCUS_REVALIDATORS); });
+    }
+    if (typeof defaultConfig.registerOnReconnect === 'function') {
+        defaultConfig.registerOnReconnect(function () { return revalidate_1(RECONNECT_REVALIDATORS); });
+    }
+}
+var trigger = function (_key, shouldRevalidate) {
+    if (shouldRevalidate === void 0) { shouldRevalidate = true; }
+    // we are ignoring the second argument which correspond to the arguments
+    // the fetcher will receive when key is an array
+    var _a = cache.serializeKey(_key), key = _a[0], keyErr = _a[2], keyValidating = _a[3];
+    if (!key)
+        return Promise.resolve();
+    var updaters = CACHE_REVALIDATORS[key];
+    if (key && updaters) {
+        var currentData = cache.get(key);
+        var currentError = cache.get(keyErr);
+        var currentIsValidating = cache.get(keyValidating);
+        var promises = [];
+        for (var i = 0; i < updaters.length; ++i) {
+            promises.push(updaters[i](shouldRevalidate, currentData, currentError, currentIsValidating, i > 0));
+        }
+        // return new updated value
+        return Promise.all(promises).then(function () { return cache.get(key); });
+    }
+    return Promise.resolve(cache.get(key));
+};
+var broadcastState = function (key, data, error, isValidating) {
+    var updaters = CACHE_REVALIDATORS[key];
+    if (key && updaters) {
+        for (var i = 0; i < updaters.length; ++i) {
+            updaters[i](false, data, error, isValidating);
+        }
+    }
+};
+var mutate = function (_key, _data, shouldRevalidate) {
+    if (shouldRevalidate === void 0) { shouldRevalidate = true; }
+    return __awaiter(void 0, void 0, void 0, function () {
+        var _a, key, keyErr, beforeMutationTs, beforeConcurrentPromisesTs, data, error, isAsyncMutation, err_1, shouldAbort, updaters, promises, i;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = cache.serializeKey(_key), key = _a[0], keyErr = _a[2];
+                    if (!key)
+                        return [2 /*return*/];
+                    // if there is no new data to update, let's just revalidate the key
+                    if (typeof _data === 'undefined')
+                        return [2 /*return*/, trigger(_key, shouldRevalidate)
+                            // update global timestamps
+                        ];
+                    // update global timestamps
+                    MUTATION_TS[key] = now() - 1;
+                    MUTATION_END_TS[key] = 0;
+                    beforeMutationTs = MUTATION_TS[key];
+                    beforeConcurrentPromisesTs = CONCURRENT_PROMISES_TS[key];
+                    isAsyncMutation = false;
+                    if (_data && typeof _data === 'function') {
+                        // `_data` is a function, call it passing current cache value
+                        try {
+                            _data = _data(cache.get(key));
+                        }
+                        catch (err) {
+                            // if `_data` function throws an error synchronously, it shouldn't be cached
+                            _data = undefined;
+                            error = err;
+                        }
+                    }
+                    if (!(_data && typeof _data.then === 'function')) return [3 /*break*/, 5];
+                    // `_data` is a promise
+                    isAsyncMutation = true;
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, _data];
+                case 2:
+                    data = _b.sent();
+                    return [3 /*break*/, 4];
+                case 3:
+                    err_1 = _b.sent();
+                    error = err_1;
+                    return [3 /*break*/, 4];
+                case 4: return [3 /*break*/, 6];
+                case 5:
+                    data = _data;
+                    _b.label = 6;
+                case 6:
+                    shouldAbort = function () {
+                        // check if other mutations have occurred since we've started this mutation
+                        if (beforeMutationTs !== MUTATION_TS[key] ||
+                            beforeConcurrentPromisesTs !== CONCURRENT_PROMISES_TS[key]) {
+                            if (error)
+                                throw error;
+                            return true;
+                        }
+                    };
+                    // if there's a race we don't update cache or broadcast change, just return the data
+                    if (shouldAbort())
+                        return [2 /*return*/, data];
+                    if (typeof data !== 'undefined') {
+                        // update cached data
+                        cache.set(key, data);
+                    }
+                    // always update or reset the error
+                    cache.set(keyErr, error);
+                    // reset the timestamp to mark the mutation has ended
+                    MUTATION_END_TS[key] = now() - 1;
+                    if (!isAsyncMutation) {
+                        // we skip broadcasting if there's another mutation happened synchronously
+                        if (shouldAbort())
+                            return [2 /*return*/, data];
+                    }
+                    updaters = CACHE_REVALIDATORS[key];
+                    if (updaters) {
+                        promises = [];
+                        for (i = 0; i < updaters.length; ++i) {
+                            promises.push(updaters[i](!!shouldRevalidate, data, error, undefined, i > 0));
+                        }
+                        // return new updated value
+                        return [2 /*return*/, Promise.all(promises).then(function () {
+                                if (error)
+                                    throw error;
+                                return cache.get(key);
+                            })];
+                    }
+                    // throw error or return data to be used by caller of mutate
+                    if (error)
+                        throw error;
+                    return [2 /*return*/, data];
+            }
+        });
+    });
+};
+function useSWR() {
+    var _this = this;
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    var _key = args[0];
+    var config = Object.assign({}, defaultConfig, React.useContext(SWRConfigContext), args.length > 2
+        ? args[2]
+        : args.length === 2 && typeof args[1] === 'object'
+            ? args[1]
+            : {});
+    // in typescript args.length > 2 is not same as args.lenth === 3
+    // we do a safe type assertion here
+    // args.length === 3
+    var fn = (args.length > 2
+        ? args[1]
+        : args.length === 2 && typeof args[1] === 'function'
+            ? args[1]
+            : /**
+                  pass fn as null will disable revalidate
+                  https://paco.sh/blog/shared-hook-state-with-swr
+                */
+                args[1] === null
+                    ? args[1]
+                    : config.fetcher);
+    // we assume `key` as the identifier of the request
+    // `key` can change but `fn` shouldn't
+    // (because `revalidate` only depends on `key`)
+    // `keyErr` is the cache key for error objects
+    var _a = cache.serializeKey(_key), key = _a[0], fnArgs = _a[1], keyErr = _a[2], keyValidating = _a[3];
+    var configRef = React.useRef(config);
+    useIsomorphicLayoutEffect(function () {
+        configRef.current = config;
+    });
+    var willRevalidateOnMount = function () {
+        return (config.revalidateOnMount ||
+            (!config.initialData && config.revalidateOnMount === undefined));
+    };
+    var resolveData = function () {
+        var cachedData = cache.get(key);
+        return typeof cachedData === 'undefined' ? config.initialData : cachedData;
+    };
+    var resolveIsValidating = function () {
+        return !!cache.get(keyValidating) || (key && willRevalidateOnMount());
+    };
+    var initialData = resolveData();
+    var initialError = cache.get(keyErr);
+    var initialIsValidating = resolveIsValidating();
+    // if a state is accessed (data, error or isValidating),
+    // we add the state to dependencies so if the state is
+    // updated in the future, we can trigger a rerender
+    var stateDependencies = React.useRef({
+        data: false,
+        error: false,
+        isValidating: false
+    });
+    var stateRef = React.useRef({
+        data: initialData,
+        error: initialError,
+        isValidating: initialIsValidating
+    });
+    // display the data label in the React DevTools next to SWR hooks
+    React.useDebugValue(stateRef.current.data);
+    var rerender = React.useState({})[1];
+    var dispatch = React.useCallback(function (payload) {
+        var shouldUpdateState = false;
+        for (var k in payload) {
+            // @ts-ignore
+            if (stateRef.current[k] === payload[k]) {
+                continue;
+            }
+            // @ts-ignore
+            stateRef.current[k] = payload[k];
+            // @ts-ignore
+            if (stateDependencies.current[k]) {
+                shouldUpdateState = true;
+            }
+        }
+        if (shouldUpdateState) {
+            // if component is unmounted, should skip rerender
+            // if component is not mounted, should skip rerender
+            if (unmountedRef.current || !initialMountedRef.current)
+                return;
+            rerender({});
+        }
+    }, 
+    // config.suspense isn't allowed to change during the lifecycle
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    []);
+    // error ref inside revalidate (is last request errored?)
+    var unmountedRef = React.useRef(false);
+    var keyRef = React.useRef(key);
+    // check if component is mounted in suspense mode
+    var initialMountedRef = React.useRef(false);
+    // do unmount check for callbacks
+    var eventsCallback = React.useCallback(function (event) {
+        var _a;
+        var params = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            params[_i - 1] = arguments[_i];
+        }
+        if (unmountedRef.current)
+            return;
+        if (!initialMountedRef.current)
+            return;
+        if (key !== keyRef.current)
+            return;
+        // @ts-ignore
+        (_a = configRef.current)[event].apply(_a, params);
+    }, [key]);
+    var boundMutate = React.useCallback(function (data, shouldRevalidate) {
+        return mutate(keyRef.current, data, shouldRevalidate);
+    }, []);
+    var addRevalidator = function (revalidators, callback) {
+        if (!revalidators[key]) {
+            revalidators[key] = [callback];
+        }
+        else {
+            revalidators[key].push(callback);
+        }
+        return function () {
+            var keyedRevalidators = revalidators[key];
+            var index = keyedRevalidators.indexOf(callback);
+            if (index >= 0) {
+                // O(1): faster than splice
+                keyedRevalidators[index] =
+                    keyedRevalidators[keyedRevalidators.length - 1];
+                keyedRevalidators.pop();
+            }
+        };
+    };
+    // start a revalidation
+    var revalidate = React.useCallback(function (revalidateOpts) {
+        if (revalidateOpts === void 0) { revalidateOpts = {}; }
+        return __awaiter(_this, void 0, void 0, function () {
+            var _a, retryCount, _b, dedupe, loading, shouldDeduping, newData, startAt, newState, err_2;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (!key || !fn)
+                            return [2 /*return*/, false];
+                        if (unmountedRef.current)
+                            return [2 /*return*/, false];
+                        if (configRef.current.isPaused())
+                            return [2 /*return*/, false];
+                        _a = revalidateOpts.retryCount, retryCount = _a === void 0 ? 0 : _a, _b = revalidateOpts.dedupe, dedupe = _b === void 0 ? false : _b;
+                        loading = true;
+                        shouldDeduping = typeof CONCURRENT_PROMISES[key] !== 'undefined' && dedupe;
+                        _c.label = 1;
+                    case 1:
+                        _c.trys.push([1, 6, , 7]);
+                        dispatch({
+                            isValidating: true
+                        });
+                        cache.set(keyValidating, true);
+                        if (!shouldDeduping) {
+                            // also update other hooks
+                            broadcastState(key, stateRef.current.data, stateRef.current.error, true);
+                        }
+                        newData = void 0;
+                        startAt = void 0;
+                        if (!shouldDeduping) return [3 /*break*/, 3];
+                        // there's already an ongoing request,
+                        // this one needs to be deduplicated.
+                        startAt = CONCURRENT_PROMISES_TS[key];
+                        return [4 /*yield*/, CONCURRENT_PROMISES[key]];
+                    case 2:
+                        newData = _c.sent();
+                        return [3 /*break*/, 5];
+                    case 3:
+                        // if no cache being rendered currently (it shows a blank page),
+                        // we trigger the loading slow event.
+                        if (config.loadingTimeout && !cache.get(key)) {
+                            setTimeout(function () {
+                                if (loading)
+                                    eventsCallback('onLoadingSlow', key, config);
+                            }, config.loadingTimeout);
+                        }
+                        if (fnArgs !== null) {
+                            CONCURRENT_PROMISES[key] = fn.apply(void 0, fnArgs);
+                        }
+                        else {
+                            CONCURRENT_PROMISES[key] = fn(key);
+                        }
+                        CONCURRENT_PROMISES_TS[key] = startAt = now();
+                        return [4 /*yield*/, CONCURRENT_PROMISES[key]];
+                    case 4:
+                        newData = _c.sent();
+                        setTimeout(function () {
+                            delete CONCURRENT_PROMISES[key];
+                            delete CONCURRENT_PROMISES_TS[key];
+                        }, config.dedupingInterval);
+                        // trigger the success event,
+                        // only do this for the original request.
+                        eventsCallback('onSuccess', newData, key, config);
+                        _c.label = 5;
+                    case 5:
+                        // if there're other ongoing request(s), started after the current one,
+                        // we need to ignore the current one to avoid possible race conditions:
+                        //   req1------------------>res1        (current one)
+                        //        req2---------------->res2
+                        // the request that fired later will always be kept.
+                        if (CONCURRENT_PROMISES_TS[key] > startAt) {
+                            return [2 /*return*/, false];
+                        }
+                        // if there're other mutations(s), overlapped with the current revalidation:
+                        // case 1:
+                        //   req------------------>res
+                        //       mutate------>end
+                        // case 2:
+                        //         req------------>res
+                        //   mutate------>end
+                        // case 3:
+                        //   req------------------>res
+                        //       mutate-------...---------->
+                        // we have to ignore the revalidation result (res) because it's no longer fresh.
+                        // meanwhile, a new revalidation should be triggered when the mutation ends.
+                        if (MUTATION_TS[key] &&
+                            // case 1
+                            (startAt <= MUTATION_TS[key] ||
+                                // case 2
+                                startAt <= MUTATION_END_TS[key] ||
+                                // case 3
+                                MUTATION_END_TS[key] === 0)) {
+                            dispatch({ isValidating: false });
+                            return [2 /*return*/, false];
+                        }
+                        cache.set(keyErr, undefined);
+                        cache.set(keyValidating, false);
+                        newState = {
+                            isValidating: false
+                        };
+                        if (typeof stateRef.current.error !== 'undefined') {
+                            // we don't have an error
+                            newState.error = undefined;
+                        }
+                        if (!config.compare(stateRef.current.data, newData)) {
+                            // deep compare to avoid extra re-render
+                            // data changed
+                            newState.data = newData;
+                        }
+                        if (!config.compare(cache.get(key), newData)) {
+                            cache.set(key, newData);
+                        }
+                        // merge the new state
+                        dispatch(newState);
+                        if (!shouldDeduping) {
+                            // also update other hooks
+                            broadcastState(key, newData, newState.error, false);
+                        }
+                        return [3 /*break*/, 7];
+                    case 6:
+                        err_2 = _c.sent();
+                        delete CONCURRENT_PROMISES[key];
+                        delete CONCURRENT_PROMISES_TS[key];
+                        if (configRef.current.isPaused()) {
+                            dispatch({
+                                isValidating: false
+                            });
+                            return [2 /*return*/, false];
+                        }
+                        cache.set(keyErr, err_2);
+                        // get a new error
+                        // don't use deep equal for errors
+                        if (stateRef.current.error !== err_2) {
+                            // we keep the stale data
+                            dispatch({
+                                isValidating: false,
+                                error: err_2
+                            });
+                            if (!shouldDeduping) {
+                                // also broadcast to update other hooks
+                                broadcastState(key, undefined, err_2, false);
+                            }
+                        }
+                        // events and retry
+                        eventsCallback('onError', err_2, key, config);
+                        if (config.shouldRetryOnError) {
+                            // when retrying, we always enable deduping
+                            eventsCallback('onErrorRetry', err_2, key, config, revalidate, {
+                                retryCount: retryCount + 1,
+                                dedupe: true
+                            });
+                        }
+                        return [3 /*break*/, 7];
+                    case 7:
+                        loading = false;
+                        return [2 /*return*/, true];
+                }
+            });
+        });
+    }, 
+    // dispatch is immutable, and `eventsCallback`, `fnArgs`, `keyErr`, and `keyValidating` are based on `key`,
+    // so we can them from the deps array.
+    //
+    // FIXME:
+    // `fn` and `config` might be changed during the lifecycle,
+    // but they might be changed every render like this.
+    // useSWR('key', () => fetch('/api/'), { suspense: true })
+    // So we omit the values from the deps array
+    // even though it might cause unexpected behaviors.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [key]);
+    // mounted (client side rendering)
+    useIsomorphicLayoutEffect(function () {
+        if (!key)
+            return undefined;
+        // after `key` updates, we need to mark it as mounted
+        unmountedRef.current = false;
+        var isUpdating = initialMountedRef.current;
+        initialMountedRef.current = true;
+        // after the component is mounted (hydrated),
+        // we need to update the data from the cache
+        // and trigger a revalidation
+        var currentHookData = stateRef.current.data;
+        var latestKeyedData = resolveData();
+        // update the state if the key changed (not the inital render) or cache updated
+        keyRef.current = key;
+        if (!config.compare(currentHookData, latestKeyedData)) {
+            dispatch({ data: latestKeyedData });
+        }
+        // revalidate with deduping
+        var softRevalidate = function () { return revalidate({ dedupe: true }); };
+        // trigger a revalidation
+        if (isUpdating || willRevalidateOnMount()) {
+            if (typeof latestKeyedData !== 'undefined' && !IS_SERVER) {
+                // delay revalidate if there's cache
+                // to not block the rendering
+                // @ts-ignore it's safe to use requestAnimationFrame in browser
+                rAF(softRevalidate);
+            }
+            else {
+                softRevalidate();
+            }
+        }
+        var pending = false;
+        var onFocus = function () {
+            if (pending || !configRef.current.revalidateOnFocus)
+                return;
+            pending = true;
+            softRevalidate();
+            setTimeout(function () { return (pending = false); }, configRef.current.focusThrottleInterval);
+        };
+        var onReconnect = function () {
+            if (configRef.current.revalidateOnReconnect) {
+                softRevalidate();
+            }
+        };
+        // register global cache update listener
+        var onUpdate = function (shouldRevalidate, updatedData, updatedError, updatedIsValidating, dedupe) {
+            if (shouldRevalidate === void 0) { shouldRevalidate = true; }
+            if (dedupe === void 0) { dedupe = true; }
+            // update hook state
+            var newState = {};
+            var needUpdate = false;
+            if (typeof updatedData !== 'undefined' &&
+                !config.compare(stateRef.current.data, updatedData)) {
+                newState.data = updatedData;
+                needUpdate = true;
+            }
+            // always update error
+            // because it can be `undefined`
+            if (stateRef.current.error !== updatedError) {
+                newState.error = updatedError;
+                needUpdate = true;
+            }
+            if (typeof updatedIsValidating !== 'undefined' &&
+                stateRef.current.isValidating !== updatedIsValidating) {
+                newState.isValidating = updatedIsValidating;
+                needUpdate = true;
+            }
+            if (needUpdate) {
+                dispatch(newState);
+            }
+            if (shouldRevalidate) {
+                if (dedupe) {
+                    return softRevalidate();
+                }
+                else {
+                    return revalidate();
+                }
+            }
+            return false;
+        };
+        var unsubFocus = addRevalidator(FOCUS_REVALIDATORS, onFocus);
+        var unsubReconnect = addRevalidator(RECONNECT_REVALIDATORS, onReconnect);
+        var unsubUpdate = addRevalidator(CACHE_REVALIDATORS, onUpdate);
+        return function () {
+            // cleanup
+            dispatch = function () { return null; };
+            // mark it as unmounted
+            unmountedRef.current = true;
+            unsubFocus();
+            unsubReconnect();
+            unsubUpdate();
+        };
+    }, [key, revalidate]);
+    useIsomorphicLayoutEffect(function () {
+        var timer = null;
+        var tick = function () { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(!stateRef.current.error &&
+                            (configRef.current.refreshWhenHidden ||
+                                configRef.current.isDocumentVisible()) &&
+                            (configRef.current.refreshWhenOffline || configRef.current.isOnline()))) return [3 /*break*/, 2];
+                        // only revalidate when the page is visible
+                        // if API request errored, we stop polling in this round
+                        // and let the error retry function handle it
+                        return [4 /*yield*/, revalidate({ dedupe: true })];
+                    case 1:
+                        // only revalidate when the page is visible
+                        // if API request errored, we stop polling in this round
+                        // and let the error retry function handle it
+                        _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        // Read the latest refreshInterval
+                        if (configRef.current.refreshInterval && timer) {
+                            timer = setTimeout(tick, configRef.current.refreshInterval);
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        }); };
+        if (configRef.current.refreshInterval) {
+            timer = setTimeout(tick, configRef.current.refreshInterval);
+        }
+        return function () {
+            if (timer) {
+                clearTimeout(timer);
+                timer = null;
+            }
+        };
+    }, [
+        config.refreshInterval,
+        config.refreshWhenHidden,
+        config.refreshWhenOffline,
+        revalidate
+    ]);
+    // suspense
+    var latestData;
+    var latestError;
+    if (config.suspense) {
+        // in suspense mode, we can't return empty state
+        // (it should be suspended)
+        // try to get data and error from cache
+        latestData = cache.get(key);
+        latestError = cache.get(keyErr);
+        if (typeof latestData === 'undefined') {
+            latestData = initialData;
+        }
+        if (typeof latestError === 'undefined') {
+            latestError = initialError;
+        }
+        if (typeof latestData === 'undefined' &&
+            typeof latestError === 'undefined') {
+            // need to start the request if it hasn't
+            if (!CONCURRENT_PROMISES[key]) {
+                // trigger revalidate immediately
+                // to get the promise
+                // in this revalidate, should not rerender
+                revalidate();
+            }
+            if (CONCURRENT_PROMISES[key] &&
+                typeof CONCURRENT_PROMISES[key].then === 'function') {
+                // if it is a promise
+                throw CONCURRENT_PROMISES[key];
+            }
+            // it's a value, return it directly (override)
+            latestData = CONCURRENT_PROMISES[key];
+        }
+        if (typeof latestData === 'undefined' && latestError) {
+            // in suspense mode, throw error if there's no content
+            throw latestError;
+        }
+    }
+    // define returned state
+    // can be memorized since the state is a ref
+    var memoizedState = React.useMemo(function () {
+        // revalidate will be deprecated in the 1.x release
+        // because mutate() covers the same use case of revalidate().
+        // This remains only for backward compatibility
+        var state = { revalidate: revalidate, mutate: boundMutate };
+        Object.defineProperties(state, {
+            error: {
+                // `key` might be changed in the upcoming hook re-render,
+                // but the previous state will stay
+                // so we need to match the latest key and data (fallback to `initialData`)
+                get: function () {
+                    stateDependencies.current.error = true;
+                    if (config.suspense) {
+                        return latestError;
+                    }
+                    return keyRef.current === key ? stateRef.current.error : initialError;
+                },
+                enumerable: true
+            },
+            data: {
+                get: function () {
+                    stateDependencies.current.data = true;
+                    if (config.suspense) {
+                        return latestData;
+                    }
+                    return keyRef.current === key ? stateRef.current.data : initialData;
+                },
+                enumerable: true
+            },
+            isValidating: {
+                get: function () {
+                    stateDependencies.current.isValidating = true;
+                    return key ? stateRef.current.isValidating : false;
+                },
+                enumerable: true
+            }
+        });
+        return state;
+        // `config.suspense` isn't allowed to change during the lifecycle.
+        // `boundMutate` is immutable, and the immutability of `revalidate` depends on `key`
+        // so we can omit them from the deps array,
+        // but we put it to enable react-hooks/exhaustive-deps rule.
+        // `initialData` and `initialError` are not initial values
+        // because they are changed during the lifecycle
+        // so we should add them in the deps array.
+    }, [
+        revalidate,
+        initialData,
+        initialError,
+        boundMutate,
+        key,
+        config.suspense,
+        latestError,
+        latestData
+    ]);
+    return memoizedState;
+}
+Object.defineProperty(SWRConfigContext.Provider, 'default', {
+    value: defaultConfig
+});
+var SWRConfig = SWRConfigContext.Provider;
+
+var __awaiter$1 = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator$1 = (undefined && undefined.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __rest = (undefined && undefined.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+
+var _this = undefined;
 
 var dataHandler = function () {
   var _ref = asyncToGenerator._asyncToGenerator( /*#__PURE__*/asyncToGenerator.regenerator.mark(function _callee(api_url, body) {
@@ -212,7 +1256,7 @@ var dataHandler = function () {
             return _context.stop();
         }
       }
-    }, _callee, _this$4, [[0, 20]]);
+    }, _callee, _this, [[0, 20]]);
   }));
 
   return function dataHandler(_x, _x2) {
@@ -225,7 +1269,7 @@ function useUser() {
       redirectTo = _ref.redirectTo,
       redirectIfFound = _ref.redirectIfFound;
 
-  var _useSWR = useSWR__default['default']('/api/auth/user', dataHandler),
+  var _useSWR = useSWR('/api/auth/user', dataHandler),
       data = _useSWR.data,
       error = _useSWR.error;
 
@@ -240,7 +1284,7 @@ function useUser() {
     redirectTo && !redirectIfFound && !hasUser ||
     // If redirectIfFound is also set, redirect if the user was found
     redirectIfFound && hasUser) {
-      Router__default['default'].push(redirectTo);
+      Router__default.push(redirectTo);
     }
   }, [redirectTo, redirectIfFound, finished, hasUser]);
 
@@ -346,43 +1390,43 @@ var LoginForm = function LoginForm(props) {
       loading = _useState4[0],
       setLoading = _useState4[1];
 
-  return React__default['default'].createElement(
+  return React__default.createElement(
     reactBootstrap.Form,
     { className: 'login', onSubmit: handleSubmit },
-    React__default['default'].createElement(
+    React__default.createElement(
       'h1',
       null,
       'Login'
     ),
-    React__default['default'].createElement('hr', null),
+    React__default.createElement('hr', null),
     returnFormField({ name: 'email', label: 'Email', type: 'email', required: true }),
     returnFormField({ name: 'password', label: 'Password', type: 'password', required: true }),
-    React__default['default'].createElement('hr', null),
-    React__default['default'].createElement(
+    React__default.createElement('hr', null),
+    React__default.createElement(
       reactBootstrap.Form.Row,
       null,
-      React__default['default'].createElement(
+      React__default.createElement(
         reactBootstrap.Form.Group,
         { as: reactBootstrap.Col },
-        React__default['default'].createElement(
+        React__default.createElement(
           'a',
           { href: '/auth/signup' },
           'I don\'t have an account'
         )
       ),
-      React__default['default'].createElement(
+      React__default.createElement(
         reactBootstrap.Form.Group,
         { as: reactBootstrap.Col, className: 'text-right' },
-        !loading && React__default['default'].createElement(
+        !loading && React__default.createElement(
           reactBootstrap.Button,
           { type: 'submit' },
           'Login'
         ),
-        loading && React__default['default'].createElement(
+        loading && React__default.createElement(
           reactBootstrap.Button,
           { variant: 'primary', disabled: true },
-          React__default['default'].createElement(reactBootstrap.Spinner, { as: 'span', animation: 'border', role: 'status', 'aria-hidden': 'true', size: 'sm' }),
-          React__default['default'].createElement(
+          React__default.createElement(reactBootstrap.Spinner, { as: 'span', animation: 'border', role: 'status', 'aria-hidden': 'true', size: 'sm' }),
+          React__default.createElement(
             'span',
             { className: 'sr-only' },
             'Loading...'
@@ -390,12 +1434,12 @@ var LoginForm = function LoginForm(props) {
         )
       )
     ),
-    errorMsg && React__default['default'].createElement(
+    errorMsg && React__default.createElement(
       'p',
       { className: 'error' },
       errorMsg
     ),
-    React__default['default'].createElement(
+    React__default.createElement(
       'style',
       { jsx: 'true'.toString() },
       '\n        .login {\n          margin: 0 auto;\n          padding: 1rem;\n          border: 1px solid #ccc;\n          border-radius: 4px;\n        }\n        .error {\n          color: red;\n          margin: 1rem 0 0;\n        }\n      '
@@ -408,9 +1452,9 @@ var countries = ["United States", "Afghanistan", "Albania", "Algeria", "American
 
 var states = ['AL', 'AK', 'AS', 'AZ', 'AR', 'CA', 'CO', 'CT', 'DE', 'DC', 'FM', 'FL', 'GA', 'GU', 'HI', 'ID', 'IL', 'IN', 'IA', 'KS', 'KY', 'LA', 'ME', 'MH', 'MD', 'MA', 'MI', 'MN', 'MS', 'MO', 'MT', 'NE', 'NV', 'NH', 'NJ', 'NM', 'NY', 'NC', 'ND', 'MP', 'OH', 'OK', 'OR', 'PW', 'PA', 'PR', 'RI', 'SC', 'SD', 'TN', 'TX', 'UT', 'VT', 'VI', 'VA', 'WA', 'WV', 'WI', 'WY'];
 
-var _this$3 = undefined;
+var _this$1 = undefined;
 
-var SignupForm$1 = function SignupForm(props) {
+var SignupForm = function SignupForm(props) {
   var handleSubmit = function () {
     var _ref3 = asyncToGenerator._asyncToGenerator( /*#__PURE__*/asyncToGenerator.regenerator.mark(function _callee3(e) {
       var formData, body, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, key, res;
@@ -571,7 +1615,7 @@ var SignupForm$1 = function SignupForm(props) {
               return _context.stop();
           }
         }
-      }, _callee, _this$3);
+      }, _callee, _this$1);
     }));
 
     return function loadInitData() {
@@ -638,7 +1682,7 @@ var SignupForm$1 = function SignupForm(props) {
               return _context2.stop();
           }
         }
-      }, _callee2, _this$3);
+      }, _callee2, _this$1);
     }));
 
     return function handleOccupationChanged(_x) {
@@ -651,29 +1695,29 @@ var SignupForm$1 = function SignupForm(props) {
       loading = _useState14[0],
       setLoading = _useState14[1];
 
-  return React__default['default'].createElement(
+  return React__default.createElement(
     reactBootstrap.Form,
     { className: 'login', id: 'signupForm', onSubmit: handleSubmit },
-    React__default['default'].createElement(
+    React__default.createElement(
       'h1',
       null,
       'Sign Up'
     ),
-    React__default['default'].createElement('hr', null),
+    React__default.createElement('hr', null),
     returnFormField({ name: 'email', label: 'Email', type: 'email', required: true }),
-    React__default['default'].createElement(
+    React__default.createElement(
       reactBootstrap.Form.Row,
       null,
       returnFormField({ name: 'password', label: 'Password', type: 'password', groupType: reactBootstrap.Col, required: true }),
       returnFormField({ name: 'rpassword', label: 'Retype Password', type: 'password', groupType: reactBootstrap.Col, required: true })
     ),
-    React__default['default'].createElement(
+    React__default.createElement(
       reactBootstrap.Form.Row,
       null,
       returnFormField({ name: 'first_name', label: 'First Name', type: 'text', groupType: reactBootstrap.Col, required: true }),
       returnFormField({ name: 'last_name', label: 'Last Name', type: 'text', groupType: reactBootstrap.Col, required: true })
     ),
-    React__default['default'].createElement(
+    React__default.createElement(
       reactBootstrap.Form.Row,
       null,
       returnFormField({
@@ -687,7 +1731,7 @@ var SignupForm$1 = function SignupForm(props) {
       }),
       countryUS && returnFormField({ name: 'state', label: 'State', type: 'select', required: true, groupType: reactBootstrap.Col, options: states })
     ),
-    React__default['default'].createElement(
+    React__default.createElement(
       reactBootstrap.Form.Row,
       null,
       countryUS && returnFormField({ name: 'zip', label: 'Working Zip Code', type: 'text', required: true, groupType: reactBootstrap.Col }),
@@ -734,38 +1778,38 @@ var SignupForm$1 = function SignupForm(props) {
       required: true,
       options: [{ label: 'By registering you agree to our <a href="/terms" style="color:blue">Terms and Conditions</a> and <a href="/privacy" style="color:blue">Privacy Policy</a> and understand that you will be receiving email communications', value: 'Y' }]
     }),
-    React__default['default'].createElement('hr', null),
-    React__default['default'].createElement(
+    React__default.createElement('hr', null),
+    React__default.createElement(
       reactBootstrap.Form.Row,
       null,
-      React__default['default'].createElement(
+      React__default.createElement(
         reactBootstrap.Form.Group,
         { as: reactBootstrap.Col },
-        React__default['default'].createElement(
+        React__default.createElement(
           'a',
           { href: '/auth/login' },
           'I already have an account'
         )
       ),
-      React__default['default'].createElement(
+      React__default.createElement(
         reactBootstrap.Form.Group,
         { as: reactBootstrap.Col, className: 'text-right' },
-        !loading && React__default['default'].createElement(
+        !loading && React__default.createElement(
           reactBootstrap.Button,
           { type: 'submit' },
           'Sign Up'
         ),
-        loading && React__default['default'].createElement(
+        loading && React__default.createElement(
           reactBootstrap.Button,
           { variant: 'primary', disabled: true },
-          React__default['default'].createElement(reactBootstrap.Spinner, {
+          React__default.createElement(reactBootstrap.Spinner, {
             as: 'span',
             animation: 'border',
             role: 'status',
             'aria-hidden': 'true',
             size: 'sm'
           }),
-          React__default['default'].createElement(
+          React__default.createElement(
             'span',
             { className: 'sr-only' },
             'Loading...'
@@ -773,12 +1817,12 @@ var SignupForm$1 = function SignupForm(props) {
         )
       )
     ),
-    errorMsg && React__default['default'].createElement(
+    errorMsg && React__default.createElement(
       'p',
       { className: 'error' },
       errorMsg
     ),
-    React__default['default'].createElement(
+    React__default.createElement(
       'style',
       { jsx: 'true'.toString() },
       ' \n        .login {\n          margin: 0 auto;\n          padding: 1rem;\n          border: 1px solid #ccc;\n          border-radius: 4px;\n        }\n        .error {\n          color: red;\n          margin: 1rem 0 0;\n        }\n      '
@@ -788,7 +1832,7 @@ var SignupForm$1 = function SignupForm(props) {
 
 var _this$2 = undefined;
 
-var SignupForm = function SignupForm(props) {
+var SignupForm$1 = function SignupForm(props) {
   var handleSubmit = function () {
     var _ref3 = asyncToGenerator._asyncToGenerator( /*#__PURE__*/asyncToGenerator.regenerator.mark(function _callee3(e) {
       var formData, body, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, key, res;
@@ -1068,32 +2112,32 @@ var SignupForm = function SignupForm(props) {
       loading = _useState18[0],
       setLoading = _useState18[1];
 
-  return React__default['default'].createElement(
+  return React__default.createElement(
     reactBootstrap.Form,
     { className: 'login', id: 'signupForm', onSubmit: handleSubmit },
-    React__default['default'].createElement(
+    React__default.createElement(
       'h1',
       null,
       'Profile'
     ),
-    React__default['default'].createElement('hr', null),
-    userData ? React__default['default'].createElement(
-      React__default['default'].Fragment,
+    React__default.createElement('hr', null),
+    userData ? React__default.createElement(
+      React__default.Fragment,
       null,
       returnFormField({ name: 'email', label: 'Email', type: 'email', required: true, readonly: true, default_value: userData.email }),
-      React__default['default'].createElement(
+      React__default.createElement(
         reactBootstrap.Form.Row,
         null,
         returnFormField({ name: 'password', label: 'Password', type: 'password', groupType: reactBootstrap.Col, required: false }),
         returnFormField({ name: 'rpassword', label: 'Retype Password', type: 'password', groupType: reactBootstrap.Col, required: false })
       ),
-      React__default['default'].createElement(
+      React__default.createElement(
         reactBootstrap.Form.Row,
         null,
         returnFormField({ name: 'first_name', label: 'First Name', type: 'text', groupType: reactBootstrap.Col, required: true, default_value: userData.shared.first_name }),
         returnFormField({ name: 'last_name', label: 'Last Name', type: 'text', groupType: reactBootstrap.Col, required: true, default_value: userData.shared.last_name })
       ),
-      React__default['default'].createElement(
+      React__default.createElement(
         reactBootstrap.Form.Row,
         null,
         returnFormField({
@@ -1108,7 +2152,7 @@ var SignupForm = function SignupForm(props) {
         }),
         countryUS && returnFormField({ name: 'state', label: 'State', type: 'select', required: true, groupType: reactBootstrap.Col, options: states, default_value: userData.shared.state })
       ),
-      React__default['default'].createElement(
+      React__default.createElement(
         reactBootstrap.Form.Row,
         null,
         countryUS && returnFormField({ name: 'zip', label: 'Working Zip Code', type: 'text', required: true, groupType: reactBootstrap.Col, default_value: userData.shared.zip }),
@@ -1158,29 +2202,29 @@ var SignupForm = function SignupForm(props) {
         required: true,
         options: [{ label: 'By registering you agree to our <a href="/terms">Terms and Conditions</a> and <a href="/privacy">Privacy Policy</a> and understand that you will be receiving email communications', value: 'Y' }]
       }),
-      React__default['default'].createElement('hr', null),
-      React__default['default'].createElement(
+      React__default.createElement('hr', null),
+      React__default.createElement(
         reactBootstrap.Form.Row,
         null,
-        React__default['default'].createElement(
+        React__default.createElement(
           reactBootstrap.Form.Group,
           { as: reactBootstrap.Col },
-          !loading && React__default['default'].createElement(
+          !loading && React__default.createElement(
             reactBootstrap.Button,
             { type: 'submit' },
             'Update'
           ),
-          loading && React__default['default'].createElement(
+          loading && React__default.createElement(
             reactBootstrap.Button,
             { variant: 'primary', disabled: true },
-            React__default['default'].createElement(reactBootstrap.Spinner, {
+            React__default.createElement(reactBootstrap.Spinner, {
               as: 'span',
               animation: 'border',
               role: 'status',
               'aria-hidden': 'true',
               size: 'sm'
             }),
-            React__default['default'].createElement(
+            React__default.createElement(
               'span',
               { className: 'sr-only' },
               'Loading...'
@@ -1188,24 +2232,24 @@ var SignupForm = function SignupForm(props) {
           )
         )
       )
-    ) : React__default['default'].createElement(reactBootstrap.Spinner, {
+    ) : React__default.createElement(reactBootstrap.Spinner, {
       as: 'span',
       animation: 'border',
       role: 'status',
       'aria-hidden': 'true',
       size: 'sm'
     }),
-    errorMsg && React__default['default'].createElement(
+    errorMsg && React__default.createElement(
       'p',
       { className: 'error' },
       errorMsg
     ),
-    successMsg && React__default['default'].createElement(
+    successMsg && React__default.createElement(
       'p',
       { className: 'success' },
       successMsg
     ),
-    React__default['default'].createElement(
+    React__default.createElement(
       'style',
       { jsx: 'true'.toString() },
       ' \n        .login {\n          margin: 0 auto;\n          padding: 1rem;\n          border: 1px solid #ccc;\n          border-radius: 4px;\n        }\n        .error {\n          color: red;\n          margin: 1rem 0 0;\n        }\n        .success {\n          color: green;\n          margin: 1rem 0 0;\n        }\n      '
@@ -1218,7 +2262,7 @@ var MAX_AGE = 60 * 60 * 8; // 8 hours
 
 function setTokenCookie(res, token, eKey) {
   var cookies_serailized = [];
-  cookies_serailized.push(index.serialize_1(TOKEN_NAME, token, {
+  cookies_serailized.push(index$5.serialize_1(TOKEN_NAME, token, {
     //maxAge: MAX_AGE,  // we want login cookie to expire when browser
     //expires: new Date(Date.now() + MAX_AGE * 1000),
     //httpOnly: true,
@@ -1227,7 +2271,7 @@ function setTokenCookie(res, token, eKey) {
     //sameSite: 'lax',
   }));
 
-  cookies_serailized.push(index.serialize_1('eKey', eKey, {
+  cookies_serailized.push(index$5.serialize_1('eKey', eKey, {
     //maxAge: MAX_AGE,  // we want login cookie to expire when browser
     //expires: new Date(Date.now() + MAX_AGE * 1000),
     //httpOnly: true,
@@ -1241,12 +2285,12 @@ function setTokenCookie(res, token, eKey) {
 
 function removeTokenCookie(res) {
   var cookies_serailized = [];
-  cookies_serailized.push(index.serialize_1(TOKEN_NAME, '', {
+  cookies_serailized.push(index$5.serialize_1(TOKEN_NAME, '', {
     maxAge: -1,
     expires: new Date(Date.now() - MAX_AGE * 1000),
     path: '/'
   }));
-  cookies_serailized.push(index.serialize_1('eKey', '', {
+  cookies_serailized.push(index$5.serialize_1('eKey', '', {
     maxAge: -1,
     expires: new Date(Date.now() - MAX_AGE * 1000),
     path: '/'
@@ -1261,7 +2305,7 @@ function parseCookies(req) {
 
   // For pages we do need to parse the cookies.
   var cookie = req.headers ? req.headers.cookie : null;
-  return index.parse_1(cookie || '');
+  return index$5.parse_1(cookie || '');
 }
 
 function getTokenCookie(req) {
@@ -1323,10 +2367,10 @@ var iron = /*#__PURE__*/Object.freeze({
   getSession: getSession
 });
 
-var toStr$5 = Object.prototype.toString;
+var toStr = Object.prototype.toString;
 
 var isArguments = function isArguments(value) {
-	var str = toStr$5.call(value);
+	var str = toStr.call(value);
 	var isArgs = str === '[object Arguments]';
 	if (!isArgs) {
 		isArgs = str !== '[object Array]' &&
@@ -1334,16 +2378,16 @@ var isArguments = function isArguments(value) {
 			typeof value === 'object' &&
 			typeof value.length === 'number' &&
 			value.length >= 0 &&
-			toStr$5.call(value.callee) === '[object Function]';
+			toStr.call(value.callee) === '[object Function]';
 	}
 	return isArgs;
 };
 
-var keysShim$1;
+var keysShim;
 if (!Object.keys) {
 	// modified from https://github.com/es-shims/es5-shim
 	var has$1 = Object.prototype.hasOwnProperty;
-	var toStr$4 = Object.prototype.toString;
+	var toStr$1 = Object.prototype.toString;
 	var isArgs = isArguments; // eslint-disable-line global-require
 	var isEnumerable = Object.prototype.propertyIsEnumerable;
 	var hasDontEnumBug = !isEnumerable.call({ toString: null }, 'toString');
@@ -1416,11 +2460,11 @@ if (!Object.keys) {
 		}
 	};
 
-	keysShim$1 = function keys(object) {
+	keysShim = function keys(object) {
 		var isObject = object !== null && typeof object === 'object';
-		var isFunction = toStr$4.call(object) === '[object Function]';
+		var isFunction = toStr$1.call(object) === '[object Function]';
 		var isArguments = isArgs(object);
-		var isString = isObject && toStr$4.call(object) === '[object String]';
+		var isString = isObject && toStr$1.call(object) === '[object String]';
 		var theKeys = [];
 
 		if (!isObject && !isFunction && !isArguments) {
@@ -1458,17 +2502,17 @@ if (!Object.keys) {
 		return theKeys;
 	};
 }
-var implementation$3 = keysShim$1;
+var implementation = keysShim;
 
-var slice$1 = Array.prototype.slice;
+var slice = Array.prototype.slice;
 
 
 var origKeys = Object.keys;
-var keysShim = origKeys ? function keys(o) { return origKeys(o); } : implementation$3;
+var keysShim$1 = origKeys ? function keys(o) { return origKeys(o); } : implementation;
 
 var originalKeys = Object.keys;
 
-keysShim.shim = function shimObjectKeys() {
+keysShim$1.shim = function shimObjectKeys() {
 	if (Object.keys) {
 		var keysWorksWithArguments = (function () {
 			// Safari 5.0 bug
@@ -1478,27 +2522,27 @@ keysShim.shim = function shimObjectKeys() {
 		if (!keysWorksWithArguments) {
 			Object.keys = function keys(object) { // eslint-disable-line func-name-matching
 				if (isArguments(object)) {
-					return originalKeys(slice$1.call(object));
+					return originalKeys(slice.call(object));
 				}
 				return originalKeys(object);
 			};
 		}
 	} else {
-		Object.keys = keysShim;
+		Object.keys = keysShim$1;
 	}
-	return Object.keys || keysShim;
+	return Object.keys || keysShim$1;
 };
 
-var objectKeys = keysShim;
+var objectKeys = keysShim$1;
 
-var hasSymbols$4 = typeof Symbol === 'function' && typeof Symbol('foo') === 'symbol';
+var hasSymbols = typeof Symbol === 'function' && typeof Symbol('foo') === 'symbol';
 
-var toStr$3 = Object.prototype.toString;
+var toStr$2 = Object.prototype.toString;
 var concat = Array.prototype.concat;
 var origDefineProperty = Object.defineProperty;
 
 var isFunction = function (fn) {
-	return typeof fn === 'function' && toStr$3.call(fn) === '[object Function]';
+	return typeof fn === 'function' && toStr$2.call(fn) === '[object Function]';
 };
 
 var arePropertyDescriptorsSupported = function () {
@@ -1535,7 +2579,7 @@ var defineProperty = function (object, name, value, predicate) {
 var defineProperties = function (object, map) {
 	var predicates = arguments.length > 2 ? arguments[2] : {};
 	var props = objectKeys(map);
-	if (hasSymbols$4) {
+	if (hasSymbols) {
 		props = concat.call(props, Object.getOwnPropertySymbols(map));
 	}
 	for (var i = 0; i < props.length; i += 1) {
@@ -1547,59 +2591,6 @@ defineProperties.supportsDescriptors = !!supportsDescriptors;
 
 var defineProperties_1 = defineProperties;
 
-/* eslint no-invalid-this: 1 */
-
-var ERROR_MESSAGE = 'Function.prototype.bind called on incompatible ';
-var slice = Array.prototype.slice;
-var toStr$2 = Object.prototype.toString;
-var funcType = '[object Function]';
-
-var implementation$2 = function bind(that) {
-    var target = this;
-    if (typeof target !== 'function' || toStr$2.call(target) !== funcType) {
-        throw new TypeError(ERROR_MESSAGE + target);
-    }
-    var args = slice.call(arguments, 1);
-
-    var bound;
-    var binder = function () {
-        if (this instanceof bound) {
-            var result = target.apply(
-                this,
-                args.concat(slice.call(arguments))
-            );
-            if (Object(result) === result) {
-                return result;
-            }
-            return this;
-        } else {
-            return target.apply(
-                that,
-                args.concat(slice.call(arguments))
-            );
-        }
-    };
-
-    var boundLength = Math.max(0, target.length - args.length);
-    var boundArgs = [];
-    for (var i = 0; i < boundLength; i++) {
-        boundArgs.push('$' + i);
-    }
-
-    bound = Function('binder', 'return function (' + boundArgs.join(',') + '){ return binder.apply(this,arguments); }')(binder);
-
-    if (target.prototype) {
-        var Empty = function Empty() {};
-        Empty.prototype = target.prototype;
-        bound.prototype = new Empty();
-        Empty.prototype = null;
-    }
-
-    return bound;
-};
-
-var functionBind = Function.prototype.bind || implementation$2;
-
 /* eslint complexity: [2, 18], max-statements: [2, 33] */
 var shams = function hasSymbols() {
 	if (typeof Symbol !== 'function' || typeof Object.getOwnPropertySymbols !== 'function') { return false; }
@@ -1623,7 +2614,7 @@ var shams = function hasSymbols() {
 
 	var symVal = 42;
 	obj[sym] = symVal;
-	for (sym in obj) { return false; } // eslint-disable-line no-restricted-syntax, no-unreachable-loop
+	for (sym in obj) { return false; } // eslint-disable-line no-restricted-syntax
 	if (typeof Object.keys === 'function' && Object.keys(obj).length !== 0) { return false; }
 
 	if (typeof Object.getOwnPropertyNames === 'function' && Object.getOwnPropertyNames(obj).length !== 0) { return false; }
@@ -1641,10 +2632,10 @@ var shams = function hasSymbols() {
 	return true;
 };
 
-var origSymbol = typeof Symbol !== 'undefined' && Symbol;
+var origSymbol = _commonjsHelpers.commonjsGlobal.Symbol;
 
 
-var hasSymbols$3 = function hasNativeSymbols() {
+var hasSymbols$1 = function hasNativeSymbols() {
 	if (typeof origSymbol !== 'function') { return false; }
 	if (typeof Symbol !== 'function') { return false; }
 	if (typeof origSymbol('foo') !== 'symbol') { return false; }
@@ -1653,34 +2644,79 @@ var hasSymbols$3 = function hasNativeSymbols() {
 	return shams();
 };
 
-var src = functionBind.call(Function.call, Object.prototype.hasOwnProperty);
+/* eslint no-invalid-this: 1 */
 
-var undefined$1;
+var ERROR_MESSAGE = 'Function.prototype.bind called on incompatible ';
+var slice$1 = Array.prototype.slice;
+var toStr$3 = Object.prototype.toString;
+var funcType = '[object Function]';
 
-var $SyntaxError$1 = SyntaxError;
-var $Function = Function;
-var $TypeError$5 = TypeError;
+var implementation$1 = function bind(that) {
+    var target = this;
+    if (typeof target !== 'function' || toStr$3.call(target) !== funcType) {
+        throw new TypeError(ERROR_MESSAGE + target);
+    }
+    var args = slice$1.call(arguments, 1);
 
-// eslint-disable-next-line consistent-return
-var getEvalledConstructor = function (expressionSyntax) {
-	try {
-		return $Function('"use strict"; return (' + expressionSyntax + ').constructor;')();
-	} catch (e) {}
+    var bound;
+    var binder = function () {
+        if (this instanceof bound) {
+            var result = target.apply(
+                this,
+                args.concat(slice$1.call(arguments))
+            );
+            if (Object(result) === result) {
+                return result;
+            }
+            return this;
+        } else {
+            return target.apply(
+                that,
+                args.concat(slice$1.call(arguments))
+            );
+        }
+    };
+
+    var boundLength = Math.max(0, target.length - args.length);
+    var boundArgs = [];
+    for (var i = 0; i < boundLength; i++) {
+        boundArgs.push('$' + i);
+    }
+
+    bound = Function('binder', 'return function (' + boundArgs.join(',') + '){ return binder.apply(this,arguments); }')(binder);
+
+    if (target.prototype) {
+        var Empty = function Empty() {};
+        Empty.prototype = target.prototype;
+        bound.prototype = new Empty();
+        Empty.prototype = null;
+    }
+
+    return bound;
 };
 
-var $gOPD$2 = Object.getOwnPropertyDescriptor;
-if ($gOPD$2) {
+var functionBind = Function.prototype.bind || implementation$1;
+
+/* globals
+	Atomics,
+	SharedArrayBuffer,
+*/
+
+var undefined$1;
+
+var $TypeError = TypeError;
+
+var $gOPD = Object.getOwnPropertyDescriptor;
+if ($gOPD) {
 	try {
-		$gOPD$2({}, '');
+		$gOPD({}, '');
 	} catch (e) {
-		$gOPD$2 = null; // this is IE 8, which has a broken gOPD
+		$gOPD = null; // this is IE 8, which has a broken gOPD
 	}
 }
 
-var throwTypeError = function () {
-	throw new $TypeError$5();
-};
-var ThrowTypeError = $gOPD$2
+var throwTypeError = function () { throw new $TypeError(); };
+var ThrowTypeError = $gOPD
 	? (function () {
 		try {
 			// eslint-disable-next-line no-unused-expressions, no-caller, no-restricted-properties
@@ -1689,7 +2725,7 @@ var ThrowTypeError = $gOPD$2
 		} catch (calleeThrows) {
 			try {
 				// IE 8 throws on Object.getOwnPropertyDescriptor(arguments, '')
-				return $gOPD$2(arguments, 'callee').get;
+				return $gOPD(arguments, 'callee').get;
 			} catch (gOPDthrows) {
 				return throwTypeError;
 			}
@@ -1697,354 +2733,206 @@ var ThrowTypeError = $gOPD$2
 	}())
 	: throwTypeError;
 
-var hasSymbols$2 = hasSymbols$3();
+var hasSymbols$2 = hasSymbols$1();
 
 var getProto = Object.getPrototypeOf || function (x) { return x.__proto__; }; // eslint-disable-line no-proto
-
-var needsEval = {};
+var generatorFunction =  undefined$1;
+var asyncFunction =  undefined$1;
+var asyncGenFunction =  undefined$1;
 
 var TypedArray = typeof Uint8Array === 'undefined' ? undefined$1 : getProto(Uint8Array);
 
 var INTRINSICS = {
-	'%AggregateError%': typeof AggregateError === 'undefined' ? undefined$1 : AggregateError,
 	'%Array%': Array,
 	'%ArrayBuffer%': typeof ArrayBuffer === 'undefined' ? undefined$1 : ArrayBuffer,
+	'%ArrayBufferPrototype%': typeof ArrayBuffer === 'undefined' ? undefined$1 : ArrayBuffer.prototype,
 	'%ArrayIteratorPrototype%': hasSymbols$2 ? getProto([][Symbol.iterator]()) : undefined$1,
+	'%ArrayPrototype%': Array.prototype,
+	'%ArrayProto_entries%': Array.prototype.entries,
+	'%ArrayProto_forEach%': Array.prototype.forEach,
+	'%ArrayProto_keys%': Array.prototype.keys,
+	'%ArrayProto_values%': Array.prototype.values,
 	'%AsyncFromSyncIteratorPrototype%': undefined$1,
-	'%AsyncFunction%': needsEval,
-	'%AsyncGenerator%': needsEval,
-	'%AsyncGeneratorFunction%': needsEval,
-	'%AsyncIteratorPrototype%': needsEval,
+	'%AsyncFunction%': asyncFunction,
+	'%AsyncFunctionPrototype%':  undefined$1,
+	'%AsyncGenerator%':  undefined$1,
+	'%AsyncGeneratorFunction%': asyncGenFunction,
+	'%AsyncGeneratorPrototype%':  undefined$1,
+	'%AsyncIteratorPrototype%':  undefined$1,
 	'%Atomics%': typeof Atomics === 'undefined' ? undefined$1 : Atomics,
-	'%BigInt%': typeof BigInt === 'undefined' ? undefined$1 : BigInt,
 	'%Boolean%': Boolean,
+	'%BooleanPrototype%': Boolean.prototype,
 	'%DataView%': typeof DataView === 'undefined' ? undefined$1 : DataView,
+	'%DataViewPrototype%': typeof DataView === 'undefined' ? undefined$1 : DataView.prototype,
 	'%Date%': Date,
+	'%DatePrototype%': Date.prototype,
 	'%decodeURI%': decodeURI,
 	'%decodeURIComponent%': decodeURIComponent,
 	'%encodeURI%': encodeURI,
 	'%encodeURIComponent%': encodeURIComponent,
 	'%Error%': Error,
+	'%ErrorPrototype%': Error.prototype,
 	'%eval%': eval, // eslint-disable-line no-eval
 	'%EvalError%': EvalError,
+	'%EvalErrorPrototype%': EvalError.prototype,
 	'%Float32Array%': typeof Float32Array === 'undefined' ? undefined$1 : Float32Array,
+	'%Float32ArrayPrototype%': typeof Float32Array === 'undefined' ? undefined$1 : Float32Array.prototype,
 	'%Float64Array%': typeof Float64Array === 'undefined' ? undefined$1 : Float64Array,
-	'%FinalizationRegistry%': typeof FinalizationRegistry === 'undefined' ? undefined$1 : FinalizationRegistry,
-	'%Function%': $Function,
-	'%GeneratorFunction%': needsEval,
+	'%Float64ArrayPrototype%': typeof Float64Array === 'undefined' ? undefined$1 : Float64Array.prototype,
+	'%Function%': Function,
+	'%FunctionPrototype%': Function.prototype,
+	'%Generator%':  undefined$1,
+	'%GeneratorFunction%': generatorFunction,
+	'%GeneratorPrototype%':  undefined$1,
 	'%Int8Array%': typeof Int8Array === 'undefined' ? undefined$1 : Int8Array,
+	'%Int8ArrayPrototype%': typeof Int8Array === 'undefined' ? undefined$1 : Int8Array.prototype,
 	'%Int16Array%': typeof Int16Array === 'undefined' ? undefined$1 : Int16Array,
+	'%Int16ArrayPrototype%': typeof Int16Array === 'undefined' ? undefined$1 : Int8Array.prototype,
 	'%Int32Array%': typeof Int32Array === 'undefined' ? undefined$1 : Int32Array,
+	'%Int32ArrayPrototype%': typeof Int32Array === 'undefined' ? undefined$1 : Int32Array.prototype,
 	'%isFinite%': isFinite,
 	'%isNaN%': isNaN,
 	'%IteratorPrototype%': hasSymbols$2 ? getProto(getProto([][Symbol.iterator]())) : undefined$1,
 	'%JSON%': typeof JSON === 'object' ? JSON : undefined$1,
+	'%JSONParse%': typeof JSON === 'object' ? JSON.parse : undefined$1,
 	'%Map%': typeof Map === 'undefined' ? undefined$1 : Map,
 	'%MapIteratorPrototype%': typeof Map === 'undefined' || !hasSymbols$2 ? undefined$1 : getProto(new Map()[Symbol.iterator]()),
+	'%MapPrototype%': typeof Map === 'undefined' ? undefined$1 : Map.prototype,
 	'%Math%': Math,
 	'%Number%': Number,
+	'%NumberPrototype%': Number.prototype,
 	'%Object%': Object,
+	'%ObjectPrototype%': Object.prototype,
+	'%ObjProto_toString%': Object.prototype.toString,
+	'%ObjProto_valueOf%': Object.prototype.valueOf,
 	'%parseFloat%': parseFloat,
 	'%parseInt%': parseInt,
 	'%Promise%': typeof Promise === 'undefined' ? undefined$1 : Promise,
+	'%PromisePrototype%': typeof Promise === 'undefined' ? undefined$1 : Promise.prototype,
+	'%PromiseProto_then%': typeof Promise === 'undefined' ? undefined$1 : Promise.prototype.then,
+	'%Promise_all%': typeof Promise === 'undefined' ? undefined$1 : Promise.all,
+	'%Promise_reject%': typeof Promise === 'undefined' ? undefined$1 : Promise.reject,
+	'%Promise_resolve%': typeof Promise === 'undefined' ? undefined$1 : Promise.resolve,
 	'%Proxy%': typeof Proxy === 'undefined' ? undefined$1 : Proxy,
 	'%RangeError%': RangeError,
+	'%RangeErrorPrototype%': RangeError.prototype,
 	'%ReferenceError%': ReferenceError,
+	'%ReferenceErrorPrototype%': ReferenceError.prototype,
 	'%Reflect%': typeof Reflect === 'undefined' ? undefined$1 : Reflect,
 	'%RegExp%': RegExp,
+	'%RegExpPrototype%': RegExp.prototype,
 	'%Set%': typeof Set === 'undefined' ? undefined$1 : Set,
 	'%SetIteratorPrototype%': typeof Set === 'undefined' || !hasSymbols$2 ? undefined$1 : getProto(new Set()[Symbol.iterator]()),
+	'%SetPrototype%': typeof Set === 'undefined' ? undefined$1 : Set.prototype,
 	'%SharedArrayBuffer%': typeof SharedArrayBuffer === 'undefined' ? undefined$1 : SharedArrayBuffer,
+	'%SharedArrayBufferPrototype%': typeof SharedArrayBuffer === 'undefined' ? undefined$1 : SharedArrayBuffer.prototype,
 	'%String%': String,
 	'%StringIteratorPrototype%': hasSymbols$2 ? getProto(''[Symbol.iterator]()) : undefined$1,
+	'%StringPrototype%': String.prototype,
 	'%Symbol%': hasSymbols$2 ? Symbol : undefined$1,
-	'%SyntaxError%': $SyntaxError$1,
+	'%SymbolPrototype%': hasSymbols$2 ? Symbol.prototype : undefined$1,
+	'%SyntaxError%': SyntaxError,
+	'%SyntaxErrorPrototype%': SyntaxError.prototype,
 	'%ThrowTypeError%': ThrowTypeError,
 	'%TypedArray%': TypedArray,
-	'%TypeError%': $TypeError$5,
+	'%TypedArrayPrototype%': TypedArray ? TypedArray.prototype : undefined$1,
+	'%TypeError%': $TypeError,
+	'%TypeErrorPrototype%': $TypeError.prototype,
 	'%Uint8Array%': typeof Uint8Array === 'undefined' ? undefined$1 : Uint8Array,
+	'%Uint8ArrayPrototype%': typeof Uint8Array === 'undefined' ? undefined$1 : Uint8Array.prototype,
 	'%Uint8ClampedArray%': typeof Uint8ClampedArray === 'undefined' ? undefined$1 : Uint8ClampedArray,
+	'%Uint8ClampedArrayPrototype%': typeof Uint8ClampedArray === 'undefined' ? undefined$1 : Uint8ClampedArray.prototype,
 	'%Uint16Array%': typeof Uint16Array === 'undefined' ? undefined$1 : Uint16Array,
+	'%Uint16ArrayPrototype%': typeof Uint16Array === 'undefined' ? undefined$1 : Uint16Array.prototype,
 	'%Uint32Array%': typeof Uint32Array === 'undefined' ? undefined$1 : Uint32Array,
+	'%Uint32ArrayPrototype%': typeof Uint32Array === 'undefined' ? undefined$1 : Uint32Array.prototype,
 	'%URIError%': URIError,
+	'%URIErrorPrototype%': URIError.prototype,
 	'%WeakMap%': typeof WeakMap === 'undefined' ? undefined$1 : WeakMap,
-	'%WeakRef%': typeof WeakRef === 'undefined' ? undefined$1 : WeakRef,
-	'%WeakSet%': typeof WeakSet === 'undefined' ? undefined$1 : WeakSet
-};
-
-var doEval = function doEval(name) {
-	var value;
-	if (name === '%AsyncFunction%') {
-		value = getEvalledConstructor('async function () {}');
-	} else if (name === '%GeneratorFunction%') {
-		value = getEvalledConstructor('function* () {}');
-	} else if (name === '%AsyncGeneratorFunction%') {
-		value = getEvalledConstructor('async function* () {}');
-	} else if (name === '%AsyncGenerator%') {
-		var fn = doEval('%AsyncGeneratorFunction%');
-		if (fn) {
-			value = fn.prototype;
-		}
-	} else if (name === '%AsyncIteratorPrototype%') {
-		var gen = doEval('%AsyncGenerator%');
-		if (gen) {
-			value = getProto(gen.prototype);
-		}
-	}
-
-	INTRINSICS[name] = value;
-
-	return value;
+	'%WeakMapPrototype%': typeof WeakMap === 'undefined' ? undefined$1 : WeakMap.prototype,
+	'%WeakSet%': typeof WeakSet === 'undefined' ? undefined$1 : WeakSet,
+	'%WeakSetPrototype%': typeof WeakSet === 'undefined' ? undefined$1 : WeakSet.prototype
 };
 
-var LEGACY_ALIASES = {
-	'%ArrayBufferPrototype%': ['ArrayBuffer', 'prototype'],
-	'%ArrayPrototype%': ['Array', 'prototype'],
-	'%ArrayProto_entries%': ['Array', 'prototype', 'entries'],
-	'%ArrayProto_forEach%': ['Array', 'prototype', 'forEach'],
-	'%ArrayProto_keys%': ['Array', 'prototype', 'keys'],
-	'%ArrayProto_values%': ['Array', 'prototype', 'values'],
-	'%AsyncFunctionPrototype%': ['AsyncFunction', 'prototype'],
-	'%AsyncGenerator%': ['AsyncGeneratorFunction', 'prototype'],
-	'%AsyncGeneratorPrototype%': ['AsyncGeneratorFunction', 'prototype', 'prototype'],
-	'%BooleanPrototype%': ['Boolean', 'prototype'],
-	'%DataViewPrototype%': ['DataView', 'prototype'],
-	'%DatePrototype%': ['Date', 'prototype'],
-	'%ErrorPrototype%': ['Error', 'prototype'],
-	'%EvalErrorPrototype%': ['EvalError', 'prototype'],
-	'%Float32ArrayPrototype%': ['Float32Array', 'prototype'],
-	'%Float64ArrayPrototype%': ['Float64Array', 'prototype'],
-	'%FunctionPrototype%': ['Function', 'prototype'],
-	'%Generator%': ['GeneratorFunction', 'prototype'],
-	'%GeneratorPrototype%': ['GeneratorFunction', 'prototype', 'prototype'],
-	'%Int8ArrayPrototype%': ['Int8Array', 'prototype'],
-	'%Int16ArrayPrototype%': ['Int16Array', 'prototype'],
-	'%Int32ArrayPrototype%': ['Int32Array', 'prototype'],
-	'%JSONParse%': ['JSON', 'parse'],
-	'%JSONStringify%': ['JSON', 'stringify'],
-	'%MapPrototype%': ['Map', 'prototype'],
-	'%NumberPrototype%': ['Number', 'prototype'],
-	'%ObjectPrototype%': ['Object', 'prototype'],
-	'%ObjProto_toString%': ['Object', 'prototype', 'toString'],
-	'%ObjProto_valueOf%': ['Object', 'prototype', 'valueOf'],
-	'%PromisePrototype%': ['Promise', 'prototype'],
-	'%PromiseProto_then%': ['Promise', 'prototype', 'then'],
-	'%Promise_all%': ['Promise', 'all'],
-	'%Promise_reject%': ['Promise', 'reject'],
-	'%Promise_resolve%': ['Promise', 'resolve'],
-	'%RangeErrorPrototype%': ['RangeError', 'prototype'],
-	'%ReferenceErrorPrototype%': ['ReferenceError', 'prototype'],
-	'%RegExpPrototype%': ['RegExp', 'prototype'],
-	'%SetPrototype%': ['Set', 'prototype'],
-	'%SharedArrayBufferPrototype%': ['SharedArrayBuffer', 'prototype'],
-	'%StringPrototype%': ['String', 'prototype'],
-	'%SymbolPrototype%': ['Symbol', 'prototype'],
-	'%SyntaxErrorPrototype%': ['SyntaxError', 'prototype'],
-	'%TypedArrayPrototype%': ['TypedArray', 'prototype'],
-	'%TypeErrorPrototype%': ['TypeError', 'prototype'],
-	'%Uint8ArrayPrototype%': ['Uint8Array', 'prototype'],
-	'%Uint8ClampedArrayPrototype%': ['Uint8ClampedArray', 'prototype'],
-	'%Uint16ArrayPrototype%': ['Uint16Array', 'prototype'],
-	'%Uint32ArrayPrototype%': ['Uint32Array', 'prototype'],
-	'%URIErrorPrototype%': ['URIError', 'prototype'],
-	'%WeakMapPrototype%': ['WeakMap', 'prototype'],
-	'%WeakSetPrototype%': ['WeakSet', 'prototype']
-};
-
-
-
-var $concat$2 = functionBind.call(Function.call, Array.prototype.concat);
-var $spliceApply = functionBind.call(Function.apply, Array.prototype.splice);
+
 var $replace = functionBind.call(Function.call, String.prototype.replace);
-var $strSlice = functionBind.call(Function.call, String.prototype.slice);
 
 /* adapted from https://github.com/lodash/lodash/blob/4.17.15/dist/lodash.js#L6735-L6744 */
 var rePropName = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g;
 var reEscapeChar = /\\(\\)?/g; /** Used to match backslashes in property paths. */
 var stringToPath = function stringToPath(string) {
-	var first = $strSlice(string, 0, 1);
-	var last = $strSlice(string, -1);
-	if (first === '%' && last !== '%') {
-		throw new $SyntaxError$1('invalid intrinsic syntax, expected closing `%`');
-	} else if (last === '%' && first !== '%') {
-		throw new $SyntaxError$1('invalid intrinsic syntax, expected opening `%`');
-	}
 	var result = [];
 	$replace(string, rePropName, function (match, number, quote, subString) {
-		result[result.length] = quote ? $replace(subString, reEscapeChar, '$1') : number || match;
+		result[result.length] = quote ? $replace(subString, reEscapeChar, '$1') : (number || match);
 	});
 	return result;
 };
 /* end adaptation */
 
 var getBaseIntrinsic = function getBaseIntrinsic(name, allowMissing) {
-	var intrinsicName = name;
-	var alias;
-	if (src(LEGACY_ALIASES, intrinsicName)) {
-		alias = LEGACY_ALIASES[intrinsicName];
-		intrinsicName = '%' + alias[0] + '%';
+	if (!(name in INTRINSICS)) {
+		throw new SyntaxError('intrinsic ' + name + ' does not exist!');
 	}
 
-	if (src(INTRINSICS, intrinsicName)) {
-		var value = INTRINSICS[intrinsicName];
-		if (value === needsEval) {
-			value = doEval(intrinsicName);
-		}
-		if (typeof value === 'undefined' && !allowMissing) {
-			throw new $TypeError$5('intrinsic ' + name + ' exists, but is not available. Please file an issue!');
-		}
-
-		return {
-			alias: alias,
-			name: intrinsicName,
-			value: value
-		};
+	// istanbul ignore if // hopefully this is impossible to test :-)
+	if (typeof INTRINSICS[name] === 'undefined' && !allowMissing) {
+		throw new $TypeError('intrinsic ' + name + ' exists, but is not available. Please file an issue!');
 	}
 
-	throw new $SyntaxError$1('intrinsic ' + name + ' does not exist!');
+	return INTRINSICS[name];
 };
 
-var getIntrinsic = function GetIntrinsic(name, allowMissing) {
+var GetIntrinsic = function GetIntrinsic(name, allowMissing) {
 	if (typeof name !== 'string' || name.length === 0) {
-		throw new $TypeError$5('intrinsic name must be a non-empty string');
+		throw new TypeError('intrinsic name must be a non-empty string');
 	}
 	if (arguments.length > 1 && typeof allowMissing !== 'boolean') {
-		throw new $TypeError$5('"allowMissing" argument must be a boolean');
+		throw new TypeError('"allowMissing" argument must be a boolean');
 	}
 
 	var parts = stringToPath(name);
-	var intrinsicBaseName = parts.length > 0 ? parts[0] : '';
-
-	var intrinsic = getBaseIntrinsic('%' + intrinsicBaseName + '%', allowMissing);
-	var intrinsicRealName = intrinsic.name;
-	var value = intrinsic.value;
-	var skipFurtherCaching = false;
-
-	var alias = intrinsic.alias;
-	if (alias) {
-		intrinsicBaseName = alias[0];
-		$spliceApply(parts, $concat$2([0, 1], alias));
-	}
-
-	for (var i = 1, isOwn = true; i < parts.length; i += 1) {
-		var part = parts[i];
-		var first = $strSlice(part, 0, 1);
-		var last = $strSlice(part, -1);
-		if (
-			(
-				(first === '"' || first === "'" || first === '`')
-				|| (last === '"' || last === "'" || last === '`')
-			)
-			&& first !== last
-		) {
-			throw new $SyntaxError$1('property names with quotes must have matching quotes');
-		}
-		if (part === 'constructor' || !isOwn) {
-			skipFurtherCaching = true;
-		}
 
-		intrinsicBaseName += '.' + part;
-		intrinsicRealName = '%' + intrinsicBaseName + '%';
-
-		if (src(INTRINSICS, intrinsicRealName)) {
-			value = INTRINSICS[intrinsicRealName];
-		} else if (value != null) {
-			if (!(part in value)) {
-				if (!allowMissing) {
-					throw new $TypeError$5('base intrinsic for ' + name + ' exists, but the property is not available.');
-				}
-				return void undefined$1;
-			}
-			if ($gOPD$2 && (i + 1) >= parts.length) {
-				var desc = $gOPD$2(value, part);
-				isOwn = !!desc;
-
-				// By convention, when a data property is converted to an accessor
-				// property to emulate a data property that does not suffer from
-				// the override mistake, that accessor's getter is marked with
-				// an `originalValue` property. Here, when we detect this, we
-				// uphold the illusion by pretending to see that original data
-				// property, i.e., returning the value rather than the getter
-				// itself.
-				if (isOwn && 'get' in desc && !('originalValue' in desc.get)) {
-					value = desc.get;
-				} else {
-					value = value[part];
+	var value = getBaseIntrinsic('%' + (parts.length > 0 ? parts[0] : '') + '%', allowMissing);
+	for (var i = 1; i < parts.length; i += 1) {
+		if (value != null) {
+			if ($gOPD && (i + 1) >= parts.length) {
+				var desc = $gOPD(value, parts[i]);
+				if (!allowMissing && !(parts[i] in value)) {
+					throw new $TypeError('base intrinsic for ' + name + ' exists, but the property is not available.');
 				}
+				value = desc ? (desc.get || desc.value) : value[parts[i]];
 			} else {
-				isOwn = src(value, part);
-				value = value[part];
-			}
-
-			if (isOwn && !skipFurtherCaching) {
-				INTRINSICS[intrinsicRealName] = value;
+				value = value[parts[i]];
 			}
 		}
 	}
 	return value;
 };
 
-var callBind = _commonjsHelpers.createCommonjsModule(function (module) {
+var $Function = GetIntrinsic('%Function%');
+var $apply = $Function.apply;
+var $call = $Function.call;
 
-
-
-
-var $apply = getIntrinsic('%Function.prototype.apply%');
-var $call = getIntrinsic('%Function.prototype.call%');
-var $reflectApply = getIntrinsic('%Reflect.apply%', true) || functionBind.call($call, $apply);
-
-var $gOPD = getIntrinsic('%Object.getOwnPropertyDescriptor%', true);
-var $defineProperty = getIntrinsic('%Object.defineProperty%', true);
-var $max = getIntrinsic('%Math.max%');
-
-if ($defineProperty) {
-	try {
-		$defineProperty({}, 'a', { value: 1 });
-	} catch (e) {
-		// IE 8 has a broken defineProperty
-		$defineProperty = null;
-	}
-}
-
-module.exports = function callBind(originalFunction) {
-	var func = $reflectApply(functionBind, $call, arguments);
-	if ($gOPD && $defineProperty) {
-		var desc = $gOPD(func, 'length');
-		if (desc.configurable) {
-			// original length, plus the receiver, minus any additional arguments (after the receiver)
-			$defineProperty(
-				func,
-				'length',
-				{ value: 1 + $max(0, originalFunction.length - (arguments.length - 1)) }
-			);
-		}
-	}
-	return func;
+var callBind = function callBind() {
+	return functionBind.apply($call, arguments);
 };
 
-var applyBind = function applyBind() {
-	return $reflectApply(functionBind, $apply, arguments);
+var apply = function applyBind() {
+	return functionBind.apply($apply, arguments);
 };
+callBind.apply = apply;
 
-if ($defineProperty) {
-	$defineProperty(module.exports, 'apply', { value: applyBind });
-} else {
-	module.exports.apply = applyBind;
-}
-});
-callBind.apply;
-
-var $indexOf = callBind(getIntrinsic('String.prototype.indexOf'));
+var $indexOf = callBind(GetIntrinsic('String.prototype.indexOf'));
 
-var callBound$1 = function callBoundIntrinsic(name, allowMissing) {
-	var intrinsic = getIntrinsic(name, !!allowMissing);
-	if (typeof intrinsic === 'function' && $indexOf(name, '.prototype.') > -1) {
+var callBound = function callBoundIntrinsic(name, allowMissing) {
+	var intrinsic = GetIntrinsic(name, !!allowMissing);
+	if (typeof intrinsic === 'function' && $indexOf(name, '.prototype.')) {
 		return callBind(intrinsic);
 	}
 	return intrinsic;
 };
 
-var $defineProperty = getIntrinsic('%Object.defineProperty%', true);
+var $defineProperty = GetIntrinsic('%Object.defineProperty%', true);
 
 if ($defineProperty) {
 	try {
@@ -2057,7 +2945,7 @@ if ($defineProperty) {
 
 
 
-var $isEnumerable$1 = callBound$1('Object.prototype.propertyIsEnumerable');
+var $isEnumerable = callBound('Object.prototype.propertyIsEnumerable');
 
 // eslint-disable-next-line max-params
 var DefineOwnProperty = function DefineOwnProperty(IsDataDescriptor, SameValue, FromPropertyDescriptor, O, P, desc) {
@@ -2071,7 +2959,7 @@ var DefineOwnProperty = function DefineOwnProperty(IsDataDescriptor, SameValue,
 		}
 
 		// fallback for ES3
-		if (P in O && $isEnumerable$1(O, P) !== !!desc['[[Enumerable]]']) {
+		if (P in O && $isEnumerable(O, P) !== !!desc['[[Enumerable]]']) {
 			// a non-enumerable existing property
 			return false;
 		}
@@ -2086,13 +2974,15 @@ var DefineOwnProperty = function DefineOwnProperty(IsDataDescriptor, SameValue,
 	return true;
 };
 
-var $TypeError$4 = getIntrinsic('%TypeError%');
-var $SyntaxError = getIntrinsic('%SyntaxError%');
+var src = functionBind.call(Function.call, Object.prototype.hasOwnProperty);
+
+var $TypeError$1 = GetIntrinsic('%TypeError%');
+var $SyntaxError = GetIntrinsic('%SyntaxError%');
 
 
 
 var predicates = {
-	// https://262.ecma-international.org/6.0/#sec-property-descriptor-specification-type
+	// https://ecma-international.org/ecma-262/6.0/#sec-property-descriptor-specification-type
 	'Property Descriptor': function isPropertyDescriptor(Type, Desc) {
 		if (Type(Desc) !== 'Object') {
 			return false;
@@ -2115,7 +3005,7 @@ var predicates = {
 		var isData = src(Desc, '[[Value]]');
 		var IsAccessor = src(Desc, '[[Get]]') || src(Desc, '[[Set]]');
 		if (isData && IsAccessor) {
-			throw new $TypeError$4('Property Descriptors may not be both accessor and data descriptors');
+			throw new $TypeError$1('Property Descriptors may not be both accessor and data descriptors');
 		}
 		return true;
 	}
@@ -2127,13 +3017,13 @@ var assertRecord = function assertRecord(Type, recordType, argumentName, value)
 		throw new $SyntaxError('unknown record type: ' + recordType);
 	}
 	if (!predicate(Type, value)) {
-		throw new $TypeError$4(argumentName + ' must be a ' + recordType);
+		throw new $TypeError$1(argumentName + ' must be a ' + recordType);
 	}
 };
 
-// https://262.ecma-international.org/5.1/#sec-8
+// https://www.ecma-international.org/ecma-262/5.1/#sec-8
 
-var Type$1 = function Type(x) {
+var Type = function Type(x) {
 	if (x === null) {
 		return 'Null';
 	}
@@ -2154,26 +3044,23 @@ var Type$1 = function Type(x) {
 	}
 };
 
-// https://262.ecma-international.org/11.0/#sec-ecmascript-data-types-and-values
+// https://www.ecma-international.org/ecma-262/6.0/#sec-tostring
 
-var Type = function Type(x) {
+var Type$1 = function Type$1(x) {
 	if (typeof x === 'symbol') {
 		return 'Symbol';
 	}
-	if (typeof x === 'bigint') {
-		return 'BigInt';
-	}
-	return Type$1(x);
+	return Type(x);
 };
 
-// https://ecma-international.org/ecma-262/6.0/#sec-frompropertydescriptor
+// https://www.ecma-international.org/ecma-262/6.0/#sec-frompropertydescriptor
 
 var FromPropertyDescriptor = function FromPropertyDescriptor(Desc) {
 	if (typeof Desc === 'undefined') {
 		return Desc;
 	}
 
-	assertRecord(Type, 'Property Descriptor', 'Desc', Desc);
+	assertRecord(Type$1, 'Property Descriptor', 'Desc', Desc);
 
 	var obj = {};
 	if ('[[Value]]' in Desc) {
@@ -2197,7 +3084,7 @@ var FromPropertyDescriptor = function FromPropertyDescriptor(Desc) {
 	return obj;
 };
 
-var $gOPD$1 = getIntrinsic('%Object.getOwnPropertyDescriptor%');
+var $gOPD$1 = GetIntrinsic('%Object.getOwnPropertyDescriptor%');
 if ($gOPD$1) {
 	try {
 		$gOPD$1([], 'length');
@@ -2209,85 +3096,65 @@ if ($gOPD$1) {
 
 var getOwnPropertyDescriptor = $gOPD$1;
 
-var $Array = getIntrinsic('%Array%');
+var $Array = GetIntrinsic('%Array%');
 
 // eslint-disable-next-line global-require
-var toStr$1 = !$Array.isArray && callBound$1('Object.prototype.toString');
+var toStr$4 = !$Array.isArray && callBound('Object.prototype.toString');
 
-// https://ecma-international.org/ecma-262/6.0/#sec-isarray
+// https://www.ecma-international.org/ecma-262/6.0/#sec-isarray
 
 var IsArray = $Array.isArray || function IsArray(argument) {
-	return toStr$1(argument) === '[object Array]';
+	return toStr$4(argument) === '[object Array]';
 };
 
-// https://ecma-international.org/ecma-262/6.0/#sec-ispropertykey
+// https://www.ecma-international.org/ecma-262/6.0/#sec-ispropertykey
 
 var IsPropertyKey = function IsPropertyKey(argument) {
 	return typeof argument === 'string' || typeof argument === 'symbol';
 };
 
-var hasSymbols$1 = hasSymbols$3();
-var hasToStringTag$1 = hasSymbols$1 && typeof Symbol.toStringTag === 'symbol';
-var has;
-var $exec;
-var isRegexMarker;
-var badStringifier;
-
-if (hasToStringTag$1) {
-	has = callBound$1('Object.prototype.hasOwnProperty');
-	$exec = callBound$1('RegExp.prototype.exec');
-	isRegexMarker = {};
+var regexExec = RegExp.prototype.exec;
+var gOPD = Object.getOwnPropertyDescriptor;
 
-	var throwRegexMarker = function () {
-		throw isRegexMarker;
-	};
-	badStringifier = {
-		toString: throwRegexMarker,
-		valueOf: throwRegexMarker
-	};
+var tryRegexExecCall = function tryRegexExec(value) {
+	try {
+		var lastIndex = value.lastIndex;
+		value.lastIndex = 0; // eslint-disable-line no-param-reassign
 
-	if (typeof Symbol.toPrimitive === 'symbol') {
-		badStringifier[Symbol.toPrimitive] = throwRegexMarker;
+		regexExec.call(value);
+		return true;
+	} catch (e) {
+		return false;
+	} finally {
+		value.lastIndex = lastIndex; // eslint-disable-line no-param-reassign
 	}
-}
-
-var $toString = callBound$1('Object.prototype.toString');
-var gOPD = Object.getOwnPropertyDescriptor;
+};
+var toStr$5 = Object.prototype.toString;
 var regexClass = '[object RegExp]';
+var hasToStringTag = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol';
 
-var isRegex = hasToStringTag$1
-	// eslint-disable-next-line consistent-return
-	? function isRegex(value) {
-		if (!value || typeof value !== 'object') {
-			return false;
-		}
-
-		var descriptor = gOPD(value, 'lastIndex');
-		var hasLastIndexDataProperty = descriptor && has(descriptor, 'value');
-		if (!hasLastIndexDataProperty) {
-			return false;
-		}
+var isRegex = function isRegex(value) {
+	if (!value || typeof value !== 'object') {
+		return false;
+	}
+	if (!hasToStringTag) {
+		return toStr$5.call(value) === regexClass;
+	}
 
-		try {
-			$exec(value, badStringifier);
-		} catch (e) {
-			return e === isRegexMarker;
-		}
+	var descriptor = gOPD(value, 'lastIndex');
+	var hasLastIndexDataProperty = descriptor && src(descriptor, 'value');
+	if (!hasLastIndexDataProperty) {
+		return false;
 	}
-	: function isRegex(value) {
-		// In older browsers, typeof regex incorrectly returns 'function'
-		if (!value || (typeof value !== 'object' && typeof value !== 'function')) {
-			return false;
-		}
 
-		return $toString(value) === regexClass;
-	};
+	return tryRegexExecCall(value);
+};
 
-// http://262.ecma-international.org/5.1/#sec-9.2
+// http://www.ecma-international.org/ecma-262/5.1/#sec-9.2
 
 var ToBoolean = function ToBoolean(value) { return !!value; };
 
-var $match = getIntrinsic('%Symbol.match%', true);
+var $match = GetIntrinsic('%Symbol.match%', true);
 
 
 
@@ -2309,27 +3176,6 @@ var IsRegExp = function IsRegExp(argument) {
 };
 
 var fnToStr = Function.prototype.toString;
-var reflectApply = typeof Reflect === 'object' && Reflect !== null && Reflect.apply;
-var badArrayLike;
-var isCallableMarker;
-if (typeof reflectApply === 'function' && typeof Object.defineProperty === 'function') {
-	try {
-		badArrayLike = Object.defineProperty({}, 'length', {
-			get: function () {
-				throw isCallableMarker;
-			}
-		});
-		isCallableMarker = {};
-		// eslint-disable-next-line no-throw-literal
-		reflectApply(function () { throw 42; }, null, badArrayLike);
-	} catch (_) {
-		if (_ !== isCallableMarker) {
-			reflectApply = null;
-		}
-	}
-} else {
-	reflectApply = null;
-}
 
 var constructorRegex = /^\s*class\b/;
 var isES6ClassFn = function isES6ClassFunction(value) {
@@ -2350,52 +3196,36 @@ var tryFunctionObject = function tryFunctionToStr(value) {
 		return false;
 	}
 };
-var toStr = Object.prototype.toString;
+var toStr$6 = Object.prototype.toString;
 var fnClass = '[object Function]';
 var genClass = '[object GeneratorFunction]';
-var hasToStringTag = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol';
-/* globals document: false */
-var documentDotAll = typeof document === 'object' && typeof document.all === 'undefined' && document.all !== undefined ? document.all : {};
-
-var isCallable = reflectApply
-	? function isCallable(value) {
-		if (value === documentDotAll) { return true; }
-		if (!value) { return false; }
-		if (typeof value !== 'function' && typeof value !== 'object') { return false; }
-		if (typeof value === 'function' && !value.prototype) { return true; }
-		try {
-			reflectApply(value, null, badArrayLike);
-		} catch (e) {
-			if (e !== isCallableMarker) { return false; }
-		}
-		return !isES6ClassFn(value);
-	}
-	: function isCallable(value) {
-		if (value === documentDotAll) { return true; }
-		if (!value) { return false; }
-		if (typeof value !== 'function' && typeof value !== 'object') { return false; }
-		if (typeof value === 'function' && !value.prototype) { return true; }
-		if (hasToStringTag) { return tryFunctionObject(value); }
-		if (isES6ClassFn(value)) { return false; }
-		var strClass = toStr.call(value);
-		return strClass === fnClass || strClass === genClass;
-	};
+var hasToStringTag$1 = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol';
+
+var isCallable = function isCallable(value) {
+	if (!value) { return false; }
+	if (typeof value !== 'function' && typeof value !== 'object') { return false; }
+	if (typeof value === 'function' && !value.prototype) { return true; }
+	if (hasToStringTag$1) { return tryFunctionObject(value); }
+	if (isES6ClassFn(value)) { return false; }
+	var strClass = toStr$6.call(value);
+	return strClass === fnClass || strClass === genClass;
+};
 
-// http://262.ecma-international.org/5.1/#sec-9.11
+// http://www.ecma-international.org/ecma-262/5.1/#sec-9.11
 
 var IsCallable = isCallable;
 
-var $TypeError$3 = getIntrinsic('%TypeError%');
+var $TypeError$2 = GetIntrinsic('%TypeError%');
 
 
 
 
 
-// https://262.ecma-international.org/5.1/#sec-8.10.5
+// https://ecma-international.org/ecma-262/5.1/#sec-8.10.5
 
 var ToPropertyDescriptor = function ToPropertyDescriptor(Obj) {
-	if (Type(Obj) !== 'Object') {
-		throw new $TypeError$3('ToPropertyDescriptor requires an object');
+	if (Type$1(Obj) !== 'Object') {
+		throw new $TypeError$2('ToPropertyDescriptor requires an object');
 	}
 
 	var desc = {};
@@ -2414,29 +3244,29 @@ var ToPropertyDescriptor = function ToPropertyDescriptor(Obj) {
 	if (src(Obj, 'get')) {
 		var getter = Obj.get;
 		if (typeof getter !== 'undefined' && !IsCallable(getter)) {
-			throw new $TypeError$3('getter must be a function');
+			throw new TypeError('getter must be a function');
 		}
 		desc['[[Get]]'] = getter;
 	}
 	if (src(Obj, 'set')) {
 		var setter = Obj.set;
 		if (typeof setter !== 'undefined' && !IsCallable(setter)) {
-			throw new $TypeError$3('setter must be a function');
+			throw new $TypeError$2('setter must be a function');
 		}
 		desc['[[Set]]'] = setter;
 	}
 
 	if ((src(desc, '[[Get]]') || src(desc, '[[Set]]')) && (src(desc, '[[Value]]') || src(desc, '[[Writable]]'))) {
-		throw new $TypeError$3('Invalid property descriptor. Cannot both specify accessors and a value or writable attribute');
+		throw new $TypeError$2('Invalid property descriptor. Cannot both specify accessors and a value or writable attribute');
 	}
 	return desc;
 };
 
-var $TypeError$2 = getIntrinsic('%TypeError%');
+var $TypeError$3 = GetIntrinsic('%TypeError%');
 
 
 
-var $isEnumerable = callBound$1('Object.prototype.propertyIsEnumerable');
+var $isEnumerable$1 = callBound('Object.prototype.propertyIsEnumerable');
 
 
 
@@ -2446,14 +3276,14 @@ var $isEnumerable = callBound$1('Object.prototype.propertyIsEnumerable');
 
 
 
-// https://ecma-international.org/ecma-262/6.0/#sec-ordinarygetownproperty
+// https://www.ecma-international.org/ecma-262/6.0/#sec-ordinarygetownproperty
 
 var OrdinaryGetOwnProperty = function OrdinaryGetOwnProperty(O, P) {
-	if (Type(O) !== 'Object') {
-		throw new $TypeError$2('Assertion failed: O must be an Object');
+	if (Type$1(O) !== 'Object') {
+		throw new $TypeError$3('Assertion failed: O must be an Object');
 	}
 	if (!IsPropertyKey(P)) {
-		throw new $TypeError$2('Assertion failed: P must be a Property Key');
+		throw new $TypeError$3('Assertion failed: P must be a Property Key');
 	}
 	if (!src(O, P)) {
 		return void 0;
@@ -2464,7 +3294,7 @@ var OrdinaryGetOwnProperty = function OrdinaryGetOwnProperty(O, P) {
 		var regexLastIndex = IsRegExp(O) && P === 'lastIndex';
 		return {
 			'[[Configurable]]': !(arrayLength || regexLastIndex),
-			'[[Enumerable]]': $isEnumerable(O, P),
+			'[[Enumerable]]': $isEnumerable$1(O, P),
 			'[[Value]]': O[P],
 			'[[Writable]]': true
 		};
@@ -2472,14 +3302,14 @@ var OrdinaryGetOwnProperty = function OrdinaryGetOwnProperty(O, P) {
 	return ToPropertyDescriptor(getOwnPropertyDescriptor(O, P));
 };
 
-// https://ecma-international.org/ecma-262/6.0/#sec-isdatadescriptor
+// https://www.ecma-international.org/ecma-262/6.0/#sec-isdatadescriptor
 
 var IsDataDescriptor = function IsDataDescriptor(Desc) {
 	if (typeof Desc === 'undefined') {
 		return false;
 	}
 
-	assertRecord(Type, 'Property Descriptor', 'Desc', Desc);
+	assertRecord(Type$1, 'Property Descriptor', 'Desc', Desc);
 
 	if (!src(Desc, '[[Value]]') && !src(Desc, '[[Writable]]')) {
 		return false;
@@ -2492,14 +3322,14 @@ var isPrimitive = function isPrimitive(value) {
 	return value === null || (typeof value !== 'function' && typeof value !== 'object');
 };
 
-var $Object$1 = getIntrinsic('%Object%');
+var $Object = GetIntrinsic('%Object%');
 
 
 
-var $preventExtensions = $Object$1.preventExtensions;
-var $isExtensible = $Object$1.isExtensible;
+var $preventExtensions = $Object.preventExtensions;
+var $isExtensible = $Object.isExtensible;
 
-// https://ecma-international.org/ecma-262/6.0/#sec-isextensible-o
+// https://www.ecma-international.org/ecma-262/6.0/#sec-isextensible-o
 
 var IsExtensible = $preventExtensions
 	? function IsExtensible(obj) {
@@ -2513,7 +3343,7 @@ var _isNaN = Number.isNaN || function isNaN(a) {
 	return a !== a;
 };
 
-// http://262.ecma-international.org/5.1/#sec-9.12
+// http://www.ecma-international.org/ecma-262/5.1/#sec-9.12
 
 var SameValue = function SameValue(x, y) {
 	if (x === y) { // 0 === -0, but they are not identical.
@@ -2523,7 +3353,7 @@ var SameValue = function SameValue(x, y) {
 	return _isNaN(x) && _isNaN(y);
 };
 
-var $TypeError$1 = getIntrinsic('%TypeError%');
+var $TypeError$4 = GetIntrinsic('%TypeError%');
 
 
 
@@ -2535,18 +3365,18 @@ var $TypeError$1 = getIntrinsic('%TypeError%');
 
 
 
-// https://ecma-international.org/ecma-262/6.0/#sec-createdataproperty
+// https://www.ecma-international.org/ecma-262/6.0/#sec-createdataproperty
 
 var CreateDataProperty = function CreateDataProperty(O, P, V) {
-	if (Type(O) !== 'Object') {
-		throw new $TypeError$1('Assertion failed: Type(O) is not Object');
+	if (Type$1(O) !== 'Object') {
+		throw new $TypeError$4('Assertion failed: Type(O) is not Object');
 	}
 	if (!IsPropertyKey(P)) {
-		throw new $TypeError$1('Assertion failed: IsPropertyKey(P) is not true');
+		throw new $TypeError$4('Assertion failed: IsPropertyKey(P) is not true');
 	}
 	var oldDesc = OrdinaryGetOwnProperty(O, P);
-	var extensible = !oldDesc || IsExtensible(O);
-	var immutable = oldDesc && (!oldDesc['[[Writable]]'] || !oldDesc['[[Configurable]]']);
+	var extensible = oldDesc || IsExtensible(O);
+	var immutable = oldDesc && (!oldDesc.writable || !oldDesc.configurable);
 	if (immutable || !extensible) {
 		return false;
 	}
@@ -2565,44 +3395,44 @@ var CreateDataProperty = function CreateDataProperty(O, P, V) {
 	);
 };
 
-var $TypeError = getIntrinsic('%TypeError%');
+var $TypeError$5 = GetIntrinsic('%TypeError%');
 
-// http://262.ecma-international.org/5.1/#sec-9.10
+// http://www.ecma-international.org/ecma-262/5.1/#sec-9.10
 
 var CheckObjectCoercible = function CheckObjectCoercible(value, optMessage) {
 	if (value == null) {
-		throw new $TypeError(optMessage || ('Cannot call method on ' + value));
+		throw new $TypeError$5(optMessage || ('Cannot call method on ' + value));
 	}
 	return value;
 };
 
 var RequireObjectCoercible = CheckObjectCoercible;
 
-var $Object = getIntrinsic('%Object%');
+var $Object$1 = GetIntrinsic('%Object%');
 
 
 
-// https://ecma-international.org/ecma-262/6.0/#sec-toobject
+// https://www.ecma-international.org/ecma-262/6.0/#sec-toobject
 
 var ToObject = function ToObject(value) {
 	RequireObjectCoercible(value);
-	return $Object(value);
+	return $Object$1(value);
 };
 
-var $gOPD = Object.getOwnPropertyDescriptor;
+var $gOPD$2 = Object.getOwnPropertyDescriptor;
 var $getOwnNames = Object.getOwnPropertyNames;
 var $getSymbols = Object.getOwnPropertySymbols;
-var $concat$1 = callBound$1('Array.prototype.concat');
-var $reduce = callBound$1('Array.prototype.reduce');
+var $concat = callBound('Array.prototype.concat');
+var $reduce = callBound('Array.prototype.reduce');
 var getAll = $getSymbols ? function (obj) {
-	return $concat$1($getOwnNames(obj), $getSymbols(obj));
+	return $concat($getOwnNames(obj), $getSymbols(obj));
 } : $getOwnNames;
 
-var isES5$1 = IsCallable($gOPD) && IsCallable($getOwnNames);
+var isES5 = IsCallable($gOPD$2) && IsCallable($getOwnNames);
 
-var implementation$1 = function getOwnPropertyDescriptors(value) {
+var implementation$2 = function getOwnPropertyDescriptors(value) {
 	RequireObjectCoercible(value);
-	if (!isES5$1) {
+	if (!isES5) {
 		throw new TypeError('getOwnPropertyDescriptors requires Object.getOwnPropertyDescriptor');
 	}
 
@@ -2610,7 +3440,7 @@ var implementation$1 = function getOwnPropertyDescriptors(value) {
 	return $reduce(
 		getAll(O),
 		function (acc, key) {
-			var descriptor = $gOPD(O, key);
+			var descriptor = $gOPD$2(O, key);
 			if (typeof descriptor !== 'undefined') {
 				CreateDataProperty(acc, key, descriptor);
 			}
@@ -2620,40 +3450,34 @@ var implementation$1 = function getOwnPropertyDescriptors(value) {
 	);
 };
 
-var polyfill$2 = function getPolyfill() {
-	return typeof Object.getOwnPropertyDescriptors === 'function' ? Object.getOwnPropertyDescriptors : implementation$1;
+var polyfill = function getPolyfill() {
+	return typeof Object.getOwnPropertyDescriptors === 'function' ? Object.getOwnPropertyDescriptors : implementation$2;
 };
 
-var shim$1 = function shimGetOwnPropertyDescriptors() {
-	var polyfill = polyfill$2();
+var shim = function shimGetOwnPropertyDescriptors() {
+	var polyfill$1 = polyfill();
 	defineProperties_1(
 		Object,
-		{ getOwnPropertyDescriptors: polyfill },
-		{ getOwnPropertyDescriptors: function () { return Object.getOwnPropertyDescriptors !== polyfill; } }
+		{ getOwnPropertyDescriptors: polyfill$1 },
+		{ getOwnPropertyDescriptors: function () { return Object.getOwnPropertyDescriptors !== polyfill$1; } }
 	);
-	return polyfill;
+	return polyfill$1;
 };
 
-var bound = callBind(polyfill$2(), Object);
-
-defineProperties_1(bound, {
-	getPolyfill: polyfill$2,
-	implementation: implementation$1,
-	shim: shim$1
+defineProperties_1(implementation$2, {
+	getPolyfill: polyfill,
+	implementation: implementation$2,
+	shim: shim
 });
 
-var object_getownpropertydescriptors = bound;
+var object_getownpropertydescriptors = implementation$2;
 
-// TODO; semver-major: remove
-
-var callBound = callBound$1;
-
-var isES5 = typeof Object.defineProperty === 'function'
+var isES5$1 = typeof Object.defineProperty === 'function'
 	&& typeof Object.defineProperties === 'function';
 
 var hasProto = [].__proto__ === Array.prototype; // eslint-disable-line no-proto
 
-if (!isES5 || !hasProto) {
+if (!isES5$1 || !hasProto) {
 	throw new TypeError('util.promisify requires a true ES5 environment, that also supports `__proto__`');
 }
 
@@ -2666,15 +3490,15 @@ if (typeof Promise !== 'function') {
 
 
 var $slice = callBound('Array.prototype.slice');
-var $concat = callBound('Array.prototype.concat');
+var $concat$1 = callBound('Array.prototype.concat');
 var $forEach = callBound('Array.prototype.forEach');
 
-var hasSymbols = hasSymbols$3();
+var hasSymbols$3 = hasSymbols$1();
 
-var kCustomPromisifiedSymbol = hasSymbols ? Symbol('util.promisify.custom') : null;
-var kCustomPromisifyArgsSymbol = hasSymbols ? Symbol('customPromisifyArgs') : null;
+var kCustomPromisifiedSymbol = hasSymbols$3 ? Symbol('util.promisify.custom') : null;
+var kCustomPromisifyArgsSymbol = hasSymbols$3 ? Symbol('customPromisifyArgs') : null;
 
-var implementation = function promisify(orig) {
+var implementation$3 = function promisify(orig) {
 	if (typeof orig !== 'function') {
 		var error = new TypeError('The "original" argument must be of type function');
 		error.name = 'TypeError [ERR_INVALID_ARG_TYPE]';
@@ -2682,7 +3506,7 @@ var implementation = function promisify(orig) {
 		throw error;
 	}
 
-	if (hasSymbols && orig[kCustomPromisifiedSymbol]) {
+	if (hasSymbols$3 && orig[kCustomPromisifiedSymbol]) {
 		var customFunction = orig[kCustomPromisifiedSymbol];
 		if (typeof customFunction !== 'function') {
 			throw new TypeError('The [util.promisify.custom] property must be a function');
@@ -2704,7 +3528,7 @@ var implementation = function promisify(orig) {
 		var args = $slice(arguments);
 		var self = this; // eslint-disable-line no-invalid-this
 		return new Promise(function (resolve, reject) {
-			orig.apply(self, $concat(args, function (err) {
+			orig.apply(self, $concat$1(args, function (err) {
 				var values = arguments.length > 1 ? $slice(arguments, 1) : [];
 				if (err) {
 					reject(err);
@@ -2734,17 +3558,17 @@ var implementation = function promisify(orig) {
 
 var custom = kCustomPromisifiedSymbol;
 var customPromisifyArgs = kCustomPromisifyArgsSymbol;
-implementation.custom = custom;
-implementation.customPromisifyArgs = customPromisifyArgs;
+implementation$3.custom = custom;
+implementation$3.customPromisifyArgs = customPromisifyArgs;
 
 var polyfill$1 = function getPolyfill() {
 	if (typeof util.util.promisify === 'function') {
 		return util.util.promisify;
 	}
-	return implementation;
+	return implementation$3;
 };
 
-var shim = function shimUtilPromisify() {
+var shim$1 = function shimUtilPromisify() {
 	var polyfill = polyfill$1();
 	if (polyfill !== util.util.promisify) {
 		Object.defineProperty(util.util, 'promisify', {
@@ -2757,20 +3581,20 @@ var shim = function shimUtilPromisify() {
 	return polyfill;
 };
 
-var polyfill = polyfill$1();
+var polyfill$2 = polyfill$1();
 
 
 /* eslint-disable no-unused-vars */
 var boundPromisify = function promisify(orig) {
 /* eslint-enable no-unused-vars */
-	return polyfill.apply(util.util, arguments);
+	return polyfill$2.apply(util.util, arguments);
 };
 defineProperties_1(boundPromisify, {
-	custom: polyfill.custom,
-	customPromisifyArgs: polyfill.customPromisifyArgs,
+	custom: polyfill$2.custom,
+	customPromisifyArgs: polyfill$2.customPromisifyArgs,
 	getPolyfill: polyfill$1,
-	implementation: implementation,
-	shim: shim
+	implementation: implementation$3,
+	shim: shim$1
 });
 
 var util_promisify = boundPromisify;
@@ -2789,7 +3613,7 @@ function connect() {
         };
     }
 
-    var connection = mysql__default['default'].createConnection(config);
+    var connection = mysql.createConnection(config);
     return {
         query: function query(sql, args) {
             return util.util.promisify(connection.query).call(connection, sql, args);
@@ -2811,16 +3635,16 @@ function connect() {
 
 var db = connect;
 
-var _this$1 = undefined;
+var _this$3 = undefined;
 
-var config$1 = {
+var config = {
   host: 'sanity-datasource.cluster-crao688bsrdh.us-east-1.rds.amazonaws.com',
   user: 'nasp',
   password: 'uRNkF9SkfXQs6AKK',
   database: 'user'
 };
 
-var findUser$1 = function () {
+var findUser = function () {
   var _ref = asyncToGenerator._asyncToGenerator( /*#__PURE__*/asyncToGenerator.regenerator.mark(function _callee(email) {
     var password = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
     var db$1, query, res, user, hash, passwordsMatch, user_shared, occupation_id;
@@ -2832,7 +3656,7 @@ var findUser$1 = function () {
             _context.prev = 1;
 
 
-            db$1 = db(config$1);
+            db$1 = db(config);
 
             query = '\n      select * \n      from user \n      where trim(lower(email)) = ?\n    ';
             _context.next = 6;
@@ -2928,7 +3752,7 @@ var findUser$1 = function () {
   };
 }();
 
-var updateUser$1 = function () {
+var updateUser = function () {
   var _ref2 = asyncToGenerator._asyncToGenerator( /*#__PURE__*/asyncToGenerator.regenerator.mark(function _callee2(data) {
     var db$1, query, res, hash, columns, i, column, occupation_name;
     return asyncToGenerator.regenerator.wrap(function _callee2$(_context2) {
@@ -2941,7 +3765,7 @@ var updateUser$1 = function () {
 
             validateUserData(data);
 
-            db$1 = db(config$1);
+            db$1 = db(config);
 
             _context2.next = 6;
             return db$1.beginTransaction();
@@ -3048,7 +3872,7 @@ var updateUser$1 = function () {
 
             return _context2.abrupt('return', {
               error: '',
-              user: findUser$1(data.email)
+              user: findUser(data.email)
             });
 
           case 45:
@@ -3160,7 +3984,7 @@ var getOccupationNameById = function () {
             return _context3.stop();
         }
       }
-    }, _callee3, _this$1);
+    }, _callee3, _this$3);
   }));
 
   return function getOccupationNameById(_x5, _x6) {
@@ -3168,7 +3992,7 @@ var getOccupationNameById = function () {
   };
 }();
 
-var createUser$1 = function () {
+var createUser = function () {
   var _ref4 = asyncToGenerator._asyncToGenerator( /*#__PURE__*/asyncToGenerator.regenerator.mark(function _callee4(data) {
     var db$1, query, res, hash, columns, i, column, user_id, occupation_name;
     return asyncToGenerator.regenerator.wrap(function _callee4$(_context4) {
@@ -3181,7 +4005,7 @@ var createUser$1 = function () {
 
             validateUserData(data, true);
 
-            db$1 = db(config$1);
+            db$1 = db(config);
 
             _context4.next = 6;
             return db$1.beginTransaction();
@@ -3277,7 +4101,7 @@ var createUser$1 = function () {
           case 39:
             return _context4.abrupt('return', {
               error: '',
-              user: findUser$1(data.email)
+              user: findUser(data.email)
             });
 
           case 42:
@@ -3315,7 +4139,7 @@ var createUser$1 = function () {
   };
 }();
 
-var createUser = function () {
+var createUser$1 = function () {
   var _ref = asyncToGenerator._asyncToGenerator( /*#__PURE__*/asyncToGenerator.regenerator.mark(function _callee(data) {
     var res;
     return asyncToGenerator.regenerator.wrap(function _callee$(_context) {
@@ -3323,7 +4147,7 @@ var createUser = function () {
         switch (_context.prev = _context.next) {
           case 0:
             _context.next = 2;
-            return createUser$1(data);
+            return createUser(data);
 
           case 2:
             res = _context.sent;
@@ -3351,7 +4175,7 @@ var createUser = function () {
   };
 }();
 
-var updateUser = function () {
+var updateUser$1 = function () {
   var _ref2 = asyncToGenerator._asyncToGenerator( /*#__PURE__*/asyncToGenerator.regenerator.mark(function _callee2(data) {
     var res;
     return asyncToGenerator.regenerator.wrap(function _callee2$(_context2) {
@@ -3359,7 +4183,7 @@ var updateUser = function () {
         switch (_context2.prev = _context2.next) {
           case 0:
             _context2.next = 2;
-            return updateUser$1(data);
+            return updateUser(data);
 
           case 2:
             res = _context2.sent;
@@ -3387,7 +4211,7 @@ var updateUser = function () {
   };
 }();
 
-var findUser = function () {
+var findUser$1 = function () {
   var _ref3 = asyncToGenerator._asyncToGenerator( /*#__PURE__*/asyncToGenerator.regenerator.mark(function _callee3(_ref4) {
     var email = _ref4.email,
         password = _ref4.password;
@@ -3397,7 +4221,7 @@ var findUser = function () {
         switch (_context3.prev = _context3.next) {
           case 0:
             _context3.next = 2;
-            return findUser$1(email, password);
+            return findUser(email, password);
 
           case 2:
             res = _context3.sent;
@@ -3427,17 +4251,17 @@ var findUser = function () {
 
 var user = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  createUser: createUser,
-  updateUser: updateUser,
-  findUser: findUser
+  createUser: createUser$1,
+  updateUser: updateUser$1,
+  findUser: findUser$1
 });
 
-var localStrategy = new Local__default['default'].Strategy({
+var localStrategy = new Local.Strategy({
   usernameField: 'email',
   passwordField: 'password'
 }, function (email, password, done) {
 
-  findUser({ email: email, password: password }).then(function (user) {
+  findUser$1({ email: email, password: password }).then(function (user) {
     done(null, user);
   }).catch(function (error) {
     done(error);
@@ -3449,9 +4273,9 @@ var passportLocal = /*#__PURE__*/Object.freeze({
   localStrategy: localStrategy
 });
 
-var _this = undefined;
+var _this$4 = undefined;
 
-var config = {
+var config$1 = {
   host: 'sanity-datasource.cluster-crao688bsrdh.us-east-1.rds.amazonaws.com',
   user: 'nasp',
   password: 'uRNkF9SkfXQs6AKK',
@@ -3465,7 +4289,7 @@ var getOccupation = function () {
       while (1) {
         switch (_context.prev = _context.next) {
           case 0:
-            db$1 = db(config);
+            db$1 = db(config$1);
             query = '\n    select name as label, id as value\n    from occupation\n    where type = ?\n  ';
             _context.next = 4;
             return db$1.query(query, [type]);
@@ -3483,7 +4307,7 @@ var getOccupation = function () {
             return _context.stop();
         }
       }
-    }, _callee, _this);
+    }, _callee, _this$4);
   }));
 
   return function getOccupation(_x) {
@@ -3498,7 +4322,7 @@ var getFieldsAndOptions = function () {
       while (1) {
         switch (_context2.prev = _context2.next) {
           case 0:
-            db$1 = db(config);
+            db$1 = db(config$1);
             query = '\n    select * \n    from field\n    where occupation_id = ?\n    order by sorting\n  ';
             _context2.next = 4;
             return db$1.query(query, [occupation]);
@@ -3546,7 +4370,7 @@ var getFieldsAndOptions = function () {
             return _context2.stop();
         }
       }
-    }, _callee2, _this);
+    }, _callee2, _this$4);
   }));
 
   return function getFieldsAndOptions(_x2) {
@@ -3617,8 +4441,8 @@ var ProcessData = (function () {
 })();
 
 var LoginForm_1 = LoginForm;
-var SignupForm_1 = SignupForm$1;
-var ProfileForm_1 = SignupForm;
+var SignupForm_1 = SignupForm;
+var ProfileForm_1 = SignupForm$1;
 var AuthCookies_1 = authCookies;
 var AuthHooks_1 = hooks;
 var Iron_1 = iron;