adapt-authoring-ui 0.0.1

package/app/libraries/polyglot.min.js

@@ -0,0 +1,2922 @@
+/**
+ * Build using Browserify from v2.4.2
+ */
+(function (f) { if (typeof exports === "object" && typeof module !== "undefined") { module.exports = f() } else if (typeof define === "function" && define.amd) { define([], f) } else { var g; if (typeof window !== "undefined") { g = window } else if (typeof global !== "undefined") { g = global } else if (typeof self !== "undefined") { g = self } else { g = this } g.moduleName = f() } })(function () {
+  var define, module, exports; return (function () { function r(e, n, t) { function o(i, f) { if (!n[i]) { if (!e[i]) { var c = "function" == typeof require && require; if (!f && c) return c(i, !0); if (u) return u(i, !0); var a = new Error("Cannot find module '" + i + "'"); throw a.code = "MODULE_NOT_FOUND", a } var p = n[i] = { exports: {} }; e[i][0].call(p.exports, function (r) { var n = e[i][1][r]; return o(n || r) }, p, p.exports, r, e, n, t) } return n[i].exports } for (var u = "function" == typeof require && require, i = 0; i < t.length; i++)o(t[i]); return o } return r })()({
+    1: [function (require, module, exports) {
+
+    }, {}], 2: [function (require, module, exports) {
+      //     (c) 2012-2018 Airbnb, Inc.
+      //
+      //     polyglot.js may be freely distributed under the terms of the BSD
+      //     license. For all licensing information, details, and documentation:
+      //     http://airbnb.github.com/polyglot.js
+      //
+      //
+      // Polyglot.js is an I18n helper library written in JavaScript, made to
+      // work both in the browser and in Node. It provides a simple solution for
+      // interpolation and pluralization, based off of Airbnb's
+      // experience adding I18n functionality to its Backbone.js and Node apps.
+      //
+      // Polylglot is agnostic to your translation backend. It doesn't perform any
+      // translation; it simply gives you a way to manage translated phrases from
+      // your client- or server-side JavaScript application.
+      //
+
+      'use strict';
+
+      var forEach = require('array.prototype.foreach');
+      var entries = require('object.entries');
+      var warning = require('warning');
+      var has = require('has');
+      var trim = require('string.prototype.trim');
+
+      var warn = function warn(message) {
+        warning(false, message);
+      };
+
+      var defaultReplace = String.prototype.replace;
+      var split = String.prototype.split;
+
+      // #### Pluralization methods
+      // The string that separates the different phrase possibilities.
+      var delimiter = '||||';
+
+      var russianPluralGroups = function (n) {
+        var lastTwo = n % 100;
+        var end = lastTwo % 10;
+        if (lastTwo !== 11 && end === 1) {
+          return 0;
+        }
+        if (2 <= end && end <= 4 && !(lastTwo >= 12 && lastTwo <= 14)) {
+          return 1;
+        }
+        return 2;
+      };
+
+      var defaultPluralRules = {
+        // Mapping from pluralization group plural logic.
+        pluralTypes: {
+          arabic: function (n) {
+            // http://www.arabeyes.org/Plural_Forms
+            if (n < 3) { return n; }
+            var lastTwo = n % 100;
+            if (lastTwo >= 3 && lastTwo <= 10) return 3;
+            return lastTwo >= 11 ? 4 : 5;
+          },
+          bosnian_serbian: russianPluralGroups,
+          chinese: function () { return 0; },
+          croatian: russianPluralGroups,
+          french: function (n) { return n >= 2 ? 1 : 0; },
+          german: function (n) { return n !== 1 ? 1 : 0; },
+          russian: russianPluralGroups,
+          lithuanian: function (n) {
+            if (n % 10 === 1 && n % 100 !== 11) { return 0; }
+            return n % 10 >= 2 && n % 10 <= 9 && (n % 100 < 11 || n % 100 > 19) ? 1 : 2;
+          },
+          czech: function (n) {
+            if (n === 1) { return 0; }
+            return (n >= 2 && n <= 4) ? 1 : 2;
+          },
+          polish: function (n) {
+            if (n === 1) { return 0; }
+            var end = n % 10;
+            return 2 <= end && end <= 4 && (n % 100 < 10 || n % 100 >= 20) ? 1 : 2;
+          },
+          icelandic: function (n) { return (n % 10 !== 1 || n % 100 === 11) ? 1 : 0; },
+          slovenian: function (n) {
+            var lastTwo = n % 100;
+            if (lastTwo === 1) {
+              return 0;
+            }
+            if (lastTwo === 2) {
+              return 1;
+            }
+            if (lastTwo === 3 || lastTwo === 4) {
+              return 2;
+            }
+            return 3;
+          },
+          romanian: function (n) {
+            if (n === 1) { return 0; }
+            var lastTwo = n % 100;
+            if (n === 0 || (lastTwo >= 2 && lastTwo <= 19)) { return 1; }
+            return 2;
+          }
+        },
+
+        // Mapping from pluralization group to individual language codes/locales.
+        // Will look up based on exact match, if not found and it's a locale will parse the locale
+        // for language code, and if that does not exist will default to 'en'
+        pluralTypeToLanguages: {
+          arabic: ['ar'],
+          bosnian_serbian: ['bs-Latn-BA', 'bs-Cyrl-BA', 'srl-RS', 'sr-RS'],
+          chinese: ['id', 'id-ID', 'ja', 'ko', 'ko-KR', 'lo', 'ms', 'th', 'th-TH', 'zh'],
+          croatian: ['hr', 'hr-HR'],
+          german: ['fa', 'da', 'de', 'en', 'es', 'fi', 'el', 'he', 'hi-IN', 'hu', 'hu-HU', 'it', 'nl', 'no', 'pt', 'sv', 'tr'],
+          french: ['fr', 'tl', 'pt-br'],
+          russian: ['ru', 'ru-RU'],
+          lithuanian: ['lt'],
+          czech: ['cs', 'cs-CZ', 'sk'],
+          polish: ['pl'],
+          icelandic: ['is', 'mk'],
+          slovenian: ['sl-SL'],
+          romanian: ['ro']
+        }
+      };
+
+      function langToTypeMap(mapping) {
+        var ret = {};
+        forEach(entries(mapping), function (entry) {
+          var type = entry[0];
+          var langs = entry[1];
+          forEach(langs, function (lang) {
+            ret[lang] = type;
+          });
+        });
+        return ret;
+      }
+
+      function pluralTypeName(pluralRules, locale) {
+        var langToPluralType = langToTypeMap(pluralRules.pluralTypeToLanguages);
+        return langToPluralType[locale]
+          || langToPluralType[split.call(locale, /-/, 1)[0]]
+          || langToPluralType.en;
+      }
+
+      function pluralTypeIndex(pluralRules, pluralType, count) {
+        return pluralRules.pluralTypes[pluralType](count);
+      }
+
+      function createMemoizedPluralTypeNameSelector() {
+        var localePluralTypeStorage = {};
+
+        return function (pluralRules, locale) {
+          var pluralType = localePluralTypeStorage[locale];
+
+          if (pluralType && !pluralRules.pluralTypes[pluralType]) {
+            pluralType = null;
+            localePluralTypeStorage[locale] = pluralType;
+          }
+
+          if (!pluralType) {
+            pluralType = pluralTypeName(pluralRules, locale);
+
+            if (pluralType) {
+              localePluralTypeStorage[locale] = pluralType;
+            }
+          }
+
+          return pluralType;
+        };
+      }
+
+      function escape(token) {
+        return token.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+      }
+
+      function constructTokenRegex(opts) {
+        var prefix = (opts && opts.prefix) || '%{';
+        var suffix = (opts && opts.suffix) || '}';
+
+        if (prefix === delimiter || suffix === delimiter) {
+          throw new RangeError('"' + delimiter + '" token is reserved for pluralization');
+        }
+
+        return new RegExp(escape(prefix) + '(.*?)' + escape(suffix), 'g');
+      }
+
+      var memoizedPluralTypeName = createMemoizedPluralTypeNameSelector();
+
+      var defaultTokenRegex = /%\{(.*?)\}/g;
+
+      // ### transformPhrase(phrase, substitutions, locale)
+      //
+      // Takes a phrase string and transforms it by choosing the correct
+      // plural form and interpolating it.
+      //
+      //     transformPhrase('Hello, %{name}!', {name: 'Spike'});
+      //     // "Hello, Spike!"
+      //
+      // The correct plural form is selected if substitutions.smart_count
+      // is set. You can pass in a number instead of an Object as `substitutions`
+      // as a shortcut for `smart_count`.
+      //
+      //     transformPhrase('%{smart_count} new messages |||| 1 new message', {smart_count: 1}, 'en');
+      //     // "1 new message"
+      //
+      //     transformPhrase('%{smart_count} new messages |||| 1 new message', {smart_count: 2}, 'en');
+      //     // "2 new messages"
+      //
+      //     transformPhrase('%{smart_count} new messages |||| 1 new message', 5, 'en');
+      //     // "5 new messages"
+      //
+      // You should pass in a third argument, the locale, to specify the correct plural type.
+      // It defaults to `'en'` with 2 plural forms.
+      function transformPhrase(
+        phrase,
+        substitutions,
+        locale,
+        tokenRegex,
+        pluralRules,
+        replaceImplementation
+      ) {
+        if (typeof phrase !== 'string') {
+          throw new TypeError('Polyglot.transformPhrase expects argument #1 to be string');
+        }
+
+        if (substitutions == null) {
+          return phrase;
+        }
+
+        var result = phrase;
+        var interpolationRegex = tokenRegex || defaultTokenRegex;
+        var replace = replaceImplementation || defaultReplace;
+
+        // allow number as a pluralization shortcut
+        var options = typeof substitutions === 'number' ? { smart_count: substitutions } : substitutions;
+
+        // Select plural form: based on a phrase text that contains `n`
+        // plural forms separated by `delimiter`, a `locale`, and a `substitutions.smart_count`,
+        // choose the correct plural form. This is only done if `count` is set.
+        if (options.smart_count != null && phrase) {
+          var pluralRulesOrDefault = pluralRules || defaultPluralRules;
+          var texts = split.call(phrase, delimiter);
+          var bestLocale = locale || 'en';
+          var pluralType = memoizedPluralTypeName(pluralRulesOrDefault, bestLocale);
+          var pluralTypeWithCount = pluralTypeIndex(
+            pluralRulesOrDefault,
+            pluralType,
+            options.smart_count
+          );
+
+          result = trim(texts[pluralTypeWithCount] || texts[0]);
+        }
+
+        // Interpolate: Creates a `RegExp` object for each interpolation placeholder.
+        result = replace.call(result, interpolationRegex, function (expression, argument) {
+          if (!has(options, argument) || options[argument] == null) { return expression; }
+          return options[argument];
+        });
+
+        return result;
+      }
+
+      // ### Polyglot class constructor
+      function Polyglot(options) {
+        var opts = options || {};
+        this.phrases = {};
+        this.extend(opts.phrases || {});
+        this.currentLocale = opts.locale || 'en';
+        var allowMissing = opts.allowMissing ? transformPhrase : null;
+        this.onMissingKey = typeof opts.onMissingKey === 'function' ? opts.onMissingKey : allowMissing;
+        this.warn = opts.warn || warn;
+        this.replaceImplementation = opts.replace || defaultReplace;
+        this.tokenRegex = constructTokenRegex(opts.interpolation);
+        this.pluralRules = opts.pluralRules || defaultPluralRules;
+      }
+
+      // ### polyglot.locale([locale])
+      //
+      // Get or set locale. Internally, Polyglot only uses locale for pluralization.
+      Polyglot.prototype.locale = function (newLocale) {
+        if (newLocale) this.currentLocale = newLocale;
+        return this.currentLocale;
+      };
+
+      // ### polyglot.extend(phrases)
+      //
+      // Use `extend` to tell Polyglot how to translate a given key.
+      //
+      //     polyglot.extend({
+      //       "hello": "Hello",
+      //       "hello_name": "Hello, %{name}"
+      //     });
+      //
+      // The key can be any string.  Feel free to call `extend` multiple times;
+      // it will override any phrases with the same key, but leave existing phrases
+      // untouched.
+      //
+      // It is also possible to pass nested phrase objects, which get flattened
+      // into an object with the nested keys concatenated using dot notation.
+      //
+      //     polyglot.extend({
+      //       "nav": {
+      //         "hello": "Hello",
+      //         "hello_name": "Hello, %{name}",
+      //         "sidebar": {
+      //           "welcome": "Welcome"
+      //         }
+      //       }
+      //     });
+      //
+      //     console.log(polyglot.phrases);
+      //     // {
+      //     //   'nav.hello': 'Hello',
+      //     //   'nav.hello_name': 'Hello, %{name}',
+      //     //   'nav.sidebar.welcome': 'Welcome'
+      //     // }
+      //
+      // `extend` accepts an optional second argument, `prefix`, which can be used
+      // to prefix every key in the phrases object with some string, using dot
+      // notation.
+      //
+      //     polyglot.extend({
+      //       "hello": "Hello",
+      //       "hello_name": "Hello, %{name}"
+      //     }, "nav");
+      //
+      //     console.log(polyglot.phrases);
+      //     // {
+      //     //   'nav.hello': 'Hello',
+      //     //   'nav.hello_name': 'Hello, %{name}'
+      //     // }
+      //
+      // This feature is used internally to support nested phrase objects.
+      Polyglot.prototype.extend = function (morePhrases, prefix) {
+        forEach(entries(morePhrases || {}), function (entry) {
+          var key = entry[0];
+          var phrase = entry[1];
+          var prefixedKey = prefix ? prefix + '.' + key : key;
+          if (typeof phrase === 'object') {
+            this.extend(phrase, prefixedKey);
+          } else {
+            this.phrases[prefixedKey] = phrase;
+          }
+        }, this);
+      };
+
+      // ### polyglot.unset(phrases)
+      // Use `unset` to selectively remove keys from a polyglot instance.
+      //
+      //     polyglot.unset("some_key");
+      //     polyglot.unset({
+      //       "hello": "Hello",
+      //       "hello_name": "Hello, %{name}"
+      //     });
+      //
+      // The unset method can take either a string (for the key), or an object hash with
+      // the keys that you would like to unset.
+      Polyglot.prototype.unset = function (morePhrases, prefix) {
+        if (typeof morePhrases === 'string') {
+          delete this.phrases[morePhrases];
+        } else {
+          forEach(entries(morePhrases || {}), function (entry) {
+            var key = entry[0];
+            var phrase = entry[1];
+            var prefixedKey = prefix ? prefix + '.' + key : key;
+            if (typeof phrase === 'object') {
+              this.unset(phrase, prefixedKey);
+            } else {
+              delete this.phrases[prefixedKey];
+            }
+          }, this);
+        }
+      };
+
+      // ### polyglot.clear()
+      //
+      // Clears all phrases. Useful for special cases, such as freeing
+      // up memory if you have lots of phrases but no longer need to
+      // perform any translation. Also used internally by `replace`.
+      Polyglot.prototype.clear = function () {
+        this.phrases = {};
+      };
+
+      // ### polyglot.replace(phrases)
+      //
+      // Completely replace the existing phrases with a new set of phrases.
+      // Normally, just use `extend` to add more phrases, but under certain
+      // circumstances, you may want to make sure no old phrases are lying around.
+      Polyglot.prototype.replace = function (newPhrases) {
+        this.clear();
+        this.extend(newPhrases);
+      };
+
+      // ### polyglot.t(key, options)
+      //
+      // The most-used method. Provide a key, and `t` will return the
+      // phrase.
+      //
+      //     polyglot.t("hello");
+      //     => "Hello"
+      //
+      // The phrase value is provided first by a call to `polyglot.extend()` or
+      // `polyglot.replace()`.
+      //
+      // Pass in an object as the second argument to perform interpolation.
+      //
+      //     polyglot.t("hello_name", {name: "Spike"});
+      //     => "Hello, Spike"
+      //
+      // If you like, you can provide a default value in case the phrase is missing.
+      // Use the special option key "_" to specify a default.
+      //
+      //     polyglot.t("i_like_to_write_in_language", {
+      //       _: "I like to write in %{language}.",
+      //       language: "JavaScript"
+      //     });
+      //     => "I like to write in JavaScript."
+      //
+      Polyglot.prototype.t = function (key, options) {
+        var phrase, result;
+        var opts = options == null ? {} : options;
+        if (typeof this.phrases[key] === 'string') {
+          phrase = this.phrases[key];
+        } else if (typeof opts._ === 'string') {
+          phrase = opts._;
+        } else if (this.onMissingKey) {
+          var onMissingKey = this.onMissingKey;
+          result = onMissingKey(
+            key,
+            opts,
+            this.currentLocale,
+            this.tokenRegex,
+            this.pluralRules,
+            this.replaceImplementation
+          );
+        } else {
+          this.warn('Missing translation for key: "' + key + '"');
+          result = key;
+        }
+        if (typeof phrase === 'string') {
+          result = transformPhrase(
+            phrase,
+            opts,
+            this.currentLocale,
+            this.tokenRegex,
+            this.pluralRules,
+            this.replaceImplementation
+          );
+        }
+        return result;
+      };
+
+      // ### polyglot.has(key)
+      //
+      // Check if polyglot has a translation for given key
+      Polyglot.prototype.has = function (key) {
+        return has(this.phrases, key);
+      };
+
+      // export transformPhrase
+      Polyglot.transformPhrase = function transform(phrase, substitutions, locale) {
+        return transformPhrase(phrase, substitutions, locale);
+      };
+
+      module.exports = Polyglot;
+
+    }, { "array.prototype.foreach": 4, "has": 46, "object.entries": 57, "string.prototype.trim": 62, "warning": 65 }], 3: [function (require, module, exports) {
+      'use strict';
+
+      var GetIntrinsic = require('get-intrinsic');
+      var callBound = require('call-bind/callBound');
+      var $TypeError = GetIntrinsic('%TypeError%');
+
+      var Call = require('es-abstract/2022/Call');
+      var Get = require('es-abstract/2022/Get');
+      var HasProperty = require('es-abstract/2022/HasProperty');
+      var IsCallable = require('es-abstract/2022/IsCallable');
+      var LengthOfArrayLike = require('es-abstract/2022/LengthOfArrayLike');
+      var ToObject = require('es-abstract/2022/ToObject');
+      var ToString = require('es-abstract/2022/ToString');
+
+      var isString = require('is-string');
+
+      var $split = callBound('String.prototype.split');
+
+      // Check failure of by-index access of string characters (IE < 9) and failure of `0 in boxedString` (Rhino)
+      var boxedString = Object('a');
+      var splitString = boxedString[0] !== 'a' || !(0 in boxedString);
+
+      module.exports = function forEach(callbackfn) {
+        var thisO = ToObject(this);
+        var O = splitString && isString(this) ? $split(this, '') : thisO;
+
+        var len = LengthOfArrayLike(O);
+
+        if (!IsCallable(callbackfn)) {
+          throw new $TypeError('Array.prototype.forEach callback must be a function');
+        }
+
+        var thisArg;
+        if (arguments.length > 1) {
+          thisArg = arguments[1];
+        }
+
+        var k = 0;
+        while (k < len) {
+          var Pk = ToString(k);
+          var kPresent = HasProperty(O, Pk);
+          if (kPresent) {
+            var kValue = Get(O, Pk);
+            Call(callbackfn, thisArg, [kValue, k, O]);
+          }
+          k += 1;
+        }
+
+        return void undefined;
+      };
+
+    }, { "call-bind/callBound": 7, "es-abstract/2022/Call": 10, "es-abstract/2022/Get": 11, "es-abstract/2022/HasProperty": 12, "es-abstract/2022/IsCallable": 14, "es-abstract/2022/LengthOfArrayLike": 16, "es-abstract/2022/ToObject": 22, "es-abstract/2022/ToString": 24, "get-intrinsic": 41, "is-string": 50 }], 4: [function (require, module, exports) {
+      'use strict';
+
+      var define = require('define-properties');
+      var callBind = require('call-bind');
+      var callBound = require('call-bind/callBound');
+      var RequireObjectCoercible = require('es-abstract/2022/RequireObjectCoercible');
+
+      var implementation = require('./implementation');
+      var getPolyfill = require('./polyfill');
+      var polyfill = getPolyfill();
+      var shim = require('./shim');
+
+      var $slice = callBound('Array.prototype.slice');
+
+      var bound = callBind.apply(polyfill);
+      // eslint-disable-next-line no-unused-vars
+      var boundCoercible = function forEach(array, callbackfn) {
+        RequireObjectCoercible(array);
+        return bound(array, $slice(arguments, 1));
+      };
+
+      define(boundCoercible, {
+        getPolyfill: getPolyfill,
+        implementation: implementation,
+        shim: shim
+      });
+
+      module.exports = boundCoercible;
+
+    }, { "./implementation": 3, "./polyfill": 5, "./shim": 6, "call-bind": 8, "call-bind/callBound": 7, "define-properties": 9, "es-abstract/2022/RequireObjectCoercible": 17 }], 5: [function (require, module, exports) {
+      'use strict';
+
+      var arrayMethodBoxesProperly = require('es-array-method-boxes-properly');
+
+      var implementation = require('./implementation');
+
+      module.exports = function getPolyfill() {
+        var method = Array.prototype.forEach;
+        return arrayMethodBoxesProperly(method) ? method : implementation;
+      };
+
+    }, { "./implementation": 3, "es-array-method-boxes-properly": 36 }], 6: [function (require, module, exports) {
+      'use strict';
+
+      var define = require('define-properties');
+      var getPolyfill = require('./polyfill');
+
+      module.exports = function shimForEach() {
+        var polyfill = getPolyfill();
+        define(
+          Array.prototype,
+          { forEach: polyfill },
+          { forEach: function () { return Array.prototype.forEach !== polyfill; } }
+        );
+        return polyfill;
+      };
+
+    }, { "./polyfill": 5, "define-properties": 9 }], 7: [function (require, module, exports) {
+      'use strict';
+
+      var GetIntrinsic = require('get-intrinsic');
+
+      var callBind = require('./');
+
+      var $indexOf = callBind(GetIntrinsic('String.prototype.indexOf'));
+
+      module.exports = function callBoundIntrinsic(name, allowMissing) {
+        var intrinsic = GetIntrinsic(name, !!allowMissing);
+        if (typeof intrinsic === 'function' && $indexOf(name, '.prototype.') > -1) {
+          return callBind(intrinsic);
+        }
+        return intrinsic;
+      };
+
+    }, { "./": 8, "get-intrinsic": 41 }], 8: [function (require, module, exports) {
+      'use strict';
+
+      var bind = require('function-bind');
+      var GetIntrinsic = require('get-intrinsic');
+
+      var $apply = GetIntrinsic('%Function.prototype.apply%');
+      var $call = GetIntrinsic('%Function.prototype.call%');
+      var $reflectApply = GetIntrinsic('%Reflect.apply%', true) || bind.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(bind, $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(bind, $apply, arguments);
+      };
+
+      if ($defineProperty) {
+        $defineProperty(module.exports, 'apply', { value: applyBind });
+      } else {
+        module.exports.apply = applyBind;
+      }
+
+    }, { "function-bind": 40, "get-intrinsic": 41 }], 9: [function (require, module, exports) {
+      'use strict';
+
+      var keys = require('object-keys');
+      var hasSymbols = typeof Symbol === 'function' && typeof Symbol('foo') === 'symbol';
+
+      var toStr = Object.prototype.toString;
+      var concat = Array.prototype.concat;
+      var origDefineProperty = Object.defineProperty;
+
+      var isFunction = function (fn) {
+        return typeof fn === 'function' && toStr.call(fn) === '[object Function]';
+      };
+
+      var hasPropertyDescriptors = require('has-property-descriptors')();
+
+      var supportsDescriptors = origDefineProperty && hasPropertyDescriptors;
+
+      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; // eslint-disable-line no-param-reassign
+        }
+      };
+
+      var defineProperties = function (object, map) {
+        var predicates = arguments.length > 2 ? arguments[2] : {};
+        var props = keys(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;
+
+      module.exports = defineProperties;
+
+    }, { "has-property-descriptors": 42, "object-keys": 54 }], 10: [function (require, module, exports) {
+      'use strict';
+
+      var GetIntrinsic = require('get-intrinsic');
+      var callBound = require('call-bind/callBound');
+
+      var $TypeError = GetIntrinsic('%TypeError%');
+
+      var IsArray = require('./IsArray');
+
+      var $apply = GetIntrinsic('%Reflect.apply%', true) || callBound('%Function.prototype.apply%');
+
+      // https://ecma-international.org/ecma-262/6.0/#sec-call
+
+      module.exports = function Call(F, V) {
+        var argumentsList = arguments.length > 2 ? arguments[2] : [];
+        if (!IsArray(argumentsList)) {
+          throw new $TypeError('Assertion failed: optional `argumentsList`, if provided, must be a List');
+        }
+        return $apply(F, V, argumentsList);
+      };
+
+    }, { "./IsArray": 13, "call-bind/callBound": 7, "get-intrinsic": 41 }], 11: [function (require, module, exports) {
+      'use strict';
+
+      var GetIntrinsic = require('get-intrinsic');
+
+      var $TypeError = GetIntrinsic('%TypeError%');
+
+      var inspect = require('object-inspect');
+
+      var IsPropertyKey = require('./IsPropertyKey');
+      var Type = require('./Type');
+
+      // https://ecma-international.org/ecma-262/6.0/#sec-get-o-p
+
+      module.exports = function Get(O, P) {
+        // 7.3.1.1
+        if (Type(O) !== 'Object') {
+          throw new $TypeError('Assertion failed: Type(O) is not Object');
+        }
+        // 7.3.1.2
+        if (!IsPropertyKey(P)) {
+          throw new $TypeError('Assertion failed: IsPropertyKey(P) is not true, got ' + inspect(P));
+        }
+        // 7.3.1.3
+        return O[P];
+      };
+
+    }, { "./IsPropertyKey": 15, "./Type": 25, "get-intrinsic": 41, "object-inspect": 52 }], 12: [function (require, module, exports) {
+      'use strict';
+
+      var GetIntrinsic = require('get-intrinsic');
+
+      var $TypeError = GetIntrinsic('%TypeError%');
+
+      var IsPropertyKey = require('./IsPropertyKey');
+      var Type = require('./Type');
+
+      // https://ecma-international.org/ecma-262/6.0/#sec-hasproperty
+
+      module.exports = function HasProperty(O, P) {
+        if (Type(O) !== 'Object') {
+          throw new $TypeError('Assertion failed: `O` must be an Object');
+        }
+        if (!IsPropertyKey(P)) {
+          throw new $TypeError('Assertion failed: `P` must be a Property Key');
+        }
+        return P in O;
+      };
+
+    }, { "./IsPropertyKey": 15, "./Type": 25, "get-intrinsic": 41 }], 13: [function (require, module, exports) {
+      'use strict';
+
+      // https://ecma-international.org/ecma-262/6.0/#sec-isarray
+      module.exports = require('../helpers/IsArray');
+
+    }, { "../helpers/IsArray": 30 }], 14: [function (require, module, exports) {
+      'use strict';
+
+      // http://262.ecma-international.org/5.1/#sec-9.11
+
+      module.exports = require('is-callable');
+
+    }, { "is-callable": 47 }], 15: [function (require, module, exports) {
+      'use strict';
+
+      // https://ecma-international.org/ecma-262/6.0/#sec-ispropertykey
+
+      module.exports = function IsPropertyKey(argument) {
+        return typeof argument === 'string' || typeof argument === 'symbol';
+      };
+
+    }, {}], 16: [function (require, module, exports) {
+      'use strict';
+
+      var GetIntrinsic = require('get-intrinsic');
+
+      var $TypeError = GetIntrinsic('%TypeError%');
+
+      var Get = require('./Get');
+      var ToLength = require('./ToLength');
+      var Type = require('./Type');
+
+      // https://262.ecma-international.org/11.0/#sec-lengthofarraylike
+
+      module.exports = function LengthOfArrayLike(obj) {
+        if (Type(obj) !== 'Object') {
+          throw new $TypeError('Assertion failed: `obj` must be an Object');
+        }
+        return ToLength(Get(obj, 'length'));
+      };
+
+      // TODO: use this all over
+
+    }, { "./Get": 11, "./ToLength": 20, "./Type": 25, "get-intrinsic": 41 }], 17: [function (require, module, exports) {
+      'use strict';
+
+      module.exports = require('../5/CheckObjectCoercible');
+
+    }, { "../5/CheckObjectCoercible": 28 }], 18: [function (require, module, exports) {
+      'use strict';
+
+      var GetIntrinsic = require('get-intrinsic');
+
+      var $Number = GetIntrinsic('%Number%');
+      var $RegExp = GetIntrinsic('%RegExp%');
+      var $TypeError = GetIntrinsic('%TypeError%');
+      var $parseInteger = GetIntrinsic('%parseInt%');
+
+      var callBound = require('call-bind/callBound');
+      var regexTester = require('safe-regex-test');
+
+      var $strSlice = callBound('String.prototype.slice');
+      var isBinary = regexTester(/^0b[01]+$/i);
+      var isOctal = regexTester(/^0o[0-7]+$/i);
+      var isInvalidHexLiteral = regexTester(/^[-+]0x[0-9a-f]+$/i);
+      var nonWS = ['\u0085', '\u200b', '\ufffe'].join('');
+      var nonWSregex = new $RegExp('[' + nonWS + ']', 'g');
+      var hasNonWS = regexTester(nonWSregex);
+
+      // whitespace from: https://es5.github.io/#x15.5.4.20
+      // implementation from https://github.com/es-shims/es5-shim/blob/v3.4.0/es5-shim.js#L1304-L1324
+      var ws = [
+        '\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003',
+        '\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028',
+        '\u2029\uFEFF'
+      ].join('');
+      var trimRegex = new RegExp('(^[' + ws + ']+)|([' + ws + ']+$)', 'g');
+      var $replace = callBound('String.prototype.replace');
+      var $trim = function (value) {
+        return $replace(value, trimRegex, '');
+      };
+
+      var Type = require('./Type');
+
+      // https://ecma-international.org/ecma-262/13.0/#sec-stringtonumber
+
+      module.exports = function StringToNumber(argument) {
+        if (Type(argument) !== 'String') {
+          throw new $TypeError('Assertion failed: `argument` is not a String');
+        }
+        if (isBinary(argument)) {
+          return $Number($parseInteger($strSlice(argument, 2), 2));
+        }
+        if (isOctal(argument)) {
+          return $Number($parseInteger($strSlice(argument, 2), 8));
+        }
+        if (hasNonWS(argument) || isInvalidHexLiteral(argument)) {
+          return NaN;
+        }
+        var trimmed = $trim(argument);
+        if (trimmed !== argument) {
+          return StringToNumber(trimmed);
+        }
+        return $Number(argument);
+      };
+
+    }, { "./Type": 25, "call-bind/callBound": 7, "get-intrinsic": 41, "safe-regex-test": 60 }], 19: [function (require, module, exports) {
+      'use strict';
+
+      var abs = require('./abs');
+      var floor = require('./floor');
+      var ToNumber = require('./ToNumber');
+
+      var $isNaN = require('../helpers/isNaN');
+      var $isFinite = require('../helpers/isFinite');
+      var $sign = require('../helpers/sign');
+
+      // https://262.ecma-international.org/12.0/#sec-tointegerorinfinity
+
+      module.exports = function ToIntegerOrInfinity(value) {
+        var number = ToNumber(value);
+        if ($isNaN(number) || number === 0) { return 0; }
+        if (!$isFinite(number)) { return number; }
+        var integer = floor(abs(number));
+        if (integer === 0) { return 0; }
+        return $sign(number) * integer;
+      };
+
+    }, { "../helpers/isFinite": 31, "../helpers/isNaN": 32, "../helpers/sign": 35, "./ToNumber": 21, "./abs": 26, "./floor": 27 }], 20: [function (require, module, exports) {
+      'use strict';
+
+      var MAX_SAFE_INTEGER = require('../helpers/maxSafeInteger');
+
+      var ToIntegerOrInfinity = require('./ToIntegerOrInfinity');
+
+      module.exports = function ToLength(argument) {
+        var len = ToIntegerOrInfinity(argument);
+        if (len <= 0) { return 0; } // includes converting -0 to +0
+        if (len > MAX_SAFE_INTEGER) { return MAX_SAFE_INTEGER; }
+        return len;
+      };
+
+    }, { "../helpers/maxSafeInteger": 34, "./ToIntegerOrInfinity": 19 }], 21: [function (require, module, exports) {
+      'use strict';
+
+      var GetIntrinsic = require('get-intrinsic');
+
+      var $TypeError = GetIntrinsic('%TypeError%');
+      var $Number = GetIntrinsic('%Number%');
+      var isPrimitive = require('../helpers/isPrimitive');
+
+      var ToPrimitive = require('./ToPrimitive');
+      var StringToNumber = require('./StringToNumber');
+
+      // https://ecma-international.org/ecma-262/13.0/#sec-tonumber
+
+      module.exports = function ToNumber(argument) {
+        var value = isPrimitive(argument) ? argument : ToPrimitive(argument, $Number);
+        if (typeof value === 'symbol') {
+          throw new $TypeError('Cannot convert a Symbol value to a number');
+        }
+        if (typeof value === 'bigint') {
+          throw new $TypeError('Conversion from \'BigInt\' to \'number\' is not allowed.');
+        }
+        if (typeof value === 'string') {
+          return StringToNumber(value);
+        }
+        return $Number(value);
+      };
+
+    }, { "../helpers/isPrimitive": 33, "./StringToNumber": 18, "./ToPrimitive": 23, "get-intrinsic": 41 }], 22: [function (require, module, exports) {
+      'use strict';
+
+      var GetIntrinsic = require('get-intrinsic');
+
+      var $Object = GetIntrinsic('%Object%');
+
+      var RequireObjectCoercible = require('./RequireObjectCoercible');
+
+      // https://ecma-international.org/ecma-262/6.0/#sec-toobject
+
+      module.exports = function ToObject(value) {
+        RequireObjectCoercible(value);
+        return $Object(value);
+      };
+
+    }, { "./RequireObjectCoercible": 17, "get-intrinsic": 41 }], 23: [function (require, module, exports) {
+      'use strict';
+
+      var toPrimitive = require('es-to-primitive/es2015');
+
+      // https://ecma-international.org/ecma-262/6.0/#sec-toprimitive
+
+      module.exports = function ToPrimitive(input) {
+        if (arguments.length > 1) {
+          return toPrimitive(input, arguments[1]);
+        }
+        return toPrimitive(input);
+      };
+
+    }, { "es-to-primitive/es2015": 37 }], 24: [function (require, module, exports) {
+      'use strict';
+
+      var GetIntrinsic = require('get-intrinsic');
+
+      var $String = GetIntrinsic('%String%');
+      var $TypeError = GetIntrinsic('%TypeError%');
+
+      // https://ecma-international.org/ecma-262/6.0/#sec-tostring
+
+      module.exports = function ToString(argument) {
+        if (typeof argument === 'symbol') {
+          throw new $TypeError('Cannot convert a Symbol value to a string');
+        }
+        return $String(argument);
+      };
+
+    }, { "get-intrinsic": 41 }], 25: [function (require, module, exports) {
+      'use strict';
+
+      var ES5Type = require('../5/Type');
+
+      // https://262.ecma-international.org/11.0/#sec-ecmascript-data-types-and-values
+
+      module.exports = function Type(x) {
+        if (typeof x === 'symbol') {
+          return 'Symbol';
+        }
+        if (typeof x === 'bigint') {
+          return 'BigInt';
+        }
+        return ES5Type(x);
+      };
+
+    }, { "../5/Type": 29 }], 26: [function (require, module, exports) {
+      'use strict';
+
+      var GetIntrinsic = require('get-intrinsic');
+
+      var $abs = GetIntrinsic('%Math.abs%');
+
+      // http://262.ecma-international.org/5.1/#sec-5.2
+
+      module.exports = function abs(x) {
+        return $abs(x);
+      };
+
+    }, { "get-intrinsic": 41 }], 27: [function (require, module, exports) {
+      'use strict';
+
+      var Type = require('./Type');
+
+      // var modulo = require('./modulo');
+      var $floor = Math.floor;
+
+      // http://262.ecma-international.org/11.0/#eqn-floor
+
+      module.exports = function floor(x) {
+        // return x - modulo(x, 1);
+        if (Type(x) === 'BigInt') {
+          return x;
+        }
+        return $floor(x);
+      };
+
+    }, { "./Type": 25 }], 28: [function (require, module, exports) {
+      'use strict';
+
+      var GetIntrinsic = require('get-intrinsic');
+
+      var $TypeError = GetIntrinsic('%TypeError%');
+
+      // http://262.ecma-international.org/5.1/#sec-9.10
+
+      module.exports = function CheckObjectCoercible(value, optMessage) {
+        if (value == null) {
+          throw new $TypeError(optMessage || ('Cannot call method on ' + value));
+        }
+        return value;
+      };
+
+    }, { "get-intrinsic": 41 }], 29: [function (require, module, exports) {
+      'use strict';
+
+      // https://262.ecma-international.org/5.1/#sec-8
+
+      module.exports = 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';
+        }
+      };
+
+    }, {}], 30: [function (require, module, exports) {
+      'use strict';
+
+      var GetIntrinsic = require('get-intrinsic');
+
+      var $Array = GetIntrinsic('%Array%');
+
+      // eslint-disable-next-line global-require
+      var toStr = !$Array.isArray && require('call-bind/callBound')('Object.prototype.toString');
+
+      module.exports = $Array.isArray || function IsArray(argument) {
+        return toStr(argument) === '[object Array]';
+      };
+
+    }, { "call-bind/callBound": 7, "get-intrinsic": 41 }], 31: [function (require, module, exports) {
+      'use strict';
+
+      var $isNaN = require('./isNaN');
+
+      module.exports = function (x) { return (typeof x === 'number' || typeof x === 'bigint') && !$isNaN(x) && x !== Infinity && x !== -Infinity; };
+
+    }, { "./isNaN": 32 }], 32: [function (require, module, exports) {
+      'use strict';
+
+      module.exports = Number.isNaN || function isNaN(a) {
+        return a !== a;
+      };
+
+    }, {}], 33: [function (require, module, exports) {
+      'use strict';
+
+      module.exports = function isPrimitive(value) {
+        return value === null || (typeof value !== 'function' && typeof value !== 'object');
+      };
+
+    }, {}], 34: [function (require, module, exports) {
+      'use strict';
+
+      var GetIntrinsic = require('get-intrinsic');
+
+      var $Math = GetIntrinsic('%Math%');
+      var $Number = GetIntrinsic('%Number%');
+
+      module.exports = $Number.MAX_SAFE_INTEGER || $Math.pow(2, 53) - 1;
+
+    }, { "get-intrinsic": 41 }], 35: [function (require, module, exports) {
+      'use strict';
+
+      module.exports = function sign(number) {
+        return number >= 0 ? 1 : -1;
+      };
+
+    }, {}], 36: [function (require, module, exports) {
+      module.exports = function properlyBoxed(method) {
+        // Check node 0.6.21 bug where third parameter is not boxed
+        var properlyBoxesNonStrict = true;
+        var properlyBoxesStrict = true;
+        var threwException = false;
+        if (typeof method === 'function') {
+          try {
+            // eslint-disable-next-line max-params
+            method.call('f', function (_, __, O) {
+              if (typeof O !== 'object') {
+                properlyBoxesNonStrict = false;
+              }
+            });
+
+            method.call(
+              [null],
+              function () {
+                'use strict';
+
+                properlyBoxesStrict = typeof this === 'string'; // eslint-disable-line no-invalid-this
+              },
+              'x'
+            );
+          } catch (e) {
+            threwException = true;
+          }
+          return !threwException && properlyBoxesNonStrict && properlyBoxesStrict;
+        }
+        return false;
+      };
+
+    }, {}], 37: [function (require, module, exports) {
+      'use strict';
+
+      var hasSymbols = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol';
+
+      var isPrimitive = require('./helpers/isPrimitive');
+      var isCallable = require('is-callable');
+      var isDate = require('is-date-object');
+      var isSymbol = require('is-symbol');
+
+      var ordinaryToPrimitive = function OrdinaryToPrimitive(O, hint) {
+        if (typeof O === 'undefined' || O === null) {
+          throw new TypeError('Cannot call method on ' + O);
+        }
+        if (typeof hint !== 'string' || (hint !== 'number' && hint !== 'string')) {
+          throw new TypeError('hint must be "string" or "number"');
+        }
+        var methodNames = hint === 'string' ? ['toString', 'valueOf'] : ['valueOf', 'toString'];
+        var method, result, i;
+        for (i = 0; i < methodNames.length; ++i) {
+          method = O[methodNames[i]];
+          if (isCallable(method)) {
+            result = method.call(O);
+            if (isPrimitive(result)) {
+              return result;
+            }
+          }
+        }
+        throw new TypeError('No default value');
+      };
+
+      var GetMethod = function GetMethod(O, P) {
+        var func = O[P];
+        if (func !== null && typeof func !== 'undefined') {
+          if (!isCallable(func)) {
+            throw new TypeError(func + ' returned for property ' + P + ' of object ' + O + ' is not a function');
+          }
+          return func;
+        }
+        return void 0;
+      };
+
+      // http://www.ecma-international.org/ecma-262/6.0/#sec-toprimitive
+      module.exports = function ToPrimitive(input) {
+        if (isPrimitive(input)) {
+          return input;
+        }
+        var hint = 'default';
+        if (arguments.length > 1) {
+          if (arguments[1] === String) {
+            hint = 'string';
+          } else if (arguments[1] === Number) {
+            hint = 'number';
+          }
+        }
+
+        var exoticToPrim;
+        if (hasSymbols) {
+          if (Symbol.toPrimitive) {
+            exoticToPrim = GetMethod(input, Symbol.toPrimitive);
+          } else if (isSymbol(input)) {
+            exoticToPrim = Symbol.prototype.valueOf;
+          }
+        }
+        if (typeof exoticToPrim !== 'undefined') {
+          var result = exoticToPrim.call(input, hint);
+          if (isPrimitive(result)) {
+            return result;
+          }
+          throw new TypeError('unable to convert exotic object to primitive');
+        }
+        if (hint === 'default' && (isDate(input) || isSymbol(input))) {
+          hint = 'string';
+        }
+        return ordinaryToPrimitive(input, hint === 'default' ? 'number' : hint);
+      };
+
+    }, { "./helpers/isPrimitive": 38, "is-callable": 47, "is-date-object": 48, "is-symbol": 51 }], 38: [function (require, module, exports) {
+      arguments[4][33][0].apply(exports, arguments)
+    }, { "dup": 33 }], 39: [function (require, module, exports) {
+      'use strict';
+
+      /* eslint no-invalid-this: 1 */
+
+      var ERROR_MESSAGE = 'Function.prototype.bind called on incompatible ';
+      var slice = Array.prototype.slice;
+      var toStr = Object.prototype.toString;
+      var funcType = '[object Function]';
+
+      module.exports = function bind(that) {
+        var target = this;
+        if (typeof target !== 'function' || toStr.call(target) !== funcType) {
+          throw new TypeError(ERROR_MESSAGE + target);
+        }
+        var args = slice.call(arguments, 1);
+
+        var bound;
+        var binder = function () {
+          if (this instanceof bound) {
+            var result = target.apply(
+              this,
+              args.concat(slice.call(arguments))
+            );
+            if (Object(result) === result) {
+              return result;
+            }
+            return this;
+          } else {
+            return target.apply(
+              that,
+              args.concat(slice.call(arguments))
+            );
+          }
+        };
+
+        var boundLength = Math.max(0, target.length - args.length);
+        var boundArgs = [];
+        for (var i = 0; i < boundLength; i++) {
+          boundArgs.push('$' + i);
+        }
+
+        bound = Function('binder', 'return function (' + boundArgs.join(',') + '){ return binder.apply(this,arguments); }')(binder);
+
+        if (target.prototype) {
+          var Empty = function Empty() { };
+          Empty.prototype = target.prototype;
+          bound.prototype = new Empty();
+          Empty.prototype = null;
+        }
+
+        return bound;
+      };
+
+    }, {}], 40: [function (require, module, exports) {
+      'use strict';
+
+      var implementation = require('./implementation');
+
+      module.exports = Function.prototype.bind || implementation;
+
+    }, { "./implementation": 39 }], 41: [function (require, module, exports) {
+      'use strict';
+
+      var undefined;
+
+      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 = require('has-symbols')();
+
+      var getProto = Object.getPrototypeOf || function (x) { return x.__proto__; }; // eslint-disable-line no-proto
+
+      var needsEval = {};
+
+      var TypedArray = typeof Uint8Array === 'undefined' ? undefined : getProto(Uint8Array);
+
+      var INTRINSICS = {
+        '%AggregateError%': typeof AggregateError === 'undefined' ? undefined : AggregateError,
+        '%Array%': Array,
+        '%ArrayBuffer%': typeof ArrayBuffer === 'undefined' ? undefined : ArrayBuffer,
+        '%ArrayIteratorPrototype%': hasSymbols ? getProto([][Symbol.iterator]()) : undefined,
+        '%AsyncFromSyncIteratorPrototype%': undefined,
+        '%AsyncFunction%': needsEval,
+        '%AsyncGenerator%': needsEval,
+        '%AsyncGeneratorFunction%': needsEval,
+        '%AsyncIteratorPrototype%': needsEval,
+        '%Atomics%': typeof Atomics === 'undefined' ? undefined : Atomics,
+        '%BigInt%': typeof BigInt === 'undefined' ? undefined : BigInt,
+        '%Boolean%': Boolean,
+        '%DataView%': typeof DataView === 'undefined' ? undefined : 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 : Float32Array,
+        '%Float64Array%': typeof Float64Array === 'undefined' ? undefined : Float64Array,
+        '%FinalizationRegistry%': typeof FinalizationRegistry === 'undefined' ? undefined : FinalizationRegistry,
+        '%Function%': $Function,
+        '%GeneratorFunction%': needsEval,
+        '%Int8Array%': typeof Int8Array === 'undefined' ? undefined : Int8Array,
+        '%Int16Array%': typeof Int16Array === 'undefined' ? undefined : Int16Array,
+        '%Int32Array%': typeof Int32Array === 'undefined' ? undefined : Int32Array,
+        '%isFinite%': isFinite,
+        '%isNaN%': isNaN,
+        '%IteratorPrototype%': hasSymbols ? getProto(getProto([][Symbol.iterator]())) : undefined,
+        '%JSON%': typeof JSON === 'object' ? JSON : undefined,
+        '%Map%': typeof Map === 'undefined' ? undefined : Map,
+        '%MapIteratorPrototype%': typeof Map === 'undefined' || !hasSymbols ? undefined : getProto(new Map()[Symbol.iterator]()),
+        '%Math%': Math,
+        '%Number%': Number,
+        '%Object%': Object,
+        '%parseFloat%': parseFloat,
+        '%parseInt%': parseInt,
+        '%Promise%': typeof Promise === 'undefined' ? undefined : Promise,
+        '%Proxy%': typeof Proxy === 'undefined' ? undefined : Proxy,
+        '%RangeError%': RangeError,
+        '%ReferenceError%': ReferenceError,
+        '%Reflect%': typeof Reflect === 'undefined' ? undefined : Reflect,
+        '%RegExp%': RegExp,
+        '%Set%': typeof Set === 'undefined' ? undefined : Set,
+        '%SetIteratorPrototype%': typeof Set === 'undefined' || !hasSymbols ? undefined : getProto(new Set()[Symbol.iterator]()),
+        '%SharedArrayBuffer%': typeof SharedArrayBuffer === 'undefined' ? undefined : SharedArrayBuffer,
+        '%String%': String,
+        '%StringIteratorPrototype%': hasSymbols ? getProto(''[Symbol.iterator]()) : undefined,
+        '%Symbol%': hasSymbols ? Symbol : undefined,
+        '%SyntaxError%': $SyntaxError,
+        '%ThrowTypeError%': ThrowTypeError,
+        '%TypedArray%': TypedArray,
+        '%TypeError%': $TypeError,
+        '%Uint8Array%': typeof Uint8Array === 'undefined' ? undefined : Uint8Array,
+        '%Uint8ClampedArray%': typeof Uint8ClampedArray === 'undefined' ? undefined : Uint8ClampedArray,
+        '%Uint16Array%': typeof Uint16Array === 'undefined' ? undefined : Uint16Array,
+        '%Uint32Array%': typeof Uint32Array === 'undefined' ? undefined : Uint32Array,
+        '%URIError%': URIError,
+        '%WeakMap%': typeof WeakMap === 'undefined' ? undefined : WeakMap,
+        '%WeakRef%': typeof WeakRef === 'undefined' ? undefined : WeakRef,
+        '%WeakSet%': typeof WeakSet === 'undefined' ? undefined : 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 bind = require('function-bind');
+      var hasOwn = require('has');
+      var $concat = bind.call(Function.call, Array.prototype.concat);
+      var $spliceApply = bind.call(Function.apply, Array.prototype.splice);
+      var $replace = bind.call(Function.call, String.prototype.replace);
+      var $strSlice = bind.call(Function.call, String.prototype.slice);
+      var $exec = bind.call(Function.call, RegExp.prototype.exec);
+
+      /* 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 (hasOwn(LEGACY_ALIASES, intrinsicName)) {
+          alias = LEGACY_ALIASES[intrinsicName];
+          intrinsicName = '%' + alias[0] + '%';
+        }
+
+        if (hasOwn(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!');
+      };
+
+      module.exports = 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');
+        }
+
+        if ($exec(/^%?[^%]*%?$/, name) === null) {
+          throw new $SyntaxError('`%` may not be present anywhere but at the beginning and end of the intrinsic name');
+        }
+        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 (hasOwn(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;
+            }
+            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 = hasOwn(value, part);
+              value = value[part];
+            }
+
+            if (isOwn && !skipFurtherCaching) {
+              INTRINSICS[intrinsicRealName] = value;
+            }
+          }
+        }
+        return value;
+      };
+
+    }, { "function-bind": 40, "has": 46, "has-symbols": 43 }], 42: [function (require, module, exports) {
+      'use strict';
+
+      var GetIntrinsic = require('get-intrinsic');
+
+      var $defineProperty = GetIntrinsic('%Object.defineProperty%', true);
+
+      var hasPropertyDescriptors = function hasPropertyDescriptors() {
+        if ($defineProperty) {
+          try {
+            $defineProperty({}, 'a', { value: 1 });
+            return true;
+          } catch (e) {
+            // IE 8 has a broken defineProperty
+            return false;
+          }
+        }
+        return false;
+      };
+
+      hasPropertyDescriptors.hasArrayLengthDefineBug = function hasArrayLengthDefineBug() {
+        // node v0.6 has a bug where array lengths can be Set but not Defined
+        if (!hasPropertyDescriptors()) {
+          return null;
+        }
+        try {
+          return $defineProperty([], 'length', { value: 1 }).length !== 1;
+        } catch (e) {
+          // In Firefox 4-22, defining length on an array throws an exception.
+          return true;
+        }
+      };
+
+      module.exports = hasPropertyDescriptors;
+
+    }, { "get-intrinsic": 41 }], 43: [function (require, module, exports) {
+      'use strict';
+
+      var origSymbol = typeof Symbol !== 'undefined' && Symbol;
+      var hasSymbolSham = require('./shams');
+
+      module.exports = 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 hasSymbolSham();
+      };
+
+    }, { "./shams": 44 }], 44: [function (require, module, exports) {
+      'use strict';
+
+      /* eslint complexity: [2, 18], max-statements: [2, 33] */
+      module.exports = 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, no-unreachable-loop
+        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;
+      };
+
+    }, {}], 45: [function (require, module, exports) {
+      'use strict';
+
+      var hasSymbols = require('has-symbols/shams');
+
+      module.exports = function hasToStringTagShams() {
+        return hasSymbols() && !!Symbol.toStringTag;
+      };
+
+    }, { "has-symbols/shams": 44 }], 46: [function (require, module, exports) {
+      'use strict';
+
+      var bind = require('function-bind');
+
+      module.exports = bind.call(Function.call, Object.prototype.hasOwnProperty);
+
+    }, { "function-bind": 40 }], 47: [function (require, module, exports) {
+      'use strict';
+
+      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 = Object.prototype.toString;
+      var objectClass = '[object Object]';
+      var fnClass = '[object Function]';
+      var genClass = '[object GeneratorFunction]';
+      var ddaClass = '[object HTMLAllCollection]'; // IE 11
+      var ddaClass2 = '[object HTML document.all class]';
+      var ddaClass3 = '[object HTMLCollection]'; // IE 9-10
+      var hasToStringTag = typeof Symbol === 'function' && !!Symbol.toStringTag; // better: use `has-tostringtag`
+
+      var isIE68 = !(0 in [,]); // eslint-disable-line no-sparse-arrays, comma-spacing
+
+      var isDDA = function isDocumentDotAll() { return false; };
+      if (typeof document === 'object') {
+        // Firefox 3 canonicalizes DDA to undefined when it's not accessed directly
+        var all = document.all;
+        if (toStr.call(all) === toStr.call(document.all)) {
+          isDDA = function isDocumentDotAll(value) {
+            /* globals document: false */
+            // in IE 6-8, typeof document.all is "object" and it's truthy
+            if ((isIE68 || !value) && (typeof value === 'undefined' || typeof value === 'object')) {
+              try {
+                var str = toStr.call(value);
+                return (
+                  str === ddaClass
+                  || str === ddaClass2
+                  || str === ddaClass3 // opera 12.16
+                  || str === objectClass // IE 6-8
+                ) && value('') == null; // eslint-disable-line eqeqeq
+              } catch (e) { /**/ }
+            }
+            return false;
+          };
+        }
+      }
+
+      module.exports = reflectApply
+        ? function isCallable(value) {
+          if (isDDA(value)) { return true; }
+          if (!value) { return false; }
+          if (typeof value !== 'function' && typeof value !== 'object') { return false; }
+          try {
+            reflectApply(value, null, badArrayLike);
+          } catch (e) {
+            if (e !== isCallableMarker) { return false; }
+          }
+          return !isES6ClassFn(value) && tryFunctionObject(value);
+        }
+        : function isCallable(value) {
+          if (isDDA(value)) { return true; }
+          if (!value) { return false; }
+          if (typeof value !== 'function' && typeof value !== 'object') { return false; }
+          if (hasToStringTag) { return tryFunctionObject(value); }
+          if (isES6ClassFn(value)) { return false; }
+          var strClass = toStr.call(value);
+          if (strClass !== fnClass && strClass !== genClass && !(/^\[object HTML/).test(strClass)) { return false; }
+          return tryFunctionObject(value);
+        };
+
+    }, {}], 48: [function (require, module, exports) {
+      'use strict';
+
+      var getDay = Date.prototype.getDay;
+      var tryDateObject = function tryDateGetDayCall(value) {
+        try {
+          getDay.call(value);
+          return true;
+        } catch (e) {
+          return false;
+        }
+      };
+
+      var toStr = Object.prototype.toString;
+      var dateClass = '[object Date]';
+      var hasToStringTag = require('has-tostringtag/shams')();
+
+      module.exports = function isDateObject(value) {
+        if (typeof value !== 'object' || value === null) {
+          return false;
+        }
+        return hasToStringTag ? tryDateObject(value) : toStr.call(value) === dateClass;
+      };
+
+    }, { "has-tostringtag/shams": 45 }], 49: [function (require, module, exports) {
+      'use strict';
+
+      var callBound = require('call-bind/callBound');
+      var hasToStringTag = require('has-tostringtag/shams')();
+      var has;
+      var $exec;
+      var isRegexMarker;
+      var badStringifier;
+
+      if (hasToStringTag) {
+        has = 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]';
+
+      module.exports = 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(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;
+        };
+
+    }, { "call-bind/callBound": 7, "has-tostringtag/shams": 45 }], 50: [function (require, module, exports) {
+      'use strict';
+
+      var strValue = String.prototype.valueOf;
+      var tryStringObject = function tryStringObject(value) {
+        try {
+          strValue.call(value);
+          return true;
+        } catch (e) {
+          return false;
+        }
+      };
+      var toStr = Object.prototype.toString;
+      var strClass = '[object String]';
+      var hasToStringTag = require('has-tostringtag/shams')();
+
+      module.exports = function isString(value) {
+        if (typeof value === 'string') {
+          return true;
+        }
+        if (typeof value !== 'object') {
+          return false;
+        }
+        return hasToStringTag ? tryStringObject(value) : toStr.call(value) === strClass;
+      };
+
+    }, { "has-tostringtag/shams": 45 }], 51: [function (require, module, exports) {
+      'use strict';
+
+      var toStr = Object.prototype.toString;
+      var hasSymbols = require('has-symbols')();
+
+      if (hasSymbols) {
+        var symToStr = Symbol.prototype.toString;
+        var symStringRegex = /^Symbol\(.*\)$/;
+        var isSymbolObject = function isRealSymbolObject(value) {
+          if (typeof value.valueOf() !== 'symbol') {
+            return false;
+          }
+          return symStringRegex.test(symToStr.call(value));
+        };
+
+        module.exports = function isSymbol(value) {
+          if (typeof value === 'symbol') {
+            return true;
+          }
+          if (toStr.call(value) !== '[object Symbol]') {
+            return false;
+          }
+          try {
+            return isSymbolObject(value);
+          } catch (e) {
+            return false;
+          }
+        };
+      } else {
+
+        module.exports = function isSymbol(value) {
+          // this environment does not support Symbols.
+          return false && value;
+        };
+      }
+
+    }, { "has-symbols": 43 }], 52: [function (require, module, exports) {
+      var hasMap = typeof Map === 'function' && Map.prototype;
+      var mapSizeDescriptor = Object.getOwnPropertyDescriptor && hasMap ? Object.getOwnPropertyDescriptor(Map.prototype, 'size') : null;
+      var mapSize = hasMap && mapSizeDescriptor && typeof mapSizeDescriptor.get === 'function' ? mapSizeDescriptor.get : null;
+      var mapForEach = hasMap && Map.prototype.forEach;
+      var hasSet = typeof Set === 'function' && Set.prototype;
+      var setSizeDescriptor = Object.getOwnPropertyDescriptor && hasSet ? Object.getOwnPropertyDescriptor(Set.prototype, 'size') : null;
+      var setSize = hasSet && setSizeDescriptor && typeof setSizeDescriptor.get === 'function' ? setSizeDescriptor.get : null;
+      var setForEach = hasSet && Set.prototype.forEach;
+      var hasWeakMap = typeof WeakMap === 'function' && WeakMap.prototype;
+      var weakMapHas = hasWeakMap ? WeakMap.prototype.has : null;
+      var hasWeakSet = typeof WeakSet === 'function' && WeakSet.prototype;
+      var weakSetHas = hasWeakSet ? WeakSet.prototype.has : null;
+      var hasWeakRef = typeof WeakRef === 'function' && WeakRef.prototype;
+      var weakRefDeref = hasWeakRef ? WeakRef.prototype.deref : null;
+      var booleanValueOf = Boolean.prototype.valueOf;
+      var objectToString = Object.prototype.toString;
+      var functionToString = Function.prototype.toString;
+      var $match = String.prototype.match;
+      var $slice = String.prototype.slice;
+      var $replace = String.prototype.replace;
+      var $toUpperCase = String.prototype.toUpperCase;
+      var $toLowerCase = String.prototype.toLowerCase;
+      var $test = RegExp.prototype.test;
+      var $concat = Array.prototype.concat;
+      var $join = Array.prototype.join;
+      var $arrSlice = Array.prototype.slice;
+      var $floor = Math.floor;
+      var bigIntValueOf = typeof BigInt === 'function' ? BigInt.prototype.valueOf : null;
+      var gOPS = Object.getOwnPropertySymbols;
+      var symToString = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol' ? Symbol.prototype.toString : null;
+      var hasShammedSymbols = typeof Symbol === 'function' && typeof Symbol.iterator === 'object';
+      // ie, `has-tostringtag/shams
+      var toStringTag = typeof Symbol === 'function' && Symbol.toStringTag && (typeof Symbol.toStringTag === hasShammedSymbols ? 'object' : 'symbol')
+        ? Symbol.toStringTag
+        : null;
+      var isEnumerable = Object.prototype.propertyIsEnumerable;
+
+      var gPO = (typeof Reflect === 'function' ? Reflect.getPrototypeOf : Object.getPrototypeOf) || (
+        [].__proto__ === Array.prototype // eslint-disable-line no-proto
+          ? function (O) {
+            return O.__proto__; // eslint-disable-line no-proto
+          }
+          : null
+      );
+
+      function addNumericSeparator(num, str) {
+        if (
+          num === Infinity
+          || num === -Infinity
+          || num !== num
+          || (num && num > -1000 && num < 1000)
+          || $test.call(/e/, str)
+        ) {
+          return str;
+        }
+        var sepRegex = /[0-9](?=(?:[0-9]{3})+(?![0-9]))/g;
+        if (typeof num === 'number') {
+          var int = num < 0 ? -$floor(-num) : $floor(num); // trunc(num)
+          if (int !== num) {
+            var intStr = String(int);
+            var dec = $slice.call(str, intStr.length + 1);
+            return $replace.call(intStr, sepRegex, '$&_') + '.' + $replace.call($replace.call(dec, /([0-9]{3})/g, '$&_'), /_$/, '');
+          }
+        }
+        return $replace.call(str, sepRegex, '$&_');
+      }
+
+      var utilInspect = require('./util.inspect');
+      var inspectCustom = utilInspect.custom;
+      var inspectSymbol = isSymbol(inspectCustom) ? inspectCustom : null;
+
+      module.exports = function inspect_(obj, options, depth, seen) {
+        var opts = options || {};
+
+        if (has(opts, 'quoteStyle') && (opts.quoteStyle !== 'single' && opts.quoteStyle !== 'double')) {
+          throw new TypeError('option "quoteStyle" must be "single" or "double"');
+        }
+        if (
+          has(opts, 'maxStringLength') && (typeof opts.maxStringLength === 'number'
+            ? opts.maxStringLength < 0 && opts.maxStringLength !== Infinity
+            : opts.maxStringLength !== null
+          )
+        ) {
+          throw new TypeError('option "maxStringLength", if provided, must be a positive integer, Infinity, or `null`');
+        }
+        var customInspect = has(opts, 'customInspect') ? opts.customInspect : true;
+        if (typeof customInspect !== 'boolean' && customInspect !== 'symbol') {
+          throw new TypeError('option "customInspect", if provided, must be `true`, `false`, or `\'symbol\'`');
+        }
+
+        if (
+          has(opts, 'indent')
+          && opts.indent !== null
+          && opts.indent !== '\t'
+          && !(parseInt(opts.indent, 10) === opts.indent && opts.indent > 0)
+        ) {
+          throw new TypeError('option "indent" must be "\\t", an integer > 0, or `null`');
+        }
+        if (has(opts, 'numericSeparator') && typeof opts.numericSeparator !== 'boolean') {
+          throw new TypeError('option "numericSeparator", if provided, must be `true` or `false`');
+        }
+        var numericSeparator = opts.numericSeparator;
+
+        if (typeof obj === 'undefined') {
+          return 'undefined';
+        }
+        if (obj === null) {
+          return 'null';
+        }
+        if (typeof obj === 'boolean') {
+          return obj ? 'true' : 'false';
+        }
+
+        if (typeof obj === 'string') {
+          return inspectString(obj, opts);
+        }
+        if (typeof obj === 'number') {
+          if (obj === 0) {
+            return Infinity / obj > 0 ? '0' : '-0';
+          }
+          var str = String(obj);
+          return numericSeparator ? addNumericSeparator(obj, str) : str;
+        }
+        if (typeof obj === 'bigint') {
+          var bigIntStr = String(obj) + 'n';
+          return numericSeparator ? addNumericSeparator(obj, bigIntStr) : bigIntStr;
+        }
+
+        var maxDepth = typeof opts.depth === 'undefined' ? 5 : opts.depth;
+        if (typeof depth === 'undefined') { depth = 0; }
+        if (depth >= maxDepth && maxDepth > 0 && typeof obj === 'object') {
+          return isArray(obj) ? '[Array]' : '[Object]';
+        }
+
+        var indent = getIndent(opts, depth);
+
+        if (typeof seen === 'undefined') {
+          seen = [];
+        } else if (indexOf(seen, obj) >= 0) {
+          return '[Circular]';
+        }
+
+        function inspect(value, from, noIndent) {
+          if (from) {
+            seen = $arrSlice.call(seen);
+            seen.push(from);
+          }
+          if (noIndent) {
+            var newOpts = {
+              depth: opts.depth
+            };
+            if (has(opts, 'quoteStyle')) {
+              newOpts.quoteStyle = opts.quoteStyle;
+            }
+            return inspect_(value, newOpts, depth + 1, seen);
+          }
+          return inspect_(value, opts, depth + 1, seen);
+        }
+
+        if (typeof obj === 'function' && !isRegExp(obj)) { // in older engines, regexes are callable
+          var name = nameOf(obj);
+          var keys = arrObjKeys(obj, inspect);
+          return '[Function' + (name ? ': ' + name : ' (anonymous)') + ']' + (keys.length > 0 ? ' { ' + $join.call(keys, ', ') + ' }' : '');
+        }
+        if (isSymbol(obj)) {
+          var symString = hasShammedSymbols ? $replace.call(String(obj), /^(Symbol\(.*\))_[^)]*$/, '$1') : symToString.call(obj);
+          return typeof obj === 'object' && !hasShammedSymbols ? markBoxed(symString) : symString;
+        }
+        if (isElement(obj)) {
+          var s = '<' + $toLowerCase.call(String(obj.nodeName));
+          var attrs = obj.attributes || [];
+          for (var i = 0; i < attrs.length; i++) {
+            s += ' ' + attrs[i].name + '=' + wrapQuotes(quote(attrs[i].value), 'double', opts);
+          }
+          s += '>';
+          if (obj.childNodes && obj.childNodes.length) { s += '...'; }
+          s += '</' + $toLowerCase.call(String(obj.nodeName)) + '>';
+          return s;
+        }
+        if (isArray(obj)) {
+          if (obj.length === 0) { return '[]'; }
+          var xs = arrObjKeys(obj, inspect);
+          if (indent && !singleLineValues(xs)) {
+            return '[' + indentedJoin(xs, indent) + ']';
+          }
+          return '[ ' + $join.call(xs, ', ') + ' ]';
+        }
+        if (isError(obj)) {
+          var parts = arrObjKeys(obj, inspect);
+          if (!('cause' in Error.prototype) && 'cause' in obj && !isEnumerable.call(obj, 'cause')) {
+            return '{ [' + String(obj) + '] ' + $join.call($concat.call('[cause]: ' + inspect(obj.cause), parts), ', ') + ' }';
+          }
+          if (parts.length === 0) { return '[' + String(obj) + ']'; }
+          return '{ [' + String(obj) + '] ' + $join.call(parts, ', ') + ' }';
+        }
+        if (typeof obj === 'object' && customInspect) {
+          if (inspectSymbol && typeof obj[inspectSymbol] === 'function' && utilInspect) {
+            return utilInspect(obj, { depth: maxDepth - depth });
+          } else if (customInspect !== 'symbol' && typeof obj.inspect === 'function') {
+            return obj.inspect();
+          }
+        }
+        if (isMap(obj)) {
+          var mapParts = [];
+          if (mapForEach) {
+            mapForEach.call(obj, function (value, key) {
+              mapParts.push(inspect(key, obj, true) + ' => ' + inspect(value, obj));
+            });
+          }
+          return collectionOf('Map', mapSize.call(obj), mapParts, indent);
+        }
+        if (isSet(obj)) {
+          var setParts = [];
+          if (setForEach) {
+            setForEach.call(obj, function (value) {
+              setParts.push(inspect(value, obj));
+            });
+          }
+          return collectionOf('Set', setSize.call(obj), setParts, indent);
+        }
+        if (isWeakMap(obj)) {
+          return weakCollectionOf('WeakMap');
+        }
+        if (isWeakSet(obj)) {
+          return weakCollectionOf('WeakSet');
+        }
+        if (isWeakRef(obj)) {
+          return weakCollectionOf('WeakRef');
+        }
+        if (isNumber(obj)) {
+          return markBoxed(inspect(Number(obj)));
+        }
+        if (isBigInt(obj)) {
+          return markBoxed(inspect(bigIntValueOf.call(obj)));
+        }
+        if (isBoolean(obj)) {
+          return markBoxed(booleanValueOf.call(obj));
+        }
+        if (isString(obj)) {
+          return markBoxed(inspect(String(obj)));
+        }
+        if (!isDate(obj) && !isRegExp(obj)) {
+          var ys = arrObjKeys(obj, inspect);
+          var isPlainObject = gPO ? gPO(obj) === Object.prototype : obj instanceof Object || obj.constructor === Object;
+          var protoTag = obj instanceof Object ? '' : 'null prototype';
+          var stringTag = !isPlainObject && toStringTag && Object(obj) === obj && toStringTag in obj ? $slice.call(toStr(obj), 8, -1) : protoTag ? 'Object' : '';
+          var constructorTag = isPlainObject || typeof obj.constructor !== 'function' ? '' : obj.constructor.name ? obj.constructor.name + ' ' : '';
+          var tag = constructorTag + (stringTag || protoTag ? '[' + $join.call($concat.call([], stringTag || [], protoTag || []), ': ') + '] ' : '');
+          if (ys.length === 0) { return tag + '{}'; }
+          if (indent) {
+            return tag + '{' + indentedJoin(ys, indent) + '}';
+          }
+          return tag + '{ ' + $join.call(ys, ', ') + ' }';
+        }
+        return String(obj);
+      };
+
+      function wrapQuotes(s, defaultStyle, opts) {
+        var quoteChar = (opts.quoteStyle || defaultStyle) === 'double' ? '"' : "'";
+        return quoteChar + s + quoteChar;
+      }
+
+      function quote(s) {
+        return $replace.call(String(s), /"/g, '&quot;');
+      }
+
+      function isArray(obj) { return toStr(obj) === '[object Array]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }
+      function isDate(obj) { return toStr(obj) === '[object Date]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }
+      function isRegExp(obj) { return toStr(obj) === '[object RegExp]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }
+      function isError(obj) { return toStr(obj) === '[object Error]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }
+      function isString(obj) { return toStr(obj) === '[object String]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }
+      function isNumber(obj) { return toStr(obj) === '[object Number]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }
+      function isBoolean(obj) { return toStr(obj) === '[object Boolean]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }
+
+      // Symbol and BigInt do have Symbol.toStringTag by spec, so that can't be used to eliminate false positives
+      function isSymbol(obj) {
+        if (hasShammedSymbols) {
+          return obj && typeof obj === 'object' && obj instanceof Symbol;
+        }
+        if (typeof obj === 'symbol') {
+          return true;
+        }
+        if (!obj || typeof obj !== 'object' || !symToString) {
+          return false;
+        }
+        try {
+          symToString.call(obj);
+          return true;
+        } catch (e) { }
+        return false;
+      }
+
+      function isBigInt(obj) {
+        if (!obj || typeof obj !== 'object' || !bigIntValueOf) {
+          return false;
+        }
+        try {
+          bigIntValueOf.call(obj);
+          return true;
+        } catch (e) { }
+        return false;
+      }
+
+      var hasOwn = Object.prototype.hasOwnProperty || function (key) { return key in this; };
+      function has(obj, key) {
+        return hasOwn.call(obj, key);
+      }
+
+      function toStr(obj) {
+        return objectToString.call(obj);
+      }
+
+      function nameOf(f) {
+        if (f.name) { return f.name; }
+        var m = $match.call(functionToString.call(f), /^function\s*([\w$]+)/);
+        if (m) { return m[1]; }
+        return null;
+      }
+
+      function indexOf(xs, x) {
+        if (xs.indexOf) { return xs.indexOf(x); }
+        for (var i = 0, l = xs.length; i < l; i++) {
+          if (xs[i] === x) { return i; }
+        }
+        return -1;
+      }
+
+      function isMap(x) {
+        if (!mapSize || !x || typeof x !== 'object') {
+          return false;
+        }
+        try {
+          mapSize.call(x);
+          try {
+            setSize.call(x);
+          } catch (s) {
+            return true;
+          }
+          return x instanceof Map; // core-js workaround, pre-v2.5.0
+        } catch (e) { }
+        return false;
+      }
+
+      function isWeakMap(x) {
+        if (!weakMapHas || !x || typeof x !== 'object') {
+          return false;
+        }
+        try {
+          weakMapHas.call(x, weakMapHas);
+          try {
+            weakSetHas.call(x, weakSetHas);
+          } catch (s) {
+            return true;
+          }
+          return x instanceof WeakMap; // core-js workaround, pre-v2.5.0
+        } catch (e) { }
+        return false;
+      }
+
+      function isWeakRef(x) {
+        if (!weakRefDeref || !x || typeof x !== 'object') {
+          return false;
+        }
+        try {
+          weakRefDeref.call(x);
+          return true;
+        } catch (e) { }
+        return false;
+      }
+
+      function isSet(x) {
+        if (!setSize || !x || typeof x !== 'object') {
+          return false;
+        }
+        try {
+          setSize.call(x);
+          try {
+            mapSize.call(x);
+          } catch (m) {
+            return true;
+          }
+          return x instanceof Set; // core-js workaround, pre-v2.5.0
+        } catch (e) { }
+        return false;
+      }
+
+      function isWeakSet(x) {
+        if (!weakSetHas || !x || typeof x !== 'object') {
+          return false;
+        }
+        try {
+          weakSetHas.call(x, weakSetHas);
+          try {
+            weakMapHas.call(x, weakMapHas);
+          } catch (s) {
+            return true;
+          }
+          return x instanceof WeakSet; // core-js workaround, pre-v2.5.0
+        } catch (e) { }
+        return false;
+      }
+
+      function isElement(x) {
+        if (!x || typeof x !== 'object') { return false; }
+        if (typeof HTMLElement !== 'undefined' && x instanceof HTMLElement) {
+          return true;
+        }
+        return typeof x.nodeName === 'string' && typeof x.getAttribute === 'function';
+      }
+
+      function inspectString(str, opts) {
+        if (str.length > opts.maxStringLength) {
+          var remaining = str.length - opts.maxStringLength;
+          var trailer = '... ' + remaining + ' more character' + (remaining > 1 ? 's' : '');
+          return inspectString($slice.call(str, 0, opts.maxStringLength), opts) + trailer;
+        }
+        // eslint-disable-next-line no-control-regex
+        var s = $replace.call($replace.call(str, /(['\\])/g, '\\$1'), /[\x00-\x1f]/g, lowbyte);
+        return wrapQuotes(s, 'single', opts);
+      }
+
+      function lowbyte(c) {
+        var n = c.charCodeAt(0);
+        var x = {
+          8: 'b',
+          9: 't',
+          10: 'n',
+          12: 'f',
+          13: 'r'
+        }[n];
+        if (x) { return '\\' + x; }
+        return '\\x' + (n < 0x10 ? '0' : '') + $toUpperCase.call(n.toString(16));
+      }
+
+      function markBoxed(str) {
+        return 'Object(' + str + ')';
+      }
+
+      function weakCollectionOf(type) {
+        return type + ' { ? }';
+      }
+
+      function collectionOf(type, size, entries, indent) {
+        var joinedEntries = indent ? indentedJoin(entries, indent) : $join.call(entries, ', ');
+        return type + ' (' + size + ') {' + joinedEntries + '}';
+      }
+
+      function singleLineValues(xs) {
+        for (var i = 0; i < xs.length; i++) {
+          if (indexOf(xs[i], '\n') >= 0) {
+            return false;
+          }
+        }
+        return true;
+      }
+
+      function getIndent(opts, depth) {
+        var baseIndent;
+        if (opts.indent === '\t') {
+          baseIndent = '\t';
+        } else if (typeof opts.indent === 'number' && opts.indent > 0) {
+          baseIndent = $join.call(Array(opts.indent + 1), ' ');
+        } else {
+          return null;
+        }
+        return {
+          base: baseIndent,
+          prev: $join.call(Array(depth + 1), baseIndent)
+        };
+      }
+
+      function indentedJoin(xs, indent) {
+        if (xs.length === 0) { return ''; }
+        var lineJoiner = '\n' + indent.prev + indent.base;
+        return lineJoiner + $join.call(xs, ',' + lineJoiner) + '\n' + indent.prev;
+      }
+
+      function arrObjKeys(obj, inspect) {
+        var isArr = isArray(obj);
+        var xs = [];
+        if (isArr) {
+          xs.length = obj.length;
+          for (var i = 0; i < obj.length; i++) {
+            xs[i] = has(obj, i) ? inspect(obj[i], obj) : '';
+          }
+        }
+        var syms = typeof gOPS === 'function' ? gOPS(obj) : [];
+        var symMap;
+        if (hasShammedSymbols) {
+          symMap = {};
+          for (var k = 0; k < syms.length; k++) {
+            symMap['$' + syms[k]] = syms[k];
+          }
+        }
+
+        for (var key in obj) { // eslint-disable-line no-restricted-syntax
+          if (!has(obj, key)) { continue; } // eslint-disable-line no-restricted-syntax, no-continue
+          if (isArr && String(Number(key)) === key && key < obj.length) { continue; } // eslint-disable-line no-restricted-syntax, no-continue
+          if (hasShammedSymbols && symMap['$' + key] instanceof Symbol) {
+            // this is to prevent shammed Symbols, which are stored as strings, from being included in the string key section
+            continue; // eslint-disable-line no-restricted-syntax, no-continue
+          } else if ($test.call(/[^\w$]/, key)) {
+            xs.push(inspect(key, obj) + ': ' + inspect(obj[key], obj));
+          } else {
+            xs.push(key + ': ' + inspect(obj[key], obj));
+          }
+        }
+        if (typeof gOPS === 'function') {
+          for (var j = 0; j < syms.length; j++) {
+            if (isEnumerable.call(obj, syms[j])) {
+              xs.push('[' + inspect(syms[j]) + ']: ' + inspect(obj[syms[j]], obj));
+            }
+          }
+        }
+        return xs;
+      }
+
+    }, { "./util.inspect": 1 }], 53: [function (require, module, exports) {
+      'use strict';
+
+      var keysShim;
+      if (!Object.keys) {
+        // modified from https://github.com/es-shims/es5-shim
+        var has = Object.prototype.hasOwnProperty;
+        var toStr = Object.prototype.toString;
+        var isArgs = require('./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.call(object) === '[object Function]';
+          var isArguments = isArgs(object);
+          var isString = isObject && toStr.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;
+        };
+      }
+      module.exports = keysShim;
+
+    }, { "./isArguments": 55 }], 54: [function (require, module, exports) {
+      'use strict';
+
+      var slice = Array.prototype.slice;
+      var isArgs = require('./isArguments');
+
+      var origKeys = Object.keys;
+      var keysShim = origKeys ? function keys(o) { return origKeys(o); } : require('./implementation');
+
+      var originalKeys = Object.keys;
+
+      keysShim.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 (isArgs(object)) {
+                return originalKeys(slice.call(object));
+              }
+              return originalKeys(object);
+            };
+          }
+        } else {
+          Object.keys = keysShim;
+        }
+        return Object.keys || keysShim;
+      };
+
+      module.exports = keysShim;
+
+    }, { "./implementation": 53, "./isArguments": 55 }], 55: [function (require, module, exports) {
+      'use strict';
+
+      var toStr = Object.prototype.toString;
+
+      module.exports = 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;
+      };
+
+    }, {}], 56: [function (require, module, exports) {
+      'use strict';
+
+      var RequireObjectCoercible = require('es-abstract/2022/RequireObjectCoercible');
+      var callBound = require('call-bind/callBound');
+      var $isEnumerable = callBound('Object.prototype.propertyIsEnumerable');
+      var $push = callBound('Array.prototype.push');
+
+      module.exports = function entries(O) {
+        var obj = RequireObjectCoercible(O);
+        var entrys = [];
+        for (var key in obj) {
+          if ($isEnumerable(obj, key)) { // checks own-ness as well
+            $push(entrys, [key, obj[key]]);
+          }
+        }
+        return entrys;
+      };
+
+    }, { "call-bind/callBound": 7, "es-abstract/2022/RequireObjectCoercible": 17 }], 57: [function (require, module, exports) {
+      'use strict';
+
+      var define = require('define-properties');
+      var callBind = require('call-bind');
+
+      var implementation = require('./implementation');
+      var getPolyfill = require('./polyfill');
+      var shim = require('./shim');
+
+      var polyfill = callBind(getPolyfill(), Object);
+
+      define(polyfill, {
+        getPolyfill: getPolyfill,
+        implementation: implementation,
+        shim: shim
+      });
+
+      module.exports = polyfill;
+
+    }, { "./implementation": 56, "./polyfill": 58, "./shim": 59, "call-bind": 8, "define-properties": 9 }], 58: [function (require, module, exports) {
+      'use strict';
+
+      var implementation = require('./implementation');
+
+      module.exports = function getPolyfill() {
+        return typeof Object.entries === 'function' ? Object.entries : implementation;
+      };
+
+    }, { "./implementation": 56 }], 59: [function (require, module, exports) {
+      'use strict';
+
+      var getPolyfill = require('./polyfill');
+      var define = require('define-properties');
+
+      module.exports = function shimEntries() {
+        var polyfill = getPolyfill();
+        define(Object, { entries: polyfill }, {
+          entries: function testEntries() {
+            return Object.entries !== polyfill;
+          }
+        });
+        return polyfill;
+      };
+
+    }, { "./polyfill": 58, "define-properties": 9 }], 60: [function (require, module, exports) {
+      'use strict';
+
+      var callBound = require('call-bind/callBound');
+      var GetIntrinsic = require('get-intrinsic');
+      var isRegex = require('is-regex');
+
+      var $exec = callBound('RegExp.prototype.exec');
+      var $TypeError = GetIntrinsic('%TypeError%');
+
+      module.exports = function regexTester(regex) {
+        if (!isRegex(regex)) {
+          throw new $TypeError('`regex` must be a RegExp');
+        }
+        return function test(s) {
+          return $exec(regex, s) !== null;
+        };
+      };
+
+    }, { "call-bind/callBound": 7, "get-intrinsic": 41, "is-regex": 49 }], 61: [function (require, module, exports) {
+      'use strict';
+
+      var RequireObjectCoercible = require('es-abstract/2022/RequireObjectCoercible');
+      var ToString = require('es-abstract/2022/ToString');
+      var callBound = require('call-bind/callBound');
+      var $replace = callBound('String.prototype.replace');
+
+      var mvsIsWS = (/^\s$/).test('\u180E');
+      /* eslint-disable no-control-regex */
+      var leftWhitespace = mvsIsWS
+        ? /^[\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF]+/
+        : /^[\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF]+/;
+      var rightWhitespace = mvsIsWS
+        ? /[\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF]+$/
+        : /[\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF]+$/;
+      /* eslint-enable no-control-regex */
+
+      module.exports = function trim() {
+        var S = ToString(RequireObjectCoercible(this));
+        return $replace($replace(S, leftWhitespace, ''), rightWhitespace, '');
+      };
+
+    }, { "call-bind/callBound": 7, "es-abstract/2022/RequireObjectCoercible": 17, "es-abstract/2022/ToString": 24 }], 62: [function (require, module, exports) {
+      'use strict';
+
+      var callBind = require('call-bind');
+      var define = require('define-properties');
+      var RequireObjectCoercible = require('es-abstract/2022/RequireObjectCoercible');
+
+      var implementation = require('./implementation');
+      var getPolyfill = require('./polyfill');
+      var shim = require('./shim');
+
+      var bound = callBind(getPolyfill());
+      var boundMethod = function trim(receiver) {
+        RequireObjectCoercible(receiver);
+        return bound(receiver);
+      };
+
+      define(boundMethod, {
+        getPolyfill: getPolyfill,
+        implementation: implementation,
+        shim: shim
+      });
+
+      module.exports = boundMethod;
+
+    }, { "./implementation": 61, "./polyfill": 63, "./shim": 64, "call-bind": 8, "define-properties": 9, "es-abstract/2022/RequireObjectCoercible": 17 }], 63: [function (require, module, exports) {
+      'use strict';
+
+      var implementation = require('./implementation');
+
+      var zeroWidthSpace = '\u200b';
+      var mongolianVowelSeparator = '\u180E';
+
+      module.exports = function getPolyfill() {
+        if (
+          String.prototype.trim
+          && zeroWidthSpace.trim() === zeroWidthSpace
+          && mongolianVowelSeparator.trim() === mongolianVowelSeparator
+          && ('_' + mongolianVowelSeparator).trim() === ('_' + mongolianVowelSeparator)
+          && (mongolianVowelSeparator + '_').trim() === (mongolianVowelSeparator + '_')
+        ) {
+          return String.prototype.trim;
+        }
+        return implementation;
+      };
+
+    }, { "./implementation": 61 }], 64: [function (require, module, exports) {
+      'use strict';
+
+      var define = require('define-properties');
+      var getPolyfill = require('./polyfill');
+
+      module.exports = function shimStringTrim() {
+        var polyfill = getPolyfill();
+        define(String.prototype, { trim: polyfill }, {
+          trim: function testTrim() {
+            return String.prototype.trim !== polyfill;
+          }
+        });
+        return polyfill;
+      };
+
+    }, { "./polyfill": 63, "define-properties": 9 }], 65: [function (require, module, exports) {
+      /**
+       * Copyright (c) 2014-present, Facebook, Inc.
+       *
+       * This source code is licensed under the MIT license found in the
+       * LICENSE file in the root directory of this source tree.
+       */
+
+      'use strict';
+
+      /**
+       * Similar to invariant but only logs a warning if the condition is not met.
+       * This can be used to log issues in development environments in critical
+       * paths. Removing the logging code for production environments will keep the
+       * same logic and follow the same code paths.
+       */
+
+      var __DEV__ = false;
+
+      var warning = function () { };
+
+      if (__DEV__) {
+        var printWarning = function printWarning(format, args) {
+          var len = arguments.length;
+          args = new Array(len > 1 ? len - 1 : 0);
+          for (var key = 1; key < len; key++) {
+            args[key - 1] = arguments[key];
+          }
+          var argIndex = 0;
+          var message = 'Warning: ' +
+            format.replace(/%s/g, function () {
+              return args[argIndex++];
+            });
+          if (typeof console !== 'undefined') {
+            console.error(message);
+          }
+          try {
+            // --- Welcome to debugging React ---
+            // This error was thrown as a convenience so that you can use this stack
+            // to find the callsite that caused this warning to fire.
+            throw new Error(message);
+          } catch (x) { }
+        }
+
+        warning = function (condition, format, args) {
+          var len = arguments.length;
+          args = new Array(len > 2 ? len - 2 : 0);
+          for (var key = 2; key < len; key++) {
+            args[key - 2] = arguments[key];
+          }
+          if (format === undefined) {
+            throw new Error(
+              '`warning(condition, format, ...args)` requires a warning ' +
+              'message argument'
+            );
+          }
+          if (!condition) {
+            printWarning.apply(null, [format].concat(args));
+          }
+        };
+      }
+
+      module.exports = warning;
+
+    }, {}]
+  }, {}, [2])(2)
+});