axe-core 4.8.1 → 4.8.2

package/axe.js

@@ -1,4 +1,4 @@
-/*! axe v4.8.1
+/*! axe v4.8.2
  * Copyright (c) 2015 - 2023 Deque Systems, Inc.
  *
  * Your use of this Source Code Form is subject to the terms of the Mozilla Public
@@ -22,7 +22,7 @@
     }, _typeof(obj);
   }
   var axe = axe || {};
-  axe.version = '4.8.1';
+  axe.version = '4.8.2';
   if (typeof define === 'function' && define.amd) {
     define('axe-core', [], function() {
       return axe;
@@ -1274,24 +1274,24 @@
         symbol: true
       };
       module.exports = function() {
-        var _Symbol = global2.Symbol;
+        var Symbol2 = global2.Symbol;
         var symbol;
-        if (typeof _Symbol !== 'function') {
+        if (typeof Symbol2 !== 'function') {
           return false;
         }
-        symbol = _Symbol('test symbol');
+        symbol = Symbol2('test symbol');
         try {
           String(symbol);
         } catch (e) {
           return false;
         }
-        if (!validTypes[_typeof(_Symbol.iterator)]) {
+        if (!validTypes[_typeof(Symbol2.iterator)]) {
           return false;
         }
-        if (!validTypes[_typeof(_Symbol.toPrimitive)]) {
+        if (!validTypes[_typeof(Symbol2.toPrimitive)]) {
           return false;
         }
-        if (!validTypes[_typeof(_Symbol.toStringTag)]) {
+        if (!validTypes[_typeof(Symbol2.toStringTag)]) {
           return false;
         }
         return true;
@@ -1419,15 +1419,15 @@
       } else {
         NativeSymbol = null;
       }
-      HiddenSymbol = function _Symbol2(description) {
+      HiddenSymbol = function Symbol2(description) {
         if (this instanceof HiddenSymbol) {
           throw new TypeError('Symbol is not a constructor');
         }
         return SymbolPolyfill(description);
       };
-      module.exports = SymbolPolyfill = function _Symbol3(description) {
+      module.exports = SymbolPolyfill = function Symbol2(description) {
         var symbol;
-        if (this instanceof _Symbol3) {
+        if (this instanceof Symbol2) {
           throw new TypeError('Symbol is not a constructor');
         }
         if (isNativeSafe) {
@@ -4959,6 +4959,670 @@
         }
       })(typeof globalThis !== 'undefined' ? globalThis : typeof self !== 'undefined' ? self : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : exports);
     });
+    var require_global = __commonJS(function(exports, module) {
+      var check = function check(it) {
+        return it && it.Math == Math && it;
+      };
+      module.exports = check((typeof globalThis === 'undefined' ? 'undefined' : _typeof(globalThis)) == 'object' && globalThis) || check((typeof window === 'undefined' ? 'undefined' : _typeof(window)) == 'object' && window) || check((typeof self === 'undefined' ? 'undefined' : _typeof(self)) == 'object' && self) || check((typeof global === 'undefined' ? 'undefined' : _typeof(global)) == 'object' && global) || function() {
+        return this;
+      }() || Function('return this')();
+    });
+    var require_fails = __commonJS(function(exports, module) {
+      module.exports = function(exec) {
+        try {
+          return !!exec();
+        } catch (error) {
+          return true;
+        }
+      };
+    });
+    var require_function_bind_native = __commonJS(function(exports, module) {
+      var fails = require_fails();
+      module.exports = !fails(function() {
+        var test = function() {}.bind();
+        return typeof test != 'function' || test.hasOwnProperty('prototype');
+      });
+    });
+    var require_function_apply = __commonJS(function(exports, module) {
+      var NATIVE_BIND = require_function_bind_native();
+      var FunctionPrototype = Function.prototype;
+      var apply = FunctionPrototype.apply;
+      var call = FunctionPrototype.call;
+      module.exports = (typeof Reflect === 'undefined' ? 'undefined' : _typeof(Reflect)) == 'object' && Reflect.apply || (NATIVE_BIND ? call.bind(apply) : function() {
+        return call.apply(apply, arguments);
+      });
+    });
+    var require_function_uncurry_this = __commonJS(function(exports, module) {
+      var NATIVE_BIND = require_function_bind_native();
+      var FunctionPrototype = Function.prototype;
+      var call = FunctionPrototype.call;
+      var uncurryThisWithBind = NATIVE_BIND && FunctionPrototype.bind.bind(call, call);
+      module.exports = NATIVE_BIND ? uncurryThisWithBind : function(fn) {
+        return function() {
+          return call.apply(fn, arguments);
+        };
+      };
+    });
+    var require_classof_raw = __commonJS(function(exports, module) {
+      var uncurryThis = require_function_uncurry_this();
+      var toString = uncurryThis({}.toString);
+      var stringSlice = uncurryThis(''.slice);
+      module.exports = function(it) {
+        return stringSlice(toString(it), 8, -1);
+      };
+    });
+    var require_function_uncurry_this_clause = __commonJS(function(exports, module) {
+      var classofRaw = require_classof_raw();
+      var uncurryThis = require_function_uncurry_this();
+      module.exports = function(fn) {
+        if (classofRaw(fn) === 'Function') {
+          return uncurryThis(fn);
+        }
+      };
+    });
+    var require_document_all = __commonJS(function(exports, module) {
+      var documentAll = (typeof document === 'undefined' ? 'undefined' : _typeof(document)) == 'object' && document.all;
+      var IS_HTMLDDA = typeof documentAll == 'undefined' && documentAll !== void 0;
+      module.exports = {
+        all: documentAll,
+        IS_HTMLDDA: IS_HTMLDDA
+      };
+    });
+    var require_is_callable2 = __commonJS(function(exports, module) {
+      var $documentAll = require_document_all();
+      var documentAll = $documentAll.all;
+      module.exports = $documentAll.IS_HTMLDDA ? function(argument) {
+        return typeof argument == 'function' || argument === documentAll;
+      } : function(argument) {
+        return typeof argument == 'function';
+      };
+    });
+    var require_descriptors = __commonJS(function(exports, module) {
+      var fails = require_fails();
+      module.exports = !fails(function() {
+        return Object.defineProperty({}, 1, {
+          get: function get() {
+            return 7;
+          }
+        })[1] != 7;
+      });
+    });
+    var require_function_call = __commonJS(function(exports, module) {
+      var NATIVE_BIND = require_function_bind_native();
+      var call = Function.prototype.call;
+      module.exports = NATIVE_BIND ? call.bind(call) : function() {
+        return call.apply(call, arguments);
+      };
+    });
+    var require_object_property_is_enumerable = __commonJS(function(exports) {
+      'use strict';
+      var $propertyIsEnumerable = {}.propertyIsEnumerable;
+      var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+      var NASHORN_BUG = getOwnPropertyDescriptor && !$propertyIsEnumerable.call({
+        1: 2
+      }, 1);
+      exports.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
+        var descriptor = getOwnPropertyDescriptor(this, V);
+        return !!descriptor && descriptor.enumerable;
+      } : $propertyIsEnumerable;
+    });
+    var require_create_property_descriptor = __commonJS(function(exports, module) {
+      module.exports = function(bitmap, value) {
+        return {
+          enumerable: !(bitmap & 1),
+          configurable: !(bitmap & 2),
+          writable: !(bitmap & 4),
+          value: value
+        };
+      };
+    });
+    var require_indexed_object = __commonJS(function(exports, module) {
+      var uncurryThis = require_function_uncurry_this();
+      var fails = require_fails();
+      var classof = require_classof_raw();
+      var $Object = Object;
+      var split = uncurryThis(''.split);
+      module.exports = fails(function() {
+        return !$Object('z').propertyIsEnumerable(0);
+      }) ? function(it) {
+        return classof(it) == 'String' ? split(it, '') : $Object(it);
+      } : $Object;
+    });
+    var require_is_null_or_undefined = __commonJS(function(exports, module) {
+      module.exports = function(it) {
+        return it === null || it === void 0;
+      };
+    });
+    var require_require_object_coercible = __commonJS(function(exports, module) {
+      var isNullOrUndefined = require_is_null_or_undefined();
+      var $TypeError = TypeError;
+      module.exports = function(it) {
+        if (isNullOrUndefined(it)) {
+          throw $TypeError('Can\'t call method on ' + it);
+        }
+        return it;
+      };
+    });
+    var require_to_indexed_object = __commonJS(function(exports, module) {
+      var IndexedObject = require_indexed_object();
+      var requireObjectCoercible = require_require_object_coercible();
+      module.exports = function(it) {
+        return IndexedObject(requireObjectCoercible(it));
+      };
+    });
+    var require_is_object2 = __commonJS(function(exports, module) {
+      var isCallable = require_is_callable2();
+      var $documentAll = require_document_all();
+      var documentAll = $documentAll.all;
+      module.exports = $documentAll.IS_HTMLDDA ? function(it) {
+        return _typeof(it) == 'object' ? it !== null : isCallable(it) || it === documentAll;
+      } : function(it) {
+        return _typeof(it) == 'object' ? it !== null : isCallable(it);
+      };
+    });
+    var require_path = __commonJS(function(exports, module) {
+      module.exports = {};
+    });
+    var require_get_built_in = __commonJS(function(exports, module) {
+      var path = require_path();
+      var global2 = require_global();
+      var isCallable = require_is_callable2();
+      var aFunction = function aFunction(variable) {
+        return isCallable(variable) ? variable : void 0;
+      };
+      module.exports = function(namespace, method) {
+        return arguments.length < 2 ? aFunction(path[namespace]) || aFunction(global2[namespace]) : path[namespace] && path[namespace][method] || global2[namespace] && global2[namespace][method];
+      };
+    });
+    var require_object_is_prototype_of = __commonJS(function(exports, module) {
+      var uncurryThis = require_function_uncurry_this();
+      module.exports = uncurryThis({}.isPrototypeOf);
+    });
+    var require_engine_user_agent = __commonJS(function(exports, module) {
+      var getBuiltIn = require_get_built_in();
+      module.exports = getBuiltIn('navigator', 'userAgent') || '';
+    });
+    var require_engine_v8_version = __commonJS(function(exports, module) {
+      var global2 = require_global();
+      var userAgent = require_engine_user_agent();
+      var process2 = global2.process;
+      var Deno = global2.Deno;
+      var versions = process2 && process2.versions || Deno && Deno.version;
+      var v8 = versions && versions.v8;
+      var match;
+      var version;
+      if (v8) {
+        match = v8.split('.');
+        version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]);
+      }
+      if (!version && userAgent) {
+        match = userAgent.match(/Edge\/(\d+)/);
+        if (!match || match[1] >= 74) {
+          match = userAgent.match(/Chrome\/(\d+)/);
+          if (match) {
+            version = +match[1];
+          }
+        }
+      }
+      module.exports = version;
+    });
+    var require_symbol_constructor_detection = __commonJS(function(exports, module) {
+      var V8_VERSION = require_engine_v8_version();
+      var fails = require_fails();
+      module.exports = !!Object.getOwnPropertySymbols && !fails(function() {
+        var symbol = Symbol();
+        return !String(symbol) || !(Object(symbol) instanceof Symbol) || !Symbol.sham && V8_VERSION && V8_VERSION < 41;
+      });
+    });
+    var require_use_symbol_as_uid = __commonJS(function(exports, module) {
+      var NATIVE_SYMBOL = require_symbol_constructor_detection();
+      module.exports = NATIVE_SYMBOL && !Symbol.sham && _typeof(Symbol.iterator) == 'symbol';
+    });
+    var require_is_symbol2 = __commonJS(function(exports, module) {
+      var getBuiltIn = require_get_built_in();
+      var isCallable = require_is_callable2();
+      var isPrototypeOf = require_object_is_prototype_of();
+      var USE_SYMBOL_AS_UID = require_use_symbol_as_uid();
+      var $Object = Object;
+      module.exports = USE_SYMBOL_AS_UID ? function(it) {
+        return _typeof(it) == 'symbol';
+      } : function(it) {
+        var $Symbol = getBuiltIn('Symbol');
+        return isCallable($Symbol) && isPrototypeOf($Symbol.prototype, $Object(it));
+      };
+    });
+    var require_try_to_string = __commonJS(function(exports, module) {
+      var $String = String;
+      module.exports = function(argument) {
+        try {
+          return $String(argument);
+        } catch (error) {
+          return 'Object';
+        }
+      };
+    });
+    var require_a_callable = __commonJS(function(exports, module) {
+      var isCallable = require_is_callable2();
+      var tryToString = require_try_to_string();
+      var $TypeError = TypeError;
+      module.exports = function(argument) {
+        if (isCallable(argument)) {
+          return argument;
+        }
+        throw $TypeError(tryToString(argument) + ' is not a function');
+      };
+    });
+    var require_get_method = __commonJS(function(exports, module) {
+      var aCallable = require_a_callable();
+      var isNullOrUndefined = require_is_null_or_undefined();
+      module.exports = function(V, P) {
+        var func = V[P];
+        return isNullOrUndefined(func) ? void 0 : aCallable(func);
+      };
+    });
+    var require_ordinary_to_primitive = __commonJS(function(exports, module) {
+      var call = require_function_call();
+      var isCallable = require_is_callable2();
+      var isObject = require_is_object2();
+      var $TypeError = TypeError;
+      module.exports = function(input, pref) {
+        var fn, val;
+        if (pref === 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) {
+          return val;
+        }
+        if (isCallable(fn = input.valueOf) && !isObject(val = call(fn, input))) {
+          return val;
+        }
+        if (pref !== 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) {
+          return val;
+        }
+        throw $TypeError('Can\'t convert object to primitive value');
+      };
+    });
+    var require_is_pure = __commonJS(function(exports, module) {
+      module.exports = true;
+    });
+    var require_define_global_property = __commonJS(function(exports, module) {
+      var global2 = require_global();
+      var defineProperty = Object.defineProperty;
+      module.exports = function(key, value) {
+        try {
+          defineProperty(global2, key, {
+            value: value,
+            configurable: true,
+            writable: true
+          });
+        } catch (error) {
+          global2[key] = value;
+        }
+        return value;
+      };
+    });
+    var require_shared_store = __commonJS(function(exports, module) {
+      var global2 = require_global();
+      var defineGlobalProperty = require_define_global_property();
+      var SHARED = '__core-js_shared__';
+      var store = global2[SHARED] || defineGlobalProperty(SHARED, {});
+      module.exports = store;
+    });
+    var require_shared = __commonJS(function(exports, module) {
+      var IS_PURE = require_is_pure();
+      var store = require_shared_store();
+      (module.exports = function(key, value) {
+        return store[key] || (store[key] = value !== void 0 ? value : {});
+      })('versions', []).push({
+        version: '3.26.1',
+        mode: IS_PURE ? 'pure' : 'global',
+        copyright: '\xa9 2014-2022 Denis Pushkarev (zloirock.ru)',
+        license: 'https://github.com/zloirock/core-js/blob/v3.26.1/LICENSE',
+        source: 'https://github.com/zloirock/core-js'
+      });
+    });
+    var require_to_object = __commonJS(function(exports, module) {
+      var requireObjectCoercible = require_require_object_coercible();
+      var $Object = Object;
+      module.exports = function(argument) {
+        return $Object(requireObjectCoercible(argument));
+      };
+    });
+    var require_has_own_property = __commonJS(function(exports, module) {
+      var uncurryThis = require_function_uncurry_this();
+      var toObject = require_to_object();
+      var hasOwnProperty2 = uncurryThis({}.hasOwnProperty);
+      module.exports = Object.hasOwn || function hasOwn2(it, key) {
+        return hasOwnProperty2(toObject(it), key);
+      };
+    });
+    var require_uid = __commonJS(function(exports, module) {
+      var uncurryThis = require_function_uncurry_this();
+      var id = 0;
+      var postfix = Math.random();
+      var toString = uncurryThis(1..toString);
+      module.exports = function(key) {
+        return 'Symbol(' + (key === void 0 ? '' : key) + ')_' + toString(++id + postfix, 36);
+      };
+    });
+    var require_well_known_symbol = __commonJS(function(exports, module) {
+      var global2 = require_global();
+      var shared = require_shared();
+      var hasOwn2 = require_has_own_property();
+      var uid = require_uid();
+      var NATIVE_SYMBOL = require_symbol_constructor_detection();
+      var USE_SYMBOL_AS_UID = require_use_symbol_as_uid();
+      var WellKnownSymbolsStore = shared('wks');
+      var Symbol2 = global2.Symbol;
+      var symbolFor = Symbol2 && Symbol2['for'];
+      var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol2 : Symbol2 && Symbol2.withoutSetter || uid;
+      module.exports = function(name) {
+        if (!hasOwn2(WellKnownSymbolsStore, name) || !(NATIVE_SYMBOL || typeof WellKnownSymbolsStore[name] == 'string')) {
+          var description = 'Symbol.' + name;
+          if (NATIVE_SYMBOL && hasOwn2(Symbol2, name)) {
+            WellKnownSymbolsStore[name] = Symbol2[name];
+          } else if (USE_SYMBOL_AS_UID && symbolFor) {
+            WellKnownSymbolsStore[name] = symbolFor(description);
+          } else {
+            WellKnownSymbolsStore[name] = createWellKnownSymbol(description);
+          }
+        }
+        return WellKnownSymbolsStore[name];
+      };
+    });
+    var require_to_primitive = __commonJS(function(exports, module) {
+      var call = require_function_call();
+      var isObject = require_is_object2();
+      var isSymbol = require_is_symbol2();
+      var getMethod = require_get_method();
+      var ordinaryToPrimitive = require_ordinary_to_primitive();
+      var wellKnownSymbol = require_well_known_symbol();
+      var $TypeError = TypeError;
+      var TO_PRIMITIVE = wellKnownSymbol('toPrimitive');
+      module.exports = function(input, pref) {
+        if (!isObject(input) || isSymbol(input)) {
+          return input;
+        }
+        var exoticToPrim = getMethod(input, TO_PRIMITIVE);
+        var result;
+        if (exoticToPrim) {
+          if (pref === void 0) {
+            pref = 'default';
+          }
+          result = call(exoticToPrim, input, pref);
+          if (!isObject(result) || isSymbol(result)) {
+            return result;
+          }
+          throw $TypeError('Can\'t convert object to primitive value');
+        }
+        if (pref === void 0) {
+          pref = 'number';
+        }
+        return ordinaryToPrimitive(input, pref);
+      };
+    });
+    var require_to_property_key = __commonJS(function(exports, module) {
+      var toPrimitive = require_to_primitive();
+      var isSymbol = require_is_symbol2();
+      module.exports = function(argument) {
+        var key = toPrimitive(argument, 'string');
+        return isSymbol(key) ? key : key + '';
+      };
+    });
+    var require_document_create_element = __commonJS(function(exports, module) {
+      var global2 = require_global();
+      var isObject = require_is_object2();
+      var document2 = global2.document;
+      var EXISTS = isObject(document2) && isObject(document2.createElement);
+      module.exports = function(it) {
+        return EXISTS ? document2.createElement(it) : {};
+      };
+    });
+    var require_ie8_dom_define = __commonJS(function(exports, module) {
+      var DESCRIPTORS = require_descriptors();
+      var fails = require_fails();
+      var createElement = require_document_create_element();
+      module.exports = !DESCRIPTORS && !fails(function() {
+        return Object.defineProperty(createElement('div'), 'a', {
+          get: function get() {
+            return 7;
+          }
+        }).a != 7;
+      });
+    });
+    var require_object_get_own_property_descriptor = __commonJS(function(exports) {
+      var DESCRIPTORS = require_descriptors();
+      var call = require_function_call();
+      var propertyIsEnumerableModule = require_object_property_is_enumerable();
+      var createPropertyDescriptor = require_create_property_descriptor();
+      var toIndexedObject = require_to_indexed_object();
+      var toPropertyKey = require_to_property_key();
+      var hasOwn2 = require_has_own_property();
+      var IE8_DOM_DEFINE = require_ie8_dom_define();
+      var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+      exports.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {
+        O = toIndexedObject(O);
+        P = toPropertyKey(P);
+        if (IE8_DOM_DEFINE) {
+          try {
+            return $getOwnPropertyDescriptor(O, P);
+          } catch (error) {}
+        }
+        if (hasOwn2(O, P)) {
+          return createPropertyDescriptor(!call(propertyIsEnumerableModule.f, O, P), O[P]);
+        }
+      };
+    });
+    var require_is_forced = __commonJS(function(exports, module) {
+      var fails = require_fails();
+      var isCallable = require_is_callable2();
+      var replacement = /#|\.prototype\./;
+      var isForced = function isForced(feature, detection) {
+        var value = data[normalize(feature)];
+        return value == POLYFILL ? true : value == NATIVE ? false : isCallable(detection) ? fails(detection) : !!detection;
+      };
+      var normalize = isForced.normalize = function(string) {
+        return String(string).replace(replacement, '.').toLowerCase();
+      };
+      var data = isForced.data = {};
+      var NATIVE = isForced.NATIVE = 'N';
+      var POLYFILL = isForced.POLYFILL = 'P';
+      module.exports = isForced;
+    });
+    var require_function_bind_context = __commonJS(function(exports, module) {
+      var uncurryThis = require_function_uncurry_this_clause();
+      var aCallable = require_a_callable();
+      var NATIVE_BIND = require_function_bind_native();
+      var bind = uncurryThis(uncurryThis.bind);
+      module.exports = function(fn, that) {
+        aCallable(fn);
+        return that === void 0 ? fn : NATIVE_BIND ? bind(fn, that) : function() {
+          return fn.apply(that, arguments);
+        };
+      };
+    });
+    var require_v8_prototype_define_bug = __commonJS(function(exports, module) {
+      var DESCRIPTORS = require_descriptors();
+      var fails = require_fails();
+      module.exports = DESCRIPTORS && fails(function() {
+        return Object.defineProperty(function() {}, 'prototype', {
+          value: 42,
+          writable: false
+        }).prototype != 42;
+      });
+    });
+    var require_an_object = __commonJS(function(exports, module) {
+      var isObject = require_is_object2();
+      var $String = String;
+      var $TypeError = TypeError;
+      module.exports = function(argument) {
+        if (isObject(argument)) {
+          return argument;
+        }
+        throw $TypeError($String(argument) + ' is not an object');
+      };
+    });
+    var require_object_define_property = __commonJS(function(exports) {
+      var DESCRIPTORS = require_descriptors();
+      var IE8_DOM_DEFINE = require_ie8_dom_define();
+      var V8_PROTOTYPE_DEFINE_BUG = require_v8_prototype_define_bug();
+      var anObject = require_an_object();
+      var toPropertyKey = require_to_property_key();
+      var $TypeError = TypeError;
+      var $defineProperty = Object.defineProperty;
+      var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+      var ENUMERABLE = 'enumerable';
+      var CONFIGURABLE = 'configurable';
+      var WRITABLE = 'writable';
+      exports.f = DESCRIPTORS ? V8_PROTOTYPE_DEFINE_BUG ? function defineProperty(O, P, Attributes) {
+        anObject(O);
+        P = toPropertyKey(P);
+        anObject(Attributes);
+        if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {
+          var current = $getOwnPropertyDescriptor(O, P);
+          if (current && current[WRITABLE]) {
+            O[P] = Attributes.value;
+            Attributes = {
+              configurable: CONFIGURABLE in Attributes ? Attributes[CONFIGURABLE] : current[CONFIGURABLE],
+              enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE],
+              writable: false
+            };
+          }
+        }
+        return $defineProperty(O, P, Attributes);
+      } : $defineProperty : function defineProperty(O, P, Attributes) {
+        anObject(O);
+        P = toPropertyKey(P);
+        anObject(Attributes);
+        if (IE8_DOM_DEFINE) {
+          try {
+            return $defineProperty(O, P, Attributes);
+          } catch (error) {}
+        }
+        if ('get' in Attributes || 'set' in Attributes) {
+          throw $TypeError('Accessors not supported');
+        }
+        if ('value' in Attributes) {
+          O[P] = Attributes.value;
+        }
+        return O;
+      };
+    });
+    var require_create_non_enumerable_property = __commonJS(function(exports, module) {
+      var DESCRIPTORS = require_descriptors();
+      var definePropertyModule = require_object_define_property();
+      var createPropertyDescriptor = require_create_property_descriptor();
+      module.exports = DESCRIPTORS ? function(object, key, value) {
+        return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));
+      } : function(object, key, value) {
+        object[key] = value;
+        return object;
+      };
+    });
+    var require_export = __commonJS(function(exports, module) {
+      'use strict';
+      var global2 = require_global();
+      var apply = require_function_apply();
+      var uncurryThis = require_function_uncurry_this_clause();
+      var isCallable = require_is_callable2();
+      var getOwnPropertyDescriptor = require_object_get_own_property_descriptor().f;
+      var isForced = require_is_forced();
+      var path = require_path();
+      var bind = require_function_bind_context();
+      var createNonEnumerableProperty = require_create_non_enumerable_property();
+      var hasOwn2 = require_has_own_property();
+      var wrapConstructor = function wrapConstructor(NativeConstructor) {
+        var Wrapper = function Wrapper(a2, b2, c4) {
+          if (this instanceof Wrapper) {
+            switch (arguments.length) {
+             case 0:
+              return new NativeConstructor();
+
+             case 1:
+              return new NativeConstructor(a2);
+
+             case 2:
+              return new NativeConstructor(a2, b2);
+            }
+            return new NativeConstructor(a2, b2, c4);
+          }
+          return apply(NativeConstructor, this, arguments);
+        };
+        Wrapper.prototype = NativeConstructor.prototype;
+        return Wrapper;
+      };
+      module.exports = function(options, source) {
+        var TARGET = options.target;
+        var GLOBAL = options.global;
+        var STATIC = options.stat;
+        var PROTO = options.proto;
+        var nativeSource = GLOBAL ? global2 : STATIC ? global2[TARGET] : (global2[TARGET] || {}).prototype;
+        var target = GLOBAL ? path : path[TARGET] || createNonEnumerableProperty(path, TARGET, {})[TARGET];
+        var targetPrototype = target.prototype;
+        var FORCED, USE_NATIVE, VIRTUAL_PROTOTYPE;
+        var key, sourceProperty, targetProperty, nativeProperty, resultProperty, descriptor;
+        for (key in source) {
+          FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);
+          USE_NATIVE = !FORCED && nativeSource && hasOwn2(nativeSource, key);
+          targetProperty = target[key];
+          if (USE_NATIVE) {
+            if (options.dontCallGetSet) {
+              descriptor = getOwnPropertyDescriptor(nativeSource, key);
+              nativeProperty = descriptor && descriptor.value;
+            } else {
+              nativeProperty = nativeSource[key];
+            }
+          }
+          sourceProperty = USE_NATIVE && nativeProperty ? nativeProperty : source[key];
+          if (USE_NATIVE && _typeof(targetProperty) == _typeof(sourceProperty)) {
+            continue;
+          }
+          if (options.bind && USE_NATIVE) {
+            resultProperty = bind(sourceProperty, global2);
+          } else if (options.wrap && USE_NATIVE) {
+            resultProperty = wrapConstructor(sourceProperty);
+          } else if (PROTO && isCallable(sourceProperty)) {
+            resultProperty = uncurryThis(sourceProperty);
+          } else {
+            resultProperty = sourceProperty;
+          }
+          if (options.sham || sourceProperty && sourceProperty.sham || targetProperty && targetProperty.sham) {
+            createNonEnumerableProperty(resultProperty, 'sham', true);
+          }
+          createNonEnumerableProperty(target, key, resultProperty);
+          if (PROTO) {
+            VIRTUAL_PROTOTYPE = TARGET + 'Prototype';
+            if (!hasOwn2(path, VIRTUAL_PROTOTYPE)) {
+              createNonEnumerableProperty(path, VIRTUAL_PROTOTYPE, {});
+            }
+            createNonEnumerableProperty(path[VIRTUAL_PROTOTYPE], key, sourceProperty);
+            if (options.real && targetPrototype && !targetPrototype[key]) {
+              createNonEnumerableProperty(targetPrototype, key, sourceProperty);
+            }
+          }
+        }
+      };
+    });
+    var require_es_object_has_own = __commonJS(function() {
+      var $ = require_export();
+      var hasOwn2 = require_has_own_property();
+      $({
+        target: 'Object',
+        stat: true
+      }, {
+        hasOwn: hasOwn2
+      });
+    });
+    var require_has_own = __commonJS(function(exports, module) {
+      require_es_object_has_own();
+      var path = require_path();
+      module.exports = path.Object.hasOwn;
+    });
+    var require_has_own2 = __commonJS(function(exports, module) {
+      var parent = require_has_own();
+      module.exports = parent;
+    });
+    var require_has_own3 = __commonJS(function(exports, module) {
+      var parent = require_has_own2();
+      module.exports = parent;
+    });
     var definitions = [ {
       name: 'NA',
       value: 'inapplicable',
@@ -15532,6 +16196,10 @@
     var import_es6_promise = __toModule(require_es6_promise());
     var import_typedarray = __toModule(require_typedarray());
     var import_weakmap_polyfill = __toModule(require_weakmap_polyfill());
+    var import_has_own = __toModule(require_has_own3());
+    if (!('hasOwn' in Object)) {
+      Object.hasOwn = import_has_own['default'];
+    }
     import_dot['default'].templateSettings.strip = false;
     if (!('Promise' in window)) {
       import_es6_promise['default'].polyfill();