axe 13.0.0 → 13.0.1

package/dist/axe.js

@@ -52,8 +52,7 @@ const get = (obj, parts, length) => {
   }
   return obj;
 };
-module.exports = function (obj, path) {
-  let sep = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '.';
+module.exports = (obj, path, sep = '.') => {
   if (!isObject(obj) || !path) {
     return obj;
   }
@@ -92,8 +91,7 @@ const set = (obj, parts, length, val) => {
 * @param {String} [sep = '.']
 * @returns {Object}
 */
-module.exports = function (obj, path, val) {
-  let sep = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : '.';
+module.exports = (obj, path, val, sep = '.') => {
   if (!isObject(obj) || !path || !path.length) {
     return obj;
   }
@@ -178,6 +176,71 @@ exports.isBooleanable = isBooleanable;
 },{}],7:[function(require,module,exports){
 
 },{}],8:[function(require,module,exports){
+'use strict';
+
+var bind = require('function-bind');
+var $apply = require('./functionApply');
+var $call = require('./functionCall');
+var $reflectApply = require('./reflectApply');
+
+/** @type {import('./actualApply')} */
+module.exports = $reflectApply || bind.call($call, $apply);
+
+},{"./functionApply":9,"./functionCall":10,"./reflectApply":12,"function-bind":27}],9:[function(require,module,exports){
+'use strict';
+
+/** @type {import('./functionApply')} */
+module.exports = Function.prototype.apply;
+
+},{}],10:[function(require,module,exports){
+'use strict';
+
+/** @type {import('./functionCall')} */
+module.exports = Function.prototype.call;
+
+},{}],11:[function(require,module,exports){
+'use strict';
+
+var bind = require('function-bind');
+var $TypeError = require('es-errors/type');
+var $call = require('./functionCall');
+var $actualApply = require('./actualApply');
+
+/** @type {(args: [Function, thisArg?: unknown, ...args: unknown[]]) => Function} TODO FIXME, find a way to use import('.') */
+module.exports = function callBindBasic(args) {
+  if (args.length < 1 || typeof args[0] !== 'function') {
+    throw new $TypeError('a function is required');
+  }
+  return $actualApply(bind, $call, args);
+};
+
+},{"./actualApply":8,"./functionCall":10,"es-errors/type":22,"function-bind":27}],12:[function(require,module,exports){
+'use strict';
+
+/** @type {import('./reflectApply')} */
+module.exports = typeof Reflect !== 'undefined' && Reflect && Reflect.apply;
+
+},{}],13:[function(require,module,exports){
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+var callBindBasic = require('call-bind-apply-helpers');
+
+/** @type {(thisArg: string, searchString: string, position?: number) => number} */
+var $indexOf = callBindBasic([GetIntrinsic('%String.prototype.indexOf%')]);
+
+/** @type {import('.')} */
+module.exports = function callBoundIntrinsic(name, allowMissing) {
+  /* eslint no-extra-parens: 0 */
+
+  var intrinsic = /** @type {(this: unknown, ...args: unknown[]) => unknown} */GetIntrinsic(name, !!allowMissing);
+  if (typeof intrinsic === 'function' && $indexOf(name, '.prototype.') > -1) {
+    return callBindBasic(/** @type {const} */[intrinsic]);
+  }
+  return intrinsic;
+};
+
+},{"call-bind-apply-helpers":11,"get-intrinsic":28}],14:[function(require,module,exports){
 // Console-polyfill. MIT license.
 // https://github.com/paulmillr/console-polyfill
 // Make it safe to do console.log() always.
@@ -197,7 +260,98 @@ exports.isBooleanable = isBooleanable;
   // Using `this` for web workers & supports Browserify / Webpack.
 })(typeof window === 'undefined' ? this : window);
 
-},{}],9:[function(require,module,exports){
+},{}],15:[function(require,module,exports){
+'use strict';
+
+var callBind = require('call-bind-apply-helpers');
+var gOPD = require('gopd');
+var hasProtoAccessor;
+try {
+  // eslint-disable-next-line no-extra-parens, no-proto
+  hasProtoAccessor = /** @type {{ __proto__?: typeof Array.prototype }} */[].__proto__ === Array.prototype;
+} catch (e) {
+  if (!e || typeof e !== 'object' || !('code' in e) || e.code !== 'ERR_PROTO_ACCESS') {
+    throw e;
+  }
+}
+
+// eslint-disable-next-line no-extra-parens
+var desc = !!hasProtoAccessor && gOPD && gOPD(Object.prototype, /** @type {keyof typeof Object.prototype} */'__proto__');
+var $Object = Object;
+var $getPrototypeOf = $Object.getPrototypeOf;
+
+/** @type {import('./get')} */
+module.exports = desc && typeof desc.get === 'function' ? callBind([desc.get]) : typeof $getPrototypeOf === 'function' ? /** @type {import('./get')} */function getDunder(value) {
+  // eslint-disable-next-line eqeqeq
+  return $getPrototypeOf(value == null ? value : $Object(value));
+} : false;
+
+},{"call-bind-apply-helpers":11,"gopd":35}],16:[function(require,module,exports){
+'use strict';
+
+/** @type {import('.')} */
+var $defineProperty = Object.defineProperty || false;
+if ($defineProperty) {
+  try {
+    $defineProperty({}, 'a', {
+      value: 1
+    });
+  } catch (e) {
+    // IE 8 has a broken defineProperty
+    $defineProperty = false;
+  }
+}
+module.exports = $defineProperty;
+
+},{}],17:[function(require,module,exports){
+'use strict';
+
+/** @type {import('./eval')} */
+module.exports = EvalError;
+
+},{}],18:[function(require,module,exports){
+'use strict';
+
+/** @type {import('.')} */
+module.exports = Error;
+
+},{}],19:[function(require,module,exports){
+'use strict';
+
+/** @type {import('./range')} */
+module.exports = RangeError;
+
+},{}],20:[function(require,module,exports){
+'use strict';
+
+/** @type {import('./ref')} */
+module.exports = ReferenceError;
+
+},{}],21:[function(require,module,exports){
+'use strict';
+
+/** @type {import('./syntax')} */
+module.exports = SyntaxError;
+
+},{}],22:[function(require,module,exports){
+'use strict';
+
+/** @type {import('./type')} */
+module.exports = TypeError;
+
+},{}],23:[function(require,module,exports){
+'use strict';
+
+/** @type {import('./uri')} */
+module.exports = URIError;
+
+},{}],24:[function(require,module,exports){
+'use strict';
+
+/** @type {import('.')} */
+module.exports = Object;
+
+},{}],25:[function(require,module,exports){
 // these are known as "placeholder tokens", see this link for more info:
 // <https://nodejs.org/api/util.html#util_util_format_format_args>
 //
@@ -207,7 +361,459 @@ exports.isBooleanable = isBooleanable;
 // <https://github.com/nodejs/node/blob/7af1ad0ec15546761233c2e90008316551db2bbd/doc/api/util.md#utilformatformat-args>
 module.exports = ['%s', '%d', '%i', '%f', '%j', '%o', '%O', '%%'];
 
-},{}],10:[function(require,module,exports){
+},{}],26:[function(require,module,exports){
+'use strict';
+
+/* eslint no-invalid-this: 1 */
+var ERROR_MESSAGE = 'Function.prototype.bind called on incompatible ';
+var toStr = Object.prototype.toString;
+var max = Math.max;
+var funcType = '[object Function]';
+var concatty = function concatty(a, b) {
+  var arr = [];
+  for (var i = 0; i < a.length; i += 1) {
+    arr[i] = a[i];
+  }
+  for (var j = 0; j < b.length; j += 1) {
+    arr[j + a.length] = b[j];
+  }
+  return arr;
+};
+var slicy = function slicy(arrLike, offset) {
+  var arr = [];
+  for (var i = offset || 0, j = 0; i < arrLike.length; i += 1, j += 1) {
+    arr[j] = arrLike[i];
+  }
+  return arr;
+};
+var joiny = function (arr, joiner) {
+  var str = '';
+  for (var i = 0; i < arr.length; i += 1) {
+    str += arr[i];
+    if (i + 1 < arr.length) {
+      str += joiner;
+    }
+  }
+  return str;
+};
+module.exports = function bind(that) {
+  var target = this;
+  if (typeof target !== 'function' || toStr.apply(target) !== funcType) {
+    throw new TypeError(ERROR_MESSAGE + target);
+  }
+  var args = slicy(arguments, 1);
+  var bound;
+  var binder = function () {
+    if (this instanceof bound) {
+      var result = target.apply(this, concatty(args, arguments));
+      if (Object(result) === result) {
+        return result;
+      }
+      return this;
+    }
+    return target.apply(that, concatty(args, arguments));
+  };
+  var boundLength = max(0, target.length - args.length);
+  var boundArgs = [];
+  for (var i = 0; i < boundLength; i++) {
+    boundArgs[i] = '$' + i;
+  }
+  bound = Function('binder', 'return function (' + joiny(boundArgs, ',') + '){ 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;
+};
+
+},{}],27:[function(require,module,exports){
+'use strict';
+
+var implementation = require('./implementation');
+module.exports = Function.prototype.bind || implementation;
+
+},{"./implementation":26}],28:[function(require,module,exports){
+'use strict';
+
+var undefined;
+var $Object = require('es-object-atoms');
+var $Error = require('es-errors');
+var $EvalError = require('es-errors/eval');
+var $RangeError = require('es-errors/range');
+var $ReferenceError = require('es-errors/ref');
+var $SyntaxError = require('es-errors/syntax');
+var $TypeError = require('es-errors/type');
+var $URIError = require('es-errors/uri');
+var abs = require('math-intrinsics/abs');
+var floor = require('math-intrinsics/floor');
+var max = require('math-intrinsics/max');
+var min = require('math-intrinsics/min');
+var pow = require('math-intrinsics/pow');
+var round = require('math-intrinsics/round');
+var sign = require('math-intrinsics/sign');
+var $Function = Function;
+
+// eslint-disable-next-line consistent-return
+var getEvalledConstructor = function (expressionSyntax) {
+  try {
+    return $Function('"use strict"; return (' + expressionSyntax + ').constructor;')();
+  } catch (e) {}
+};
+var $gOPD = require('gopd');
+var $defineProperty = require('es-define-property');
+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 = require('get-proto');
+var $ObjectGPO = require('get-proto/Object.getPrototypeOf');
+var $ReflectGPO = require('get-proto/Reflect.getPrototypeOf');
+var $apply = require('call-bind-apply-helpers/functionApply');
+var $call = require('call-bind-apply-helpers/functionCall');
+var needsEval = {};
+var TypedArray = typeof Uint8Array === 'undefined' || !getProto ? undefined : getProto(Uint8Array);
+var INTRINSICS = {
+  __proto__: null,
+  '%AggregateError%': typeof AggregateError === 'undefined' ? undefined : AggregateError,
+  '%Array%': Array,
+  '%ArrayBuffer%': typeof ArrayBuffer === 'undefined' ? undefined : ArrayBuffer,
+  '%ArrayIteratorPrototype%': hasSymbols && getProto ? 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,
+  '%BigInt64Array%': typeof BigInt64Array === 'undefined' ? undefined : BigInt64Array,
+  '%BigUint64Array%': typeof BigUint64Array === 'undefined' ? undefined : BigUint64Array,
+  '%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,
+  '%Float16Array%': typeof Float16Array === 'undefined' ? undefined : Float16Array,
+  '%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(getProto([][Symbol.iterator]())) : undefined,
+  '%JSON%': typeof JSON === 'object' ? JSON : undefined,
+  '%Map%': typeof Map === 'undefined' ? undefined : Map,
+  '%MapIteratorPrototype%': typeof Map === 'undefined' || !hasSymbols || !getProto ? undefined : getProto(new Map()[Symbol.iterator]()),
+  '%Math%': Math,
+  '%Number%': Number,
+  '%Object%': $Object,
+  '%Object.getOwnPropertyDescriptor%': $gOPD,
+  '%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 || !getProto ? undefined : getProto(new Set()[Symbol.iterator]()),
+  '%SharedArrayBuffer%': typeof SharedArrayBuffer === 'undefined' ? undefined : SharedArrayBuffer,
+  '%String%': String,
+  '%StringIteratorPrototype%': hasSymbols && getProto ? 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,
+  '%Function.prototype.call%': $call,
+  '%Function.prototype.apply%': $apply,
+  '%Object.defineProperty%': $defineProperty,
+  '%Object.getPrototypeOf%': $ObjectGPO,
+  '%Math.abs%': abs,
+  '%Math.floor%': floor,
+  '%Math.max%': max,
+  '%Math.min%': min,
+  '%Math.pow%': pow,
+  '%Math.round%': round,
+  '%Math.sign%': sign,
+  '%Reflect.getPrototypeOf%': $ReflectGPO
+};
+if (getProto) {
+  try {
+    null.error; // eslint-disable-line no-unused-expressions
+  } catch (e) {
+    // https://github.com/tc39/proposal-shadowrealm/pull/384#issuecomment-1364264229
+    var errorProto = getProto(getProto(e));
+    INTRINSICS['%Error.prototype%'] = errorProto;
+  }
+}
+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 && getProto) {
+      value = getProto(gen.prototype);
+    }
+  }
+  INTRINSICS[name] = value;
+  return value;
+};
+var LEGACY_ALIASES = {
+  __proto__: null,
+  '%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('hasown');
+var $concat = bind.call($call, Array.prototype.concat);
+var $spliceApply = bind.call($apply, Array.prototype.splice);
+var $replace = bind.call($call, String.prototype.replace);
+var $strSlice = bind.call($call, String.prototype.slice);
+var $exec = bind.call($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;
+};
+
+},{"call-bind-apply-helpers/functionApply":9,"call-bind-apply-helpers/functionCall":10,"es-define-property":16,"es-errors":18,"es-errors/eval":17,"es-errors/range":19,"es-errors/ref":20,"es-errors/syntax":21,"es-errors/type":22,"es-errors/uri":23,"es-object-atoms":24,"function-bind":27,"get-proto":31,"get-proto/Object.getPrototypeOf":29,"get-proto/Reflect.getPrototypeOf":30,"gopd":35,"has-symbols":36,"hasown":41,"math-intrinsics/abs":49,"math-intrinsics/floor":50,"math-intrinsics/max":52,"math-intrinsics/min":53,"math-intrinsics/pow":54,"math-intrinsics/round":55,"math-intrinsics/sign":56}],29:[function(require,module,exports){
+'use strict';
+
+var $Object = require('es-object-atoms');
+
+/** @type {import('./Object.getPrototypeOf')} */
+module.exports = $Object.getPrototypeOf || null;
+
+},{"es-object-atoms":24}],30:[function(require,module,exports){
+'use strict';
+
+/** @type {import('./Reflect.getPrototypeOf')} */
+module.exports = typeof Reflect !== 'undefined' && Reflect.getPrototypeOf || null;
+
+},{}],31:[function(require,module,exports){
+'use strict';
+
+var reflectGetProto = require('./Reflect.getPrototypeOf');
+var originalGetProto = require('./Object.getPrototypeOf');
+var getDunderProto = require('dunder-proto/get');
+
+/** @type {import('.')} */
+module.exports = reflectGetProto ? function getProto(O) {
+  // @ts-expect-error TS can't narrow inside a closure, for some reason
+  return reflectGetProto(O);
+} : originalGetProto ? function getProto(O) {
+  if (!O || typeof O !== 'object' && typeof O !== 'function') {
+    throw new TypeError('getProto: not an object');
+  }
+  // @ts-expect-error TS can't narrow inside a closure, for some reason
+  return originalGetProto(O);
+} : getDunderProto ? function getProto(O) {
+  // @ts-expect-error TS can't narrow inside a closure, for some reason
+  return getDunderProto(O);
+} : null;
+
+},{"./Object.getPrototypeOf":29,"./Reflect.getPrototypeOf":30,"dunder-proto/get":15}],32:[function(require,module,exports){
 /*!
  * get-value <https://github.com/jonschlinkert/get-value>
  *
@@ -300,7 +906,7 @@ function isValidObject(val) {
   return isObject(val) || Array.isArray(val) || typeof val === 'function';
 }
 
-},{"isobject":11}],11:[function(require,module,exports){
+},{"isobject":33}],33:[function(require,module,exports){
 /*!
  * isobject <https://github.com/jonschlinkert/isobject>
  *
@@ -314,11 +920,34 @@ module.exports = function isObject(val) {
   return val != null && typeof val === 'object' && Array.isArray(val) === false;
 };
 
-},{}],12:[function(require,module,exports){
+},{}],34:[function(require,module,exports){
+'use strict';
+
+/** @type {import('./gOPD')} */
+module.exports = Object.getOwnPropertyDescriptor;
+
+},{}],35:[function(require,module,exports){
+'use strict';
+
+/** @type {import('.')} */
+var $gOPD = require('./gOPD');
+if ($gOPD) {
+  try {
+    $gOPD([], 'length');
+  } catch (e) {
+    // IE 8 has a broken gOPD
+    $gOPD = null;
+  }
+}
+module.exports = $gOPD;
+
+},{"./gOPD":34}],36:[function(require,module,exports){
 'use strict';
 
 var origSymbol = typeof Symbol !== 'undefined' && Symbol;
 var hasSymbolSham = require('./shams');
+
+/** @type {import('.')} */
 module.exports = function hasNativeSymbols() {
   if (typeof origSymbol !== 'function') {
     return false;
@@ -335,9 +964,10 @@ module.exports = function hasNativeSymbols() {
   return hasSymbolSham();
 };
 
-},{"./shams":13}],13:[function(require,module,exports){
+},{"./shams":37}],37:[function(require,module,exports){
 'use strict';
 
+/** @type {import('./shams')} */
 /* eslint complexity: [2, 18], max-statements: [2, 33] */
 module.exports = function hasSymbols() {
   if (typeof Symbol !== 'function' || typeof Object.getOwnPropertySymbols !== 'function') {
@@ -346,6 +976,8 @@ module.exports = function hasSymbols() {
   if (typeof Symbol.iterator === 'symbol') {
     return true;
   }
+
+  /** @type {{ [k in symbol]?: unknown }} */
   var obj = {};
   var sym = Symbol('test');
   var symObj = Object(sym);
@@ -369,7 +1001,7 @@ module.exports = function hasSymbols() {
 
   var symVal = 42;
   obj[sym] = symVal;
-  for (sym in obj) {
+  for (var _ in obj) {
     return false;
   } // eslint-disable-line no-restricted-syntax, no-unreachable-loop
   if (typeof Object.keys === 'function' && Object.keys(obj).length !== 0) {
@@ -386,7 +1018,8 @@ module.exports = function hasSymbols() {
     return false;
   }
   if (typeof Object.getOwnPropertyDescriptor === 'function') {
-    var descriptor = Object.getOwnPropertyDescriptor(obj, sym);
+    // eslint-disable-next-line no-extra-parens
+    var descriptor = /** @type {PropertyDescriptor} */Object.getOwnPropertyDescriptor(obj, sym);
     if (descriptor.value !== symVal || descriptor.enumerable !== true) {
       return false;
     }
@@ -394,7 +1027,17 @@ module.exports = function hasSymbols() {
   return true;
 };
 
-},{}],14:[function(require,module,exports){
+},{}],38:[function(require,module,exports){
+'use strict';
+
+var hasSymbols = require('has-symbols/shams');
+
+/** @type {import('.')} */
+module.exports = function hasToStringTagShams() {
+  return hasSymbols() && !!Symbol.toStringTag;
+};
+
+},{"has-symbols/shams":37}],39:[function(require,module,exports){
 /*!
  * has-value <https://github.com/jonschlinkert/has-value>
  *
@@ -416,7 +1059,7 @@ function isObject(val) {
   return val != null && (typeof val === 'object' || typeof val === 'function' || Array.isArray(val));
 }
 
-},{"get-value":10,"has-values":15}],15:[function(require,module,exports){
+},{"get-value":32,"has-values":40}],40:[function(require,module,exports){
 /*!
  * has-values <https://github.com/jonschlinkert/has-values>
  *
@@ -467,7 +1110,17 @@ module.exports = function has(val) {
   }
 };
 
-},{"kind-of":21}],16:[function(require,module,exports){
+},{"kind-of":48}],41:[function(require,module,exports){
+'use strict';
+
+var call = Function.prototype.call;
+var $hasOwn = Object.prototype.hasOwnProperty;
+var bind = require('function-bind');
+
+/** @type {import('.')} */
+module.exports = bind.call(call, $hasOwn);
+
+},{"function-bind":27}],42:[function(require,module,exports){
 /*!
  * Determine if an object is a Buffer
  *
@@ -479,7 +1132,7 @@ module.exports = function isBuffer(obj) {
   return obj != null && obj.constructor != null && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj);
 };
 
-},{}],17:[function(require,module,exports){
+},{}],43:[function(require,module,exports){
 'use strict';
 
 module.exports = value => {
@@ -490,25 +1143,96 @@ module.exports = value => {
   return prototype === null || prototype === Object.prototype;
 };
 
-},{}],18:[function(require,module,exports){
+},{}],44:[function(require,module,exports){
 'use strict';
 
-var toStr = Object.prototype.toString;
+var callBound = require('call-bound');
+var hasToStringTag = require('has-tostringtag/shams')();
+var hasOwn = require('hasown');
+var gOPD = require('gopd');
+
+/** @type {import('.')} */
+var fn;
+if (hasToStringTag) {
+  /** @type {(receiver: ThisParameterType<typeof RegExp.prototype.exec>, ...args: Parameters<typeof RegExp.prototype.exec>) => ReturnType<typeof RegExp.prototype.exec>} */
+  var $exec = callBound('RegExp.prototype.exec');
+  /** @type {object} */
+  var isRegexMarker = {};
+  var throwRegexMarker = function () {
+    throw isRegexMarker;
+  };
+  /** @type {{ toString(): never, valueOf(): never, [Symbol.toPrimitive]?(): never }} */
+  var badStringifier = {
+    toString: throwRegexMarker,
+    valueOf: throwRegexMarker
+  };
+  if (typeof Symbol.toPrimitive === 'symbol') {
+    badStringifier[Symbol.toPrimitive] = throwRegexMarker;
+  }
+
+  /** @type {import('.')} */
+  // @ts-expect-error TS can't figure out that the $exec call always throws
+  // eslint-disable-next-line consistent-return
+  fn = function isRegex(value) {
+    if (!value || typeof value !== 'object') {
+      return false;
+    }
+
+    // eslint-disable-next-line no-extra-parens
+    var descriptor = /** @type {NonNullable<typeof gOPD>} */gOPD(/** @type {{ lastIndex?: unknown }} */value, 'lastIndex');
+    var hasLastIndexDataProperty = descriptor && hasOwn(descriptor, 'value');
+    if (!hasLastIndexDataProperty) {
+      return false;
+    }
+    try {
+      // eslint-disable-next-line no-extra-parens
+      $exec(value, /** @type {string} */ /** @type {unknown} */badStringifier);
+    } catch (e) {
+      return e === isRegexMarker;
+    }
+  };
+} else {
+  /** @type {(receiver: ThisParameterType<typeof Object.prototype.toString>, ...args: Parameters<typeof Object.prototype.toString>) => ReturnType<typeof Object.prototype.toString>} */
+  var $toString = callBound('Object.prototype.toString');
+  /** @const @type {'[object RegExp]'} */
+  var regexClass = '[object RegExp]';
+
+  /** @type {import('.')} */
+  fn = 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;
+  };
+}
+module.exports = fn;
+
+},{"call-bound":13,"gopd":35,"has-tostringtag/shams":38,"hasown":41}],45:[function(require,module,exports){
+'use strict';
+
+var callBound = require('call-bound');
+var $toString = callBound('Object.prototype.toString');
 var hasSymbols = require('has-symbols')();
+var safeRegexTest = require('safe-regex-test');
 if (hasSymbols) {
-  var symToStr = Symbol.prototype.toString;
-  var symStringRegex = /^Symbol\(.*\)$/;
+  var $symToStr = callBound('Symbol.prototype.toString');
+  var isSymString = safeRegexTest(/^Symbol\(.*\)$/);
+
+  /** @type {(value: object) => value is Symbol} */
   var isSymbolObject = function isRealSymbolObject(value) {
     if (typeof value.valueOf() !== 'symbol') {
       return false;
     }
-    return symStringRegex.test(symToStr.call(value));
+    return isSymString($symToStr(value));
   };
+
+  /** @type {import('.')} */
   module.exports = function isSymbol(value) {
     if (typeof value === 'symbol') {
       return true;
     }
-    if (toStr.call(value) !== '[object Symbol]') {
+    if (!value || typeof value !== 'object' || $toString(value) !== '[object Symbol]') {
       return false;
     }
     try {
@@ -518,13 +1242,14 @@ if (hasSymbols) {
     }
   };
 } else {
+  /** @type {import('.')} */
   module.exports = function isSymbol(value) {
     // this environment does not support Symbols.
     return false && value;
   };
 }
 
-},{"has-symbols":12}],19:[function(require,module,exports){
+},{"call-bound":13,"has-symbols":36,"safe-regex-test":63}],46:[function(require,module,exports){
 /**
  * Expose `isError`.
  */
@@ -551,7 +1276,7 @@ function isError(value) {
   }
 }
 
-},{}],20:[function(require,module,exports){
+},{}],47:[function(require,module,exports){
 'use strict';
 
 /*!
@@ -565,7 +1290,7 @@ function isObject(val) {
 }
 module.exports = isObject;
 
-},{}],21:[function(require,module,exports){
+},{}],48:[function(require,module,exports){
 var toString = Object.prototype.toString;
 module.exports = function kindOf(val) {
   if (val === void 0) return 'undefined';
@@ -696,7 +1421,64 @@ function isBuffer(val) {
   return false;
 }
 
-},{}],22:[function(require,module,exports){
+},{}],49:[function(require,module,exports){
+'use strict';
+
+/** @type {import('./abs')} */
+module.exports = Math.abs;
+
+},{}],50:[function(require,module,exports){
+'use strict';
+
+/** @type {import('./floor')} */
+module.exports = Math.floor;
+
+},{}],51:[function(require,module,exports){
+'use strict';
+
+/** @type {import('./isNaN')} */
+module.exports = Number.isNaN || function isNaN(a) {
+  return a !== a;
+};
+
+},{}],52:[function(require,module,exports){
+'use strict';
+
+/** @type {import('./max')} */
+module.exports = Math.max;
+
+},{}],53:[function(require,module,exports){
+'use strict';
+
+/** @type {import('./min')} */
+module.exports = Math.min;
+
+},{}],54:[function(require,module,exports){
+'use strict';
+
+/** @type {import('./pow')} */
+module.exports = Math.pow;
+
+},{}],55:[function(require,module,exports){
+'use strict';
+
+/** @type {import('./round')} */
+module.exports = Math.round;
+
+},{}],56:[function(require,module,exports){
+'use strict';
+
+var $isNaN = require('./isNaN');
+
+/** @type {import('./sign')} */
+module.exports = function sign(number) {
+  if ($isNaN(number) || number === 0) {
+    return number;
+  }
+  return number < 0 ? -1 : +1;
+};
+
+},{"./isNaN":51}],57:[function(require,module,exports){
 'use strict';
 
 const isOptionObject = require('is-plain-obj');
@@ -832,14 +1614,11 @@ function merge(merged, source, config) {
   }
   return mergeKeys(merged, source, getEnumerableOwnPropertyKeys(source), config);
 }
-module.exports = function () {
+module.exports = function (...options) {
   const config = merge(clone(defaultMergeOptions), this !== globalThis && this || {}, defaultMergeOptions);
   let merged = {
     _: {}
   };
-  for (var _len = arguments.length, options = new Array(_len), _key = 0; _key < _len; _key++) {
-    options[_key] = arguments[_key];
-  }
   for (const option of options) {
     if (option === undefined) {
       continue;
@@ -854,7 +1633,7 @@ module.exports = function () {
   return merged._;
 };
 
-},{"is-plain-obj":17}],23:[function(require,module,exports){
+},{"is-plain-obj":43}],58:[function(require,module,exports){
 exports.endianness = function () {
   return 'LE';
 };
@@ -904,7 +1683,7 @@ exports.homedir = function () {
   return '/';
 };
 
-},{}],24:[function(require,module,exports){
+},{}],59:[function(require,module,exports){
 'use strict';
 
 const pMapSeries = async (iterable, mapper) => {
@@ -920,7 +1699,7 @@ module.exports = pMapSeries;
 // TODO: Remove this for the next major release
 module.exports.default = pMapSeries;
 
-},{}],25:[function(require,module,exports){
+},{}],60:[function(require,module,exports){
 "use strict";
 
 function _createForOfIteratorHelper(o, allowArrayLike) {
@@ -1038,7 +1817,7 @@ const parseErr = function parseErr(err) {
 };
 module.exports = parseErr;
 
-},{"iserror":19}],26:[function(require,module,exports){
+},{"iserror":46}],61:[function(require,module,exports){
 'use strict';
 
 const get = require('@strikeentco/get');
@@ -1056,8 +1835,7 @@ const pick = (obj, paths, length, sep) => {
   }
   return picked;
 };
-module.exports = function (obj, paths) {
-  let sep = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '.';
+module.exports = (obj, paths, sep = '.') => {
   if (!isObject(obj) || !paths || !(Array.isArray(paths) || typeof paths === 'string')) {
     return {};
   }
@@ -1072,7 +1850,7 @@ module.exports = function (obj, paths) {
   return pick(obj, paths, length, sep);
 };
 
-},{"@strikeentco/get":2,"@strikeentco/set":3}],27:[function(require,module,exports){
+},{"@strikeentco/get":2,"@strikeentco/set":3}],62:[function(require,module,exports){
 // shim for using process in browser
 var process = module.exports = {};
 
@@ -1249,7 +2027,25 @@ process.umask = function () {
   return 0;
 };
 
-},{}],28:[function(require,module,exports){
+},{}],63:[function(require,module,exports){
+'use strict';
+
+var callBound = require('call-bound');
+var isRegex = require('is-regex');
+var $exec = callBound('RegExp.prototype.exec');
+var $TypeError = require('es-errors/type');
+
+/** @type {import('.')} */
+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-bound":13,"es-errors/type":22,"is-regex":44}],64:[function(require,module,exports){
 /*!
  * unset-value <https://github.com/jonschlinkert/unset-value>
  *
@@ -1294,11 +2090,11 @@ module.exports = function unset(obj, prop) {
   return true;
 };
 
-},{"has-value":14,"isobject":20}],29:[function(require,module,exports){
+},{"has-value":39,"isobject":47}],65:[function(require,module,exports){
 module.exports={
   "name": "axe",
   "description": "Axe is a logger-agnostic wrapper that normalizes logs regardless of argument style. Great for large development teams, old and new projects, and works with Pino, Bunyan, Winston, console, and more. It is lightweight, performant, highly-configurable, and automatically adds OS, CPU, and Git information to your logs. It supports hooks (useful for masking sensitive data) and dot-notation remapping, omitting, and picking of log metadata properties. Made for Forward Email, Lad, and Cabin.",
-  "version": "13.0.0",
+  "version": "13.0.1",
   "author": "Nick Baugh <niftylettuce@gmail.com> (http://niftylettuce.com)",
   "browser": {
     "parse-app-info": false
@@ -1360,6 +2156,7 @@ module.exports={
     "sinon": "^18.0.0",
     "tinyify": "3.0.0",
     "tsd": "^0.31.2",
+    "typescript": "5.5.4",
     "xo": "0.56.0"
   },
   "engines": {
@@ -1435,7 +2232,7 @@ module.exports={
   "unpkg": "dist/axe.min.js"
 }
 
-},{}],30:[function(require,module,exports){
+},{}],66:[function(require,module,exports){
 (function (process){(function (){
 // eslint-disable-next-line import/no-unassigned-import
 require('console-polyfill');
@@ -1525,9 +2322,7 @@ function getFunction(value) {
 }
 class Axe {
   // eslint-disable-next-line complexity
-  constructor() {
-    var _this = this;
-    let config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  constructor(config = {}) {
     const remappedFields = {};
     if (process.env.AXE_REMAPPED_META_FIELDS) {
       const fields = process.env.AXE_REMAPPED_META_FIELDS;
@@ -1591,12 +2386,7 @@ class Axe {
       }
 
       // Bind log handler which normalizes args and populates meta
-      this[element] = function () {
-        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-          args[_key] = arguments[_key];
-        }
-        return _this.log(element, ...Array.prototype.slice.call(args));
-      };
+      this[element] = (...args) => this.log(element, ...Array.prototype.slice.call(args));
     }
     this.setLevel = this.setLevel.bind(this);
     this.getNormalizedLevel = this.getNormalizedLevel.bind(this);
@@ -1614,19 +2404,13 @@ class Axe {
 
     // Pre and Post Hooks
     this.pre = function (level, fn) {
-      this.config.hooks.pre.push(function (_level) {
-        for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
-          args[_key2 - 1] = arguments[_key2];
-        }
+      this.config.hooks.pre.push(function (_level, ...args) {
         if (level !== _level) return [...args];
         return fn(...args);
       });
     };
     this.post = function (level, fn) {
-      this.config.hooks.post.push(function (_level) {
-        for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
-          args[_key3 - 1] = arguments[_key3];
-        }
+      this.config.hooks.post.push(function (_level, ...args) {
         if (level !== _level) return [...args];
         return fn(...args);
       });
@@ -1653,7 +2437,7 @@ class Axe {
   }
 
   // eslint-disable-next-line complexity
-  log(level, message, meta) {
+  log(level, message, meta, ...args) {
     const originalArgs = [];
     const errors = [];
     let hasMessage = false;
@@ -1661,9 +2445,6 @@ class Axe {
     if (!isUndefined(level)) originalArgs.push(level);
     if (!isUndefined(message)) originalArgs.push(message);
     if (!isUndefined(meta)) originalArgs.push(meta);
-    for (var _len4 = arguments.length, args = new Array(_len4 > 3 ? _len4 - 3 : 0), _key4 = 3; _key4 < _len4; _key4++) {
-      args[_key4 - 3] = arguments[_key4];
-    }
     for (const arg of Array.prototype.slice.call(args)) {
       originalArgs.push(arg);
     }
@@ -1719,7 +2500,7 @@ class Axe {
         hasMessage = true;
       }
       if (errors.length > 0 && level === 'log') level = 'error';
-    } else if (!isBunyan && originalArgs.length === 3 + modifier && isString(message) && formatSpecifiers.some(t => message.indexOf(t) !== -1)) {
+    } else if (!isBunyan && originalArgs.length === 3 + modifier && isString(message) && !(meta && meta.is_http) && formatSpecifiers.some(t => message.indexOf(t) !== -1)) {
       // Otherwise if there are three args and if the `message` contains
       // a placeholder token (e.g. '%s' or '%d' - see above `formatSpecifiers` variable)
       // then we can infer that the `meta` arg passed is used for formatting
@@ -1975,5 +2756,5 @@ class Axe {
 module.exports = Axe;
 
 }).call(this)}).call(this,require('_process'))
-},{"../package.json":29,"@ladjs/format-util":1,"@strikeentco/get":2,"@strikeentco/set":3,"_process":27,"boolean":5,"console-polyfill":8,"format-specifiers":9,"is-buffer":16,"is-symbol":18,"iserror":19,"merge-options":22,"os":23,"p-map-series":24,"parse-app-info":7,"parse-err":25,"pick-deep":26,"unset-value":28}]},{},[30])(30)
+},{"../package.json":65,"@ladjs/format-util":1,"@strikeentco/get":2,"@strikeentco/set":3,"_process":62,"boolean":5,"console-polyfill":14,"format-specifiers":25,"is-buffer":42,"is-symbol":45,"iserror":46,"merge-options":57,"os":58,"p-map-series":59,"parse-app-info":7,"parse-err":60,"pick-deep":61,"unset-value":64}]},{},[66])(66)
 });