@mjhls/mjh-framework 1.0.689 → 1.0.690

package/dist/esm/Auth.js

@@ -1,23 +1,24 @@
-import { a as commonjsGlobal, c as createCommonjsModule } from './_commonjsHelpers-0c4b6f40.js';
-import './_to-object-ded78eb9.js';
-import './es6.string.iterator-9b2af4a5.js';
-import './_library-528f1934.js';
-import './_iter-detect-59409a32.js';
-import './core.get-iterator-method-54d2e411.js';
-import './_object-pie-71ac75a4.js';
-import { _ as _extends } from './extends-cc5da797.js';
-import './web.dom.iterable-8956f9a5.js';
-import React__default, { useEffect, useState } from 'react';
+import { a as _asyncToGenerator, r as regenerator } from './asyncToGenerator-b0af4000.js';
+import { _ as _JSON$stringify } from './stringify-7c97a94d.js';
+import { _ as _slicedToArray, a as _getIterator } from './slicedToArray-648674b3.js';
+import React, { useEffect, useState } from 'react';
 import Router from 'next/router';
-import { _ as _JSON$stringify } from './stringify-008c8802.js';
-import { _ as _slicedToArray, a as _getIterator } from './slicedToArray-7021e5df.js';
-import { a as _asyncToGenerator, r as regenerator } from './asyncToGenerator-7c654f36.js';
-import './_set-species-cede29f8.js';
+import { _ as _extends } from './extends-03593dc6.js';
 import { Col, Form, Button, Spinner } from 'react-bootstrap';
-import { u as util } from './util-7700fc59.js';
 import useSWR from 'swr';
+import { s as serialize_1, p as parse_1 } from './index-db3bb315.js';
 import Local from 'passport-local';
 import mysql from 'mysql';
