@mjhls/mjh-framework 1.0.786-beta.1 → 1.0.786

package/dist/cjs/Auth.js

@@ -0,0 +1,4231 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var asyncToGenerator = require('./asyncToGenerator-b6a175bf.js');
+var stringify = require('./stringify-01cf47f7.js');
+var slicedToArray = require('./slicedToArray-db24842a.js');
+var React = require('react');
+var Router = require('next/router');
+var _extends = require('./extends-1e24fc8d.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');
+require('./es6.string.iterator-20d42c53.js');
+require('./_to-object-821a2927.js');
+require('./web.dom.iterable-4480325a.js');
+require('./_library-dd23b178.js');
+require('./core.get-iterator-method-b4615fd3.js');
+require('./_iter-detect-2613ffa1.js');
+require('./_object-pie-68c5bcbc.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,
+      label = _ref.label,
+      type = _ref.type,
+      _ref$required = _ref.required,
+      required = _ref$required === undefined ? false : _ref$required,
+      _ref$readonly = _ref.readonly,
+      readonly = _ref$readonly === undefined ? false : _ref$readonly,
+      _ref$options = _ref.options,
+      options = _ref$options === undefined ? null : _ref$options,
+      _ref$groupType = _ref.groupType,
+      groupType = _ref$groupType === undefined ? '' : _ref$groupType,
+      _ref$errors = _ref.errors,
+      errors = _ref$errors === undefined ? {} : _ref$errors,
+      _ref$handleChanged = _ref.handleChanged,
+      handleChanged = _ref$handleChanged === undefined ? null : _ref$handleChanged,
+      _ref$default_value = _ref.default_value,
+      default_value = _ref$default_value === undefined ? null : _ref$default_value;
+
+  var opts = [];
+  if (groupType) {
+    opts['as'] = groupType;
+    if (groupType === reactBootstrap.Col) {
+      opts['xs'] = 12;
+      opts['md'] = 6;
+    }
+  }
+
+  if (handleChanged) {
+    opts['onChange'] = handleChanged;
+  }
+
+  if (readonly) {
+    opts['readOnly'] = readonly;
+  }
+
+  if (type == 'text' || type == 'email' || type == 'password' || type == 'number') {
+    return React__default['default'].createElement(
+      reactBootstrap.Form.Group,
+      _extends._extends({}, opts, { controlId: name }),
+      React__default['default'].createElement(
+        reactBootstrap.Form.Label,
+        { kye: name + '_label' },
+        label,
+        required && React__default['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(
+        reactBootstrap.Form.Control.Feedback,
+        { key: name + '_feedback', type: 'invalid' },
+        errors[name]
+      )
+    );
+  }
+  if (type == 'select') {
+    return React__default['default'].createElement(
+      reactBootstrap.Form.Group,
+      _extends._extends({}, opts, { key: name, controlId: name }),
+      React__default['default'].createElement(
+        reactBootstrap.Form.Label,
+        { key: name + '_' + label },
+        label,
+        required && React__default['default'].createElement(
+          'span',
+          { key: name + '_required_span', style: { color: 'red' } },
+          '*'
+        )
+      ),
+      React__default['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' }),
+        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(
+            'option',
+            { key: key, value: value },
+            label
+          );
+        })
+      )
+    );
+  }
+
+  if (type == 'radio' || type == 'checkbox') {
+    return React__default['default'].createElement(
+      reactBootstrap.Form.Group,
+      opts,
+      React__default['default'].createElement(
+        reactBootstrap.Form.Label,
+        null,
+        label,
+        required && React__default['default'].createElement(
+          'span',
+          { style: { color: 'red' } },
+          '*'
+        )
+      ),
+      options.map(function (option, index) {
+        return React__default['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 } })
+        );
+      })
+    );
+  }
+};
+
+var _this = undefined;
+
+var dataHandler = function () {
+  var _ref = asyncToGenerator._asyncToGenerator( /*#__PURE__*/asyncToGenerator.regenerator.mark(function _callee(api_url, body) {
+    var res, result;
+    return asyncToGenerator.regenerator.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            _context.prev = 0;
+            _context.next = 3;
+            return fetch(api_url, {
+              method: 'POST',
+              headers: { 'Content-Type': 'application/json' },
+              body: stringify._JSON$stringify(body)
+            });
+
+          case 3:
+            res = _context.sent;
+
+            if (!(res.status === 200)) {
+              _context.next = 13;
+              break;
+            }
+
+            _context.next = 7;
+            return res.json();
+
+          case 7:
+            result = _context.sent;
+
+            if (!result.error) {
+              _context.next = 10;
+              break;
+            }
+
+            throw new Error(result.error);
+
+          case 10:
+            return _context.abrupt('return', result.data);
+
+          case 13:
+            _context.t0 = Error;
+            _context.next = 16;
+            return res.text();
+
+          case 16:
+            _context.t1 = _context.sent;
+            throw new _context.t0(_context.t1);
+
+          case 18:
+            _context.next = 24;
+            break;
+
+          case 20:
+            _context.prev = 20;
+            _context.t2 = _context['catch'](0);
+
+            console.error('data handler failed : ' + api_url, _context.t2);
+            return _context.abrupt('return', null);
+
+          case 24:
+          case 'end':
+            return _context.stop();
+        }
+      }
+    }, _callee, _this, [[0, 20]]);
+  }));
+
+  return function dataHandler(_x, _x2) {
+    return _ref.apply(this, arguments);
+  };
+}();
+
+function useUser() {
+  var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+      redirectTo = _ref.redirectTo,
+      redirectIfFound = _ref.redirectIfFound;
+
+  var _useSWR = useSWR__default['default']('/api/auth/user', dataHandler),
+      data = _useSWR.data,
+      error = _useSWR.error;
+
+  var user = data;
+  var finished = Boolean(data);
+  var hasUser = Boolean(user);
+
+  React.useEffect(function () {
+    if (!redirectTo || !finished) return;
+    if (
+    // If redirectTo is set, redirect if the user was not found.
+    redirectTo && !redirectIfFound && !hasUser ||
+    // If redirectIfFound is also set, redirect if the user was found
+    redirectIfFound && hasUser) {
+      Router__default['default'].push(redirectTo);
+    }
+  }, [redirectTo, redirectIfFound, finished, hasUser]);
+
+  return error ? null : user;
+}
+
+var hooks = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  useUser: useUser
+});
+
+var LoginForm = function LoginForm(props) {
+  var handleSubmit = function () {
+    var _ref = asyncToGenerator._asyncToGenerator( /*#__PURE__*/asyncToGenerator.regenerator.mark(function _callee(e) {
+      var body, res;
+      return asyncToGenerator.regenerator.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              event.preventDefault();
+
+              if (errorMsg) setErrorMsg('');
+              setLoading(true);
+
+              body = {
+                email: e.currentTarget.email.value,
+                password: e.currentTarget.password.value
+              };
+              _context.prev = 4;
+              _context.next = 7;
+              return fetch('/api/auth/login', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: stringify._JSON$stringify(body)
+              });
+
+            case 7:
+              res = _context.sent;
+
+              setLoading(false);
+
+              if (!(res.status === 200)) {
+                _context.next = 13;
+                break;
+              }
+
+              // here, Router.push() does not carry new cookie value.
+              // so need hard redirect
+              window.location.href = callbackUrl;
+              _context.next = 18;
+              break;
+
+            case 13:
+              _context.t0 = Error;
+              _context.next = 16;
+              return res.text();
+
+            case 16:
+              _context.t1 = _context.sent;
+              throw new _context.t0(_context.t1);
+
+            case 18:
+              _context.next = 23;
+              break;
+
+            case 20:
+              _context.prev = 20;
+              _context.t2 = _context['catch'](4);
+
+              setErrorMsg(_context.t2.message);
+
+            case 23:
+            case 'end':
+              return _context.stop();
+          }
+        }
+      }, _callee, this, [[4, 20]]);
+    }));
+
+    return function handleSubmit(_x) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+
+  var _props$callbackUrl = props.callbackUrl,
+      callbackUrl = _props$callbackUrl === undefined ? '/' : _props$callbackUrl;
+
+
+  React.useEffect(function () {
+    if (props.user) {
+      window.location.href = '/auth/profile';
+    }
+  }, []);
+  useUser('/auth/profile', true);
+
+  var _useState = React.useState(''),
+      _useState2 = slicedToArray._slicedToArray(_useState, 2),
+      errorMsg = _useState2[0],
+      setErrorMsg = _useState2[1];
+
+  var _useState3 = React.useState(false),
+      _useState4 = slicedToArray._slicedToArray(_useState3, 2),
+      loading = _useState4[0],
+      setLoading = _useState4[1];
+
+  return React__default['default'].createElement(
+    reactBootstrap.Form,
+    { className: 'login', onSubmit: handleSubmit },
+    React__default['default'].createElement(
+      'h1',
+      null,
+      'Login'
+    ),
+    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['default'].createElement('hr', null),
+    React__default['default'].createElement(
+      reactBootstrap.Form.Row,
+      null,
+      React__default['default'].createElement(
+        reactBootstrap.Form.Group,
+        { as: reactBootstrap.Col },
+        React__default['default'].createElement(
+          'a',
+          { href: '/auth/signup' },
+          'I don\'t have an account'
+        )
+      ),
+      React__default['default'].createElement(
+        reactBootstrap.Form.Group,
+        { as: reactBootstrap.Col, className: 'text-right' },
+        !loading && React__default['default'].createElement(
+          reactBootstrap.Button,
+          { type: 'submit' },
+          'Login'
+        ),
+        loading && React__default['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(
+            'span',
+            { className: 'sr-only' },
+            'Loading...'
+          )
+        )
+      )
+    ),
+    errorMsg && React__default['default'].createElement(
+      'p',
+      { className: 'error' },
+      errorMsg
+    ),
+    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      '
+    )
+  );
+};
+
+// get country & state options 
+var countries = ["United States", "Afghanistan", "Albania", "Algeria", "American Samoa", "Andorra", "Angola", "Anguilla", "Antarctica", "Antigua and Barbuda", "Argentina", "Armenia", "Aruba", "Australia", "Austria", "Azerbaijan", "Bahamas (the)", "Bahrain", "Bangladesh", "Barbados", "Belarus", "Belgium", "Belize", "Benin", "Bermuda", "Bhutan", "Bolivia (Plurinational State of)", "Bonaire, Sint Eustatius and Saba", "Bosnia and Herzegovina", "Botswana", "Bouvet Island", "Brazil", "British Indian Ocean Territory (the)", "Brunei Darussalam", "Bulgaria", "Burkina Faso", "Burundi", "Cabo Verde", "Cambodia", "Cameroon", "Canada", "Cayman Islands (the)", "Central African Republic (the)", "Chad", "Chile", "China", "Christmas Island", "Cocos (Keeling) Islands (the)", "Colombia", "Comoros (the)", "Congo (the Democratic Republic of the)", "Congo (the)", "Cook Islands (the)", "Costa Rica", "Croatia", "Cuba", "Curaçao", "Cyprus", "Czechia", "Côte d'Ivoire", "Denmark", "Djibouti", "Dominica", "Dominican Republic (the)", "Ecuador", "Egypt", "El Salvador", "Equatorial Guinea", "Eritrea", "Estonia", "Eswatini", "Ethiopia", "Falkland Islands (the) [Malvinas]", "Faroe Islands (the)", "Fiji", "Finland", "France", "French Guiana", "French Polynesia", "French Southern Territories (the)", "Gabon", "Gambia (the)", "Georgia", "Germany", "Ghana", "Gibraltar", "Greece", "Greenland", "Grenada", "Guadeloupe", "Guam", "Guatemala", "Guernsey", "Guinea", "Guinea-Bissau", "Guyana", "Haiti", "Heard Island and McDonald Islands", "Holy See (the)", "Honduras", "Hong Kong", "Hungary", "Iceland", "India", "Indonesia", "Iran (Islamic Republic of)", "Iraq", "Ireland", "Isle of Man", "Israel", "Italy", "Jamaica", "Japan", "Jersey", "Jordan", "Kazakhstan", "Kenya", "Kiribati", "Korea (the Democratic People's Republic of)", "Korea (the Republic of)", "Kuwait", "Kyrgyzstan", "Lao People's Democratic Republic (the)", "Latvia", "Lebanon", "Lesotho", "Liberia", "Libya", "Liechtenstein", "Lithuania", "Luxembourg", "Macao", "Madagascar", "Malawi", "Malaysia", "Maldives", "Mali", "Malta", "Marshall Islands (the)", "Martinique", "Mauritania", "Mauritius", "Mayotte", "Mexico", "Micronesia (Federated States of)", "Moldova (the Republic of)", "Monaco", "Mongolia", "Montenegro", "Montserrat", "Morocco", "Mozambique", "Myanmar", "Namibia", "Nauru", "Nepal", "Netherlands (the)", "New Caledonia", "New Zealand", "Nicaragua", "Niger (the)", "Nigeria", "Niue", "Norfolk Island", "Northern Mariana Islands (the)", "Norway", "Oman", "Pakistan", "Palau", "Palestine, State of", "Panama", "Papua New Guinea", "Paraguay", "Peru", "Philippines (the)", "Pitcairn", "Poland", "Portugal", "Puerto Rico", "Qatar", "Republic of North Macedonia", "Romania", "Russian Federation (the)", "Rwanda", "Réunion", "Saint Barthélemy", "Saint Helena, Ascension and Tristan da Cunha", "Saint Kitts and Nevis", "Saint Lucia", "Saint Martin (French part)", "Saint Pierre and Miquelon", "Saint Vincent and the Grenadines", "Samoa", "San Marino", "Sao Tome and Principe", "Saudi Arabia", "Senegal", "Serbia", "Seychelles", "Sierra Leone", "Singapore", "Sint Maarten (Dutch part)", "Slovakia", "Slovenia", "Solomon Islands", "Somalia", "South Africa", "South Georgia and the South Sandwich Islands", "South Sudan", "Spain", "Sri Lanka", "Sudan (the)", "Suriname", "Svalbard and Jan Mayen", "Sweden", "Switzerland", "Syrian Arab Republic", "Taiwan (Province of China)", "Tajikistan", "Tanzania, United Republic of", "Thailand", "Timor-Leste", "Togo", "Tokelau", "Tonga", "Trinidad and Tobago", "Tunisia", "Turkey", "Turkmenistan", "Turks and Caicos Islands (the)", "Tuvalu", "Uganda", "Ukraine", "United Arab Emirates (the)", "United Kingdom of Great Britain and Northern Ireland (the)", "United States Minor Outlying Islands (the)", "Uruguay", "Uzbekistan", "Vanuatu", "Venezuela (Bolivarian Republic of)", "Viet Nam", "Virgin Islands (British)", "Virgin Islands (U.S.)", "Wallis and Futuna", "Western Sahara", "Yemen", "Zambia", "Zimbabwe", "Åland Islands"];
+
+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$1 = undefined;
+
+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;
+
+      return asyncToGenerator.regenerator.wrap(function _callee3$(_context3) {
+        while (1) {
+          switch (_context3.prev = _context3.next) {
+            case 0:
+              event.preventDefault();
+              setLoading(true);
+              if (errorMsg) setErrorMsg('');
+
+              formData = new FormData(e.currentTarget);
+              body = {};
+              _iteratorNormalCompletion = true;
+              _didIteratorError = false;
+              _iteratorError = undefined;
+              _context3.prev = 8;
+
+              for (_iterator = slicedToArray._getIterator(formData.keys()); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+                key = _step.value;
+
+                body[key] = formData.get(key);
+              }
+
+              _context3.next = 16;
+              break;
+
+            case 12:
+              _context3.prev = 12;
+              _context3.t0 = _context3['catch'](8);
+              _didIteratorError = true;
+              _iteratorError = _context3.t0;
+
+            case 16:
+              _context3.prev = 16;
+              _context3.prev = 17;
+
+              if (!_iteratorNormalCompletion && _iterator.return) {
+                _iterator.return();
+              }
+
+            case 19:
+              _context3.prev = 19;
+
+              if (!_didIteratorError) {
+                _context3.next = 22;
+                break;
+              }
+
+              throw _iteratorError;
+
+            case 22:
+              return _context3.finish(19);
+
+            case 23:
+              return _context3.finish(16);
+
+            case 24:
+              _context3.prev = 24;
+              _context3.next = 27;
+              return fetch('/api/auth/signup', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: stringify._JSON$stringify(body)
+              });
+
+            case 27:
+              res = _context3.sent;
+
+              setLoading(false);
+
+              if (!(res.status === 200)) {
+                _context3.next = 33;
+                break;
+              }
+
+              window.location.href = '/';
+              _context3.next = 38;
+              break;
+
+            case 33:
+              _context3.t1 = Error;
+              _context3.next = 36;
+              return res.text();
+
+            case 36:
+              _context3.t2 = _context3.sent;
+              throw new _context3.t1(_context3.t2);
+
+            case 38:
+              _context3.next = 43;
+              break;
+
+            case 40:
+              _context3.prev = 40;
+              _context3.t3 = _context3['catch'](24);
+
+              setErrorMsg(_context3.t3.message);
+
+            case 43:
+            case 'end':
+              return _context3.stop();
+          }
+        }
+      }, _callee3, this, [[8, 12, 16, 24], [17,, 19, 23], [24, 40]]);
+    }));
+
+    return function handleSubmit(_x2) {
+      return _ref3.apply(this, arguments);
+    };
+  }();
+
+  var _useState = React.useState(''),
+      _useState2 = slicedToArray._slicedToArray(_useState, 2),
+      errorMsg = _useState2[0],
+      setErrorMsg = _useState2[1];
+
+  var _useState3 = React.useState(false),
+      _useState4 = slicedToArray._slicedToArray(_useState3, 2),
+      countryUS = _useState4[0],
+      setCountryUS = _useState4[1];
+
+  var _useState5 = React.useState([]),
+      _useState6 = slicedToArray._slicedToArray(_useState5, 2),
+      healthcareOccupation = _useState6[0],
+      setHealthcareOccupation = _useState6[1];
+
+  var _useState7 = React.useState([]),
+      _useState8 = slicedToArray._slicedToArray(_useState7, 2),
+      nonHealthcareOccupation = _useState8[0],
+      setNonHealthcareOccupation = _useState8[1];
+
+  var loadInitData = function () {
+    var _ref = asyncToGenerator._asyncToGenerator( /*#__PURE__*/asyncToGenerator.regenerator.mark(function _callee() {
+      var healthcare_occupation, non_healthcare_occupation;
+      return asyncToGenerator.regenerator.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              _context.next = 2;
+              return dataHandler('/api/auth/data', { action: 'get-occupation', type: 'Healthcare' });
+
+            case 2:
+              healthcare_occupation = _context.sent;
+              _context.next = 5;
+              return dataHandler('/api/auth/data', { action: 'get-occupation', type: 'Non-Healthcare' });
+
+            case 5:
+              non_healthcare_occupation = _context.sent;
+
+
+              setHealthcareOccupation(healthcare_occupation);
+              setNonHealthcareOccupation(non_healthcare_occupation);
+
+            case 8:
+            case 'end':
+              return _context.stop();
+          }
+        }
+      }, _callee, _this$1);
+    }));
+
+    return function loadInitData() {
+      return _ref.apply(this, arguments);
+    };
+  }();
+
+  React.useEffect(function () {
+    if (props.user) {
+      window.location.href = '/auth/profile';
+    } else {
+      loadInitData();
+    }
+  }, []);
+
+  // make it to change layout based on radio buton 
+  var handleCountryChanged = function handleCountryChanged(e) {
+    if (e.target.value === 'United States') {
+      setCountryUS(true);
+    } else {
+      setCountryUS(false);
+    }
+  };
+
+  var _useState9 = React.useState(true),
+      _useState10 = slicedToArray._slicedToArray(_useState9, 2),
+      healcareProfessional = _useState10[0],
+      setHealthcareProfessional = _useState10[1];
+
+  var handleHealthcareProfessionalChanged = function handleHealthcareProfessionalChanged(e) {
+
+    if (e.target.value === 'Y') {
+      setHealthcareProfessional(true);
+    } else {
+      setHealthcareProfessional(false);
+    }
+    document.getElementById('occupation').value = '';
+    setOccupationFields(null);
+  };
+
+  var _useState11 = React.useState(null),
+      _useState12 = slicedToArray._slicedToArray(_useState11, 2),
+      occupationFields = _useState12[0],
+      setOccupationFields = _useState12[1];
+
+  var handleOccupationChanged = function () {
+    var _ref2 = asyncToGenerator._asyncToGenerator( /*#__PURE__*/asyncToGenerator.regenerator.mark(function _callee2(e) {
+      var occupation, fields;
+      return asyncToGenerator.regenerator.wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              occupation = e.target.value;
+              _context2.next = 3;
+              return dataHandler('/api/auth/data', { action: 'get-fields', occupation: occupation });
+
+            case 3:
+              fields = _context2.sent;
+
+              setOccupationFields(fields);
+
+            case 5:
+            case 'end':
+              return _context2.stop();
+          }
+        }
+      }, _callee2, _this$1);
+    }));
+
+    return function handleOccupationChanged(_x) {
+      return _ref2.apply(this, arguments);
+    };
+  }();
+
+  var _useState13 = React.useState(false),
+      _useState14 = slicedToArray._slicedToArray(_useState13, 2),
+      loading = _useState14[0],
+      setLoading = _useState14[1];
+
+  return React__default['default'].createElement(
+    reactBootstrap.Form,
+    { className: 'login', id: 'signupForm', onSubmit: handleSubmit },
+    React__default['default'].createElement(
+      'h1',
+      null,
+      'Sign Up'
+    ),
+    React__default['default'].createElement('hr', null),
+    returnFormField({ name: 'email', label: 'Email', type: 'email', required: true }),
+    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['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(
+      reactBootstrap.Form.Row,
+      null,
+      returnFormField({
+        name: 'country',
+        label: 'Country',
+        type: 'select',
+        required: true,
+        groupType: reactBootstrap.Col,
+        options: countries,
+        handleChanged: handleCountryChanged
+      }),
+      countryUS && returnFormField({ name: 'state', label: 'State', type: 'select', required: true, groupType: reactBootstrap.Col, options: states })
+    ),
+    React__default['default'].createElement(
+      reactBootstrap.Form.Row,
+      null,
+      countryUS && returnFormField({ name: 'zip', label: 'Working Zip Code', type: 'text', required: true, groupType: reactBootstrap.Col }),
+      countryUS && returnFormField({ name: 'phone', label: 'Phone', type: 'text', required: true, groupType: reactBootstrap.Col })
+    ),
+    returnFormField({
+      name: 'healthcare_professional',
+      label: 'Are You a Health Care Professional?',
+      type: 'radio',
+      required: true,
+      options: [{ value: 'Y', label: 'Yes', checked: true }, { value: 'N', label: 'No', checked: false }],
+      handleChanged: handleHealthcareProfessionalChanged,
+      default_value: 'Y'
+    }),
+    healcareProfessional && returnFormField({
+      name: 'occupation',
+      label: 'Occupation',
+      type: 'select',
+      required: true,
+      options: healthcareOccupation,
+      handleChanged: handleOccupationChanged
+    }),
+    !healcareProfessional && returnFormField({
+      name: 'occupation',
+      label: 'Non Provider Role',
+      type: 'select',
+      required: true,
+      options: nonHealthcareOccupation,
+      handleChanged: handleOccupationChanged
+    }),
+    occupationFields && occupationFields.map(function (field) {
+      return returnFormField({
+        name: field.name,
+        label: field.label,
+        type: field.type,
+        required: field.required === 1,
+        options: field.options
+      });
+    }),
+    returnFormField({
+      name: 'agree',
+      label: 'Terms & Conditions | Privacy Policy',
+      type: 'checkbox',
+      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(
+      reactBootstrap.Form.Row,
+      null,
+      React__default['default'].createElement(
+        reactBootstrap.Form.Group,
+        { as: reactBootstrap.Col },
+        React__default['default'].createElement(
+          'a',
+          { href: '/auth/login' },
+          'I already have an account'
+        )
+      ),
+      React__default['default'].createElement(
+        reactBootstrap.Form.Group,
+        { as: reactBootstrap.Col, className: 'text-right' },
+        !loading && React__default['default'].createElement(
+          reactBootstrap.Button,
+          { type: 'submit' },
+          'Sign Up'
+        ),
+        loading && React__default['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(
+            'span',
+            { className: 'sr-only' },
+            'Loading...'
+          )
+        )
+      )
+    ),
+    errorMsg && React__default['default'].createElement(
+      'p',
+      { className: 'error' },
+      errorMsg
+    ),
+    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      '
+    )
+  );
+};
+
+var _this$2 = undefined;
+
+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;
+
+      return asyncToGenerator.regenerator.wrap(function _callee3$(_context3) {
+        while (1) {
+          switch (_context3.prev = _context3.next) {
+            case 0:
+              event.preventDefault();
+
+              setErrorMsg('');
+              setSuccessMsg('');
+              setLoading(true);
+
+              formData = new FormData(e.currentTarget);
+              body = {};
+              _iteratorNormalCompletion = true;
+              _didIteratorError = false;
+              _iteratorError = undefined;
+              _context3.prev = 9;
+
+              for (_iterator = slicedToArray._getIterator(formData.keys()); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+                key = _step.value;
+
+                body[key] = formData.get(key);
+              }
+
+              _context3.next = 17;
+              break;
+
+            case 13:
+              _context3.prev = 13;
+              _context3.t0 = _context3['catch'](9);
+              _didIteratorError = true;
+              _iteratorError = _context3.t0;
+
+            case 17:
+              _context3.prev = 17;
+              _context3.prev = 18;
+
+              if (!_iteratorNormalCompletion && _iterator.return) {
+                _iterator.return();
+              }
+
+            case 20:
+              _context3.prev = 20;
+
+              if (!_didIteratorError) {
+                _context3.next = 23;
+                break;
+              }
+
+              throw _iteratorError;
+
+            case 23:
+              return _context3.finish(20);
+
+            case 24:
+              return _context3.finish(17);
+
+            case 25:
+              body['user_id'] = userData.id;
+
+              _context3.prev = 26;
+              _context3.next = 29;
+              return fetch('/api/auth/profile', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: stringify._JSON$stringify(body)
+              });
+
+            case 29:
+              res = _context3.sent;
+
+              setLoading(false);
+
+              if (!(res.status === 200)) {
+                _context3.next = 35;
+                break;
+              }
+
+              setSuccessMsg('Your request has been processed successfully!');
+              _context3.next = 40;
+              break;
+
+            case 35:
+              _context3.t1 = Error;
+              _context3.next = 38;
+              return res.text();
+
+            case 38:
+              _context3.t2 = _context3.sent;
+              throw new _context3.t1(_context3.t2);
+
+            case 40:
+              _context3.next = 45;
+              break;
+
+            case 42:
+              _context3.prev = 42;
+              _context3.t3 = _context3['catch'](26);
+
+              setErrorMsg(_context3.t3.message);
+
+            case 45:
+            case 'end':
+              return _context3.stop();
+          }
+        }
+      }, _callee3, this, [[9, 13, 17, 25], [18,, 20, 24], [26, 42]]);
+    }));
+
+    return function handleSubmit(_x2) {
+      return _ref3.apply(this, arguments);
+    };
+  }();
+
+  var _useState = React.useState(''),
+      _useState2 = slicedToArray._slicedToArray(_useState, 2),
+      errorMsg = _useState2[0],
+      setErrorMsg = _useState2[1];
+
+  var _useState3 = React.useState(false),
+      _useState4 = slicedToArray._slicedToArray(_useState3, 2),
+      countryUS = _useState4[0],
+      setCountryUS = _useState4[1];
+
+  var _useState5 = React.useState([]),
+      _useState6 = slicedToArray._slicedToArray(_useState5, 2),
+      healthcareOccupation = _useState6[0],
+      setHealthcareOccupation = _useState6[1];
+
+  var _useState7 = React.useState([]),
+      _useState8 = slicedToArray._slicedToArray(_useState7, 2),
+      nonHealthcareOccupation = _useState8[0],
+      setNonHealthcareOccupation = _useState8[1];
+
+  var _useState9 = React.useState(null),
+      _useState10 = slicedToArray._slicedToArray(_useState9, 2),
+      userData = _useState10[0],
+      setUserData = _useState10[1];
+
+  var user = props.user;
+
+  var loadInitData = function () {
+    var _ref = asyncToGenerator._asyncToGenerator( /*#__PURE__*/asyncToGenerator.regenerator.mark(function _callee() {
+      var healthcare_occupation, non_healthcare_occupation, foundOccupation, fields;
+      return asyncToGenerator.regenerator.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              _context.next = 2;
+              return dataHandler('/api/auth/data', { action: 'get-occupation', type: 'Healthcare' });
+
+            case 2:
+              healthcare_occupation = _context.sent;
+              _context.next = 5;
+              return dataHandler('/api/auth/data', { action: 'get-occupation', type: 'Non-Healthcare' });
+
+            case 5:
+              non_healthcare_occupation = _context.sent;
+              foundOccupation = healthcare_occupation.find(function (item) {
+                return item.value === user.shared.occupation_id;
+              });
+
+              if (foundOccupation) {
+                user.shared.healthcare_professional = 'Y';
+              } else {
+                user.shared.healthcare_professional = 'N';
+              }
+
+              setHealthcareOccupation(healthcare_occupation);
+              setNonHealthcareOccupation(non_healthcare_occupation);
+              setUserData(user);
+
+              if (user.shared.country === 'United States') {
+                setCountryUS(true);
+              } else {
+                setCountryUS(false);
+              }
+
+              _context.next = 14;
+              return dataHandler('/api/auth/data', { action: 'get-fields', occupation: user.shared.occupation_id });
+
+            case 14:
+              fields = _context.sent;
+
+              setOccupationFields(fields);
+
+            case 16:
+            case 'end':
+              return _context.stop();
+          }
+        }
+      }, _callee, _this$2);
+    }));
+
+    return function loadInitData() {
+      return _ref.apply(this, arguments);
+    };
+  }();
+
+  React.useEffect(function () {
+    if (!user) {
+      window.location.href = '/auth/login';
+    } else {
+      loadInitData();
+    }
+  }, []);
+
+  // make it to change layout based on radio buton 
+  var handleCountryChanged = function handleCountryChanged(e) {
+    if (e.target.value === 'United States') {
+      setCountryUS(true);
+    } else {
+      setCountryUS(false);
+    }
+  };
+
+  var _useState11 = React.useState(true),
+      _useState12 = slicedToArray._slicedToArray(_useState11, 2),
+      healcareProfessional = _useState12[0],
+      setHealthcareProfessional = _useState12[1];
+
+  var handleHealthcareProfessionalChanged = function handleHealthcareProfessionalChanged(e) {
+
+    if (e.target.value === 'Y') {
+      setHealthcareProfessional(true);
+    } else {
+      setHealthcareProfessional(false);
+    }
+    document.getElementById('occupation').value = '';
+    setOccupationFields(null);
+  };
+
+  var _useState13 = React.useState(null),
+      _useState14 = slicedToArray._slicedToArray(_useState13, 2),
+      occupationFields = _useState14[0],
+      setOccupationFields = _useState14[1];
+
+  var handleOccupationChanged = function () {
+    var _ref2 = asyncToGenerator._asyncToGenerator( /*#__PURE__*/asyncToGenerator.regenerator.mark(function _callee2(e) {
+      var occupation, fields;
+      return asyncToGenerator.regenerator.wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              occupation = e.target.value;
+              _context2.next = 3;
+              return dataHandler('/api/auth/data', { action: 'get-fields', occupation: occupation });
+
+            case 3:
+              fields = _context2.sent;
+
+              setOccupationFields(fields);
+
+            case 5:
+            case 'end':
+              return _context2.stop();
+          }
+        }
+      }, _callee2, _this$2);
+    }));
+
+    return function handleOccupationChanged(_x) {
+      return _ref2.apply(this, arguments);
+    };
+  }();
+
+  var _useState15 = React.useState(''),
+      _useState16 = slicedToArray._slicedToArray(_useState15, 2),
+      successMsg = _useState16[0],
+      setSuccessMsg = _useState16[1];
+
+  var _useState17 = React.useState(false),
+      _useState18 = slicedToArray._slicedToArray(_useState17, 2),
+      loading = _useState18[0],
+      setLoading = _useState18[1];
+
+  return React__default['default'].createElement(
+    reactBootstrap.Form,
+    { className: 'login', id: 'signupForm', onSubmit: handleSubmit },
+    React__default['default'].createElement(
+      'h1',
+      null,
+      'Profile'
+    ),
+    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['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(
+        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(
+        reactBootstrap.Form.Row,
+        null,
+        returnFormField({
+          name: 'country',
+          label: 'Country',
+          type: 'select',
+          required: true,
+          groupType: reactBootstrap.Col,
+          options: countries,
+          handleChanged: handleCountryChanged,
+          default_value: userData.shared.country
+        }),
+        countryUS && returnFormField({ name: 'state', label: 'State', type: 'select', required: true, groupType: reactBootstrap.Col, options: states, default_value: userData.shared.state })
+      ),
+      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 }),
+        countryUS && returnFormField({ name: 'phone', label: 'Phone', type: 'text', required: true, groupType: reactBootstrap.Col, default_value: userData.shared.phone })
+      ),
+      returnFormField({
+        name: 'healthcare_professional',
+        label: 'Are You a Health Care Professional?',
+        type: 'radio',
+        required: true,
+        options: [{ value: 'Y', label: 'Yes', checked: true }, { value: 'N', label: 'No', checked: false }],
+        default_value: userData.shared.healthcare_professional,
+        handleChanged: handleHealthcareProfessionalChanged
+      }),
+      healcareProfessional && returnFormField({
+        name: 'occupation',
+        label: 'Occupation',
+        type: 'select',
+        required: true,
+        options: healthcareOccupation,
+        handleChanged: handleOccupationChanged,
+        default_value: userData.shared.occupation_id
+      }),
+      !healcareProfessional && returnFormField({
+        name: 'occupation',
+        label: 'Non Provider Role',
+        type: 'select',
+        required: true,
+        options: nonHealthcareOccupation,
+        handleChanged: handleOccupationChanged,
+        default_value: userData.shared.occupation_id
+      }),
+      occupationFields && occupationFields.map(function (field) {
+        return returnFormField({
+          name: field.name,
+          label: field.label,
+          type: field.type,
+          required: field.required === 1,
+          options: field.options,
+          default_value: userData.shared[field.name]
+        });
+      }),
+      returnFormField({
+        name: 'agree',
+        label: 'Terms & Conditions | Privacy Policy',
+        type: 'checkbox',
+        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(
+        reactBootstrap.Form.Row,
+        null,
+        React__default['default'].createElement(
+          reactBootstrap.Form.Group,
+          { as: reactBootstrap.Col },
+          !loading && React__default['default'].createElement(
+            reactBootstrap.Button,
+            { type: 'submit' },
+            'Update'
+          ),
+          loading && React__default['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(
+              'span',
+              { className: 'sr-only' },
+              'Loading...'
+            )
+          )
+        )
+      )
+    ) : React__default['default'].createElement(reactBootstrap.Spinner, {
+      as: 'span',
+      animation: 'border',
+      role: 'status',
+      'aria-hidden': 'true',
+      size: 'sm'
+    }),
+    errorMsg && React__default['default'].createElement(
+      'p',
+      { className: 'error' },
+      errorMsg
+    ),
+    successMsg && React__default['default'].createElement(
+      'p',
+      { className: 'success' },
+      successMsg
+    ),
+    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      '
+    )
+  );
+};
+
+var TOKEN_NAME = 'token';
+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, {
+    //maxAge: MAX_AGE,  // we want login cookie to expire when browser
+    //expires: new Date(Date.now() + MAX_AGE * 1000),
+    //httpOnly: true,
+    //secure: process.env.NODE_ENV === 'production',
+    path: '/'
+    //sameSite: 'lax',
+  }));
+
+  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,
+    //secure: process.env.NODE_ENV === 'production',
+    path: '/'
+    //sameSite: 'lax',
+  }));
+
+  res.setHeader('Set-Cookie', cookies_serailized);
+}
+
+function removeTokenCookie(res) {
+  var cookies_serailized = [];
+  cookies_serailized.push(index.serialize_1(TOKEN_NAME, '', {
+    maxAge: -1,
+    expires: new Date(Date.now() - MAX_AGE * 1000),
+    path: '/'
+  }));
+  cookies_serailized.push(index.serialize_1('eKey', '', {
+    maxAge: -1,
+    expires: new Date(Date.now() - MAX_AGE * 1000),
+    path: '/'
+  }));
+
+  res.setHeader('Set-Cookie', cookies_serailized);
+}
+
+function parseCookies(req) {
+  // For API Routes we don't need to parse the cookies.
+  if (req.cookies) return req.cookies;
+
+  // For pages we do need to parse the cookies.
+  var cookie = req.headers ? req.headers.cookie : null;
+  return index.parse_1(cookie || '');
+}
+
+function getTokenCookie(req) {
+  var cookies = parseCookies(req);
+  return cookies[TOKEN_NAME];
+}
+
+var authCookies = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  setTokenCookie: setTokenCookie,
+  removeTokenCookie: removeTokenCookie,
+  parseCookies: parseCookies,
+  getTokenCookie: getTokenCookie
+});
+
+function encryptSession(session) {
+  var buffer = new Buffer(stringify._JSON$stringify(session));
+  return buffer.toString('base64');
+  //return jwt.sign(session, TOKEN_SECRET)
+  //return Iron.seal(session, TOKEN_SECRET, Iron.defaults)
+}
+
+var getSession = function () {
+  var _ref = asyncToGenerator._asyncToGenerator( /*#__PURE__*/asyncToGenerator.regenerator.mark(function _callee(req) {
+    var token, buff;
+    return asyncToGenerator.regenerator.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            token = getTokenCookie(req);
+
+            if (!token) {
+              _context.next = 4;
+              break;
+            }
+
+            buff = new Buffer(token, 'base64');
+            return _context.abrupt('return', JSON.parse(buff.toString('utf8')));
+
+          case 4:
+            return _context.abrupt('return', null);
+
+          case 5:
+          case 'end':
+            return _context.stop();
+        }
+      }
+    }, _callee, this);
+  }));
+
+  return function getSession(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();
+
+var iron = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  encryptSession: encryptSession,
+  getSession: getSession
+});
+
+var toStr = Object.prototype.toString;
+
+var isArguments = function isArguments(value) {
+	var str = toStr.call(value);
+	var isArgs = str === '[object Arguments]';
+	if (!isArgs) {
+		isArgs = str !== '[object Array]' &&
+			value !== null &&
+			typeof value === 'object' &&
+			typeof value.length === 'number' &&
+			value.length >= 0 &&
+			toStr.call(value.callee) === '[object Function]';
+	}
+	return isArgs;
+};
+
+var keysShim;
+if (!Object.keys) {
+	// modified from https://github.com/es-shims/es5-shim
+	var has = Object.prototype.hasOwnProperty;
+	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');
+	var hasProtoEnumBug = isEnumerable.call(function () {}, 'prototype');
+	var dontEnums = [
+		'toString',
+		'toLocaleString',
+		'valueOf',
+		'hasOwnProperty',
+		'isPrototypeOf',
+		'propertyIsEnumerable',
+		'constructor'
+	];
+	var equalsConstructorPrototype = function (o) {
+		var ctor = o.constructor;
+		return ctor && ctor.prototype === o;
+	};
+	var excludedKeys = {
+		$applicationCache: true,
+		$console: true,
+		$external: true,
+		$frame: true,
+		$frameElement: true,
+		$frames: true,
+		$innerHeight: true,
+		$innerWidth: true,
+		$onmozfullscreenchange: true,
+		$onmozfullscreenerror: true,
+		$outerHeight: true,
+		$outerWidth: true,
+		$pageXOffset: true,
+		$pageYOffset: true,
+		$parent: true,
+		$scrollLeft: true,
+		$scrollTop: true,
+		$scrollX: true,
+		$scrollY: true,
+		$self: true,
+		$webkitIndexedDB: true,
+		$webkitStorageInfo: true,
+		$window: true
+	};
+	var hasAutomationEqualityBug = (function () {
+		/* global window */
+		if (typeof window === 'undefined') { return false; }
+		for (var k in window) {
+			try {
+				if (!excludedKeys['$' + k] && has.call(window, k) && window[k] !== null && typeof window[k] === 'object') {
+					try {
+						equalsConstructorPrototype(window[k]);
+					} catch (e) {
+						return true;
+					}
+				}
+			} catch (e) {
+				return true;
+			}
+		}
+		return false;
+	}());
+	var equalsConstructorPrototypeIfNotBuggy = function (o) {
+		/* global window */
+		if (typeof window === 'undefined' || !hasAutomationEqualityBug) {
+			return equalsConstructorPrototype(o);
+		}
+		try {
+			return equalsConstructorPrototype(o);
+		} catch (e) {
+			return false;
+		}
+	};
+
+	keysShim = function keys(object) {
+		var isObject = object !== null && typeof object === 'object';
+		var isFunction = toStr$1.call(object) === '[object Function]';
+		var isArguments = isArgs(object);
+		var isString = isObject && toStr$1.call(object) === '[object String]';
+		var theKeys = [];
+
+		if (!isObject && !isFunction && !isArguments) {
+			throw new TypeError('Object.keys called on a non-object');
+		}
+
+		var skipProto = hasProtoEnumBug && isFunction;
+		if (isString && object.length > 0 && !has.call(object, 0)) {
+			for (var i = 0; i < object.length; ++i) {
+				theKeys.push(String(i));
+			}
+		}
+
+		if (isArguments && object.length > 0) {
+			for (var j = 0; j < object.length; ++j) {
+				theKeys.push(String(j));
+			}
+		} else {
+			for (var name in object) {
+				if (!(skipProto && name === 'prototype') && has.call(object, name)) {
+					theKeys.push(String(name));
+				}
+			}
+		}
+
+		if (hasDontEnumBug) {
+			var skipConstructor = equalsConstructorPrototypeIfNotBuggy(object);
+
+			for (var k = 0; k < dontEnums.length; ++k) {
+				if (!(skipConstructor && dontEnums[k] === 'constructor') && has.call(object, dontEnums[k])) {
+					theKeys.push(dontEnums[k]);
+				}
+			}
+		}
+		return theKeys;
+	};
+}
+var implementation = keysShim;
+
+var slice = Array.prototype.slice;
+
+
+var origKeys = Object.keys;
+var keysShim$1 = origKeys ? function keys(o) { return origKeys(o); } : implementation;
+
+var originalKeys = Object.keys;
+
+keysShim$1.shim = function shimObjectKeys() {
+	if (Object.keys) {
+		var keysWorksWithArguments = (function () {
+			// Safari 5.0 bug
+			var args = Object.keys(arguments);
+			return args && args.length === arguments.length;
+		}(1, 2));
+		if (!keysWorksWithArguments) {
+			Object.keys = function keys(object) { // eslint-disable-line func-name-matching
+				if (isArguments(object)) {
+					return originalKeys(slice.call(object));
+				}
+				return originalKeys(object);
+			};
+		}
+	} else {
+		Object.keys = keysShim$1;
+	}
+	return Object.keys || keysShim$1;
+};
+
+var objectKeys = keysShim$1;
+
+var hasSymbols = typeof Symbol === 'function' && typeof Symbol('foo') === 'symbol';
+
+var toStr$2 = Object.prototype.toString;
+var concat = Array.prototype.concat;
+var origDefineProperty = Object.defineProperty;
+
+var isFunction = function (fn) {
+	return typeof fn === 'function' && toStr$2.call(fn) === '[object Function]';
+};
+
+var arePropertyDescriptorsSupported = function () {
+	var obj = {};
+	try {
+		origDefineProperty(obj, 'x', { enumerable: false, value: obj });
+		// eslint-disable-next-line no-unused-vars, no-restricted-syntax
+		for (var _ in obj) { // jscs:ignore disallowUnusedVariables
+			return false;
+		}
+		return obj.x === obj;
+	} catch (e) { /* this is IE 8. */
+		return false;
+	}
+};
+var supportsDescriptors = origDefineProperty && arePropertyDescriptorsSupported();
+
+var defineProperty = function (object, name, value, predicate) {
+	if (name in object && (!isFunction(predicate) || !predicate())) {
+		return;
+	}
+	if (supportsDescriptors) {
+		origDefineProperty(object, name, {
+			configurable: true,
+			enumerable: false,
+			value: value,
+			writable: true
+		});
+	} else {
+		object[name] = value;
+	}
+};
+
+var defineProperties = function (object, map) {
+	var predicates = arguments.length > 2 ? arguments[2] : {};
+	var props = objectKeys(map);
+	if (hasSymbols) {
+		props = concat.call(props, Object.getOwnPropertySymbols(map));
+	}
+	for (var i = 0; i < props.length; i += 1) {
+		defineProperty(object, props[i], map[props[i]], predicates[props[i]]);
+	}
+};
+
+defineProperties.supportsDescriptors = !!supportsDescriptors;
+
+var defineProperties_1 = defineProperties;
+
+/* eslint no-invalid-this: 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 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);
+
+    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 functionBind = Function.prototype.bind || implementation$1;
+
+/* eslint complexity: [2, 18], max-statements: [2, 33] */
+var shams = function hasSymbols() {
+	if (typeof Symbol !== 'function' || typeof Object.getOwnPropertySymbols !== 'function') { return false; }
+	if (typeof Symbol.iterator === 'symbol') { return true; }
+
+	var obj = {};
+	var sym = Symbol('test');
+	var symObj = Object(sym);
+	if (typeof sym === 'string') { return false; }
+
+	if (Object.prototype.toString.call(sym) !== '[object Symbol]') { return false; }
+	if (Object.prototype.toString.call(symObj) !== '[object Symbol]') { return false; }
+
+	// temp disabled per https://github.com/ljharb/object.assign/issues/17
+	// if (sym instanceof Symbol) { return false; }
+	// temp disabled per https://github.com/WebReflection/get-own-property-symbols/issues/4
+	// if (!(symObj instanceof Symbol)) { return false; }
+
+	// if (typeof Symbol.prototype.toString !== 'function') { return false; }
+	// if (String(sym) !== Symbol.prototype.toString.call(sym)) { return false; }
+
+	var symVal = 42;
+	obj[sym] = symVal;
+	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; }
+
+	var syms = Object.getOwnPropertySymbols(obj);
+	if (syms.length !== 1 || syms[0] !== sym) { return false; }
+
+	if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) { return false; }
+
+	if (typeof Object.getOwnPropertyDescriptor === 'function') {
+		var descriptor = Object.getOwnPropertyDescriptor(obj, sym);
+		if (descriptor.value !== symVal || descriptor.enumerable !== true) { return false; }
+	}
+
+	return true;
+};
+
+var origSymbol = _commonjsHelpers.commonjsGlobal.Symbol;
+
+
+var hasSymbols$1 = function hasNativeSymbols() {
+	if (typeof origSymbol !== 'function') { return false; }
+	if (typeof Symbol !== 'function') { return false; }
+	if (typeof origSymbol('foo') !== 'symbol') { return false; }
+	if (typeof Symbol('bar') !== 'symbol') { return false; }
+
+	return shams();
+};
+
+var src = functionBind.call(Function.call, Object.prototype.hasOwnProperty);
+
+var undefined$1;
+
+var $SyntaxError = SyntaxError;
+var $Function = Function;
+var $TypeError = TypeError;
+
+// eslint-disable-next-line consistent-return
+var getEvalledConstructor = function (expressionSyntax) {
+	try {
+		return $Function('"use strict"; return (' + expressionSyntax + ').constructor;')();
+	} catch (e) {}
+};
+
+var $gOPD = Object.getOwnPropertyDescriptor;
+if ($gOPD) {
+	try {
+		$gOPD({}, '');
+	} catch (e) {
+		$gOPD = null; // this is IE 8, which has a broken gOPD
+	}
+}
+
+var throwTypeError = function () {
+	throw new $TypeError();
+};
+var ThrowTypeError = $gOPD
+	? (function () {
+		try {
+			// eslint-disable-next-line no-unused-expressions, no-caller, no-restricted-properties
+			arguments.callee; // IE 8 does not throw here
+			return throwTypeError;
+		} catch (calleeThrows) {
+			try {
+				// IE 8 throws on Object.getOwnPropertyDescriptor(arguments, '')
+				return $gOPD(arguments, 'callee').get;
+			} catch (gOPDthrows) {
+				return throwTypeError;
+			}
+		}
+	}())
+	: throwTypeError;
+
+var hasSymbols$2 = hasSymbols$1();
+
+var getProto = Object.getPrototypeOf || function (x) { return x.__proto__; }; // eslint-disable-line no-proto
+
+var needsEval = {};
+
+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,
+	'%ArrayIteratorPrototype%': hasSymbols$2 ? getProto([][Symbol.iterator]()) : undefined$1,
+	'%AsyncFromSyncIteratorPrototype%': undefined$1,
+	'%AsyncFunction%': needsEval,
+	'%AsyncGenerator%': needsEval,
+	'%AsyncGeneratorFunction%': needsEval,
+	'%AsyncIteratorPrototype%': needsEval,
+	'%Atomics%': typeof Atomics === 'undefined' ? undefined$1 : Atomics,
+	'%BigInt%': typeof BigInt === 'undefined' ? undefined$1 : BigInt,
+	'%Boolean%': Boolean,
+	'%DataView%': typeof DataView === 'undefined' ? undefined$1 : DataView,
+	'%Date%': Date,
+	'%decodeURI%': decodeURI,
+	'%decodeURIComponent%': decodeURIComponent,
+	'%encodeURI%': encodeURI,
+	'%encodeURIComponent%': encodeURIComponent,
+	'%Error%': Error,
+	'%eval%': eval, // eslint-disable-line no-eval
+	'%EvalError%': EvalError,
+	'%Float32Array%': typeof Float32Array === 'undefined' ? undefined$1 : Float32Array,
+	'%Float64Array%': typeof Float64Array === 'undefined' ? undefined$1 : Float64Array,
+	'%FinalizationRegistry%': typeof FinalizationRegistry === 'undefined' ? undefined$1 : FinalizationRegistry,
+	'%Function%': $Function,
+	'%GeneratorFunction%': needsEval,
+	'%Int8Array%': typeof Int8Array === 'undefined' ? undefined$1 : Int8Array,
+	'%Int16Array%': typeof Int16Array === 'undefined' ? undefined$1 : Int16Array,
+	'%Int32Array%': typeof Int32Array === 'undefined' ? undefined$1 : Int32Array,
+	'%isFinite%': isFinite,
+	'%isNaN%': isNaN,
+	'%IteratorPrototype%': hasSymbols$2 ? getProto(getProto([][Symbol.iterator]())) : undefined$1,
+	'%JSON%': typeof JSON === 'object' ? JSON : undefined$1,
+	'%Map%': typeof Map === 'undefined' ? undefined$1 : Map,
+	'%MapIteratorPrototype%': typeof Map === 'undefined' || !hasSymbols$2 ? undefined$1 : getProto(new Map()[Symbol.iterator]()),
+	'%Math%': Math,
+	'%Number%': Number,
+	'%Object%': Object,
+	'%parseFloat%': parseFloat,
+	'%parseInt%': parseInt,
+	'%Promise%': typeof Promise === 'undefined' ? undefined$1 : Promise,
+	'%Proxy%': typeof Proxy === 'undefined' ? undefined$1 : Proxy,
+	'%RangeError%': RangeError,
+	'%ReferenceError%': ReferenceError,
+	'%Reflect%': typeof Reflect === 'undefined' ? undefined$1 : Reflect,
+	'%RegExp%': RegExp,
+	'%Set%': typeof Set === 'undefined' ? undefined$1 : Set,
+	'%SetIteratorPrototype%': typeof Set === 'undefined' || !hasSymbols$2 ? undefined$1 : getProto(new Set()[Symbol.iterator]()),
+	'%SharedArrayBuffer%': typeof SharedArrayBuffer === 'undefined' ? undefined$1 : SharedArrayBuffer,
+	'%String%': String,
+	'%StringIteratorPrototype%': hasSymbols$2 ? getProto(''[Symbol.iterator]()) : undefined$1,
+	'%Symbol%': hasSymbols$2 ? Symbol : undefined$1,
+	'%SyntaxError%': $SyntaxError,
+	'%ThrowTypeError%': ThrowTypeError,
+	'%TypedArray%': TypedArray,
+	'%TypeError%': $TypeError,
+	'%Uint8Array%': typeof Uint8Array === 'undefined' ? undefined$1 : Uint8Array,
+	'%Uint8ClampedArray%': typeof Uint8ClampedArray === 'undefined' ? undefined$1 : Uint8ClampedArray,
+	'%Uint16Array%': typeof Uint16Array === 'undefined' ? undefined$1 : Uint16Array,
+	'%Uint32Array%': typeof Uint32Array === 'undefined' ? undefined$1 : Uint32Array,
+	'%URIError%': URIError,
+	'%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;
+};
+
+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 = 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('invalid intrinsic syntax, expected closing `%`');
+	} else if (last === '%' && first !== '%') {
+		throw new $SyntaxError('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;
+	});
+	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 (src(INTRINSICS, intrinsicName)) {
+		var value = INTRINSICS[intrinsicName];
+		if (value === needsEval) {
+			value = doEval(intrinsicName);
+		}
+		if (typeof value === 'undefined' && !allowMissing) {
+			throw new $TypeError('intrinsic ' + name + ' exists, but is not available. Please file an issue!');
+		}
+
+		return {
+			alias: alias,
+			name: intrinsicName,
+			value: value
+		};
+	}
+
+	throw new $SyntaxError('intrinsic ' + name + ' does not exist!');
+};
+
+var getIntrinsic = function GetIntrinsic(name, allowMissing) {
+	if (typeof name !== 'string' || name.length === 0) {
+		throw new $TypeError('intrinsic name must be a non-empty string');
+	}
+	if (arguments.length > 1 && typeof allowMissing !== '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([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('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('base intrinsic for ' + name + ' exists, but the property is not available.');
+				}
+				return void undefined$1;
+			}
+			if ($gOPD && (i + 1) >= parts.length) {
+				var desc = $gOPD(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];
+				}
+			} else {
+				isOwn = src(value, part);
+				value = value[part];
+			}
+
+			if (isOwn && !skipFurtherCaching) {
+				INTRINSICS[intrinsicRealName] = value;
+			}
+		}
+	}
+	return value;
+};
+
+var callBind = _commonjsHelpers.createCommonjsModule(function (module) {
+
+
+
+
+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 applyBind = function applyBind() {
+	return $reflectApply(functionBind, $apply, arguments);
+};
+
+if ($defineProperty) {
+	$defineProperty(module.exports, 'apply', { value: applyBind });
+} else {
+	module.exports.apply = applyBind;
+}
+});
+callBind.apply;
+
+var $indexOf = callBind(getIntrinsic('String.prototype.indexOf'));
+
+var callBound = function callBoundIntrinsic(name, allowMissing) {
+	var intrinsic = getIntrinsic(name, !!allowMissing);
+	if (typeof intrinsic === 'function' && $indexOf(name, '.prototype.') > -1) {
+		return callBind(intrinsic);
+	}
+	return intrinsic;
+};
+
+var $defineProperty = getIntrinsic('%Object.defineProperty%', true);
+
+if ($defineProperty) {
+	try {
+		$defineProperty({}, 'a', { value: 1 });
+	} catch (e) {
+		// IE 8 has a broken defineProperty
+		$defineProperty = null;
+	}
+}
+
+
+
+var $isEnumerable = callBound('Object.prototype.propertyIsEnumerable');
+
+// eslint-disable-next-line max-params
+var DefineOwnProperty = function DefineOwnProperty(IsDataDescriptor, SameValue, FromPropertyDescriptor, O, P, desc) {
+	if (!$defineProperty) {
+		if (!IsDataDescriptor(desc)) {
+			// ES3 does not support getters/setters
+			return false;
+		}
+		if (!desc['[[Configurable]]'] || !desc['[[Writable]]']) {
+			return false;
+		}
+
+		// fallback for ES3
+		if (P in O && $isEnumerable(O, P) !== !!desc['[[Enumerable]]']) {
+			// a non-enumerable existing property
+			return false;
+		}
+
+		// property does not exist at all, or exists but is enumerable
+		var V = desc['[[Value]]'];
+		// eslint-disable-next-line no-param-reassign
+		O[P] = V; // will use [[Define]]
+		return SameValue(O[P], V);
+	}
+	$defineProperty(O, P, FromPropertyDescriptor(desc));
+	return true;
+};
+
+var $TypeError$1 = getIntrinsic('%TypeError%');
+var $SyntaxError$1 = getIntrinsic('%SyntaxError%');
+
+
+
+var predicates = {
+	// 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;
+		}
+		var allowed = {
+			'[[Configurable]]': true,
+			'[[Enumerable]]': true,
+			'[[Get]]': true,
+			'[[Set]]': true,
+			'[[Value]]': true,
+			'[[Writable]]': true
+		};
+
+		for (var key in Desc) { // eslint-disable-line
+			if (src(Desc, key) && !allowed[key]) {
+				return false;
+			}
+		}
+
+		var isData = src(Desc, '[[Value]]');
+		var IsAccessor = src(Desc, '[[Get]]') || src(Desc, '[[Set]]');
+		if (isData && IsAccessor) {
+			throw new $TypeError$1('Property Descriptors may not be both accessor and data descriptors');
+		}
+		return true;
+	}
+};
+
+var assertRecord = function assertRecord(Type, recordType, argumentName, value) {
+	var predicate = predicates[recordType];
+	if (typeof predicate !== 'function') {
+		throw new $SyntaxError$1('unknown record type: ' + recordType);
+	}
+	if (!predicate(Type, value)) {
+		throw new $TypeError$1(argumentName + ' must be a ' + recordType);
+	}
+};
+
+// https://ecma-international.org/ecma-262/5.1/#sec-8
+
+var Type = function Type(x) {
+	if (x === null) {
+		return 'Null';
+	}
+	if (typeof x === 'undefined') {
+		return 'Undefined';
+	}
+	if (typeof x === 'function' || typeof x === 'object') {
+		return 'Object';
+	}
+	if (typeof x === 'number') {
+		return 'Number';
+	}
+	if (typeof x === 'boolean') {
+		return 'Boolean';
+	}
+	if (typeof x === 'string') {
+		return 'String';
+	}
+};
+
+// https://ecma-international.org/ecma-262/11.0/#sec-ecmascript-data-types-and-values
+
+var Type$1 = function Type$1(x) {
+	if (typeof x === 'symbol') {
+		return 'Symbol';
+	}
+	if (typeof x === 'bigint') {
+		return 'BigInt';
+	}
+	return Type(x);
+};
+
+// https://ecma-international.org/ecma-262/6.0/#sec-frompropertydescriptor
+
+var FromPropertyDescriptor = function FromPropertyDescriptor(Desc) {
+	if (typeof Desc === 'undefined') {
+		return Desc;
+	}
+
+	assertRecord(Type$1, 'Property Descriptor', 'Desc', Desc);
+
+	var obj = {};
+	if ('[[Value]]' in Desc) {
+		obj.value = Desc['[[Value]]'];
+	}
+	if ('[[Writable]]' in Desc) {
+		obj.writable = Desc['[[Writable]]'];
+	}
+	if ('[[Get]]' in Desc) {
+		obj.get = Desc['[[Get]]'];
+	}
+	if ('[[Set]]' in Desc) {
+		obj.set = Desc['[[Set]]'];
+	}
+	if ('[[Enumerable]]' in Desc) {
+		obj.enumerable = Desc['[[Enumerable]]'];
+	}
+	if ('[[Configurable]]' in Desc) {
+		obj.configurable = Desc['[[Configurable]]'];
+	}
+	return obj;
+};
+
+var $gOPD$1 = getIntrinsic('%Object.getOwnPropertyDescriptor%');
+if ($gOPD$1) {
+	try {
+		$gOPD$1([], 'length');
+	} catch (e) {
+		// IE 8 has a broken gOPD
+		$gOPD$1 = null;
+	}
+}
+
+var getOwnPropertyDescriptor = $gOPD$1;
+
+var $Array = getIntrinsic('%Array%');
+
+// eslint-disable-next-line global-require
+var toStr$4 = !$Array.isArray && callBound('Object.prototype.toString');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-isarray
+
+var IsArray = $Array.isArray || function IsArray(argument) {
+	return toStr$4(argument) === '[object Array]';
+};
+
+// https://ecma-international.org/ecma-262/6.0/#sec-ispropertykey
+
+var IsPropertyKey = function IsPropertyKey(argument) {
+	return typeof argument === 'string' || typeof argument === 'symbol';
+};
+
+var hasSymbols$3 = hasSymbols$1();
+var hasToStringTag = hasSymbols$3 && typeof Symbol.toStringTag === 'symbol';
+var has$1;
+var $exec;
+var isRegexMarker;
+var badStringifier;
+
+if (hasToStringTag) {
+	has$1 = callBound('Object.prototype.hasOwnProperty');
+	$exec = callBound('RegExp.prototype.exec');
+	isRegexMarker = {};
+
+	var throwRegexMarker = function () {
+		throw isRegexMarker;
+	};
+	badStringifier = {
+		toString: throwRegexMarker,
+		valueOf: throwRegexMarker
+	};
+
+	if (typeof Symbol.toPrimitive === 'symbol') {
+		badStringifier[Symbol.toPrimitive] = throwRegexMarker;
+	}
+}
+
+var $toString = callBound('Object.prototype.toString');
+var gOPD = Object.getOwnPropertyDescriptor;
+var regexClass = '[object RegExp]';
+
+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 && has$1(descriptor, 'value');
+		if (!hasLastIndexDataProperty) {
+			return false;
+		}
+
+		try {
+			$exec(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 $toString(value) === regexClass;
+	};
+
+// http://ecma-international.org/ecma-262/5.1/#sec-9.2
+
+var ToBoolean = function ToBoolean(value) { return !!value; };
+
+var $match = getIntrinsic('%Symbol.match%', true);
+
+
+
+
+
+// https://ecma-international.org/ecma-262/6.0/#sec-isregexp
+
+var IsRegExp = function IsRegExp(argument) {
+	if (!argument || typeof argument !== 'object') {
+		return false;
+	}
+	if ($match) {
+		var isRegExp = argument[$match];
+		if (typeof isRegExp !== 'undefined') {
+			return ToBoolean(isRegExp);
+		}
+	}
+	return isRegex(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) {
+	try {
+		var fnStr = fnToStr.call(value);
+		return constructorRegex.test(fnStr);
+	} catch (e) {
+		return false; // not a function
+	}
+};
+
+var tryFunctionObject = function tryFunctionToStr(value) {
+	try {
+		if (isES6ClassFn(value)) { return false; }
+		fnToStr.call(value);
+		return true;
+	} catch (e) {
+		return false;
+	}
+};
+var toStr$5 = Object.prototype.toString;
+var fnClass = '[object Function]';
+var genClass = '[object GeneratorFunction]';
+var hasToStringTag$1 = 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$1) { return tryFunctionObject(value); }
+		if (isES6ClassFn(value)) { return false; }
+		var strClass = toStr$5.call(value);
+		return strClass === fnClass || strClass === genClass;
+	};
+
+// http://ecma-international.org/ecma-262/5.1/#sec-9.11
+
+var IsCallable = isCallable;
+
+var $TypeError$2 = getIntrinsic('%TypeError%');
+
+
+
+
+
+// https://ecma-international.org/ecma-262/5.1/#sec-8.10.5
+
+var ToPropertyDescriptor = function ToPropertyDescriptor(Obj) {
+	if (Type$1(Obj) !== 'Object') {
+		throw new $TypeError$2('ToPropertyDescriptor requires an object');
+	}
+
+	var desc = {};
+	if (src(Obj, 'enumerable')) {
+		desc['[[Enumerable]]'] = ToBoolean(Obj.enumerable);
+	}
+	if (src(Obj, 'configurable')) {
+		desc['[[Configurable]]'] = ToBoolean(Obj.configurable);
+	}
+	if (src(Obj, 'value')) {
+		desc['[[Value]]'] = Obj.value;
+	}
+	if (src(Obj, 'writable')) {
+		desc['[[Writable]]'] = ToBoolean(Obj.writable);
+	}
+	if (src(Obj, 'get')) {
+		var getter = Obj.get;
+		if (typeof getter !== 'undefined' && !IsCallable(getter)) {
+			throw new $TypeError$2('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$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$2('Invalid property descriptor. Cannot both specify accessors and a value or writable attribute');
+	}
+	return desc;
+};
+
+var $TypeError$3 = getIntrinsic('%TypeError%');
+
+
+
+var $isEnumerable$1 = callBound('Object.prototype.propertyIsEnumerable');
+
+
+
+
+
+
+
+
+
+// https://ecma-international.org/ecma-262/6.0/#sec-ordinarygetownproperty
+
+var OrdinaryGetOwnProperty = function OrdinaryGetOwnProperty(O, P) {
+	if (Type$1(O) !== 'Object') {
+		throw new $TypeError$3('Assertion failed: O must be an Object');
+	}
+	if (!IsPropertyKey(P)) {
+		throw new $TypeError$3('Assertion failed: P must be a Property Key');
+	}
+	if (!src(O, P)) {
+		return void 0;
+	}
+	if (!getOwnPropertyDescriptor) {
+		// ES3 / IE 8 fallback
+		var arrayLength = IsArray(O) && P === 'length';
+		var regexLastIndex = IsRegExp(O) && P === 'lastIndex';
+		return {
+			'[[Configurable]]': !(arrayLength || regexLastIndex),
+			'[[Enumerable]]': $isEnumerable$1(O, P),
+			'[[Value]]': O[P],
+			'[[Writable]]': true
+		};
+	}
+	return ToPropertyDescriptor(getOwnPropertyDescriptor(O, P));
+};
+
+// https://ecma-international.org/ecma-262/6.0/#sec-isdatadescriptor
+
+var IsDataDescriptor = function IsDataDescriptor(Desc) {
+	if (typeof Desc === 'undefined') {
+		return false;
+	}
+
+	assertRecord(Type$1, 'Property Descriptor', 'Desc', Desc);
+
+	if (!src(Desc, '[[Value]]') && !src(Desc, '[[Writable]]')) {
+		return false;
+	}
+
+	return true;
+};
+
+var isPrimitive = function isPrimitive(value) {
+	return value === null || (typeof value !== 'function' && typeof value !== 'object');
+};
+
+var $Object = getIntrinsic('%Object%');
+
+
+
+var $preventExtensions = $Object.preventExtensions;
+var $isExtensible = $Object.isExtensible;
+
+// https://ecma-international.org/ecma-262/6.0/#sec-isextensible-o
+
+var IsExtensible = $preventExtensions
+	? function IsExtensible(obj) {
+		return !isPrimitive(obj) && $isExtensible(obj);
+	}
+	: function IsExtensible(obj) {
+		return !isPrimitive(obj);
+	};
+
+var _isNaN = Number.isNaN || function isNaN(a) {
+	return a !== a;
+};
+
+// http://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.
+		if (x === 0) { return 1 / x === 1 / y; }
+		return true;
+	}
+	return _isNaN(x) && _isNaN(y);
+};
+
+var $TypeError$4 = getIntrinsic('%TypeError%');
+
+
+
+
+
+
+
+
+
+
+
+// https://ecma-international.org/ecma-262/6.0/#sec-createdataproperty
+
+var CreateDataProperty = function CreateDataProperty(O, P, V) {
+	if (Type$1(O) !== 'Object') {
+		throw new $TypeError$4('Assertion failed: Type(O) is not Object');
+	}
+	if (!IsPropertyKey(P)) {
+		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]]']);
+	if (immutable || !extensible) {
+		return false;
+	}
+	return DefineOwnProperty(
+		IsDataDescriptor,
+		SameValue,
+		FromPropertyDescriptor,
+		O,
+		P,
+		{
+			'[[Configurable]]': true,
+			'[[Enumerable]]': true,
+			'[[Value]]': V,
+			'[[Writable]]': true
+		}
+	);
+};
+
+var $TypeError$5 = getIntrinsic('%TypeError%');
+
+// http://ecma-international.org/ecma-262/5.1/#sec-9.10
+
+var CheckObjectCoercible = function CheckObjectCoercible(value, optMessage) {
+	if (value == null) {
+		throw new $TypeError$5(optMessage || ('Cannot call method on ' + value));
+	}
+	return value;
+};
+
+var RequireObjectCoercible = CheckObjectCoercible;
+
+var $Object$1 = getIntrinsic('%Object%');
+
+
+
+// https://ecma-international.org/ecma-262/6.0/#sec-toobject
+
+var ToObject = function ToObject(value) {
+	RequireObjectCoercible(value);
+	return $Object$1(value);
+};
+
+var $gOPD$2 = Object.getOwnPropertyDescriptor;
+var $getOwnNames = Object.getOwnPropertyNames;
+var $getSymbols = Object.getOwnPropertySymbols;
+var $concat$1 = callBound('Array.prototype.concat');
+var $reduce = callBound('Array.prototype.reduce');
+var getAll = $getSymbols ? function (obj) {
+	return $concat$1($getOwnNames(obj), $getSymbols(obj));
+} : $getOwnNames;
+
+var isES5 = IsCallable($gOPD$2) && IsCallable($getOwnNames);
+
+var implementation$2 = function getOwnPropertyDescriptors(value) {
+	RequireObjectCoercible(value);
+	if (!isES5) {
+		throw new TypeError('getOwnPropertyDescriptors requires Object.getOwnPropertyDescriptor');
+	}
+
+	var O = ToObject(value);
+	return $reduce(
+		getAll(O),
+		function (acc, key) {
+			var descriptor = $gOPD$2(O, key);
+			if (typeof descriptor !== 'undefined') {
+				CreateDataProperty(acc, key, descriptor);
+			}
+			return acc;
+		},
+		{}
+	);
+};
+
+var polyfill = function getPolyfill() {
+	return typeof Object.getOwnPropertyDescriptors === 'function' ? Object.getOwnPropertyDescriptors : implementation$2;
+};
+
+var shim = function shimGetOwnPropertyDescriptors() {
+	var polyfill$1 = polyfill();
+	defineProperties_1(
+		Object,
+		{ getOwnPropertyDescriptors: polyfill$1 },
+		{ getOwnPropertyDescriptors: function () { return Object.getOwnPropertyDescriptors !== polyfill$1; } }
+	);
+	return polyfill$1;
+};
+
+var bound = callBind(polyfill(), Object);
+
+defineProperties_1(bound, {
+	getPolyfill: polyfill,
+	implementation: implementation$2,
+	shim: shim
+});
+
+var object_getownpropertydescriptors = bound;
+
+/* globals
+	Atomics,
+	SharedArrayBuffer,
+*/
+
+var undefined$2;
+
+var $TypeError$6 = TypeError;
+
+var $gOPD$3 = Object.getOwnPropertyDescriptor;
+if ($gOPD$3) {
+	try {
+		$gOPD$3({}, '');
+	} catch (e) {
+		$gOPD$3 = null; // this is IE 8, which has a broken gOPD
+	}
+}
+
+var throwTypeError$1 = function () { throw new $TypeError$6(); };
+var ThrowTypeError$1 = $gOPD$3
+	? (function () {
+		try {
+			// eslint-disable-next-line no-unused-expressions, no-caller, no-restricted-properties
+			arguments.callee; // IE 8 does not throw here
+			return throwTypeError$1;
+		} catch (calleeThrows) {
+			try {
+				// IE 8 throws on Object.getOwnPropertyDescriptor(arguments, '')
+				return $gOPD$3(arguments, 'callee').get;
+			} catch (gOPDthrows) {
+				return throwTypeError$1;
+			}
+		}
+	}())
+	: throwTypeError$1;
+
+var hasSymbols$4 = hasSymbols$1();
+
+var getProto$1 = Object.getPrototypeOf || function (x) { return x.__proto__; }; // eslint-disable-line no-proto
+var generatorFunction = undefined$2;
+var asyncFunction = undefined$2;
+var asyncGenFunction = undefined$2;
+
+var TypedArray$1 = typeof Uint8Array === 'undefined' ? undefined$2 : getProto$1(Uint8Array);
+
+var INTRINSICS$1 = {
+	'%Array%': Array,
+	'%ArrayBuffer%': typeof ArrayBuffer === 'undefined' ? undefined$2 : ArrayBuffer,
+	'%ArrayBufferPrototype%': typeof ArrayBuffer === 'undefined' ? undefined$2 : ArrayBuffer.prototype,
+	'%ArrayIteratorPrototype%': hasSymbols$4 ? getProto$1([][Symbol.iterator]()) : undefined$2,
+	'%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$2,
+	'%AsyncFunction%': asyncFunction,
+	'%AsyncFunctionPrototype%': undefined$2,
+	'%AsyncGenerator%': undefined$2,
+	'%AsyncGeneratorFunction%': asyncGenFunction,
+	'%AsyncGeneratorPrototype%': undefined$2,
+	'%AsyncIteratorPrototype%': undefined$2,
+	'%Atomics%': typeof Atomics === 'undefined' ? undefined$2 : Atomics,
+	'%Boolean%': Boolean,
+	'%BooleanPrototype%': Boolean.prototype,
+	'%DataView%': typeof DataView === 'undefined' ? undefined$2 : DataView,
+	'%DataViewPrototype%': typeof DataView === 'undefined' ? undefined$2 : 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$2 : Float32Array,
+	'%Float32ArrayPrototype%': typeof Float32Array === 'undefined' ? undefined$2 : Float32Array.prototype,
+	'%Float64Array%': typeof Float64Array === 'undefined' ? undefined$2 : Float64Array,
+	'%Float64ArrayPrototype%': typeof Float64Array === 'undefined' ? undefined$2 : Float64Array.prototype,
+	'%Function%': Function,
+	'%FunctionPrototype%': Function.prototype,
+	'%Generator%': undefined$2,
+	'%GeneratorFunction%': generatorFunction,
+	'%GeneratorPrototype%': undefined$2,
+	'%Int8Array%': typeof Int8Array === 'undefined' ? undefined$2 : Int8Array,
+	'%Int8ArrayPrototype%': typeof Int8Array === 'undefined' ? undefined$2 : Int8Array.prototype,
+	'%Int16Array%': typeof Int16Array === 'undefined' ? undefined$2 : Int16Array,
+	'%Int16ArrayPrototype%': typeof Int16Array === 'undefined' ? undefined$2 : Int8Array.prototype,
+	'%Int32Array%': typeof Int32Array === 'undefined' ? undefined$2 : Int32Array,
+	'%Int32ArrayPrototype%': typeof Int32Array === 'undefined' ? undefined$2 : Int32Array.prototype,
+	'%isFinite%': isFinite,
+	'%isNaN%': isNaN,
+	'%IteratorPrototype%': hasSymbols$4 ? getProto$1(getProto$1([][Symbol.iterator]())) : undefined$2,
+	'%JSON%': typeof JSON === 'object' ? JSON : undefined$2,
+	'%JSONParse%': typeof JSON === 'object' ? JSON.parse : undefined$2,
+	'%Map%': typeof Map === 'undefined' ? undefined$2 : Map,
+	'%MapIteratorPrototype%': typeof Map === 'undefined' || !hasSymbols$4 ? undefined$2 : getProto$1(new Map()[Symbol.iterator]()),
+	'%MapPrototype%': typeof Map === 'undefined' ? undefined$2 : 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$2 : Promise,
+	'%PromisePrototype%': typeof Promise === 'undefined' ? undefined$2 : Promise.prototype,
+	'%PromiseProto_then%': typeof Promise === 'undefined' ? undefined$2 : Promise.prototype.then,
+	'%Promise_all%': typeof Promise === 'undefined' ? undefined$2 : Promise.all,
+	'%Promise_reject%': typeof Promise === 'undefined' ? undefined$2 : Promise.reject,
+	'%Promise_resolve%': typeof Promise === 'undefined' ? undefined$2 : Promise.resolve,
+	'%Proxy%': typeof Proxy === 'undefined' ? undefined$2 : Proxy,
+	'%RangeError%': RangeError,
+	'%RangeErrorPrototype%': RangeError.prototype,
+	'%ReferenceError%': ReferenceError,
+	'%ReferenceErrorPrototype%': ReferenceError.prototype,
+	'%Reflect%': typeof Reflect === 'undefined' ? undefined$2 : Reflect,
+	'%RegExp%': RegExp,
+	'%RegExpPrototype%': RegExp.prototype,
+	'%Set%': typeof Set === 'undefined' ? undefined$2 : Set,
+	'%SetIteratorPrototype%': typeof Set === 'undefined' || !hasSymbols$4 ? undefined$2 : getProto$1(new Set()[Symbol.iterator]()),
+	'%SetPrototype%': typeof Set === 'undefined' ? undefined$2 : Set.prototype,
+	'%SharedArrayBuffer%': typeof SharedArrayBuffer === 'undefined' ? undefined$2 : SharedArrayBuffer,
+	'%SharedArrayBufferPrototype%': typeof SharedArrayBuffer === 'undefined' ? undefined$2 : SharedArrayBuffer.prototype,
+	'%String%': String,
+	'%StringIteratorPrototype%': hasSymbols$4 ? getProto$1(''[Symbol.iterator]()) : undefined$2,
+	'%StringPrototype%': String.prototype,
+	'%Symbol%': hasSymbols$4 ? Symbol : undefined$2,
+	'%SymbolPrototype%': hasSymbols$4 ? Symbol.prototype : undefined$2,
+	'%SyntaxError%': SyntaxError,
+	'%SyntaxErrorPrototype%': SyntaxError.prototype,
+	'%ThrowTypeError%': ThrowTypeError$1,
+	'%TypedArray%': TypedArray$1,
+	'%TypedArrayPrototype%': TypedArray$1 ? TypedArray$1.prototype : undefined$2,
+	'%TypeError%': $TypeError$6,
+	'%TypeErrorPrototype%': $TypeError$6.prototype,
+	'%Uint8Array%': typeof Uint8Array === 'undefined' ? undefined$2 : Uint8Array,
+	'%Uint8ArrayPrototype%': typeof Uint8Array === 'undefined' ? undefined$2 : Uint8Array.prototype,
+	'%Uint8ClampedArray%': typeof Uint8ClampedArray === 'undefined' ? undefined$2 : Uint8ClampedArray,
+	'%Uint8ClampedArrayPrototype%': typeof Uint8ClampedArray === 'undefined' ? undefined$2 : Uint8ClampedArray.prototype,
+	'%Uint16Array%': typeof Uint16Array === 'undefined' ? undefined$2 : Uint16Array,
+	'%Uint16ArrayPrototype%': typeof Uint16Array === 'undefined' ? undefined$2 : Uint16Array.prototype,
+	'%Uint32Array%': typeof Uint32Array === 'undefined' ? undefined$2 : Uint32Array,
+	'%Uint32ArrayPrototype%': typeof Uint32Array === 'undefined' ? undefined$2 : Uint32Array.prototype,
+	'%URIError%': URIError,
+	'%URIErrorPrototype%': URIError.prototype,
+	'%WeakMap%': typeof WeakMap === 'undefined' ? undefined$2 : WeakMap,
+	'%WeakMapPrototype%': typeof WeakMap === 'undefined' ? undefined$2 : WeakMap.prototype,
+	'%WeakSet%': typeof WeakSet === 'undefined' ? undefined$2 : WeakSet,
+	'%WeakSetPrototype%': typeof WeakSet === 'undefined' ? undefined$2 : WeakSet.prototype
+};
+
+
+var $replace$1 = functionBind.call(Function.call, String.prototype.replace);
+
+/* adapted from https://github.com/lodash/lodash/blob/4.17.15/dist/lodash.js#L6735-L6744 */
+var rePropName$1 = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g;
+var reEscapeChar$1 = /\\(\\)?/g; /** Used to match backslashes in property paths. */
+var stringToPath$1 = function stringToPath(string) {
+	var result = [];
+	$replace$1(string, rePropName$1, function (match, number, quote, subString) {
+		result[result.length] = quote ? $replace$1(subString, reEscapeChar$1, '$1') : (number || match);
+	});
+	return result;
+};
+/* end adaptation */
+
+var getBaseIntrinsic$1 = function getBaseIntrinsic(name, allowMissing) {
+	if (!(name in INTRINSICS$1)) {
+		throw new SyntaxError('intrinsic ' + name + ' does not exist!');
+	}
+
+	// istanbul ignore if // hopefully this is impossible to test :-)
+	if (typeof INTRINSICS$1[name] === 'undefined' && !allowMissing) {
+		throw new $TypeError$6('intrinsic ' + name + ' exists, but is not available. Please file an issue!');
+	}
+
+	return INTRINSICS$1[name];
+};
+
+var GetIntrinsic = function GetIntrinsic(name, allowMissing) {
+	if (typeof name !== 'string' || name.length === 0) {
+		throw new TypeError('intrinsic name must be a non-empty string');
+	}
+	if (arguments.length > 1 && typeof allowMissing !== 'boolean') {
+		throw new TypeError('"allowMissing" argument must be a boolean');
+	}
+
+	var parts = stringToPath$1(name);
+
+	var value = getBaseIntrinsic$1('%' + (parts.length > 0 ? parts[0] : '') + '%', allowMissing);
+	for (var i = 1; i < parts.length; i += 1) {
+		if (value != null) {
+			if ($gOPD$3 && (i + 1) >= parts.length) {
+				var desc = $gOPD$3(value, parts[i]);
+				if (!allowMissing && !(parts[i] in value)) {
+					throw new $TypeError$6('base intrinsic for ' + name + ' exists, but the property is not available.');
+				}
+				// 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.
+				value = desc && 'get' in desc && !('originalValue' in desc.get) ? desc.get : value[parts[i]];
+			} else {
+				value = value[parts[i]];
+			}
+		}
+	}
+	return value;
+};
+
+var callBind$1 = _commonjsHelpers.createCommonjsModule(function (module) {
+
+
+
+
+
+var $apply = GetIntrinsic('%Function.prototype.apply%');
+var $call = GetIntrinsic('%Function.prototype.call%');
+var $reflectApply = GetIntrinsic('%Reflect.apply%', true) || functionBind.call($call, $apply);
+
+var $defineProperty = GetIntrinsic('%Object.defineProperty%', true);
+
+if ($defineProperty) {
+	try {
+		$defineProperty({}, 'a', { value: 1 });
+	} catch (e) {
+		// IE 8 has a broken defineProperty
+		$defineProperty = null;
+	}
+}
+
+module.exports = function callBind() {
+	return $reflectApply(functionBind, $call, arguments);
+};
+
+var applyBind = function applyBind() {
+	return $reflectApply(functionBind, $apply, arguments);
+};
+
+if ($defineProperty) {
+	$defineProperty(module.exports, 'apply', { value: applyBind });
+} else {
+	module.exports.apply = applyBind;
+}
+});
+callBind$1.apply;
+
+var $indexOf$1 = callBind$1(GetIntrinsic('String.prototype.indexOf'));
+
+var callBound$1 = function callBoundIntrinsic(name, allowMissing) {
+	var intrinsic = GetIntrinsic(name, !!allowMissing);
+	if (typeof intrinsic === 'function' && $indexOf$1(name, '.prototype.')) {
+		return callBind$1(intrinsic);
+	}
+	return intrinsic;
+};
+
+var isES5$1 = typeof Object.defineProperty === 'function'
+	&& typeof Object.defineProperties === 'function';
+
+var hasProto = [].__proto__ === Array.prototype; // eslint-disable-line no-proto
+
+if (!isES5$1 || !hasProto) {
+	throw new TypeError('util.promisify requires a true ES5 environment, that also supports `__proto__`');
+}
+
+
+
+if (typeof Promise !== 'function') {
+	throw new TypeError('`Promise` must be globally available for util.promisify to work.');
+}
+
+
+
+var $slice = callBound$1('Array.prototype.slice');
+var $concat$2 = callBound$1('Array.prototype.concat');
+var $forEach = callBound$1('Array.prototype.forEach');
+
+var hasSymbols$5 = hasSymbols$1();
+
+var kCustomPromisifiedSymbol = hasSymbols$5 ? Symbol('util.promisify.custom') : null;
+var kCustomPromisifyArgsSymbol = hasSymbols$5 ? Symbol('customPromisifyArgs') : null;
+
+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]';
+		error.code = 'ERR_INVALID_ARG_TYPE';
+		throw error;
+	}
+
+	if (hasSymbols$5 && orig[kCustomPromisifiedSymbol]) {
+		var customFunction = orig[kCustomPromisifiedSymbol];
+		if (typeof customFunction !== 'function') {
+			throw new TypeError('The [util.promisify.custom] property must be a function');
+		}
+		Object.defineProperty(customFunction, kCustomPromisifiedSymbol, {
+			configurable: true,
+			enumerable: false,
+			value: customFunction,
+			writable: false
+		});
+		return customFunction;
+	}
+
+	// Names to create an object from in case the callback receives multiple
+	// arguments, e.g. ['stdout', 'stderr'] for child_process.exec.
+	var argumentNames = orig[kCustomPromisifyArgsSymbol];
+
+	var promisified = function fn() {
+		var args = $slice(arguments);
+		var self = this; // eslint-disable-line no-invalid-this
+		return new Promise(function (resolve, reject) {
+			orig.apply(self, $concat$2(args, function (err) {
+				var values = arguments.length > 1 ? $slice(arguments, 1) : [];
+				if (err) {
+					reject(err);
+				} else if (typeof argumentNames !== 'undefined' && values.length > 1) {
+					var obj = {};
+					$forEach(argumentNames, function (name, index) {
+						obj[name] = values[index];
+					});
+					resolve(obj);
+				} else {
+					resolve(values[0]);
+				}
+			}));
+		});
+	};
+
+	promisified.__proto__ = orig.__proto__; // eslint-disable-line no-proto
+
+	Object.defineProperty(promisified, kCustomPromisifiedSymbol, {
+		configurable: true,
+		enumerable: false,
+		value: promisified,
+		writable: false
+	});
+	return Object.defineProperties(promisified, object_getownpropertydescriptors(orig));
+};
+
+var custom = kCustomPromisifiedSymbol;
+var customPromisifyArgs = kCustomPromisifyArgsSymbol;
+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$3;
+};
+
+var shim$1 = function shimUtilPromisify() {
+	var polyfill = polyfill$1();
+	if (polyfill !== util.util.promisify) {
+		Object.defineProperty(util.util, 'promisify', {
+			configurable: true,
+			enumerable: true,
+			value: polyfill,
+			writable: true
+		});
+	}
+	return polyfill;
+};
+
+var polyfill$2 = polyfill$1();
+
+
+/* eslint-disable no-unused-vars */
+var boundPromisify = function promisify(orig) {
+/* eslint-enable no-unused-vars */
+	return polyfill$2.apply(util.util, arguments);
+};
+defineProperties_1(boundPromisify, {
+	custom: polyfill$2.custom,
+	customPromisifyArgs: polyfill$2.customPromisifyArgs,
+	getPolyfill: polyfill$1,
+	implementation: implementation$3,
+	shim: shim$1
+});
+
+var util_promisify = boundPromisify;
+
+util_promisify.shim();
+
+function connect() {
+    var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+
+    if (!config) {
+        config = {
+            host: 'sanity-datasource.cluster-crao688bsrdh.us-east-1.rds.amazonaws.com',
+            user: 'nasp',
+            password: 'uRNkF9SkfXQs6AKK',
+            database: 'user'
+        };
+    }
+
+    var connection = mysql__default['default'].createConnection(config);
+    return {
+        query: function query(sql, args) {
+            return util.util.promisify(connection.query).call(connection, sql, args);
+        },
+        beginTransaction: function beginTransaction() {
+            return util.util.promisify(connection.beginTransaction).call(connection);
+        },
+        commit: function commit() {
+            return util.util.promisify(connection.commit).call(connection);
+        },
+        rollback: function rollback() {
+            return util.util.promisify(connection.rollback).call(connection);
+        },
+        close: function close() {
+            return util.util.promisify(connection.end).call(connection);
+        }
+    };
+}
+
+var db = connect;
+
+var crypt = _commonjsHelpers.createCommonjsModule(function (module) {
+(function() {
+  var base64map
+      = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',
+
+  crypt = {
+    // Bit-wise rotation left
+    rotl: function(n, b) {
+      return (n << b) | (n >>> (32 - b));
+    },
+
+    // Bit-wise rotation right
+    rotr: function(n, b) {
+      return (n << (32 - b)) | (n >>> b);
+    },
+
+    // Swap big-endian to little-endian and vice versa
+    endian: function(n) {
+      // If number given, swap endian
+      if (n.constructor == Number) {
+        return crypt.rotl(n, 8) & 0x00FF00FF | crypt.rotl(n, 24) & 0xFF00FF00;
+      }
+
+      // Else, assume array and swap all items
+      for (var i = 0; i < n.length; i++)
+        n[i] = crypt.endian(n[i]);
+      return n;
+    },
+
+    // Generate an array of any length of random bytes
+    randomBytes: function(n) {
+      for (var bytes = []; n > 0; n--)
+        bytes.push(Math.floor(Math.random() * 256));
+      return bytes;
+    },
+
+    // Convert a byte array to big-endian 32-bit words
+    bytesToWords: function(bytes) {
+      for (var words = [], i = 0, b = 0; i < bytes.length; i++, b += 8)
+        words[b >>> 5] |= bytes[i] << (24 - b % 32);
+      return words;
+    },
+
+    // Convert big-endian 32-bit words to a byte array
+    wordsToBytes: function(words) {
+      for (var bytes = [], b = 0; b < words.length * 32; b += 8)
+        bytes.push((words[b >>> 5] >>> (24 - b % 32)) & 0xFF);
+      return bytes;
+    },
+
+    // Convert a byte array to a hex string
+    bytesToHex: function(bytes) {
+      for (var hex = [], i = 0; i < bytes.length; i++) {
+        hex.push((bytes[i] >>> 4).toString(16));
+        hex.push((bytes[i] & 0xF).toString(16));
+      }
+      return hex.join('');
+    },
+
+    // Convert a hex string to a byte array
+    hexToBytes: function(hex) {
+      for (var bytes = [], c = 0; c < hex.length; c += 2)
+        bytes.push(parseInt(hex.substr(c, 2), 16));
+      return bytes;
+    },
+
+    // Convert a byte array to a base-64 string
+    bytesToBase64: function(bytes) {
+      for (var base64 = [], i = 0; i < bytes.length; i += 3) {
+        var triplet = (bytes[i] << 16) | (bytes[i + 1] << 8) | bytes[i + 2];
+        for (var j = 0; j < 4; j++)
+          if (i * 8 + j * 6 <= bytes.length * 8)
+            base64.push(base64map.charAt((triplet >>> 6 * (3 - j)) & 0x3F));
+          else
+            base64.push('=');
+      }
+      return base64.join('');
+    },
+
+    // Convert a base-64 string to a byte array
+    base64ToBytes: function(base64) {
+      // Remove non-base-64 characters
+      base64 = base64.replace(/[^A-Z0-9+\/]/ig, '');
+
+      for (var bytes = [], i = 0, imod4 = 0; i < base64.length;
+          imod4 = ++i % 4) {
+        if (imod4 == 0) continue;
+        bytes.push(((base64map.indexOf(base64.charAt(i - 1))
+            & (Math.pow(2, -2 * imod4 + 8) - 1)) << (imod4 * 2))
+            | (base64map.indexOf(base64.charAt(i)) >>> (6 - imod4 * 2)));
+      }
+      return bytes;
+    }
+  };
+
+  module.exports = crypt;
+})();
+});
+
+var charenc = {
+  // UTF-8 encoding
+  utf8: {
+    // Convert a string to a byte array
+    stringToBytes: function(str) {
+      return charenc.bin.stringToBytes(unescape(encodeURIComponent(str)));
+    },
+
+    // Convert a byte array to a string
+    bytesToString: function(bytes) {
+      return decodeURIComponent(escape(charenc.bin.bytesToString(bytes)));
+    }
+  },
+
+  // Binary encoding
+  bin: {
+    // Convert a string to a byte array
+    stringToBytes: function(str) {
+      for (var bytes = [], i = 0; i < str.length; i++)
+        bytes.push(str.charCodeAt(i) & 0xFF);
+      return bytes;
+    },
+
+    // Convert a byte array to a string
+    bytesToString: function(bytes) {
+      for (var str = [], i = 0; i < bytes.length; i++)
+        str.push(String.fromCharCode(bytes[i]));
+      return str.join('');
+    }
+  }
+};
+
+var charenc_1 = charenc;
+
+/*!
+ * Determine if an object is a Buffer
+ *
+ * @author   Feross Aboukhadijeh <https://feross.org>
+ * @license  MIT
+ */
+
+// The _isBuffer check is for Safari 5-7 support, because it's missing
+// Object.prototype.constructor. Remove this eventually
+var isBuffer_1 = function (obj) {
+  return obj != null && (isBuffer(obj) || isSlowBuffer(obj) || !!obj._isBuffer)
+};
+
+function isBuffer (obj) {
+  return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)
+}
+
+// For Node v0.10 support. Remove this eventually.
+function isSlowBuffer (obj) {
+  return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isBuffer(obj.slice(0, 0))
+}
+
+var md5 = _commonjsHelpers.createCommonjsModule(function (module) {
+(function(){
+  var crypt$1 = crypt,
+      utf8 = charenc_1.utf8,
+      isBuffer = isBuffer_1,
+      bin = charenc_1.bin,
+
+  // The core
+  md5 = function (message, options) {
+    // Convert to byte array
+    if (message.constructor == String)
+      if (options && options.encoding === 'binary')
+        message = bin.stringToBytes(message);
+      else
+        message = utf8.stringToBytes(message);
+    else if (isBuffer(message))
+      message = Array.prototype.slice.call(message, 0);
+    else if (!Array.isArray(message) && message.constructor !== Uint8Array)
+      message = message.toString();
+    // else, assume byte array already
+
+    var m = crypt$1.bytesToWords(message),
+        l = message.length * 8,
+        a =  1732584193,
+        b = -271733879,
+        c = -1732584194,
+        d =  271733878;
+
+    // Swap endian
+    for (var i = 0; i < m.length; i++) {
+      m[i] = ((m[i] <<  8) | (m[i] >>> 24)) & 0x00FF00FF |
+             ((m[i] << 24) | (m[i] >>>  8)) & 0xFF00FF00;
+    }
+
+    // Padding
+    m[l >>> 5] |= 0x80 << (l % 32);
+    m[(((l + 64) >>> 9) << 4) + 14] = l;
+
+    // Method shortcuts
+    var FF = md5._ff,
+        GG = md5._gg,
+        HH = md5._hh,
+        II = md5._ii;
+
+    for (var i = 0; i < m.length; i += 16) {
+
+      var aa = a,
+          bb = b,
+          cc = c,
+          dd = d;
+
+      a = FF(a, b, c, d, m[i+ 0],  7, -680876936);
+      d = FF(d, a, b, c, m[i+ 1], 12, -389564586);
+      c = FF(c, d, a, b, m[i+ 2], 17,  606105819);
+      b = FF(b, c, d, a, m[i+ 3], 22, -1044525330);
+      a = FF(a, b, c, d, m[i+ 4],  7, -176418897);
+      d = FF(d, a, b, c, m[i+ 5], 12,  1200080426);
+      c = FF(c, d, a, b, m[i+ 6], 17, -1473231341);
+      b = FF(b, c, d, a, m[i+ 7], 22, -45705983);
+      a = FF(a, b, c, d, m[i+ 8],  7,  1770035416);
+      d = FF(d, a, b, c, m[i+ 9], 12, -1958414417);
+      c = FF(c, d, a, b, m[i+10], 17, -42063);
+      b = FF(b, c, d, a, m[i+11], 22, -1990404162);
+      a = FF(a, b, c, d, m[i+12],  7,  1804603682);
+      d = FF(d, a, b, c, m[i+13], 12, -40341101);
+      c = FF(c, d, a, b, m[i+14], 17, -1502002290);
+      b = FF(b, c, d, a, m[i+15], 22,  1236535329);
+
+      a = GG(a, b, c, d, m[i+ 1],  5, -165796510);
+      d = GG(d, a, b, c, m[i+ 6],  9, -1069501632);
+      c = GG(c, d, a, b, m[i+11], 14,  643717713);
+      b = GG(b, c, d, a, m[i+ 0], 20, -373897302);
+      a = GG(a, b, c, d, m[i+ 5],  5, -701558691);
+      d = GG(d, a, b, c, m[i+10],  9,  38016083);
+      c = GG(c, d, a, b, m[i+15], 14, -660478335);
+      b = GG(b, c, d, a, m[i+ 4], 20, -405537848);
+      a = GG(a, b, c, d, m[i+ 9],  5,  568446438);
+      d = GG(d, a, b, c, m[i+14],  9, -1019803690);
+      c = GG(c, d, a, b, m[i+ 3], 14, -187363961);
+      b = GG(b, c, d, a, m[i+ 8], 20,  1163531501);
+      a = GG(a, b, c, d, m[i+13],  5, -1444681467);
+      d = GG(d, a, b, c, m[i+ 2],  9, -51403784);
+      c = GG(c, d, a, b, m[i+ 7], 14,  1735328473);
+      b = GG(b, c, d, a, m[i+12], 20, -1926607734);
+
+      a = HH(a, b, c, d, m[i+ 5],  4, -378558);
+      d = HH(d, a, b, c, m[i+ 8], 11, -2022574463);
+      c = HH(c, d, a, b, m[i+11], 16,  1839030562);
+      b = HH(b, c, d, a, m[i+14], 23, -35309556);
+      a = HH(a, b, c, d, m[i+ 1],  4, -1530992060);
+      d = HH(d, a, b, c, m[i+ 4], 11,  1272893353);
+      c = HH(c, d, a, b, m[i+ 7], 16, -155497632);
+      b = HH(b, c, d, a, m[i+10], 23, -1094730640);
+      a = HH(a, b, c, d, m[i+13],  4,  681279174);
+      d = HH(d, a, b, c, m[i+ 0], 11, -358537222);
+      c = HH(c, d, a, b, m[i+ 3], 16, -722521979);
+      b = HH(b, c, d, a, m[i+ 6], 23,  76029189);
+      a = HH(a, b, c, d, m[i+ 9],  4, -640364487);
+      d = HH(d, a, b, c, m[i+12], 11, -421815835);
+      c = HH(c, d, a, b, m[i+15], 16,  530742520);
+      b = HH(b, c, d, a, m[i+ 2], 23, -995338651);
+
+      a = II(a, b, c, d, m[i+ 0],  6, -198630844);
+      d = II(d, a, b, c, m[i+ 7], 10,  1126891415);
+      c = II(c, d, a, b, m[i+14], 15, -1416354905);
+      b = II(b, c, d, a, m[i+ 5], 21, -57434055);
+      a = II(a, b, c, d, m[i+12],  6,  1700485571);
+      d = II(d, a, b, c, m[i+ 3], 10, -1894986606);
+      c = II(c, d, a, b, m[i+10], 15, -1051523);
+      b = II(b, c, d, a, m[i+ 1], 21, -2054922799);
+      a = II(a, b, c, d, m[i+ 8],  6,  1873313359);
+      d = II(d, a, b, c, m[i+15], 10, -30611744);
+      c = II(c, d, a, b, m[i+ 6], 15, -1560198380);
+      b = II(b, c, d, a, m[i+13], 21,  1309151649);
+      a = II(a, b, c, d, m[i+ 4],  6, -145523070);
+      d = II(d, a, b, c, m[i+11], 10, -1120210379);
+      c = II(c, d, a, b, m[i+ 2], 15,  718787259);
+      b = II(b, c, d, a, m[i+ 9], 21, -343485551);
+
+      a = (a + aa) >>> 0;
+      b = (b + bb) >>> 0;
+      c = (c + cc) >>> 0;
+      d = (d + dd) >>> 0;
+    }
+
+    return crypt$1.endian([a, b, c, d]);
+  };
+
+  // Auxiliary functions
+  md5._ff  = function (a, b, c, d, x, s, t) {
+    var n = a + (b & c | ~b & d) + (x >>> 0) + t;
+    return ((n << s) | (n >>> (32 - s))) + b;
+  };
+  md5._gg  = function (a, b, c, d, x, s, t) {
+    var n = a + (b & d | c & ~d) + (x >>> 0) + t;
+    return ((n << s) | (n >>> (32 - s))) + b;
+  };
+  md5._hh  = function (a, b, c, d, x, s, t) {
+    var n = a + (b ^ c ^ d) + (x >>> 0) + t;
+    return ((n << s) | (n >>> (32 - s))) + b;
+  };
+  md5._ii  = function (a, b, c, d, x, s, t) {
+    var n = a + (c ^ (b | ~d)) + (x >>> 0) + t;
+    return ((n << s) | (n >>> (32 - s))) + b;
+  };
+
+  // Package private blocksize
+  md5._blocksize = 16;
+  md5._digestsize = 16;
+
+  module.exports = function (message, options) {
+    if (message === undefined || message === null)
+      throw new Error('Illegal argument ' + message);
+
+    var digestbytes = crypt$1.wordsToBytes(md5(message, options));
+    return options && options.asBytes ? digestbytes :
+        options && options.asString ? bin.bytesToString(digestbytes) :
+        crypt$1.bytesToHex(digestbytes);
+  };
+
+})();
+});
+
+var _this$3 = undefined;
+
+var config = {
+  host: 'sanity-datasource.cluster-crao688bsrdh.us-east-1.rds.amazonaws.com',
+  user: 'nasp',
+  password: 'uRNkF9SkfXQs6AKK',
+  database: 'user'
+};
+
+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;
+    return asyncToGenerator.regenerator.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            db$1 = null;
+            _context.prev = 1;
+
+
+            db$1 = db(config);
+
+            query = '\n      select * \n      from user \n      where trim(lower(email)) = ?\n    ';
+            _context.next = 6;
+            return db$1.query(query, [email.toLowerCase().trim()]);
+
+          case 6:
+            res = _context.sent;
+            user = res.length > 0 ? res[0] : null;
+
+            if (user) {
+              _context.next = 10;
+              break;
+            }
+
+            throw new Error('Invalid credential provided');
+
+          case 10:
+            if (!password) {
+              _context.next = 15;
+              break;
+            }
+
+            hash = md5(password);
+            passwordsMatch = hash === user.password;
+
+            if (passwordsMatch) {
+              _context.next = 15;
+              break;
+            }
+
+            throw new Error('Password doesn\'t match');
+
+          case 15:
+
+            query = '\n      select * \n      from user_shared \n      where user_id = ?\n    ';
+            _context.next = 18;
+            return db$1.query(query, [user.id]);
+
+          case 18:
+            res = _context.sent;
+            user_shared = res.length > 0 ? res[0] : null;
+
+            user.shared = user_shared;
+
+            // occupation 
+            query = '\n      select id \n      from occupation \n      where name = ?\n    ';
+            _context.next = 24;
+            return db$1.query(query, [user_shared.occupation]);
+
+          case 24:
+            res = _context.sent;
+            occupation_id = res.length > 0 ? res[0].id : '';
+
+            user.shared.occupation_id = occupation_id;
+
+            _context.next = 29;
+            return db$1.close();
+
+          case 29:
+            return _context.abrupt('return', {
+              error: '',
+              user: user
+            });
+
+          case 32:
+            _context.prev = 32;
+            _context.t0 = _context['catch'](1);
+
+            if (!db$1) {
+              _context.next = 37;
+              break;
+            }
+
+            _context.next = 37;
+            return db$1.close();
+
+          case 37:
+            return _context.abrupt('return', {
+              error: _context.t0.message,
+              user: null
+            });
+
+          case 38:
+          case 'end':
+            return _context.stop();
+        }
+      }
+    }, _callee, this, [[1, 32]]);
+  }));
+
+  return function findUser(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();
+
+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) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            db$1 = null;
+            _context2.prev = 1;
+
+
+            validateUserData(data);
+
+            db$1 = db(config);
+
+            _context2.next = 6;
+            return db$1.beginTransaction();
+
+          case 6:
+            if (data.user_id) {
+              _context2.next = 8;
+              break;
+            }
+
+            throw new Error('Please provide user ID');
+
+          case 8:
+
+            data.email = data.email.toLowerCase().trim();
+
+            // check if new email is taken
+            query = '\n      select * \n      from user \n      where lower(trim(email)) = ?\n      and id != ?\n    ';
+            _context2.next = 12;
+            return db$1.query(query, [data.email, data.user_id]);
+
+          case 12:
+            res = _context2.sent;
+
+            if (!(res && res.length > 0)) {
+              _context2.next = 15;
+              break;
+            }
+
+            throw new Error('Email already taken');
+
+          case 15:
+            if (!data.password) {
+              _context2.next = 23;
+              break;
+            }
+
+            hash = md5(data.password);
+
+            query = '\n        update user \n        set password = ?\n        where user_id = ?\n      ';
+            _context2.next = 20;
+            return db$1.query(query, [hash, data.user_id]);
+
+          case 20:
+            res = _context2.sent;
+
+            if (!(!res || res.affectedRows < 1)) {
+              _context2.next = 23;
+              break;
+            }
+
+            throw new Error('Failed to update password');
+
+          case 23:
+
+            query = 'show columns from user_shared';
+            _context2.next = 26;
+            return db$1.query(query);
+
+          case 26:
+            columns = _context2.sent;
+
+
+            for (i = 0; i < columns.length; i++) {
+              column = columns[i].Field;
+
+              if (typeof data[column] === 'undefined') {
+                data[column] = '';
+              }
+            }
+
+            // user_shared 
+            query = '\n      update user_shared\n      set \n        first_name = ?,\n        last_name = ?,\n        country = ?,\n        city = ?,\n        state = ?,\n        zip = ?,\n        phone = ?,\n        occupation = ?,\n        primary_specialty = ?,\n        area_of_practice = ?,\n        work_place = ?,\n        graduation_year = ?,\n        medical_school = ?,\n        npi = ?,\n        role = ?,\n        updated = current_timestamp\n      where user_id = ?\n    ';
+
+            _context2.next = 31;
+            return getOccupationNameById(db$1, data.occupation);
+
+          case 31:
+            occupation_name = _context2.sent;
+            _context2.next = 34;
+            return db$1.query(query, [data.first_name, data.last_name, data.country, data.city, data.state, data.zip, data.phone, occupation_name, data.primary_specialty, data.area_of_practice, data.work_place, data.graduation_year, data.medical_school, data.npi, data.role, data.user_id]);
+
+          case 34:
+            res = _context2.sent;
+
+            if (!(!res || res.affectedRows < 1)) {
+              _context2.next = 37;
+              break;
+            }
+
+            throw new Error('Failed to update user shared information record');
+
+          case 37:
+            _context2.next = 39;
+            return db$1.commit();
+
+          case 39:
+            _context2.next = 41;
+            return db$1.close();
+
+          case 41:
+
+            db$1 = null;
+
+            return _context2.abrupt('return', {
+              error: '',
+              user: findUser(data.email)
+            });
+
+          case 45:
+            _context2.prev = 45;
+            _context2.t0 = _context2['catch'](1);
+
+
+            console.log('error:', _context2.t0);
+
+            if (!db$1) {
+              _context2.next = 53;
+              break;
+            }
+
+            _context2.next = 51;
+            return db$1.rollback();
+
+          case 51:
+            _context2.next = 53;
+            return db$1.close();
+
+          case 53:
+            return _context2.abrupt('return', {
+              error: _context2.t0.message,
+              user: null
+            });
+
+          case 54:
+          case 'end':
+            return _context2.stop();
+        }
+      }
+    }, _callee2, this, [[1, 45]]);
+  }));
+
+  return function updateUser(_x3) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+
+var validateUserData = function validateUserData(data) {
+  var requirePassword = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+
+  if (!data.email) {
+    throw new Error('Email is required');
+  }
+
+  if (requirePassword && !data.password) {
+    throw new Error('Password is required');
+  }
+
+  if (data.password && data.password !== data.rpassword) {
+    throw new Error('Password does not match');
+  }
+
+  if (!data.first_name) {
+    throw new Error('First name is required');
+  }
+
+  if (!data.last_name) {
+    throw new Error('Last name is required');
+  }
+
+  if (!data.country) {
+    throw new Error('Country is required');
+  }
+
+  if (data.country === 'United States') {
+    if (!data.state) {
+      throw new Error('State is required');
+    }
+
+    if (!data.zip) {
+      throw new Error('Zip code is required');
+    }
+
+    if (!data.phone) {
+      throw new Error('Phone is required');
+    }
+  }
+};
+
+var getOccupationNameById = function () {
+  var _ref3 = asyncToGenerator._asyncToGenerator( /*#__PURE__*/asyncToGenerator.regenerator.mark(function _callee3(db, occupation_id) {
+    var query, res;
+    return asyncToGenerator.regenerator.wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            query = '\n    select name\n    from occupation \n    where id = ?\n  ';
+            _context3.next = 3;
+            return db.query(query, [occupation_id]);
+
+          case 3:
+            res = _context3.sent;
+
+            if (!(res && res.length > 0)) {
+              _context3.next = 6;
+              break;
+            }
+
+            return _context3.abrupt('return', res[0].name);
+
+          case 6:
+            throw new Error('Failed to get occupation name by ID: ' + occupation_id);
+
+          case 7:
+          case 'end':
+            return _context3.stop();
+        }
+      }
+    }, _callee3, _this$3);
+  }));
+
+  return function getOccupationNameById(_x5, _x6) {
+    return _ref3.apply(this, arguments);
+  };
+}();
+
+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) {
+      while (1) {
+        switch (_context4.prev = _context4.next) {
+          case 0:
+            db$1 = null;
+            _context4.prev = 1;
+
+
+            validateUserData(data, true);
+
+            db$1 = db(config);
+
+            _context4.next = 6;
+            return db$1.beginTransaction();
+
+          case 6:
+
+            data.email = data.email.toLowerCase().trim();
+
+            // check if user exists 
+            query = '\n      select * \n      from user \n      where lower(trim(email)) = ?\n    ';
+            _context4.next = 10;
+            return db$1.query(query, [data.email]);
+
+          case 10:
+            res = _context4.sent;
+
+            if (!(res && res.length > 0)) {
+              _context4.next = 13;
+              break;
+            }
+
+            throw new Error('User already exists');
+
+          case 13:
+            hash = md5(data.password);
+
+            // basic user info 
+
+            query = '\n      insert into user ( \n        email, password, created\n      ) values (\n        ?, ?, current_timestamp\n      )\n    ';
+            _context4.next = 17;
+            return db$1.query(query, [data.email, hash]);
+
+          case 17:
+            res = _context4.sent;
+
+            if (!(!res || res.insertId < 1)) {
+              _context4.next = 20;
+              break;
+            }
+
+            throw new Error('Failed to create user');
+
+          case 20:
+
+            query = 'show columns from user_shared';
+            _context4.next = 23;
+            return db$1.query(query);
+
+          case 23:
+            columns = _context4.sent;
+
+
+            for (i = 0; i < columns.length; i++) {
+              column = columns[i].Field;
+
+              if (typeof data[column] === 'undefined') {
+                data[column] = '';
+              }
+            }
+
+            user_id = res.insertId;
+
+            // user_shared 
+
+            query = '\n      insert into user_shared (\n        user_id, first_name, last_name, country, city, state, zip, phone, \n        occupation, primary_specialty, area_of_practice, work_place, graduation_year, medical_school, \n        npi, role, updated \n      ) values (\n        ?, ?, ?, ?, ?, ?, ?, ?,\n        ?, ?, ?, ?, ?, ?,\n        ?, ?, current_timestamp\n      )\n    ';
+
+            _context4.next = 29;
+            return getOccupationNameById(db$1, data.occupation);
+
+          case 29:
+            occupation_name = _context4.sent;
+            _context4.next = 32;
+            return db$1.query(query, [user_id, data.first_name, data.last_name, data.country, data.city, data.state, data.zip, data.phone, occupation_name, data.primary_specialty, data.area_of_practice, data.work_place, data.graduation_year, data.medical_school, data.npi, data.role]);
+
+          case 32:
+            res = _context4.sent;
+
+            if (!(!res || res.affectedRows < 1)) {
+              _context4.next = 35;
+              break;
+            }
+
+            throw new Error('Failed to create user shared information record');
+
+          case 35:
+            _context4.next = 37;
+            return db$1.commit();
+
+          case 37:
+            _context4.next = 39;
+            return db$1.close();
+
+          case 39:
+            return _context4.abrupt('return', {
+              error: '',
+              user: findUser(data.email)
+            });
+
+          case 42:
+            _context4.prev = 42;
+            _context4.t0 = _context4['catch'](1);
+
+            if (!db$1) {
+              _context4.next = 49;
+              break;
+            }
+
+            _context4.next = 47;
+            return db$1.rollback();
+
+          case 47:
+            _context4.next = 49;
+            return db$1.close();
+
+          case 49:
+            return _context4.abrupt('return', {
+              error: _context4.t0.message,
+              user: null
+            });
+
+          case 50:
+          case 'end':
+            return _context4.stop();
+        }
+      }
+    }, _callee4, this, [[1, 42]]);
+  }));
+
+  return function createUser(_x7) {
+    return _ref4.apply(this, arguments);
+  };
+}();
+
+var createUser$1 = function () {
+  var _ref = asyncToGenerator._asyncToGenerator( /*#__PURE__*/asyncToGenerator.regenerator.mark(function _callee(data) {
+    var res;
+    return asyncToGenerator.regenerator.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return createUser(data);
+
+          case 2:
+            res = _context.sent;
+
+            if (!res.error) {
+              _context.next = 5;
+              break;
+            }
+
+            throw new Error(res.error);
+
+          case 5:
+            return _context.abrupt('return', res.user);
+
+          case 6:
+          case 'end':
+            return _context.stop();
+        }
+      }
+    }, _callee, this);
+  }));
+
+  return function createUser(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();
+
+var updateUser$1 = function () {
+  var _ref2 = asyncToGenerator._asyncToGenerator( /*#__PURE__*/asyncToGenerator.regenerator.mark(function _callee2(data) {
+    var res;
+    return asyncToGenerator.regenerator.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            _context2.next = 2;
+            return updateUser(data);
+
+          case 2:
+            res = _context2.sent;
+
+            if (!res.error) {
+              _context2.next = 5;
+              break;
+            }
+
+            throw new Error(res.error);
+
+          case 5:
+            return _context2.abrupt('return', res.user);
+
+          case 6:
+          case 'end':
+            return _context2.stop();
+        }
+      }
+    }, _callee2, this);
+  }));
+
+  return function updateUser(_x2) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+
+var findUser$1 = function () {
+  var _ref3 = asyncToGenerator._asyncToGenerator( /*#__PURE__*/asyncToGenerator.regenerator.mark(function _callee3(_ref4) {
+    var email = _ref4.email,
+        password = _ref4.password;
+    var res;
+    return asyncToGenerator.regenerator.wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            _context3.next = 2;
+            return findUser(email, password);
+
+          case 2:
+            res = _context3.sent;
+
+            if (!res.error) {
+              _context3.next = 5;
+              break;
+            }
+
+            throw new Error(res.error);
+
+          case 5:
+            return _context3.abrupt('return', res.user);
+
+          case 6:
+          case 'end':
+            return _context3.stop();
+        }
+      }
+    }, _callee3, this);
+  }));
+
+  return function findUser(_x3) {
+    return _ref3.apply(this, arguments);
+  };
+}();
+
+var user = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  createUser: createUser$1,
+  updateUser: updateUser$1,
+  findUser: findUser$1
+});
+
+var localStrategy = new Local__default['default'].Strategy({
+  usernameField: 'email',
+  passwordField: 'password'
+}, function (email, password, done) {
+
+  findUser$1({ email: email, password: password }).then(function (user) {
+    done(null, user);
+  }).catch(function (error) {
+    done(error);
+  });
+});
+
+var passportLocal = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  localStrategy: localStrategy
+});
+
+var _this$4 = undefined;
+
+var config$1 = {
+  host: 'sanity-datasource.cluster-crao688bsrdh.us-east-1.rds.amazonaws.com',
+  user: 'nasp',
+  password: 'uRNkF9SkfXQs6AKK',
+  database: 'user'
+};
+
+var getOccupation = function () {
+  var _ref = asyncToGenerator._asyncToGenerator( /*#__PURE__*/asyncToGenerator.regenerator.mark(function _callee(type) {
+    var db$1, query, result;
+    return asyncToGenerator.regenerator.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            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]);
+
+          case 4:
+            result = _context.sent;
+            _context.next = 7;
+            return db$1.close();
+
+          case 7:
+            return _context.abrupt('return', result);
+
+          case 8:
+          case 'end':
+            return _context.stop();
+        }
+      }
+    }, _callee, _this$4);
+  }));
+
+  return function getOccupation(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();
+
+var getFieldsAndOptions = function () {
+  var _ref2 = asyncToGenerator._asyncToGenerator( /*#__PURE__*/asyncToGenerator.regenerator.mark(function _callee2(occupation) {
+    var db$1, query, result, i, field, optionQuery, options;
+    return asyncToGenerator.regenerator.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            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]);
+
+          case 4:
+            result = _context2.sent;
+            i = 0;
+
+          case 6:
+            if (!(i < result.length)) {
+              _context2.next = 17;
+              break;
+            }
+
+            field = result[i];
+
+            if (!(field.type === 'select')) {
+              _context2.next = 14;
+              break;
+            }
+
+            optionQuery = '\n        select * \n        from options\n        where list_id = ?\n        order by sorting\n      ';
+            _context2.next = 12;
+            return db$1.query(optionQuery, [field.list_id]);
+
+          case 12:
+            options = _context2.sent;
+
+            field.options = options ? options : [];
+
+          case 14:
+            i++;
+            _context2.next = 6;
+            break;
+
+          case 17:
+            _context2.next = 19;
+            return db$1.close();
+
+          case 19:
+            return _context2.abrupt('return', result);
+
+          case 20:
+          case 'end':
+            return _context2.stop();
+        }
+      }
+    }, _callee2, _this$4);
+  }));
+
+  return function getFieldsAndOptions(_x2) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+
+var ProcessData = (function () {
+  var _ref3 = asyncToGenerator._asyncToGenerator( /*#__PURE__*/asyncToGenerator.regenerator.mark(function _callee3(req, res) {
+    var action, data, type, occupation;
+    return asyncToGenerator.regenerator.wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            _context3.prev = 0;
+            action = req.body.action;
+            data = null;
+            _context3.t0 = action;
+            _context3.next = _context3.t0 === 'get-occupation' ? 6 : _context3.t0 === 'get-fields' ? 11 : 16;
+            break;
+
+          case 6:
+            type = req.body.type;
+            _context3.next = 9;
+            return getOccupation(type);
+
+          case 9:
+            data = _context3.sent;
+            return _context3.abrupt('break', 17);
+
+          case 11:
+            occupation = req.body.occupation;
+            _context3.next = 14;
+            return getFieldsAndOptions(occupation);
+
+          case 14:
+            data = _context3.sent;
+            return _context3.abrupt('break', 17);
+
+          case 16:
+            throw new Error('Invalid action: ' + action);
+
+          case 17:
+            return _context3.abrupt('return', res.json({
+              error: '',
+              data: data
+            }));
+
+          case 20:
+            _context3.prev = 20;
+            _context3.t1 = _context3['catch'](0);
+            return _context3.abrupt('return', res.json({
+              error: _context3.t1.message,
+              data: null
+            }));
+
+          case 23:
+          case 'end':
+            return _context3.stop();
+        }
+      }
+    }, _callee3, this, [[0, 20]]);
+  }));
+
+  return function (_x3, _x4) {
+    return _ref3.apply(this, arguments);
+  };
+})();
+
+var LoginForm_1 = LoginForm;
+var SignupForm_1 = SignupForm;
+var ProfileForm_1 = SignupForm$1;
+var AuthCookies_1 = authCookies;
+var AuthHooks_1 = hooks;
+var Iron_1 = iron;
+var PassportLocal_1 = passportLocal;
+var User_1 = user;
+var ProcessData_1 = ProcessData;
+
+var auth = {
+	LoginForm: LoginForm_1,
+	SignupForm: SignupForm_1,
+	ProfileForm: ProfileForm_1,
+	AuthCookies: AuthCookies_1,
+	AuthHooks: AuthHooks_1,
+	Iron: Iron_1,
+	PassportLocal: PassportLocal_1,
+	User: User_1,
+	ProcessData: ProcessData_1
+};
+
+exports.AuthCookies = AuthCookies_1;
+exports.AuthHooks = AuthHooks_1;
+exports.Iron = Iron_1;
+exports.LoginForm = LoginForm_1;
+exports.PassportLocal = PassportLocal_1;
+exports.ProcessData = ProcessData_1;
+exports.ProfileForm = ProfileForm_1;
+exports.SignupForm = SignupForm_1;
+exports.User = User_1;
+exports.default = auth;