@mjhls/mjh-framework 1.0.859-beta.4 → 1.0.859-d4d-374

package/dist/cjs/Auth.js

@@ -2,8 +2,6 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
-
 var _commonjsHelpers = require('./_commonjsHelpers-06173234.js');
 require('./_to-object-329a650b.js');
 require('./es6.string.iterator-cc0bbaa4.js');
@@ -11,21 +9,28 @@ require('./_library-dd23b178.js');
 require('./_iter-detect-60b2f026.js');
 require('./core.get-iterator-method-f62321d4.js');
 require('./_object-pie-68c5bcbc.js');
-var _extends$1 = require('./extends-0a918631.js');
+var _extends = require('./extends-0a918631.js');
 require('./web.dom.iterable-a0e279c1.js');
 var React = require('react');
-var React__default = _interopDefault(React);
 var Router = require('next/router');
-var Router__default = _interopDefault(Router);
 var slicedToArray = require('./slicedToArray-8f385299.js');
 var stringify = require('./stringify-7c5aff47.js');
 var asyncToGenerator = require('./asyncToGenerator-140e5f89.js');
 var reactBootstrap = require('react-bootstrap');
 var util = require('./util-f2c1b65b.js');
-var index$6 = require('./index-bd6c9f56.js');
-var Local = _interopDefault(require('passport-local'));
-var mysql = _interopDefault(require('mysql'));
-var md5 = require('./md5-5039b1a6.js');
+var index = require('./index-bd6c9f56.js');
+var useSWR = require('swr');
+var Local = require('passport-local');
+var mysql = require('mysql');
+var md5 = require('./md5-e1ca5797.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 returnFormField = function returnFormField(_ref) {
   var name = _ref.name,
@@ -64,21 +69,21 @@ var returnFormField = function returnFormField(_ref) {
   }
 
   if (type == 'text' || type == 'email' || type == 'password' || type == 'number') {
-    return React__default.createElement(
+    return React__default['default'].createElement(
       reactBootstrap.Form.Group,
-      _extends$1._extends({}, opts, { controlId: name }),
-      React__default.createElement(
+      _extends._extends({}, opts, { controlId: name }),
+      React__default['default'].createElement(
         reactBootstrap.Form.Label,
         { kye: name + '_label' },
         label,
-        required && React__default.createElement(
+        required && React__default['default'].createElement(
           'span',
           { style: { color: 'red' } },
           '*'
         )
       ),
-      React__default.createElement(reactBootstrap.Form.Control, { key: name + '_' + type, type: type, readOnly: readonly, name: name, placeholder: '', defaultValue: default_value, required: required }),
-      React__default.createElement(
+      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(
         reactBootstrap.Form.Control.Feedback,
         { key: name + '_feedback', type: 'invalid' },
         errors[name]
@@ -86,28 +91,28 @@ var returnFormField = function returnFormField(_ref) {
     );
   }
   if (type == 'select') {
-    return React__default.createElement(
+    return React__default['default'].createElement(
       reactBootstrap.Form.Group,
-      _extends$1._extends({}, opts, { key: name, controlId: name }),
-      React__default.createElement(
+      _extends._extends({}, opts, { key: name, controlId: name }),
+      React__default['default'].createElement(
         reactBootstrap.Form.Label,
         { key: name + '_' + label },
         label,
-        required && React__default.createElement(
+        required && React__default['default'].createElement(
           'span',
           { key: name + '_required_span', style: { color: 'red' } },
           '*'
         )
       ),
-      React__default.createElement(
+      React__default['default'].createElement(
         reactBootstrap.Form.Control,
         { key: name + '_select', as: 'select', name: name, required: required, defaultValue: default_value },
-        React__default.createElement('option', { value: '', key: name + '_options_empty' }),
+        React__default['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.createElement(
+          return React__default['default'].createElement(
             'option',
             { key: key, value: value },
             label
@@ -118,1080 +123,31 @@ var returnFormField = function returnFormField(_ref) {
   }
 
   if (type == 'radio' || type == 'checkbox') {
-    return React__default.createElement(
+    return React__default['default'].createElement(
       reactBootstrap.Form.Group,
       opts,
-      React__default.createElement(
+      React__default['default'].createElement(
         reactBootstrap.Form.Label,
         null,
         label,
-        required && React__default.createElement(
+        required && React__default['default'].createElement(
           'span',
           { style: { color: 'red' } },
           '*'
         )
       ),
       options.map(function (option, index) {
-        return React__default.createElement(
+        return React__default['default'].createElement(
           reactBootstrap.Form.Check,
           { type: type, key: index, required: required },
-          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 } })
+          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 } })
         );
       })
     );
   }
 };
 
-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 () {
@@ -1271,7 +227,7 @@ function useUser() {
       redirectTo = _ref.redirectTo,
       redirectIfFound = _ref.redirectIfFound;
 
-  var _useSWR = useSWR('/api/auth/user', dataHandler),
+  var _useSWR = useSWR__default['default']('/api/auth/user', dataHandler),
       data = _useSWR.data,
       error = _useSWR.error;
 
@@ -1286,7 +242,7 @@ function useUser() {
     redirectTo && !redirectIfFound && !hasUser ||
     // If redirectIfFound is also set, redirect if the user was found
     redirectIfFound && hasUser) {
-      Router__default.push(redirectTo);
+      Router__default['default'].push(redirectTo);
     }
   }, [redirectTo, redirectIfFound, finished, hasUser]);
 
@@ -1392,43 +348,43 @@ var LoginForm = function LoginForm(props) {
       loading = _useState4[0],
       setLoading = _useState4[1];
 
-  return React__default.createElement(
+  return React__default['default'].createElement(
     reactBootstrap.Form,
     { className: 'login', onSubmit: handleSubmit },
-    React__default.createElement(
+    React__default['default'].createElement(
       'h1',
       null,
       'Login'
     ),
-    React__default.createElement('hr', null),
+    React__default['default'].createElement('hr', null),
     returnFormField({ name: 'email', label: 'Email', type: 'email', required: true }),
     returnFormField({ name: 'password', label: 'Password', type: 'password', required: true }),
-    React__default.createElement('hr', null),
-    React__default.createElement(
+    React__default['default'].createElement('hr', null),
+    React__default['default'].createElement(
       reactBootstrap.Form.Row,
       null,
-      React__default.createElement(
+      React__default['default'].createElement(
         reactBootstrap.Form.Group,
         { as: reactBootstrap.Col },
-        React__default.createElement(
+        React__default['default'].createElement(
           'a',
           { href: '/auth/signup' },
           'I don\'t have an account'
         )
       ),
-      React__default.createElement(
+      React__default['default'].createElement(
         reactBootstrap.Form.Group,
         { as: reactBootstrap.Col, className: 'text-right' },
-        !loading && React__default.createElement(
+        !loading && React__default['default'].createElement(
           reactBootstrap.Button,
           { type: 'submit' },
           'Login'
         ),
-        loading && React__default.createElement(
+        loading && React__default['default'].createElement(
           reactBootstrap.Button,
           { variant: 'primary', disabled: true },
-          React__default.createElement(reactBootstrap.Spinner, { as: 'span', animation: 'border', role: 'status', 'aria-hidden': 'true', size: 'sm' }),
-          React__default.createElement(
+          React__default['default'].createElement(reactBootstrap.Spinner, { as: 'span', animation: 'border', role: 'status', 'aria-hidden': 'true', size: 'sm' }),
+          React__default['default'].createElement(
             'span',
             { className: 'sr-only' },
             'Loading...'
@@ -1436,12 +392,12 @@ var LoginForm = function LoginForm(props) {
         )
       )
     ),
-    errorMsg && React__default.createElement(
+    errorMsg && React__default['default'].createElement(
       'p',
       { className: 'error' },
       errorMsg
     ),
-    React__default.createElement(
+    React__default['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      '
@@ -1697,29 +653,29 @@ var SignupForm = function SignupForm(props) {
       loading = _useState14[0],
       setLoading = _useState14[1];
 
-  return React__default.createElement(
+  return React__default['default'].createElement(
     reactBootstrap.Form,
     { className: 'login', id: 'signupForm', onSubmit: handleSubmit },
-    React__default.createElement(
+    React__default['default'].createElement(
       'h1',
       null,
       'Sign Up'
     ),
-    React__default.createElement('hr', null),
+    React__default['default'].createElement('hr', null),
     returnFormField({ name: 'email', label: 'Email', type: 'email', required: true }),
-    React__default.createElement(
+    React__default['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.createElement(
+    React__default['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.createElement(
+    React__default['default'].createElement(
       reactBootstrap.Form.Row,
       null,
       returnFormField({
@@ -1733,7 +689,7 @@ var SignupForm = function SignupForm(props) {
       }),
       countryUS && returnFormField({ name: 'state', label: 'State', type: 'select', required: true, groupType: reactBootstrap.Col, options: states })
     ),
-    React__default.createElement(
+    React__default['default'].createElement(
       reactBootstrap.Form.Row,
       null,
       countryUS && returnFormField({ name: 'zip', label: 'Working Zip Code', type: 'text', required: true, groupType: reactBootstrap.Col }),
@@ -1780,38 +736,38 @@ var SignupForm = 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.createElement('hr', null),
-    React__default.createElement(
+    React__default['default'].createElement('hr', null),
+    React__default['default'].createElement(
       reactBootstrap.Form.Row,
       null,
-      React__default.createElement(
+      React__default['default'].createElement(
         reactBootstrap.Form.Group,
         { as: reactBootstrap.Col },
-        React__default.createElement(
+        React__default['default'].createElement(
           'a',
           { href: '/auth/login' },
           'I already have an account'
         )
       ),
-      React__default.createElement(
+      React__default['default'].createElement(
         reactBootstrap.Form.Group,
         { as: reactBootstrap.Col, className: 'text-right' },
-        !loading && React__default.createElement(
+        !loading && React__default['default'].createElement(
           reactBootstrap.Button,
           { type: 'submit' },
           'Sign Up'
         ),
-        loading && React__default.createElement(
+        loading && React__default['default'].createElement(
           reactBootstrap.Button,
           { variant: 'primary', disabled: true },
-          React__default.createElement(reactBootstrap.Spinner, {
+          React__default['default'].createElement(reactBootstrap.Spinner, {
             as: 'span',
             animation: 'border',
             role: 'status',
             'aria-hidden': 'true',
             size: 'sm'
           }),
-          React__default.createElement(
+          React__default['default'].createElement(
             'span',
             { className: 'sr-only' },
             'Loading...'
@@ -1819,12 +775,12 @@ var SignupForm = function SignupForm(props) {
         )
       )
     ),
-    errorMsg && React__default.createElement(
+    errorMsg && React__default['default'].createElement(
       'p',
       { className: 'error' },
       errorMsg
     ),
-    React__default.createElement(
+    React__default['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      '
@@ -2114,32 +1070,32 @@ var SignupForm$1 = function SignupForm(props) {
       loading = _useState18[0],
       setLoading = _useState18[1];
 
-  return React__default.createElement(
+  return React__default['default'].createElement(
     reactBootstrap.Form,
     { className: 'login', id: 'signupForm', onSubmit: handleSubmit },
-    React__default.createElement(
+    React__default['default'].createElement(
       'h1',
       null,
       'Profile'
     ),
-    React__default.createElement('hr', null),
-    userData ? React__default.createElement(
-      React__default.Fragment,
+    React__default['default'].createElement('hr', null),
+    userData ? React__default['default'].createElement(
+      React__default['default'].Fragment,
       null,
       returnFormField({ name: 'email', label: 'Email', type: 'email', required: true, readonly: true, default_value: userData.email }),
-      React__default.createElement(
+      React__default['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.createElement(
+      React__default['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.createElement(
+      React__default['default'].createElement(
         reactBootstrap.Form.Row,
         null,
         returnFormField({
@@ -2154,7 +1110,7 @@ var SignupForm$1 = 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.createElement(
+      React__default['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 }),
@@ -2204,29 +1160,29 @@ var SignupForm$1 = 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.createElement('hr', null),
-      React__default.createElement(
+      React__default['default'].createElement('hr', null),
+      React__default['default'].createElement(
         reactBootstrap.Form.Row,
         null,
-        React__default.createElement(
+        React__default['default'].createElement(
           reactBootstrap.Form.Group,
           { as: reactBootstrap.Col },
-          !loading && React__default.createElement(
+          !loading && React__default['default'].createElement(
             reactBootstrap.Button,
             { type: 'submit' },
             'Update'
           ),
-          loading && React__default.createElement(
+          loading && React__default['default'].createElement(
             reactBootstrap.Button,
             { variant: 'primary', disabled: true },
-            React__default.createElement(reactBootstrap.Spinner, {
+            React__default['default'].createElement(reactBootstrap.Spinner, {
               as: 'span',
               animation: 'border',
               role: 'status',
               'aria-hidden': 'true',
               size: 'sm'
             }),
-            React__default.createElement(
+            React__default['default'].createElement(
               'span',
               { className: 'sr-only' },
               'Loading...'
@@ -2234,24 +1190,24 @@ var SignupForm$1 = function SignupForm(props) {
           )
         )
       )
-    ) : React__default.createElement(reactBootstrap.Spinner, {
+    ) : React__default['default'].createElement(reactBootstrap.Spinner, {
       as: 'span',
       animation: 'border',
       role: 'status',
       'aria-hidden': 'true',
       size: 'sm'
     }),
-    errorMsg && React__default.createElement(
+    errorMsg && React__default['default'].createElement(
       'p',
       { className: 'error' },
       errorMsg
     ),
-    successMsg && React__default.createElement(
+    successMsg && React__default['default'].createElement(
       'p',
       { className: 'success' },
       successMsg
     ),
-    React__default.createElement(
+    React__default['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      '
@@ -2264,7 +1220,7 @@ var MAX_AGE = 60 * 60 * 8; // 8 hours
 
 function setTokenCookie(res, token, eKey) {
   var cookies_serailized = [];
-  cookies_serailized.push(index$6.serialize_1(TOKEN_NAME, token, {
+  cookies_serailized.push(index.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,
@@ -2273,7 +1229,7 @@ function setTokenCookie(res, token, eKey) {
     //sameSite: 'lax',
   }));
 
-  cookies_serailized.push(index$6.serialize_1('eKey', eKey, {
+  cookies_serailized.push(index.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,
@@ -2287,12 +1243,12 @@ function setTokenCookie(res, token, eKey) {
 
 function removeTokenCookie(res) {
   var cookies_serailized = [];
-  cookies_serailized.push(index$6.serialize_1(TOKEN_NAME, '', {
+  cookies_serailized.push(index.serialize_1(TOKEN_NAME, '', {
     maxAge: -1,
     expires: new Date(Date.now() - MAX_AGE * 1000),
     path: '/'
   }));
-  cookies_serailized.push(index$6.serialize_1('eKey', '', {
+  cookies_serailized.push(index.serialize_1('eKey', '', {
     maxAge: -1,
     expires: new Date(Date.now() - MAX_AGE * 1000),
     path: '/'
@@ -2307,7 +1263,7 @@ function parseCookies(req) {
 
   // For pages we do need to parse the cookies.
   var cookie = req.headers ? req.headers.cookie : null;
-  return index$6.parse_1(cookie || '');
+  return index.parse_1(cookie || '');
 }
 
 function getTokenCookie(req) {
@@ -2388,7 +1344,7 @@ var isArguments = function isArguments(value) {
 var keysShim;
 if (!Object.keys) {
 	// modified from https://github.com/es-shims/es5-shim
-	var has$1 = Object.prototype.hasOwnProperty;
+	var has = Object.prototype.hasOwnProperty;
 	var toStr$1 = Object.prototype.toString;
 	var isArgs = isArguments; // eslint-disable-line global-require
 	var isEnumerable = Object.prototype.propertyIsEnumerable;
@@ -2437,7 +1393,7 @@ if (!Object.keys) {
 		if (typeof window === 'undefined') { return false; }
 		for (var k in window) {
 			try {
-				if (!excludedKeys['$' + k] && has$1.call(window, k) && window[k] !== null && typeof window[k] === 'object') {
+				if (!excludedKeys['$' + k] && has.call(window, k) && window[k] !== null && typeof window[k] === 'object') {
 					try {
 						equalsConstructorPrototype(window[k]);
 					} catch (e) {
@@ -2474,7 +1430,7 @@ if (!Object.keys) {
 		}
 
 		var skipProto = hasProtoEnumBug && isFunction;
-		if (isString && object.length > 0 && !has$1.call(object, 0)) {
+		if (isString && object.length > 0 && !has.call(object, 0)) {
 			for (var i = 0; i < object.length; ++i) {
 				theKeys.push(String(i));
 			}
@@ -2486,7 +1442,7 @@ if (!Object.keys) {
 			}
 		} else {
 			for (var name in object) {
-				if (!(skipProto && name === 'prototype') && has$1.call(object, name)) {
+				if (!(skipProto && name === 'prototype') && has.call(object, name)) {
 					theKeys.push(String(name));
 				}
 			}
@@ -2496,7 +1452,7 @@ if (!Object.keys) {
 			var skipConstructor = equalsConstructorPrototypeIfNotBuggy(object);
 
 			for (var k = 0; k < dontEnums.length; ++k) {
-				if (!(skipConstructor && dontEnums[k] === 'constructor') && has$1.call(object, dontEnums[k])) {
+				if (!(skipConstructor && dontEnums[k] === 'constructor') && has.call(object, dontEnums[k])) {
 					theKeys.push(dontEnums[k]);
 				}
 			}
@@ -2911,16 +1867,16 @@ var GetIntrinsic = function GetIntrinsic(name, allowMissing) {
 	return value;
 };
 
-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 callBind = function callBind() {
-	return functionBind.apply($call, arguments);
+	return $reflectApply(functionBind, $call, arguments);
 };
 
 var apply = function applyBind() {
-	return functionBind.apply($apply, arguments);
+	return $reflectApply(functionBind, $apply, arguments);
 };
 callBind.apply = apply;
 
@@ -3046,7 +2002,7 @@ var Type = function Type(x) {
 	}
 };
 
-// https://www.ecma-international.org/ecma-262/6.0/#sec-tostring
+// https://ecma-international.org/ecma-262/6.0/#sec-ecmascript-data-types-and-values
 
 var Type$1 = function Type$1(x) {
 	if (typeof x === 'symbol') {
@@ -3115,42 +2071,62 @@ var IsPropertyKey = function IsPropertyKey(argument) {
 	return typeof argument === 'string' || typeof argument === 'symbol';
 };
 
-var regexExec = RegExp.prototype.exec;
-var gOPD = Object.getOwnPropertyDescriptor;
-
-var tryRegexExecCall = function tryRegexExec(value) {
-	try {
-		var lastIndex = value.lastIndex;
-		value.lastIndex = 0; // eslint-disable-line no-param-reassign
+var hasSymbols$3 = hasSymbols$1();
+var hasToStringTag = hasSymbols$3 && typeof Symbol.toStringTag === 'symbol';
+var hasOwnProperty;
+var regexExec;
+var isRegexMarker;
+var badStringifier;
+
+if (hasToStringTag) {
+	hasOwnProperty = Function.call.bind(Object.prototype.hasOwnProperty);
+	regexExec = Function.call.bind(RegExp.prototype.exec);
+	isRegexMarker = {};
+
+	var throwRegexMarker = function () {
+		throw isRegexMarker;
+	};
+	badStringifier = {
+		toString: throwRegexMarker,
+		valueOf: throwRegexMarker
+	};
 
-		regexExec.call(value);
-		return true;
-	} catch (e) {
-		return false;
-	} finally {
-		value.lastIndex = lastIndex; // eslint-disable-line no-param-reassign
+	if (typeof Symbol.toPrimitive === 'symbol') {
+		badStringifier[Symbol.toPrimitive] = throwRegexMarker;
 	}
-};
+}
+
 var toStr$5 = Object.prototype.toString;
+var gOPD = Object.getOwnPropertyDescriptor;
 var regexClass = '[object RegExp]';
-var hasToStringTag = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol';
 
-var isRegex = function isRegex(value) {
-	if (!value || typeof value !== 'object') {
-		return false;
-	}
-	if (!hasToStringTag) {
-		return toStr$5.call(value) === regexClass;
-	}
+var isRegex = hasToStringTag
+	// eslint-disable-next-line consistent-return
+	? function isRegex(value) {
+		if (!value || typeof value !== 'object') {
+			return false;
+		}
 
-	var descriptor = gOPD(value, 'lastIndex');
-	var hasLastIndexDataProperty = descriptor && src(descriptor, 'value');
-	if (!hasLastIndexDataProperty) {
-		return false;
+		var descriptor = gOPD(value, 'lastIndex');
+		var hasLastIndexDataProperty = descriptor && hasOwnProperty(descriptor, 'value');
+		if (!hasLastIndexDataProperty) {
+			return false;
+		}
+
+		try {
+			regexExec(value, badStringifier);
+		} catch (e) {
+			return e === isRegexMarker;
+		}
 	}
+	: function isRegex(value) {
+		// In older browsers, typeof regex incorrectly returns 'function'
+		if (!value || (typeof value !== 'object' && typeof value !== 'function')) {
+			return false;
+		}
 
-	return tryRegexExecCall(value);
-};
+		return toStr$5.call(value) === regexClass;
+	};
 
 // http://www.ecma-international.org/ecma-262/5.1/#sec-9.2
 
@@ -3178,6 +2154,23 @@ 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 = {};
+	} catch (_) {
+		reflectApply = null;
+	}
+} else {
+	reflectApply = null;
+}
 
 var constructorRegex = /^\s*class\b/;
 var isES6ClassFn = function isES6ClassFunction(value) {
@@ -3203,15 +2196,27 @@ var fnClass = '[object Function]';
 var genClass = '[object GeneratorFunction]';
 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;
-};
+var isCallable = reflectApply
+	? function isCallable(value) {
+		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) { 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://www.ecma-international.org/ecma-262/5.1/#sec-9.11
 
@@ -3377,8 +2382,8 @@ var CreateDataProperty = function CreateDataProperty(O, P, V) {
 		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;
 	}
@@ -3495,10 +2500,10 @@ var $slice = callBound('Array.prototype.slice');
 var $concat$1 = callBound('Array.prototype.concat');
 var $forEach = callBound('Array.prototype.forEach');
 
-var hasSymbols$3 = hasSymbols$1();
+var hasSymbols$4 = hasSymbols$1();
 
-var kCustomPromisifiedSymbol = hasSymbols$3 ? Symbol('util.promisify.custom') : null;
-var kCustomPromisifyArgsSymbol = hasSymbols$3 ? Symbol('customPromisifyArgs') : null;
+var kCustomPromisifiedSymbol = hasSymbols$4 ? Symbol('util.promisify.custom') : null;
+var kCustomPromisifyArgsSymbol = hasSymbols$4 ? Symbol('customPromisifyArgs') : null;
 
 var implementation$3 = function promisify(orig) {
 	if (typeof orig !== 'function') {
@@ -3508,7 +2513,7 @@ var implementation$3 = function promisify(orig) {
 		throw error;
 	}
 
-	if (hasSymbols$3 && orig[kCustomPromisifiedSymbol]) {
+	if (hasSymbols$4 && orig[kCustomPromisifiedSymbol]) {
 		var customFunction = orig[kCustomPromisifiedSymbol];
 		if (typeof customFunction !== 'function') {
 			throw new TypeError('The [util.promisify.custom] property must be a function');
@@ -3615,7 +2620,7 @@ function connect() {
         };
     }
 
-    var connection = mysql.createConnection(config);
+    var connection = mysql__default['default'].createConnection(config);
     return {
         query: function query(sql, args) {
             return util.util.promisify(connection.query).call(connection, sql, args);
@@ -4258,7 +3263,7 @@ var user = /*#__PURE__*/Object.freeze({
   findUser: findUser$1
 });
 
-var localStrategy = new Local.Strategy({
+var localStrategy = new Local__default['default'].Strategy({
   usernameField: 'email',
   passwordField: 'password'
 }, function (email, password, done) {