+import { u as util } from './util-7700fc59.js';
+import { a as commonjsGlobal, c as createCommonjsModule } from './_commonjsHelpers-0c4b6f40.js';
+import './es6.string.iterator-c5179428.js';
+import './_to-object-ee10dabb.js';
+import './web.dom.iterable-de3b4afb.js';
+import './_library-528f1934.js';
+import './core.get-iterator-method-0e6dc181.js';
+import './_set-species-09ba387c.js';
+import './_iter-detect-256a4d61.js';
+import './_object-pie-71ac75a4.js';
 
 var returnFormField = function returnFormField(_ref) {
   var name = _ref.name,
@@ -56,21 +57,21 @@ var returnFormField = function returnFormField(_ref) {
   }
 
   if (type == 'text' || type == 'email' || type == 'password' || type == 'number') {
-    return React__default.createElement(
+    return React.createElement(
       Form.Group,
       _extends({}, opts, { controlId: name }),
-      React__default.createElement(
+      React.createElement(
         Form.Label,
         { kye: name + '_label' },
         label,
-        required && React__default.createElement(
+        required && React.createElement(
           'span',
           { style: { color: 'red' } },
           '*'
         )
       ),
-      React__default.createElement(Form.Control, { key: name + '_' + type, type: type, readOnly: readonly, name: name, placeholder: '', defaultValue: default_value, required: required }),
-      React__default.createElement(
+      React.createElement(Form.Control, { key: name + '_' + type, type: type, readOnly: readonly, name: name, placeholder: '', defaultValue: default_value, required: required }),
+      React.createElement(
         Form.Control.Feedback,
         { key: name + '_feedback', type: 'invalid' },
         errors[name]
@@ -78,28 +79,28 @@ var returnFormField = function returnFormField(_ref) {
     );
   }
   if (type == 'select') {
-    return React__default.createElement(
+    return React.createElement(
       Form.Group,
       _extends({}, opts, { key: name, controlId: name }),
-      React__default.createElement(
+      React.createElement(
         Form.Label,
         { key: name + '_' + label },
         label,
-        required && React__default.createElement(
+        required && React.createElement(
           'span',
           { key: name + '_required_span', style: { color: 'red' } },
           '*'
         )
       ),
-      React__default.createElement(
+      React.createElement(
         Form.Control,
         { key: name + '_select', as: 'select', name: name, required: required, defaultValue: default_value },
-        React__default.createElement('option', { value: '', key: name + '_options_empty' }),
+        React.createElement('option', { value: '', key: name + '_options_empty' }),
         options.map(function (option, index) {
           var value = option.value ? option.value : option;
           var label = option.label ? option.label : option;
           var key = name + '_options_' + index;
-          return React__default.createElement(
+          return React.createElement(
             'option',
             { key: key, value: value },
             label
@@ -110,25 +111,25 @@ var returnFormField = function returnFormField(_ref) {
   }
 
   if (type == 'radio' || type == 'checkbox') {
-    return React__default.createElement(
+    return React.createElement(
       Form.Group,
       opts,
-      React__default.createElement(
+      React.createElement(
         Form.Label,
         null,
         label,
-        required && React__default.createElement(
+        required && React.createElement(
           'span',
           { style: { color: 'red' } },
           '*'
         )
       ),
       options.map(function (option, index) {
-        return React__default.createElement(
+        return React.createElement(
           Form.Check,
           { type: type, key: index, required: required },
-          React__default.createElement(Form.Check.Input, { type: type, key: type + '_' + index + '_input', defaultChecked: default_value ? default_value === option.value : false, name: name, id: name + '_' + index, value: option.value, required: required }),
-          React__default.createElement(Form.Check.Label, { style: { cursor: 'pointer' }, 'for': name + '_' + index, key: type + '_' + index + '_label', dangerouslySetInnerHTML: { __html: option.label } })
+          React.createElement(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.createElement(Form.Check.Label, { style: { cursor: 'pointer' }, 'for': name + '_' + index, key: type + '_' + index + '_label', dangerouslySetInnerHTML: { __html: option.label } })
         );
       })
     );
@@ -335,43 +336,43 @@ var LoginForm = function LoginForm(props) {
       loading = _useState4[0],
       setLoading = _useState4[1];
 
-  return React__default.createElement(
+  return React.createElement(
     Form,
     { className: 'login', onSubmit: handleSubmit },
-    React__default.createElement(
+    React.createElement(
       'h1',
       null,
       'Login'
     ),
-    React__default.createElement('hr', null),
+    React.createElement('hr', null),
     returnFormField({ name: 'email', label: 'Email', type: 'email', required: true }),
     returnFormField({ name: 'password', label: 'Password', type: 'password', required: true }),
-    React__default.createElement('hr', null),
-    React__default.createElement(
+    React.createElement('hr', null),
+    React.createElement(
       Form.Row,
       null,
-      React__default.createElement(
+      React.createElement(
         Form.Group,
         { as: Col },
-        React__default.createElement(
+        React.createElement(
           'a',
           { href: '/auth/signup' },
           'I don\'t have an account'
         )
       ),
-      React__default.createElement(
+      React.createElement(
         Form.Group,
         { as: Col, className: 'text-right' },
-        !loading && React__default.createElement(
+        !loading && React.createElement(
           Button,
           { type: 'submit' },
           'Login'
         ),
-        loading && React__default.createElement(
+        loading && React.createElement(
           Button,
           { variant: 'primary', disabled: true },
-          React__default.createElement(Spinner, { as: 'span', animation: 'border', role: 'status', 'aria-hidden': 'true', size: 'sm' }),
-          React__default.createElement(
+          React.createElement(Spinner, { as: 'span', animation: 'border', role: 'status', 'aria-hidden': 'true', size: 'sm' }),
+          React.createElement(
             'span',
             { className: 'sr-only' },
             'Loading...'
@@ -379,12 +380,12 @@ var LoginForm = function LoginForm(props) {
         )
       )
     ),
-    errorMsg && React__default.createElement(
+    errorMsg && React.createElement(
       'p',
       { className: 'error' },
       errorMsg
     ),
-    React__default.createElement(
+    React.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      '
@@ -640,29 +641,29 @@ var SignupForm = function SignupForm(props) {
       loading = _useState14[0],
       setLoading = _useState14[1];
 
-  return React__default.createElement(
+  return React.createElement(
     Form,
     { className: 'login', id: 'signupForm', onSubmit: handleSubmit },
-    React__default.createElement(
+    React.createElement(
       'h1',
       null,
       'Sign Up'
     ),
-    React__default.createElement('hr', null),
+    React.createElement('hr', null),
     returnFormField({ name: 'email', label: 'Email', type: 'email', required: true }),
-    React__default.createElement(
+    React.createElement(
       Form.Row,
       null,
       returnFormField({ name: 'password', label: 'Password', type: 'password', groupType: Col, required: true }),
       returnFormField({ name: 'rpassword', label: 'Retype Password', type: 'password', groupType: Col, required: true })
     ),
-    React__default.createElement(
+    React.createElement(
       Form.Row,
       null,
       returnFormField({ name: 'first_name', label: 'First Name', type: 'text', groupType: Col, required: true }),
       returnFormField({ name: 'last_name', label: 'Last Name', type: 'text', groupType: Col, required: true })
     ),
-    React__default.createElement(
+    React.createElement(
       Form.Row,
       null,
       returnFormField({
@@ -676,7 +677,7 @@ var SignupForm = function SignupForm(props) {
       }),
       countryUS && returnFormField({ name: 'state', label: 'State', type: 'select', required: true, groupType: Col, options: states })
     ),
-    React__default.createElement(
+    React.createElement(
       Form.Row,
       null,
       countryUS && returnFormField({ name: 'zip', label: 'Working Zip Code', type: 'text', required: true, groupType: Col }),
@@ -723,38 +724,38 @@ var SignupForm = function SignupForm(props) {
       required: true,
       options: [{ label: 'By registering you agree to our <a href="/terms" style="color:blue">Terms and Conditions</a> and <a href="/privacy" style="color:blue">Privacy Policy</a> and understand that you will be receiving email communications', value: 'Y' }]
     }),
-    React__default.createElement('hr', null),
-    React__default.createElement(
+    React.createElement('hr', null),
+    React.createElement(
       Form.Row,
       null,
-      React__default.createElement(
+      React.createElement(
         Form.Group,
         { as: Col },
-        React__default.createElement(
+        React.createElement(
           'a',
           { href: '/auth/login' },
           'I already have an account'
         )
       ),
-      React__default.createElement(
+      React.createElement(
         Form.Group,
         { as: Col, className: 'text-right' },
-        !loading && React__default.createElement(
+        !loading && React.createElement(
           Button,
           { type: 'submit' },
           'Sign Up'
         ),
-        loading && React__default.createElement(
+        loading && React.createElement(
           Button,
           { variant: 'primary', disabled: true },
-          React__default.createElement(Spinner, {
+          React.createElement(Spinner, {
             as: 'span',
             animation: 'border',
             role: 'status',
             'aria-hidden': 'true',
             size: 'sm'
           }),
-          React__default.createElement(
+          React.createElement(
             'span',
             { className: 'sr-only' },
             'Loading...'
@@ -762,12 +763,12 @@ var SignupForm = function SignupForm(props) {
         )
       )
     ),
-    errorMsg && React__default.createElement(
+    errorMsg && React.createElement(
       'p',
       { className: 'error' },
       errorMsg
     ),
-    React__default.createElement(
+    React.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      '
@@ -1057,32 +1058,32 @@ var SignupForm$1 = function SignupForm(props) {
       loading = _useState18[0],
       setLoading = _useState18[1];
 
-  return React__default.createElement(
+  return React.createElement(
     Form,
     { className: 'login', id: 'signupForm', onSubmit: handleSubmit },
-    React__default.createElement(
+    React.createElement(
       'h1',
       null,
       'Profile'
     ),
-    React__default.createElement('hr', null),
-    userData ? React__default.createElement(
-      React__default.Fragment,
+    React.createElement('hr', null),
+    userData ? React.createElement(
+      React.Fragment,
       null,
       returnFormField({ name: 'email', label: 'Email', type: 'email', required: true, readonly: true, default_value: userData.email }),
-      React__default.createElement(
+      React.createElement(
         Form.Row,
         null,
         returnFormField({ name: 'password', label: 'Password', type: 'password', groupType: Col, required: false }),
         returnFormField({ name: 'rpassword', label: 'Retype Password', type: 'password', groupType: Col, required: false })
       ),
-      React__default.createElement(
+      React.createElement(
         Form.Row,
         null,
         returnFormField({ name: 'first_name', label: 'First Name', type: 'text', groupType: Col, required: true, default_value: userData.shared.first_name }),
         returnFormField({ name: 'last_name', label: 'Last Name', type: 'text', groupType: Col, required: true, default_value: userData.shared.last_name })
       ),
-      React__default.createElement(
+      React.createElement(
         Form.Row,
         null,
         returnFormField({
@@ -1097,7 +1098,7 @@ var SignupForm$1 = function SignupForm(props) {
         }),
         countryUS && returnFormField({ name: 'state', label: 'State', type: 'select', required: true, groupType: Col, options: states, default_value: userData.shared.state })
       ),
-      React__default.createElement(
+      React.createElement(
         Form.Row,
         null,
         countryUS && returnFormField({ name: 'zip', label: 'Working Zip Code', type: 'text', required: true, groupType: Col, default_value: userData.shared.zip }),
@@ -1147,29 +1148,29 @@ var SignupForm$1 = function SignupForm(props) {
         required: true,
         options: [{ label: 'By registering you agree to our <a href="/terms">Terms and Conditions</a> and <a href="/privacy">Privacy Policy</a> and understand that you will be receiving email communications', value: 'Y' }]
       }),
-      React__default.createElement('hr', null),
-      React__default.createElement(
+      React.createElement('hr', null),
+      React.createElement(
         Form.Row,
         null,
-        React__default.createElement(
+        React.createElement(
           Form.Group,
           { as: Col },
-          !loading && React__default.createElement(
+          !loading && React.createElement(
             Button,
             { type: 'submit' },
             'Update'
           ),
-          loading && React__default.createElement(
+          loading && React.createElement(
             Button,
             { variant: 'primary', disabled: true },
-            React__default.createElement(Spinner, {
+            React.createElement(Spinner, {
               as: 'span',
               animation: 'border',
               role: 'status',
               'aria-hidden': 'true',
               size: 'sm'
             }),
-            React__default.createElement(
+            React.createElement(
               'span',
               { className: 'sr-only' },
               'Loading...'
@@ -1177,24 +1178,24 @@ var SignupForm$1 = function SignupForm(props) {
           )
         )
       )
-    ) : React__default.createElement(Spinner, {
+    ) : React.createElement(Spinner, {
       as: 'span',
       animation: 'border',
       role: 'status',
       'aria-hidden': 'true',
       size: 'sm'
     }),
-    errorMsg && React__default.createElement(
+    errorMsg && React.createElement(
       'p',
       { className: 'error' },
       errorMsg
     ),
-    successMsg && React__default.createElement(
+    successMsg && React.createElement(
       'p',
       { className: 'success' },
       successMsg
     ),
-    React__default.createElement(
+    React.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      '
@@ -1202,207 +1203,6 @@ var SignupForm$1 = function SignupForm(props) {
   );
 };
 
-/*!
- * cookie
- * Copyright(c) 2012-2014 Roman Shtylman
- * Copyright(c) 2015 Douglas Christopher Wilson
- * MIT Licensed
- */
-
-/**
- * Module exports.
- * @public
- */
-
-var parse_1 = parse;
-var serialize_1 = serialize;
-
-/**
- * Module variables.
- * @private
- */
-
-var decode = decodeURIComponent;
-var encode = encodeURIComponent;
-var pairSplitRegExp = /; */;
-
-/**
- * RegExp to match field-content in RFC 7230 sec 3.2
- *
- * field-content = field-vchar [ 1*( SP / HTAB ) field-vchar ]
- * field-vchar   = VCHAR / obs-text
- * obs-text      = %x80-FF
- */
-
-var fieldContentRegExp = /^[\u0009\u0020-\u007e\u0080-\u00ff]+$/;
-
-/**
- * Parse a cookie header.
- *
- * Parse the given cookie header string into an object
- * The object has the various cookies as keys(names) => values
- *
- * @param {string} str
- * @param {object} [options]
- * @return {object}
- * @public
- */
-
-function parse(str, options) {
-  if (typeof str !== 'string') {
-    throw new TypeError('argument str must be a string');
-  }
-
-  var obj = {};
-  var opt = options || {};
-  var pairs = str.split(pairSplitRegExp);
-  var dec = opt.decode || decode;
-
-  for (var i = 0; i < pairs.length; i++) {
-    var pair = pairs[i];
-    var eq_idx = pair.indexOf('=');
-
-    // skip things that don't look like key=value
-    if (eq_idx < 0) {
-      continue;
-    }
-
-    var key = pair.substr(0, eq_idx).trim();
-    var val = pair.substr(++eq_idx, pair.length).trim();
-
-    // quoted values
-    if ('"' == val[0]) {
-      val = val.slice(1, -1);
-    }
-
-    // only assign once
-    if (undefined == obj[key]) {
-      obj[key] = tryDecode(val, dec);
-    }
-  }
-
-  return obj;
-}
-
-/**
- * Serialize data into a cookie header.
- *
- * Serialize the a name value pair into a cookie string suitable for
- * http headers. An optional options object specified cookie parameters.
- *
- * serialize('foo', 'bar', { httpOnly: true })
- *   => "foo=bar; httpOnly"
- *
- * @param {string} name
- * @param {string} val
- * @param {object} [options]
- * @return {string}
- * @public
- */
-
-function serialize(name, val, options) {
-  var opt = options || {};
-  var enc = opt.encode || encode;
-
-  if (typeof enc !== 'function') {
-    throw new TypeError('option encode is invalid');
-  }
-
-  if (!fieldContentRegExp.test(name)) {
-    throw new TypeError('argument name is invalid');
-  }
-
-  var value = enc(val);
-
-  if (value && !fieldContentRegExp.test(value)) {
-    throw new TypeError('argument val is invalid');
-  }
-
-  var str = name + '=' + value;
-
-  if (null != opt.maxAge) {
-    var maxAge = opt.maxAge - 0;
-
-    if (isNaN(maxAge) || !isFinite(maxAge)) {
-      throw new TypeError('option maxAge is invalid')
-    }
-
-    str += '; Max-Age=' + Math.floor(maxAge);
-  }
-
-  if (opt.domain) {
-    if (!fieldContentRegExp.test(opt.domain)) {
-      throw new TypeError('option domain is invalid');
-    }
-
-    str += '; Domain=' + opt.domain;
-  }
-
-  if (opt.path) {
-    if (!fieldContentRegExp.test(opt.path)) {
-      throw new TypeError('option path is invalid');
-    }
-
-    str += '; Path=' + opt.path;
-  }
-
-  if (opt.expires) {
-    if (typeof opt.expires.toUTCString !== 'function') {
-      throw new TypeError('option expires is invalid');
-    }
-
-    str += '; Expires=' + opt.expires.toUTCString();
-  }
-
-  if (opt.httpOnly) {
-    str += '; HttpOnly';
-  }
-
-  if (opt.secure) {
-    str += '; Secure';
-  }
-
-  if (opt.sameSite) {
-    var sameSite = typeof opt.sameSite === 'string'
-      ? opt.sameSite.toLowerCase() : opt.sameSite;
-
-    switch (sameSite) {
-      case true:
-        str += '; SameSite=Strict';
-        break;
-      case 'lax':
-        str += '; SameSite=Lax';
-        break;
-      case 'strict':
-        str += '; SameSite=Strict';
-        break;
-      case 'none':
-        str += '; SameSite=None';
-        break;
-      default:
-        throw new TypeError('option sameSite is invalid');
-    }
-  }
-
-  return str;
-}
-
-/**
- * Try decoding a string using a decoding function.
- *
- * @param {string} str
- * @param {function} decode
- * @private
- */
-
-function tryDecode(str, decode) {
-  try {
-    return decode(str);
-  } catch (e) {
-    return str;
-  }
-}
-
 var TOKEN_NAME = 'token';
 var MAX_AGE = 60 * 60 * 8; // 8 hours
 
@@ -1737,6 +1537,59 @@ 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; }
@@ -1790,68 +1643,26 @@ var hasSymbols$1 = function hasNativeSymbols() {
 	return shams();
 };
 
-/* 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;
+var src = functionBind.call(Function.call, Object.prototype.hasOwnProperty);
 
 /* globals
-	Atomics,
+	AggregateError,
 	SharedArrayBuffer,
 */
 
 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 {
@@ -1861,7 +1672,9 @@ if ($gOPD) {
 	}
 }
 
-var throwTypeError = function () { throw new $TypeError(); };
+var throwTypeError = function () {
+	throw new $TypeError();
+};
 var ThrowTypeError = $gOPD
 	? (function () {
 		try {
@@ -1882,200 +1695,360 @@ var ThrowTypeError = $gOPD
 var hasSymbols$2 = hasSymbols$1();
 
 var getProto = Object.getPrototypeOf || function (x) { return x.__proto__; }; // eslint-disable-line no-proto
-var generatorFunction =  undefined$1;
-var asyncFunction =  undefined$1;
-var asyncGenFunction =  undefined$1;
+
+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,
-	'%ArrayBufferPrototype%': typeof ArrayBuffer === 'undefined' ? undefined$1 : ArrayBuffer.prototype,
 	'%ArrayIteratorPrototype%': hasSymbols$2 ? getProto([][Symbol.iterator]()) : undefined$1,
-	'%ArrayPrototype%': Array.prototype,
-	'%ArrayProto_entries%': Array.prototype.entries,
-	'%ArrayProto_forEach%': Array.prototype.forEach,
-	'%ArrayProto_keys%': Array.prototype.keys,
-	'%ArrayProto_values%': Array.prototype.values,
 	'%AsyncFromSyncIteratorPrototype%': undefined$1,
-	'%AsyncFunction%': asyncFunction,
-	'%AsyncFunctionPrototype%':  undefined$1,
-	'%AsyncGenerator%':  undefined$1,
-	'%AsyncGeneratorFunction%': asyncGenFunction,
-	'%AsyncGeneratorPrototype%':  undefined$1,
-	'%AsyncIteratorPrototype%':  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,
-	'%BooleanPrototype%': Boolean.prototype,
 	'%DataView%': typeof DataView === 'undefined' ? undefined$1 : DataView,
-	'%DataViewPrototype%': typeof DataView === 'undefined' ? undefined$1 : DataView.prototype,
 	'%Date%': Date,
-	'%DatePrototype%': Date.prototype,
 	'%decodeURI%': decodeURI,
 	'%decodeURIComponent%': decodeURIComponent,
 	'%encodeURI%': encodeURI,
 	'%encodeURIComponent%': encodeURIComponent,
 	'%Error%': Error,
-	'%ErrorPrototype%': Error.prototype,
 	'%eval%': eval, // eslint-disable-line no-eval
 	'%EvalError%': EvalError,
-	'%EvalErrorPrototype%': EvalError.prototype,
 	'%Float32Array%': typeof Float32Array === 'undefined' ? undefined$1 : Float32Array,
-	'%Float32ArrayPrototype%': typeof Float32Array === 'undefined' ? undefined$1 : Float32Array.prototype,
 	'%Float64Array%': typeof Float64Array === 'undefined' ? undefined$1 : Float64Array,
-	'%Float64ArrayPrototype%': typeof Float64Array === 'undefined' ? undefined$1 : Float64Array.prototype,
-	'%Function%': Function,
-	'%FunctionPrototype%': Function.prototype,
-	'%Generator%':  undefined$1,
-	'%GeneratorFunction%': generatorFunction,
-	'%GeneratorPrototype%':  undefined$1,
+	'%FinalizationRegistry%': typeof FinalizationRegistry === 'undefined' ? undefined$1 : FinalizationRegistry,
+	'%Function%': $Function,
+	'%GeneratorFunction%': needsEval,
 	'%Int8Array%': typeof Int8Array === 'undefined' ? undefined$1 : Int8Array,
-	'%Int8ArrayPrototype%': typeof Int8Array === 'undefined' ? undefined$1 : Int8Array.prototype,
 	'%Int16Array%': typeof Int16Array === 'undefined' ? undefined$1 : Int16Array,
-	'%Int16ArrayPrototype%': typeof Int16Array === 'undefined' ? undefined$1 : Int8Array.prototype,
 	'%Int32Array%': typeof Int32Array === 'undefined' ? undefined$1 : Int32Array,
-	'%Int32ArrayPrototype%': typeof Int32Array === 'undefined' ? undefined$1 : Int32Array.prototype,
 	'%isFinite%': isFinite,
 	'%isNaN%': isNaN,
 	'%IteratorPrototype%': hasSymbols$2 ? getProto(getProto([][Symbol.iterator]())) : undefined$1,
 	'%JSON%': typeof JSON === 'object' ? JSON : undefined$1,
-	'%JSONParse%': typeof JSON === 'object' ? JSON.parse : undefined$1,
 	'%Map%': typeof Map === 'undefined' ? undefined$1 : Map,
 	'%MapIteratorPrototype%': typeof Map === 'undefined' || !hasSymbols$2 ? undefined$1 : getProto(new Map()[Symbol.iterator]()),
-	'%MapPrototype%': typeof Map === 'undefined' ? undefined$1 : Map.prototype,
 	'%Math%': Math,
 	'%Number%': Number,
-	'%NumberPrototype%': Number.prototype,
 	'%Object%': Object,
-	'%ObjectPrototype%': Object.prototype,
-	'%ObjProto_toString%': Object.prototype.toString,
-	'%ObjProto_valueOf%': Object.prototype.valueOf,
 	'%parseFloat%': parseFloat,
 	'%parseInt%': parseInt,
 	'%Promise%': typeof Promise === 'undefined' ? undefined$1 : Promise,
-	'%PromisePrototype%': typeof Promise === 'undefined' ? undefined$1 : Promise.prototype,
-	'%PromiseProto_then%': typeof Promise === 'undefined' ? undefined$1 : Promise.prototype.then,
-	'%Promise_all%': typeof Promise === 'undefined' ? undefined$1 : Promise.all,
-	'%Promise_reject%': typeof Promise === 'undefined' ? undefined$1 : Promise.reject,
-	'%Promise_resolve%': typeof Promise === 'undefined' ? undefined$1 : Promise.resolve,
 	'%Proxy%': typeof Proxy === 'undefined' ? undefined$1 : Proxy,
 	'%RangeError%': RangeError,
-	'%RangeErrorPrototype%': RangeError.prototype,
 	'%ReferenceError%': ReferenceError,
-	'%ReferenceErrorPrototype%': ReferenceError.prototype,
 	'%Reflect%': typeof Reflect === 'undefined' ? undefined$1 : Reflect,
 	'%RegExp%': RegExp,
-	'%RegExpPrototype%': RegExp.prototype,
 	'%Set%': typeof Set === 'undefined' ? undefined$1 : Set,
 	'%SetIteratorPrototype%': typeof Set === 'undefined' || !hasSymbols$2 ? undefined$1 : getProto(new Set()[Symbol.iterator]()),
-	'%SetPrototype%': typeof Set === 'undefined' ? undefined$1 : Set.prototype,
 	'%SharedArrayBuffer%': typeof SharedArrayBuffer === 'undefined' ? undefined$1 : SharedArrayBuffer,
-	'%SharedArrayBufferPrototype%': typeof SharedArrayBuffer === 'undefined' ? undefined$1 : SharedArrayBuffer.prototype,
 	'%String%': String,
 	'%StringIteratorPrototype%': hasSymbols$2 ? getProto(''[Symbol.iterator]()) : undefined$1,
-	'%StringPrototype%': String.prototype,
 	'%Symbol%': hasSymbols$2 ? Symbol : undefined$1,
-	'%SymbolPrototype%': hasSymbols$2 ? Symbol.prototype : undefined$1,
-	'%SyntaxError%': SyntaxError,
-	'%SyntaxErrorPrototype%': SyntaxError.prototype,
+	'%SyntaxError%': $SyntaxError,
 	'%ThrowTypeError%': ThrowTypeError,
 	'%TypedArray%': TypedArray,
-	'%TypedArrayPrototype%': TypedArray ? TypedArray.prototype : undefined$1,
 	'%TypeError%': $TypeError,
-	'%TypeErrorPrototype%': $TypeError.prototype,
 	'%Uint8Array%': typeof Uint8Array === 'undefined' ? undefined$1 : Uint8Array,
-	'%Uint8ArrayPrototype%': typeof Uint8Array === 'undefined' ? undefined$1 : Uint8Array.prototype,
 	'%Uint8ClampedArray%': typeof Uint8ClampedArray === 'undefined' ? undefined$1 : Uint8ClampedArray,
-	'%Uint8ClampedArrayPrototype%': typeof Uint8ClampedArray === 'undefined' ? undefined$1 : Uint8ClampedArray.prototype,
 	'%Uint16Array%': typeof Uint16Array === 'undefined' ? undefined$1 : Uint16Array,
-	'%Uint16ArrayPrototype%': typeof Uint16Array === 'undefined' ? undefined$1 : Uint16Array.prototype,
 	'%Uint32Array%': typeof Uint32Array === 'undefined' ? undefined$1 : Uint32Array,
-	'%Uint32ArrayPrototype%': typeof Uint32Array === 'undefined' ? undefined$1 : Uint32Array.prototype,
 	'%URIError%': URIError,
-	'%URIErrorPrototype%': URIError.prototype,
 	'%WeakMap%': typeof WeakMap === 'undefined' ? undefined$1 : WeakMap,
-	'%WeakMapPrototype%': typeof WeakMap === 'undefined' ? undefined$1 : WeakMap.prototype,
-	'%WeakSet%': typeof WeakSet === 'undefined' ? undefined$1 : WeakSet,
-	'%WeakSetPrototype%': typeof WeakSet === 'undefined' ? undefined$1 : WeakSet.prototype
+	'%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);
+		result[result.length] = quote ? $replace(subString, reEscapeChar, '$1') : number || match;
 	});
 	return result;
 };
 /* end adaptation */
 
 var getBaseIntrinsic = function getBaseIntrinsic(name, allowMissing) {
-	if (!(name in INTRINSICS)) {
-		throw new SyntaxError('intrinsic ' + name + ' does not exist!');
+	var intrinsicName = name;
+	var alias;
+	if (src(LEGACY_ALIASES, intrinsicName)) {
+		alias = LEGACY_ALIASES[intrinsicName];
+		intrinsicName = '%' + alias[0] + '%';
 	}
 
-	// istanbul ignore if // hopefully this is impossible to test :-)
-	if (typeof INTRINSICS[name] === 'undefined' && !allowMissing) {
-		throw new $TypeError('intrinsic ' + name + ' exists, but is not available. Please file an issue!');
+	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
+		};
 	}
 
-	return INTRINSICS[name];
+	throw new $SyntaxError('intrinsic ' + name + ' does not exist!');
 };
 
-var GetIntrinsic = function GetIntrinsic(name, allowMissing) {
+var getIntrinsic = function GetIntrinsic(name, allowMissing) {
 	if (typeof name !== 'string' || name.length === 0) {
-		throw new TypeError('intrinsic name must be a non-empty string');
+		throw new $TypeError('intrinsic name must be a non-empty string');
 	}
 	if (arguments.length > 1 && typeof allowMissing !== 'boolean') {
-		throw new TypeError('"allowMissing" argument must be a boolean');
+		throw new $TypeError('"allowMissing" argument must be a boolean');
 	}
 
 	var parts = stringToPath(name);
+	var intrinsicBaseName = parts.length > 0 ? parts[0] : '';
 
-	var value = getBaseIntrinsic('%' + (parts.length > 0 ? parts[0] : '') + '%', allowMissing);
-	for (var i = 1; i < parts.length; i += 1) {
-		if (value != null) {
+	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, parts[i]);
-				value = desc ? (desc.get || desc.value) : value[parts[i]];
+				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 {
-				value = value[parts[i]];
+				isOwn = src(value, part);
+				value = value[part];
+			}
+
+			if (isOwn && !skipFurtherCaching) {
+				INTRINSICS[intrinsicRealName] = value;
 			}
 		}
 	}
 	return value;
 };
 
-var $Function = GetIntrinsic('%Function%');
-var $apply = $Function.apply;
-var $call = $Function.call;
+var callBind = 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;
+	}
+}
 
-var callBind = function callBind() {
-	return functionBind.apply($call, arguments);
+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 apply = function applyBind() {
-	return functionBind.apply($apply, arguments);
+var applyBind = function applyBind() {
+	return $reflectApply(functionBind, $apply, arguments);
 };
-callBind.apply = apply;
 
-var $indexOf = callBind(GetIntrinsic('String.prototype.indexOf'));
+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.')) {
+	var intrinsic = getIntrinsic(name, !!allowMissing);
+	if (typeof intrinsic === 'function' && $indexOf(name, '.prototype.') > -1) {
 		return callBind(intrinsic);
 	}
 	return intrinsic;
 };
 
-var $defineProperty = GetIntrinsic('%Object.defineProperty%');
+var $defineProperty = getIntrinsic('%Object.defineProperty%', true);
+
+if ($defineProperty) {
+	try {
+		$defineProperty({}, 'a', { value: 1 });
+	} catch (e) {
+		// IE 8 has a broken defineProperty
+		$defineProperty = null;
+	}
+}
 
 
 
@@ -2108,10 +2081,8 @@ var DefineOwnProperty = function DefineOwnProperty(IsDataDescriptor, SameValue,
 	return true;
 };
 
-var src = functionBind.call(Function.call, Object.prototype.hasOwnProperty);
-
-var $TypeError$1 = GetIntrinsic('%TypeError%');
-var $SyntaxError = GetIntrinsic('%SyntaxError%');
+var $TypeError$1 = getIntrinsic('%TypeError%');
+var $SyntaxError$1 = getIntrinsic('%SyntaxError%');
 
 
 
@@ -2148,14 +2119,14 @@ var predicates = {
 var assertRecord = function assertRecord(Type, recordType, argumentName, value) {
 	var predicate = predicates[recordType];
 	if (typeof predicate !== 'function') {
-		throw new $SyntaxError('unknown record type: ' + recordType);
+		throw new $SyntaxError$1('unknown record type: ' + recordType);
 	}
 	if (!predicate(Type, value)) {
 		throw new $TypeError$1(argumentName + ' must be a ' + recordType);
 	}
 };
 
-// https://www.ecma-international.org/ecma-262/5.1/#sec-8
+// https://ecma-international.org/ecma-262/5.1/#sec-8
 
 var Type = function Type(x) {
 	if (x === null) {
@@ -2178,16 +2149,19 @@ var Type = function Type(x) {
 	}
 };
 
-// https://www.ecma-international.org/ecma-262/6.0/#sec-tostring
+// 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://www.ecma-international.org/ecma-262/6.0/#sec-frompropertydescriptor
+// https://ecma-international.org/ecma-262/6.0/#sec-frompropertydescriptor
 
 var FromPropertyDescriptor = function FromPropertyDescriptor(Desc) {
 	if (typeof Desc === 'undefined') {
@@ -2218,7 +2192,278 @@ var FromPropertyDescriptor = function FromPropertyDescriptor(Desc) {
 	return obj;
 };
 
-// https://www.ecma-international.org/ecma-262/6.0/#sec-isdatadescriptor
+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 hasOwnProperty;
+var regexExec;
+var isRegexMarker;
+var badStringifier;
+
+if (hasToStringTag) {
+	hasOwnProperty = Function.call.bind(Object.prototype.hasOwnProperty);
+	regexExec = Function.call.bind(RegExp.prototype.exec);
+	isRegexMarker = {};
+
+	var throwRegexMarker = function () {
+		throw isRegexMarker;
+	};
+	badStringifier = {
+		toString: throwRegexMarker,
+		valueOf: throwRegexMarker
+	};
+
+	if (typeof Symbol.toPrimitive === 'symbol') {
+		badStringifier[Symbol.toPrimitive] = throwRegexMarker;
+	}
+}
+
+var toStr$5 = 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 && hasOwnProperty(descriptor, 'value');
+		if (!hasLastIndexDataProperty) {
+			return false;
+		}
+
+		try {
+			regexExec(value, badStringifier);
+		} catch (e) {
+			return e === isRegexMarker;
+		}
+	}
+	: function isRegex(value) {
+		// In older browsers, typeof regex incorrectly returns 'function'
+		if (!value || (typeof value !== 'object' && typeof value !== 'function')) {
+			return false;
+		}
+
+		return toStr$5.call(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$6 = Object.prototype.toString;
+var fnClass = '[object Function]';
+var genClass = '[object GeneratorFunction]';
+var hasToStringTag$1 = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol';
+
+var isCallable = reflectApply
+	? function isCallable(value) {
+		if (!value) { return false; }
+		if (typeof value !== 'function' && typeof value !== 'object') { return false; }
+		if (typeof value === 'function' && !value.prototype) { return true; }
+		try {
+			reflectApply(value, null, badArrayLike);
+		} catch (e) {
+			if (e !== isCallableMarker) { return false; }
+		}
+		return !isES6ClassFn(value);
+	}
+	: function isCallable(value) {
+		if (!value) { return false; }
+		if (typeof value !== 'function' && typeof value !== 'object') { return false; }
+		if (typeof value === 'function' && !value.prototype) { return true; }
+		if (hasToStringTag$1) { return tryFunctionObject(value); }
+		if (isES6ClassFn(value)) { return false; }
+		var strClass = toStr$6.call(value);
+		return strClass === fnClass || strClass === genClass;
+	};
+
+// http://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') {
@@ -2238,34 +2483,28 @@ var isPrimitive = function isPrimitive(value) {
 	return value === null || (typeof value !== 'function' && typeof value !== 'object');
 };
 
-var $Object = GetIntrinsic('%Object%');
+var $Object = getIntrinsic('%Object%');
 
 
 
 var $preventExtensions = $Object.preventExtensions;
 var $isExtensible = $Object.isExtensible;
 
-// https://www.ecma-international.org/ecma-262/6.0/#sec-isextensible-o
+// 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) { // eslint-disable-line no-unused-vars
-		return true;
+	: function IsExtensible(obj) {
+		return !isPrimitive(obj);
 	};
 
-// https://www.ecma-international.org/ecma-262/6.0/#sec-ispropertykey
-
-var IsPropertyKey = function IsPropertyKey(argument) {
-	return typeof argument === 'string' || typeof argument === 'symbol';
-};
-
 var _isNaN = Number.isNaN || function isNaN(a) {
 	return a !== a;
 };
 
-// http://www.ecma-international.org/ecma-262/5.1/#sec-9.12
+// 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.
@@ -2275,8 +2514,7 @@ var SameValue = function SameValue(x, y) {
 	return _isNaN(x) && _isNaN(y);
 };
 
-var $gOPD$1 = GetIntrinsic('%Object.getOwnPropertyDescriptor%');
-var $TypeError$2 = GetIntrinsic('%TypeError%');
+var $TypeError$4 = getIntrinsic('%TypeError%');
 
 
 
@@ -2287,18 +2525,19 @@ var $TypeError$2 = GetIntrinsic('%TypeError%');
 
 
 
-// https://www.ecma-international.org/ecma-262/6.0/#sec-createdataproperty
+
+// 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$2('Assertion failed: Type(O) is not Object');
+		throw new $TypeError$4('Assertion failed: Type(O) is not Object');
 	}
 	if (!IsPropertyKey(P)) {
-		throw new $TypeError$2('Assertion failed: IsPropertyKey(P) is not true');
+		throw new $TypeError$4('Assertion failed: IsPropertyKey(P) is not true');
 	}
-	var oldDesc = $gOPD$1(O, P);
-	var extensible = oldDesc || IsExtensible(O);
-	var immutable = oldDesc && (!oldDesc.writable || !oldDesc.configurable);
+	var oldDesc = OrdinaryGetOwnProperty(O, P);
+	var extensible = !oldDesc || IsExtensible(O);
+	var immutable = oldDesc && (!oldDesc['[[Writable]]'] || !oldDesc['[[Configurable]]']);
 	if (immutable || !extensible) {
 		return false;
 	}
@@ -2317,64 +2556,24 @@ var CreateDataProperty = function CreateDataProperty(O, P, V) {
 	);
 };
 
-var fnToStr = Function.prototype.toString;
-
-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 $TypeError$5 = getIntrinsic('%TypeError%');
 
-var tryFunctionObject = function tryFunctionToStr(value) {
-	try {
-		if (isES6ClassFn(value)) { return false; }
-		fnToStr.call(value);
-		return true;
-	} catch (e) {
-		return false;
-	}
-};
-var toStr$4 = Object.prototype.toString;
-var fnClass = '[object Function]';
-var genClass = '[object GeneratorFunction]';
-var hasToStringTag = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol';
-
-var isCallable = function isCallable(value) {
-	if (!value) { return false; }
-	if (typeof value !== 'function' && typeof value !== 'object') { return false; }
-	if (typeof value === 'function' && !value.prototype) { return true; }
-	if (hasToStringTag) { return tryFunctionObject(value); }
-	if (isES6ClassFn(value)) { return false; }
-	var strClass = toStr$4.call(value);
-	return strClass === fnClass || strClass === genClass;
-};
-
-// http://www.ecma-international.org/ecma-262/5.1/#sec-9.11
-
-var IsCallable = isCallable;
-
-var $TypeError$3 = GetIntrinsic('%TypeError%');
-
-// http://www.ecma-international.org/ecma-262/5.1/#sec-9.10
+// http://ecma-international.org/ecma-262/5.1/#sec-9.10
 
 var CheckObjectCoercible = function CheckObjectCoercible(value, optMessage) {
 	if (value == null) {
-		throw new $TypeError$3(optMessage || ('Cannot call method on ' + value));
+		throw new $TypeError$5(optMessage || ('Cannot call method on ' + value));
 	}
 	return value;
 };
 
 var RequireObjectCoercible = CheckObjectCoercible;
 
-var $Object$1 = GetIntrinsic('%Object%');
+var $Object$1 = getIntrinsic('%Object%');
 
 
 
-// https://www.ecma-international.org/ecma-262/6.0/#sec-toobject
+// https://ecma-international.org/ecma-262/6.0/#sec-toobject
 
 var ToObject = function ToObject(value) {
 	RequireObjectCoercible(value);
@@ -2384,10 +2583,10 @@ var ToObject = function ToObject(value) {
 var $gOPD$2 = Object.getOwnPropertyDescriptor;
 var $getOwnNames = Object.getOwnPropertyNames;
 var $getSymbols = Object.getOwnPropertySymbols;
-var $concat = callBound('Array.prototype.concat');
+var $concat$1 = callBound('Array.prototype.concat');
 var $reduce = callBound('Array.prototype.reduce');
 var getAll = $getSymbols ? function (obj) {
-	return $concat($getOwnNames(obj), $getSymbols(obj));
+	return $concat$1($getOwnNames(obj), $getSymbols(obj));
 } : $getOwnNames;
 
 var isES5 = IsCallable($gOPD$2) && IsCallable($getOwnNames);
@@ -2426,13 +2625,15 @@ var shim = function shimGetOwnPropertyDescriptors() {
 	return polyfill$1;
 };
 
-defineProperties_1(implementation$2, {
+var bound = callBind(polyfill(), Object);
+
+defineProperties_1(bound, {
 	getPolyfill: polyfill,
 	implementation: implementation$2,
 	shim: shim
 });
 
-var object_getownpropertydescriptors = implementation$2;
+var object_getownpropertydescriptors = bound;
 
 /* globals
 	Atomics,
@@ -2441,7 +2642,7 @@ var object_getownpropertydescriptors = implementation$2;
 
 var undefined$2;
 
-var $TypeError$4 = TypeError;
+var $TypeError$6 = TypeError;
 
 var $gOPD$3 = Object.getOwnPropertyDescriptor;
 if ($gOPD$3) {
@@ -2452,7 +2653,7 @@ if ($gOPD$3) {
 	}
 }
 
-var throwTypeError$1 = function () { throw new $TypeError$4(); };
+var throwTypeError$1 = function () { throw new $TypeError$6(); };
 var ThrowTypeError$1 = $gOPD$3
 	? (function () {
 		try {
@@ -2470,12 +2671,12 @@ var ThrowTypeError$1 = $gOPD$3
 	}())
 	: throwTypeError$1;
 
-var hasSymbols$3 = hasSymbols$1();
+var hasSymbols$4 = hasSymbols$1();
 
 var getProto$1 = Object.getPrototypeOf || function (x) { return x.__proto__; }; // eslint-disable-line no-proto
-var generatorFunction$1 =  undefined$2;
-var asyncFunction$1 =  undefined$2;
-var asyncGenFunction$1 =  undefined$2;
+var generatorFunction =  undefined$2;
+var asyncFunction =  undefined$2;
+var asyncGenFunction =  undefined$2;
 
 var TypedArray$1 = typeof Uint8Array === 'undefined' ? undefined$2 : getProto$1(Uint8Array);
 
@@ -2483,17 +2684,17 @@ var INTRINSICS$1 = {
 	'%Array%': Array,
 	'%ArrayBuffer%': typeof ArrayBuffer === 'undefined' ? undefined$2 : ArrayBuffer,
 	'%ArrayBufferPrototype%': typeof ArrayBuffer === 'undefined' ? undefined$2 : ArrayBuffer.prototype,
-	'%ArrayIteratorPrototype%': hasSymbols$3 ? getProto$1([][Symbol.iterator]()) : undefined$2,
+	'%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$1,
+	'%AsyncFunction%': asyncFunction,
 	'%AsyncFunctionPrototype%':  undefined$2,
 	'%AsyncGenerator%':  undefined$2,
-	'%AsyncGeneratorFunction%': asyncGenFunction$1,
+	'%AsyncGeneratorFunction%': asyncGenFunction,
 	'%AsyncGeneratorPrototype%':  undefined$2,
 	'%AsyncIteratorPrototype%':  undefined$2,
 	'%Atomics%': typeof Atomics === 'undefined' ? undefined$2 : Atomics,
@@ -2519,7 +2720,7 @@ var INTRINSICS$1 = {
 	'%Function%': Function,
 	'%FunctionPrototype%': Function.prototype,
 	'%Generator%':  undefined$2,
-	'%GeneratorFunction%': generatorFunction$1,
+	'%GeneratorFunction%': generatorFunction,
 	'%GeneratorPrototype%':  undefined$2,
 	'%Int8Array%': typeof Int8Array === 'undefined' ? undefined$2 : Int8Array,
 	'%Int8ArrayPrototype%': typeof Int8Array === 'undefined' ? undefined$2 : Int8Array.prototype,
@@ -2529,11 +2730,11 @@ var INTRINSICS$1 = {
 	'%Int32ArrayPrototype%': typeof Int32Array === 'undefined' ? undefined$2 : Int32Array.prototype,
 	'%isFinite%': isFinite,
 	'%isNaN%': isNaN,
-	'%IteratorPrototype%': hasSymbols$3 ? getProto$1(getProto$1([][Symbol.iterator]())) : undefined$2,
+	'%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$3 ? undefined$2 : getProto$1(new Map()[Symbol.iterator]()),
+	'%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,
@@ -2559,22 +2760,22 @@ var INTRINSICS$1 = {
 	'%RegExp%': RegExp,
 	'%RegExpPrototype%': RegExp.prototype,
 	'%Set%': typeof Set === 'undefined' ? undefined$2 : Set,
-	'%SetIteratorPrototype%': typeof Set === 'undefined' || !hasSymbols$3 ? undefined$2 : getProto$1(new Set()[Symbol.iterator]()),
+	'%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$3 ? getProto$1(''[Symbol.iterator]()) : undefined$2,
+	'%StringIteratorPrototype%': hasSymbols$4 ? getProto$1(''[Symbol.iterator]()) : undefined$2,
 	'%StringPrototype%': String.prototype,
-	'%Symbol%': hasSymbols$3 ? Symbol : undefined$2,
-	'%SymbolPrototype%': hasSymbols$3 ? Symbol.prototype : undefined$2,
+	'%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$4,
-	'%TypeErrorPrototype%': $TypeError$4.prototype,
+	'%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,
@@ -2613,13 +2814,13 @@ var getBaseIntrinsic$1 = function getBaseIntrinsic(name, allowMissing) {
 
 	// istanbul ignore if // hopefully this is impossible to test :-)
 	if (typeof INTRINSICS$1[name] === 'undefined' && !allowMissing) {
-		throw new $TypeError$4('intrinsic ' + name + ' exists, but is not available. Please file an issue!');
+		throw new $TypeError$6('intrinsic ' + name + ' exists, but is not available. Please file an issue!');
 	}
 
 	return INTRINSICS$1[name];
 };
 
-var GetIntrinsic$1 = function GetIntrinsic(name, allowMissing) {
+var GetIntrinsic = function GetIntrinsic(name, allowMissing) {
 	if (typeof name !== 'string' || name.length === 0) {
 		throw new TypeError('intrinsic name must be a non-empty string');
 	}
@@ -2635,9 +2836,16 @@ var GetIntrinsic$1 = function GetIntrinsic(name, allowMissing) {
 			if ($gOPD$3 && (i + 1) >= parts.length) {
 				var desc = $gOPD$3(value, parts[i]);
 				if (!allowMissing && !(parts[i] in value)) {
-					throw new $TypeError$4('base intrinsic for ' + name + ' exists, but the property is not available.');
+					throw new $TypeError$6('base intrinsic for ' + name + ' exists, but the property is not available.');
 				}
-				value = desc ? (desc.get || desc.value) : value[parts[i]];
+				// 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]];
 			}
@@ -2646,23 +2854,47 @@ var GetIntrinsic$1 = function GetIntrinsic(name, allowMissing) {
 	return value;
 };
 
-var $apply$1 = GetIntrinsic$1('%Function.prototype.apply%');
-var $call$1 = GetIntrinsic$1('%Function.prototype.call%');
-var $reflectApply = GetIntrinsic$1('%Reflect.apply%', true) || functionBind.call($call$1, $apply$1);
+var callBind$1 = createCommonjsModule(function (module) {
+
+
 
-var callBind$1 = function callBind() {
-	return $reflectApply(functionBind, $call$1, arguments);
+
+
+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 apply$1 = function applyBind() {
-	return $reflectApply(functionBind, $apply$1, arguments);
+var applyBind = function applyBind() {
+	return $reflectApply(functionBind, $apply, arguments);
 };
-callBind$1.apply = apply$1;
 
-var $indexOf$1 = callBind$1(GetIntrinsic$1('String.prototype.indexOf'));
+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$1(name, !!allowMissing);
+	var intrinsic = GetIntrinsic(name, !!allowMissing);
 	if (typeof intrinsic === 'function' && $indexOf$1(name, '.prototype.')) {
 		return callBind$1(intrinsic);
 	}
@@ -2687,13 +2919,13 @@ if (typeof Promise !== 'function') {
 
 
 var $slice = callBound$1('Array.prototype.slice');
-var $concat$1 = callBound$1('Array.prototype.concat');
+var $concat$2 = callBound$1('Array.prototype.concat');
 var $forEach = callBound$1('Array.prototype.forEach');
 
-var hasSymbols$4 = hasSymbols$1();
+var hasSymbols$5 = hasSymbols$1();
 
-var kCustomPromisifiedSymbol = hasSymbols$4 ? Symbol('util.promisify.custom') : null;
-var kCustomPromisifyArgsSymbol = hasSymbols$4 ? Symbol('customPromisifyArgs') : null;
+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') {
@@ -2703,7 +2935,7 @@ var implementation$3 = function promisify(orig) {
 		throw error;
 	}
 
-	if (hasSymbols$4 && orig[kCustomPromisifiedSymbol]) {
+	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');
@@ -2725,7 +2957,7 @@ var implementation$3 = function promisify(orig) {
 		var args = $slice(arguments);
 		var self = this; // eslint-disable-line no-invalid-this
 		return new Promise(function (resolve, reject) {
-			orig.apply(self, $concat$1(args, function (err) {
+			orig.apply(self, $concat$2(args, function (err) {
 				var values = arguments.length > 1 ? $slice(arguments, 1) : [];
 				if (err) {
 					reject(err);
@@ -3004,7 +3236,7 @@ var md5 = createCommonjsModule(function (module) {
         message = utf8.stringToBytes(message);
     else if (isBuffer(message))
       message = Array.prototype.slice.call(message, 0);
-    else if (!Array.isArray(message))
+    else if (!Array.isArray(message) && message.constructor !== Uint8Array)
       message = message.toString();
     // else, assume byte array already