axe 10.0.0 → 10.0.1

package/dist/axe.js

@@ -1,77 +1,62 @@
 (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.Axe = 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){
 function format(fmt) {
   var re = /(%?)(%([jds]))/g,
-      args = Array.prototype.slice.call(arguments, 1);
-
+    args = Array.prototype.slice.call(arguments, 1);
   if (args.length) {
     fmt = fmt.toString().replace(re, function (match, escaped, ptn, flag) {
       var arg = args.shift();
-
       switch (flag) {
         case 's':
           arg = '' + arg;
           break;
-
         case 'd':
           arg = Number(arg);
           break;
-
         case 'j':
           arg = JSON.stringify(arg);
           break;
       }
-
       if (!escaped) {
         return arg;
       }
-
       args.unshift(arg);
       return match;
     });
-  } // arguments remain after formatting
-
+  }
 
+  // arguments remain after formatting
   if (args.length) {
     fmt = fmt.toString() + ' ' + args.join(' ');
-  } // update escaped %% values
-
+  }
 
+  // update escaped %% values
   fmt = fmt.toString().replace(/%{2,2}/g, '%');
   return '' + fmt;
 }
-
 module.exports = format;
 
 },{}],2:[function(require,module,exports){
 'use strict';
 
 const isObject = val => Object.prototype.toString.call(val) === '[object Object]';
-
 const get = (obj, parts, length) => {
   for (let i = 0; i < length; i++) {
     if (obj === null) {
       return;
     }
-
     const v = obj[parts[i]];
-
     if (v === undefined) {
       return;
     }
-
     obj = v;
   }
-
   return obj;
 };
-
 module.exports = function (obj, path) {
   let sep = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '.';
-
   if (!isObject(obj) || !path) {
     return obj;
   }
-
   const parts = Array.isArray(path) ? path : String(path).split(sep);
   const {
     length
@@ -81,29 +66,24 @@ module.exports = function (obj, path) {
 
 },{}],3:[function(require,module,exports){
 'use strict';
-/* eslint-disable no-continue, eqeqeq */
 
+/* eslint-disable no-continue, eqeqeq */
 const isObject = val => typeof val === 'object' || typeof val === 'function';
-
 const isProto = (val, obj) => val == '__proto__' || val == 'constructor' && typeof obj.constructor === 'function';
-
 const set = (obj, parts, length, val) => {
   let tmp = obj;
   let i = 0;
-
   for (; i < length - 1; i++) {
     const part = parts[i];
-
     if (isProto(part, tmp)) {
       continue;
     }
-
     tmp = !isObject(tmp[part]) ? tmp[part] = {} : tmp[part];
   }
-
   tmp[parts[i]] = val;
   return obj;
 };
+
 /**
 * Sets nested values on an object using a dot path or custom separator
 * @param {Object} obj
@@ -112,30 +92,22 @@ 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] : '.';
-
   if (!isObject(obj) || !path || !path.length) {
     return obj;
   }
-
   const parts = Array.isArray(path) ? path : String(path).split(sep);
-
   if (isProto(parts[0], obj)) {
     return obj;
   }
-
   const {
     length
   } = parts;
-
   if (length === 1) {
     obj[parts[0]] = val;
     return obj;
   }
-
   return set(obj, parts, length, val);
 };
 
@@ -146,23 +118,18 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.boolean = void 0;
-
 const boolean = function (value) {
   switch (Object.prototype.toString.call(value)) {
     case '[object String]':
       return ['true', 't', 'yes', 'y', 'on', '1'].includes(value.trim().toLowerCase());
-
     case '[object Number]':
       return value.valueOf() === 1;
-
     case '[object Boolean]':
       return value.valueOf();
-
     default:
       return false;
   }
 };
-
 exports.boolean = boolean;
 
 },{}],5:[function(require,module,exports){
@@ -172,18 +139,14 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.isBooleanable = exports.boolean = void 0;
-
 const boolean_1 = require("./boolean");
-
 Object.defineProperty(exports, "boolean", {
   enumerable: true,
   get: function () {
     return boolean_1.boolean;
   }
 });
-
 const isBooleanable_1 = require("./isBooleanable");
-
 Object.defineProperty(exports, "isBooleanable", {
   enumerable: true,
   get: function () {
@@ -198,23 +161,18 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.isBooleanable = void 0;
-
 const isBooleanable = function (value) {
   switch (Object.prototype.toString.call(value)) {
     case '[object String]':
       return ['true', 't', 'yes', 'y', 'on', '1', 'false', 'f', 'no', 'n', 'off', '0'].includes(value.trim().toLowerCase());
-
     case '[object Number]':
       return [0, 1].includes(value.valueOf());
-
     case '[object Boolean]':
       return true;
-
     default:
       return false;
   }
 };
-
 exports.isBooleanable = isBooleanable;
 
 },{}],7:[function(require,module,exports){
@@ -229,19 +187,14 @@ exports.isBooleanable = isBooleanable;
   if (!global.console) {
     global.console = {};
   }
-
   var con = global.console;
   var prop, method;
-
   var dummy = function () {};
-
   var properties = ['memory'];
   var methods = ('assert,clear,count,debug,dir,dirxml,error,exception,group,' + 'groupCollapsed,groupEnd,info,log,markTimeline,profile,profiles,profileEnd,' + 'show,table,time,timeEnd,timeline,timelineEnd,timeStamp,trace,warn').split(',');
-
   while (prop = properties.pop()) if (!con[prop]) con[prop] = {};
-
-  while (method = methods.pop()) if (!con[method]) con[method] = dummy; // Using `this` for web workers & supports Browserify / Webpack.
-
+  while (method = methods.pop()) if (!con[method]) con[method] = dummy;
+  // Using `this` for web workers & supports Browserify / Webpack.
 })(typeof window === 'undefined' ? this : window);
 
 },{}],9:[function(require,module,exports){
@@ -261,112 +214,88 @@ module.exports = ['%s', '%d', '%i', '%f', '%j', '%o', '%O', '%%'];
  * Copyright (c) 2014-2018, Jon Schlinkert.
  * Released under the MIT License.
  */
-const isObject = require('isobject');
 
+const isObject = require('isobject');
 module.exports = function (target, path, options) {
   if (!isObject(options)) {
     options = {
       default: options
     };
   }
-
   if (!isValidObject(target)) {
     return typeof options.default !== 'undefined' ? options.default : target;
   }
-
   if (typeof path === 'number') {
     path = String(path);
   }
-
   const isArray = Array.isArray(path);
   const isString = typeof path === 'string';
   const splitChar = options.separator || '.';
   const joinChar = options.joinChar || (typeof splitChar === 'string' ? splitChar : '.');
-
   if (!isString && !isArray) {
     return target;
   }
-
   if (isString && path in target) {
     return isValid(path, target, options) ? target[path] : options.default;
   }
-
   let segs = isArray ? path : split(path, splitChar, options);
   let len = segs.length;
   let idx = 0;
-
   do {
     let prop = segs[idx];
-
     if (typeof prop === 'number') {
       prop = String(prop);
     }
-
     while (prop && prop.slice(-1) === '\\') {
       prop = join([prop.slice(0, -1), segs[++idx] || ''], joinChar, options);
     }
-
     if (prop in target) {
       if (!isValid(prop, target, options)) {
         return options.default;
       }
-
       target = target[prop];
     } else {
       let hasProp = false;
       let n = idx + 1;
-
       while (n < len) {
         prop = join([prop, segs[n++]], joinChar, options);
-
         if (hasProp = prop in target) {
           if (!isValid(prop, target, options)) {
             return options.default;
           }
-
           target = target[prop];
           idx = n - 1;
           break;
         }
       }
-
       if (!hasProp) {
         return options.default;
       }
     }
   } while (++idx < len && isValidObject(target));
-
   if (idx === len) {
     return target;
   }
-
   return options.default;
 };
-
 function join(segs, joinChar, options) {
   if (typeof options.join === 'function') {
     return options.join(segs);
   }
-
   return segs[0] + joinChar + segs[1];
 }
-
 function split(path, splitChar, options) {
   if (typeof options.split === 'function') {
     return options.split(path);
   }
-
   return path.split(splitChar);
 }
-
 function isValid(key, target, options) {
   if (typeof options.isValid === 'function') {
     return options.isValid(key, target);
   }
-
   return true;
 }
-
 function isValidObject(val) {
   return isObject(val) || Array.isArray(val) || typeof val === 'function';
 }
@@ -378,6 +307,7 @@ function isValidObject(val) {
  * Copyright (c) 2014-2017, Jon Schlinkert.
  * Released under the MIT License.
  */
+
 'use strict';
 
 module.exports = function isObject(val) {
@@ -391,20 +321,17 @@ module.exports = function isObject(val) {
  * Copyright (c) 2014-2018, Jon Schlinkert.
  * Released under the MIT License.
  */
+
 'use strict';
 
 const get = require('get-value');
-
 const has = require('has-values');
-
 module.exports = function (obj, path, options) {
   if (isObject(obj) && (typeof path === 'string' || Array.isArray(path))) {
     return has(get(obj, path, options));
   }
-
   return false;
 };
-
 function isObject(val) {
   return val != null && (typeof val === 'object' || typeof val === 'function' || Array.isArray(val));
 }
@@ -416,10 +343,10 @@ function isObject(val) {
  * Copyright (c) 2014-2018, Jon Schlinkert.
  * Released under the MIT License.
  */
+
 'use strict';
 
 const typeOf = require('kind-of');
-
 module.exports = function has(val) {
   switch (typeOf(val)) {
     case 'boolean':
@@ -428,28 +355,21 @@ module.exports = function has(val) {
     case 'null':
     case 'number':
       return true;
-
     case 'undefined':
       return false;
-
     case 'regexp':
       return val.source !== '(?:)' && val.source !== '';
-
     case 'buffer':
       return val.toString() !== '';
-
     case 'error':
       return val.message !== '';
-
     case 'string':
     case 'arguments':
       return val.length !== 0;
-
     case 'file':
     case 'map':
     case 'set':
       return val.size !== 0;
-
     case 'array':
     case 'object':
       for (const key of Object.keys(val)) {
@@ -457,10 +377,9 @@ module.exports = function has(val) {
           return true;
         }
       }
-
       return false;
-    // everything else
 
+    // everything else
     default:
       {
         return true;
@@ -475,7 +394,6 @@ module.exports = value => {
   if (Object.prototype.toString.call(value) !== '[object Object]') {
     return false;
   }
-
   const prototype = Object.getPrototypeOf(value);
   return prototype === null || prototype === Object.prototype;
 };
@@ -484,7 +402,9 @@ module.exports = value => {
 /**
  * Expose `isError`.
  */
+
 module.exports = isError;
+
 /**
  * Test whether `value` is error object.
  *
@@ -496,13 +416,10 @@ function isError(value) {
   switch (Object.prototype.toString.call(value)) {
     case '[object Error]':
       return true;
-
     case '[object Exception]':
       return true;
-
     case '[object DOMException]':
       return true;
-
     default:
       return value instanceof Error;
   }
@@ -510,22 +427,20 @@ function isError(value) {
 
 },{}],16:[function(require,module,exports){
 'use strict';
+
 /*!
  * isobject <https://github.com/jonschlinkert/isobject>
  *
  * Copyright (c) 2014-2017, Jon Schlinkert.
  * Released under the MIT License.
  */
-
 function isObject(val) {
   return val != null && typeof val === 'object' && Array.isArray(val) === false;
 }
-
 module.exports = isObject;
 
 },{}],17:[function(require,module,exports){
 var toString = Object.prototype.toString;
-
 module.exports = function kindOf(val) {
   if (val === void 0) return 'undefined';
   if (val === null) return 'null';
@@ -534,129 +449,102 @@ module.exports = function kindOf(val) {
   if (type === 'string') return 'string';
   if (type === 'number') return 'number';
   if (type === 'symbol') return 'symbol';
-
   if (type === 'function') {
     return isGeneratorFn(val) ? 'generatorfunction' : 'function';
   }
-
   if (isArray(val)) return 'array';
   if (isBuffer(val)) return 'buffer';
   if (isArguments(val)) return 'arguments';
   if (isDate(val)) return 'date';
   if (isError(val)) return 'error';
   if (isRegexp(val)) return 'regexp';
-
   switch (ctorName(val)) {
     case 'Symbol':
       return 'symbol';
-
     case 'Promise':
       return 'promise';
-    // Set, Map, WeakSet, WeakMap
 
+    // Set, Map, WeakSet, WeakMap
     case 'WeakMap':
       return 'weakmap';
-
     case 'WeakSet':
       return 'weakset';
-
     case 'Map':
       return 'map';
-
     case 'Set':
       return 'set';
-    // 8-bit typed arrays
 
+    // 8-bit typed arrays
     case 'Int8Array':
       return 'int8array';
-
     case 'Uint8Array':
       return 'uint8array';
-
     case 'Uint8ClampedArray':
       return 'uint8clampedarray';
-    // 16-bit typed arrays
 
+    // 16-bit typed arrays
     case 'Int16Array':
       return 'int16array';
-
     case 'Uint16Array':
       return 'uint16array';
-    // 32-bit typed arrays
 
+    // 32-bit typed arrays
     case 'Int32Array':
       return 'int32array';
-
     case 'Uint32Array':
       return 'uint32array';
-
     case 'Float32Array':
       return 'float32array';
-
     case 'Float64Array':
       return 'float64array';
   }
-
   if (isGeneratorObj(val)) {
     return 'generator';
-  } // Non-plain objects
-
+  }
 
+  // Non-plain objects
   type = toString.call(val);
-
   switch (type) {
     case '[object Object]':
       return 'object';
     // iterators
-
     case '[object Map Iterator]':
       return 'mapiterator';
-
     case '[object Set Iterator]':
       return 'setiterator';
-
     case '[object String Iterator]':
       return 'stringiterator';
-
     case '[object Array Iterator]':
       return 'arrayiterator';
-  } // other
-
+  }
 
+  // other
   return type.slice(8, -1).toLowerCase().replace(/\s/g, '');
 };
-
 function ctorName(val) {
   return typeof val.constructor === 'function' ? val.constructor.name : null;
 }
-
 function isArray(val) {
   if (Array.isArray) return Array.isArray(val);
   return val instanceof Array;
 }
-
 function isError(val) {
   return val instanceof Error || typeof val.message === 'string' && val.constructor && typeof val.constructor.stackTraceLimit === 'number';
 }
-
 function isDate(val) {
   if (val instanceof Date) return true;
   return typeof val.toDateString === 'function' && typeof val.getDate === 'function' && typeof val.setDate === 'function';
 }
-
 function isRegexp(val) {
   if (val instanceof RegExp) return true;
   return typeof val.flags === 'string' && typeof val.ignoreCase === 'boolean' && typeof val.multiline === 'boolean' && typeof val.global === 'boolean';
 }
-
 function isGeneratorFn(name, val) {
   return ctorName(name) === 'GeneratorFunction';
 }
-
 function isGeneratorObj(val) {
   return typeof val.throw === 'function' && typeof val.return === 'function' && typeof val.next === 'function';
 }
-
 function isArguments(val) {
   try {
     if (typeof val.length === 'number' && typeof val.callee === 'function') {
@@ -667,20 +555,18 @@ function isArguments(val) {
       return true;
     }
   }
-
   return false;
 }
+
 /**
  * If you need to support Safari 5-7 (8-10 yr-old browser),
  * take a look at https://github.com/feross/is-buffer
  */
 
-
 function isBuffer(val) {
   if (val.constructor && typeof val.constructor.isBuffer === 'function') {
     return val.constructor.isBuffer(val);
   }
-
   return false;
 }
 
@@ -688,14 +574,12 @@ function isBuffer(val) {
 'use strict';
 
 const kErrors = Symbol('kErrors');
-
 module.exports = function (errors) {
   errors = errors.filter(defined);
   if (errors.length === 0) return;
   if (errors.length === 1) return errors[0];
   return new CombinedError(errors);
 };
-
 class CombinedError extends Error {
   constructor(errors) {
     const unique = new Set(errors.map(getMessage).filter(Boolean));
@@ -707,41 +591,32 @@ class CombinedError extends Error {
     getter(this, 'transient', () => errors.length > 0 && errors.every(transient));
     getter(this, 'expected', () => errors.length > 0 && errors.every(expected));
   }
-
   [Symbol.iterator]() {
     return this[kErrors][Symbol.iterator]();
   }
-
 }
-
 function value(obj, prop, value) {
   Object.defineProperty(obj, prop, {
     value
   });
 }
-
 function getter(obj, prop, get) {
   Object.defineProperty(obj, prop, {
     get
   });
 }
-
 function defined(err) {
   return err != null;
 }
-
 function getMessage(err) {
   return err.message;
 }
-
 function getStack(err) {
   return err.stack;
 }
-
 function transient(err) {
   return err.transient === true;
 }
-
 function expected(err) {
   return err.expected === true;
 }
@@ -750,63 +625,51 @@ function expected(err) {
 'use strict';
 
 const isOptionObject = require('is-plain-obj');
-
 const {
   hasOwnProperty
 } = Object.prototype;
 const {
   propertyIsEnumerable
 } = Object;
-
 const defineProperty = (object, name, value) => Object.defineProperty(object, name, {
   value,
   writable: true,
   enumerable: true,
   configurable: true
 });
-
 const globalThis = this;
 const defaultMergeOptions = {
   concatArrays: false,
   ignoreUndefined: false
 };
-
 const getEnumerableOwnPropertyKeys = value => {
   const keys = [];
-
   for (const key in value) {
     if (hasOwnProperty.call(value, key)) {
       keys.push(key);
     }
   }
-  /* istanbul ignore else  */
-
 
+  /* istanbul ignore else  */
   if (Object.getOwnPropertySymbols) {
     const symbols = Object.getOwnPropertySymbols(value);
-
     for (const symbol of symbols) {
       if (propertyIsEnumerable.call(value, symbol)) {
         keys.push(symbol);
       }
     }
   }
-
   return keys;
 };
-
 function clone(value) {
   if (Array.isArray(value)) {
     return cloneArray(value);
   }
-
   if (isOptionObject(value)) {
     return cloneOptionObject(value);
   }
-
   return value;
 }
-
 function cloneArray(array) {
   const result = array.slice(0, 0);
   getEnumerableOwnPropertyKeys(array).forEach(key => {
@@ -814,7 +677,6 @@ function cloneArray(array) {
   });
   return result;
 }
-
 function cloneOptionObject(object) {
   const result = Object.getPrototypeOf(object) === null ? Object.create(null) : {};
   getEnumerableOwnPropertyKeys(object).forEach(key => {
@@ -822,6 +684,7 @@ function cloneOptionObject(object) {
   });
   return result;
 }
+
 /**
  * @param {*} merged already cloned
  * @param {*} source something to merge
@@ -829,15 +692,13 @@ function cloneOptionObject(object) {
  * @param {Object} config Config Object
  * @returns {*} cloned Object
  */
-
-
 const mergeKeys = (merged, source, keys, config) => {
   keys.forEach(key => {
     if (typeof source[key] === 'undefined' && config.ignoreUndefined) {
       return;
-    } // Do not recurse into prototype chain of merged
-
+    }
 
+    // Do not recurse into prototype chain of merged
     if (key in merged && merged[key] !== Object.getPrototypeOf(merged)) {
       defineProperty(merged, key, merge(merged[key], source[key], config));
     } else {
@@ -846,6 +707,7 @@ const mergeKeys = (merged, source, keys, config) => {
   });
   return merged;
 };
+
 /**
  * @param {*} merged already cloned
  * @param {*} source something to merge
@@ -854,78 +716,66 @@ const mergeKeys = (merged, source, keys, config) => {
  *
  * see [Array.prototype.concat ( ...arguments )](http://www.ecma-international.org/ecma-262/6.0/#sec-array.prototype.concat)
  */
-
-
 const concatArrays = (merged, source, config) => {
   let result = merged.slice(0, 0);
   let resultIndex = 0;
   [merged, source].forEach(array => {
-    const indices = []; // `result.concat(array)` with cloning
+    const indices = [];
 
+    // `result.concat(array)` with cloning
     for (let k = 0; k < array.length; k++) {
       if (!hasOwnProperty.call(array, k)) {
         continue;
       }
-
       indices.push(String(k));
-
       if (array === merged) {
         // Already cloned
         defineProperty(result, resultIndex++, array[k]);
       } else {
         defineProperty(result, resultIndex++, clone(array[k]));
       }
-    } // Merge non-index keys
-
+    }
 
+    // Merge non-index keys
     result = mergeKeys(result, array, getEnumerableOwnPropertyKeys(array).filter(key => !indices.includes(key)), config);
   });
   return result;
 };
+
 /**
  * @param {*} merged already cloned
  * @param {*} source something to merge
  * @param {Object} config Config Object
  * @returns {*} cloned Object
  */
-
-
 function merge(merged, source, config) {
   if (config.concatArrays && Array.isArray(merged) && Array.isArray(source)) {
     return concatArrays(merged, source, config);
   }
-
   if (!isOptionObject(source) || !isOptionObject(merged)) {
     return clone(source);
   }
-
   return mergeKeys(merged, source, getEnumerableOwnPropertyKeys(source), config);
 }
-
 module.exports = function () {
   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;
     }
-
     if (!isOptionObject(option)) {
       throw new TypeError('`' + option + '` is not an Option Object');
     }
-
     merged = merge(merged, {
       _: option
     }, config);
   }
-
   return merged._;
 };
 
@@ -935,17 +785,14 @@ module.exports = function () {
 const pMapSeries = async (iterable, mapper) => {
   const result = [];
   let index = 0;
-
   for (const value of iterable) {
     // eslint-disable-next-line no-await-in-loop
     result.push(await mapper(await value, index++));
   }
-
   return result;
 };
-
-module.exports = pMapSeries; // TODO: Remove this for the next major release
-
+module.exports = pMapSeries;
+// TODO: Remove this for the next major release
 module.exports.default = pMapSeries;
 
 },{}],21:[function(require,module,exports){
@@ -955,7 +802,6 @@ var isError = require('iserror'); // we want to support parsing other fields tha
 // <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors>
 // <https://github.com/stripe/stripe-node/blob/3c07d851cf897490d8b93dd4457dda0c4c8e667f/lib/Error.js#L33>
 
-
 var parseErr = function parseErr(err) {
   var fields = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
   if (!isError(err)) throw new Error('`err` must be an Error');
@@ -969,73 +815,60 @@ var parseErr = function parseErr(err) {
     return fields.includes(key);
   }) : keys;
 };
-
 module.exports = parseErr;
 
 },{"iserror":15}],22:[function(require,module,exports){
 'use strict';
 
 const get = require('@strikeentco/get');
-
 const set = require('@strikeentco/set');
-
 const isObject = val => Object.prototype.toString.call(val) === '[object Object]';
-
 const pick = (obj, paths, length, sep) => {
   const picked = {};
-
   for (let i = 0; i < length; i++) {
     const path = paths[i];
     const val = get(obj, path, sep);
-
     if (val === undefined) {
       continue; // eslint-disable-line no-continue
     }
 
     set(picked, path, val, sep);
   }
-
   return picked;
 };
-
 module.exports = function (obj, paths) {
   let sep = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '.';
-
   if (!isObject(obj) || !paths || !(Array.isArray(paths) || typeof paths === 'string')) {
     return {};
   }
-
   const {
     length
   } = paths;
-
   if (typeof paths === 'string' || length < 2) {
     const path = typeof paths === 'string' ? paths : paths[0];
     const val = get(obj, path, sep);
     return val !== undefined ? set({}, path, val, sep) : {};
   }
-
   return pick(obj, paths, length, sep);
 };
 
 },{"@strikeentco/get":2,"@strikeentco/set":3}],23:[function(require,module,exports){
 // shim for using process in browser
-var process = module.exports = {}; // cached from whatever global is present so that test runners that stub it
+var process = module.exports = {};
+
+// cached from whatever global is present so that test runners that stub it
 // don't break things.  But we need to wrap it in a try catch in case it is
 // wrapped in strict mode code which doesn't define any globals.  It's inside a
 // function because try/catches deoptimize in certain engines.
 
 var cachedSetTimeout;
 var cachedClearTimeout;
-
 function defaultSetTimout() {
   throw new Error('setTimeout has not been defined');
 }
-
 function defaultClearTimeout() {
   throw new Error('clearTimeout has not been defined');
 }
-
 (function () {
   try {
     if (typeof setTimeout === 'function') {
@@ -1046,7 +879,6 @@ function defaultClearTimeout() {
   } catch (e) {
     cachedSetTimeout = defaultSetTimout;
   }
-
   try {
     if (typeof clearTimeout === 'function') {
       cachedClearTimeout = clearTimeout;
@@ -1057,19 +889,16 @@ function defaultClearTimeout() {
     cachedClearTimeout = defaultClearTimeout;
   }
 })();
-
 function runTimeout(fun) {
   if (cachedSetTimeout === setTimeout) {
     //normal enviroments in sane situations
     return setTimeout(fun, 0);
-  } // if setTimeout wasn't available but was latter defined
-
-
+  }
+  // if setTimeout wasn't available but was latter defined
   if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
     cachedSetTimeout = setTimeout;
     return setTimeout(fun, 0);
   }
-
   try {
     // when when somebody has screwed with setTimeout but no I.E. maddness
     return cachedSetTimeout(fun, 0);
@@ -1083,19 +912,16 @@ function runTimeout(fun) {
     }
   }
 }
-
 function runClearTimeout(marker) {
   if (cachedClearTimeout === clearTimeout) {
     //normal enviroments in sane situations
     return clearTimeout(marker);
-  } // if clearTimeout wasn't available but was latter defined
-
-
+  }
+  // if clearTimeout wasn't available but was latter defined
   if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
     cachedClearTimeout = clearTimeout;
     return clearTimeout(marker);
   }
-
   try {
     // when when somebody has screwed with setTimeout but no I.E. maddness
     return cachedClearTimeout(marker);
@@ -1110,94 +936,74 @@ function runClearTimeout(marker) {
     }
   }
 }
-
 var queue = [];
 var draining = false;
 var currentQueue;
 var queueIndex = -1;
-
 function cleanUpNextTick() {
   if (!draining || !currentQueue) {
     return;
   }
-
   draining = false;
-
   if (currentQueue.length) {
     queue = currentQueue.concat(queue);
   } else {
     queueIndex = -1;
   }
-
   if (queue.length) {
     drainQueue();
   }
 }
-
 function drainQueue() {
   if (draining) {
     return;
   }
-
   var timeout = runTimeout(cleanUpNextTick);
   draining = true;
   var len = queue.length;
-
   while (len) {
     currentQueue = queue;
     queue = [];
-
     while (++queueIndex < len) {
       if (currentQueue) {
         currentQueue[queueIndex].run();
       }
     }
-
     queueIndex = -1;
     len = queue.length;
   }
-
   currentQueue = null;
   draining = false;
   runClearTimeout(timeout);
 }
-
 process.nextTick = function (fun) {
   var args = new Array(arguments.length - 1);
-
   if (arguments.length > 1) {
     for (var i = 1; i < arguments.length; i++) {
       args[i - 1] = arguments[i];
     }
   }
-
   queue.push(new Item(fun, args));
-
   if (queue.length === 1 && !draining) {
     runTimeout(drainQueue);
   }
-}; // v8 likes predictible objects
-
+};
 
+// v8 likes predictible objects
 function Item(fun, array) {
   this.fun = fun;
   this.array = array;
 }
-
 Item.prototype.run = function () {
   this.fun.apply(null, this.array);
 };
-
 process.title = 'browser';
 process.browser = true;
 process.env = {};
 process.argv = [];
 process.version = ''; // empty string to avoid regexp issues
-
 process.versions = {};
-
 function noop() {}
-
 process.on = noop;
 process.addListener = noop;
 process.once = noop;
@@ -1207,23 +1013,18 @@ process.removeAllListeners = noop;
 process.emit = noop;
 process.prependListener = noop;
 process.prependOnceListener = noop;
-
 process.listeners = function (name) {
   return [];
 };
-
 process.binding = function (name) {
   throw new Error('process.binding is not supported');
 };
-
 process.cwd = function () {
   return '/';
 };
-
 process.chdir = function (dir) {
   throw new Error('process.chdir is not supported');
 };
-
 process.umask = function () {
   return 0;
 };
@@ -1235,51 +1036,41 @@ process.umask = function () {
  * Copyright (c) 2015, 2017, Jon Schlinkert.
  * Released under the MIT License.
  */
+
 'use strict';
 
 var isObject = require('isobject');
-
 var has = require('has-value');
-
 const isUnsafeKey = key => {
   return key === '__proto__' || key === 'constructor' || key === 'prototype';
 };
-
 const validateKey = key => {
   if (isUnsafeKey(key)) {
     throw new Error(`Cannot set unsafe key: "${key}"`);
   }
 };
-
 module.exports = function unset(obj, prop) {
   if (!isObject(obj)) {
     throw new TypeError('expected an object.');
   }
-
   var isArray = Array.isArray(prop);
-
   if (!isArray && obj.hasOwnProperty(prop)) {
     delete obj[prop];
     return true;
   }
-
   if (has(obj, prop)) {
     var segs = isArray ? prop.slice() : prop.split('.');
     var last = segs.pop();
-
     while (segs.length && segs[segs.length - 1].slice(-1) === '\\') {
       last = segs.pop().slice(0, -1) + '.' + last;
     }
-
     while (segs.length) {
       prop = segs.shift();
       validateKey(prop);
       obj = obj[prop];
     }
-
     return delete obj[last];
   }
-
   return true;
 };
 
@@ -1287,7 +1078,7 @@ module.exports = function unset(obj, prop) {
 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": "10.0.0",
+  "version": "10.0.1",
   "author": "Nick Baugh <niftylettuce@gmail.com> (http://niftylettuce.com)",
   "browser": {
     "parse-app-info": false
@@ -1346,7 +1137,7 @@ module.exports={
     "rimraf": "^3.0.2",
     "signale": "^1.4.0",
     "sinon": "^14.0.0",
-    "tinyify": "^3.0.0",
+    "tinyify": "3.0.0",
     "xo": "^0.50.0"
   },
   "engines": {
@@ -1424,64 +1215,47 @@ module.exports={
 (function (process){(function (){
 // eslint-disable-next-line import/no-unassigned-import
 require('console-polyfill');
-
 const combine = require('maybe-combine-errors');
-
 const format = require('@ladjs/format-util');
-
 const formatSpecifiers = require('format-specifiers');
-
 const get = require('@strikeentco/get');
-
 const isError = require('iserror');
-
 const mergeOptions = require('merge-options');
-
 const pMapSeries = require('p-map-series');
-
 const parseAppInfo = require('parse-app-info');
-
 const parseErr = require('parse-err');
-
 const pickDeep = require('pick-deep');
-
 const set = require('@strikeentco/set');
-
 const unset = require('unset-value');
-
 const {
   boolean
 } = require('boolean');
-
 const pkg = require('../package.json');
-
 const omittedLoggerKeys = new Set(['config', 'log']);
 const levels = ['trace', 'debug', 'info', 'warn', 'error', 'fatal'];
 const aliases = {
   warning: 'warn',
   err: 'error'
 };
-const levelError = `\`level\` invalid, must be: ${levels.join(', ')}`; // <https://github.com/sindresorhus/is-plain-obj/blob/main/index.js>
+const levelError = `\`level\` invalid, must be: ${levels.join(', ')}`;
 
+// <https://github.com/sindresorhus/is-plain-obj/blob/main/index.js>
 function isPlainObject(value) {
   if (typeof value !== 'object' || value === null) {
     return false;
   }
-
   const prototype = Object.getPrototypeOf(value);
   return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);
-} // <https://github.com/GeenenTijd/dotify/blob/master/dotify.js>
-
+}
 
+// <https://github.com/GeenenTijd/dotify/blob/master/dotify.js>
 function dotifyToArray(obj) {
   const res = [];
-
   function recurse(obj, current) {
     for (const key of Object.keys(obj)) {
       const value = obj[key];
       const newKey = current ? current + '.' + key : key; // joined key with dot
       // if (value && typeof value === 'object' && !(value instanceof Date) && !ObjectID.isValid(value)) {
-
       if (isPlainObject(value)) {
         recurse(value, newKey); // it's a nested object, so do it again
       } else {
@@ -1489,51 +1263,40 @@ function dotifyToArray(obj) {
       }
     }
   }
-
   recurse(obj);
   return res;
-} // <https://stackoverflow.com/a/43233163>
-
+}
 
+// <https://stackoverflow.com/a/43233163>
 function isEmpty(value) {
   return value === undefined || value === null || typeof value === 'object' && Object.keys(value).length === 0 || typeof value === 'string' && value.trim().length === 0;
 }
-
 function isNull(value) {
   return value === null;
 }
-
 function isUndefined(value) {
   return typeof value === 'undefined';
 }
-
 function isObject(value) {
   return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
-
 function isString(value) {
   return typeof value === 'string';
 }
-
 function isFunction(value) {
   return typeof value === 'function';
 }
-
 class Axe {
   constructor() {
     var _this = this;
-
     let config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
     const remappedFields = {};
-
     if (process.env.AXE_REMAPPED_META_FIELDS) {
       const arr = process.env.AXE_REMAPPED_META_FIELDS.split(',').map(v => v.split(':'));
-
       for (const [prop, value] of arr) {
         remappedFields[prop] = value;
       }
     }
-
     this.config = mergeOptions({
       showStack: process.env.AXE_SHOW_STACK ? boolean(process.env.AXE_SHOW_STACK) : true,
       meta: Object.assign({
@@ -1556,15 +1319,15 @@ class Axe {
       }, typeof config.hooks === 'object' ? config.hooks : {})
     }, config);
     this.appInfo = this.config.appInfo ? isFunction(parseAppInfo) ? parseAppInfo() : false : false;
-    this.log = this.log.bind(this); // Inherit methods from parent logger
+    this.log = this.log.bind(this);
 
+    // Inherit methods from parent logger
     const methods = Object.keys(this.config.logger).filter(key => !omittedLoggerKeys.has(key));
-
     for (const element of methods) {
       this[element] = this.config.logger[element];
-    } // Bind helper functions for each log level
-
+    }
 
+    // Bind helper functions for each log level
     for (const element of levels) {
       // Ensure function exists in logger passed
       if (typeof this.config.logger[element] !== 'function') {
@@ -1573,95 +1336,87 @@ class Axe {
         } else {
           this.config.logger[element] = this.config.logger.info || this.config.logger.log;
         }
-      } // Bind log handler which normalizes args and populates meta
-
+      }
 
+      // 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.setLevel = this.setLevel.bind(this);
     this.getNormalizedLevel = this.getNormalizedLevel.bind(this);
-    this.setName = this.setName.bind(this); // Set the logger name
+    this.setName = this.setName.bind(this);
 
-    if (this.config.name) this.setName(this.config.name); // Set the logger level
+    // Set the logger name
+    if (this.config.name) this.setName(this.config.name);
 
-    this.setLevel(this.config.level); // Aliases
+    // Set the logger level
+    this.setLevel(this.config.level);
 
+    // Aliases
     this.err = this.error;
-    this.warning = this.warn; // Pre and Post Hooks
+    this.warning = this.warn;
 
+    // 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];
         }
-
         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];
         }
-
         if (level !== _level) return [...args];
         return fn(...args);
       });
     };
   }
-
   setLevel(level) {
-    if (!isString(level) || levels.indexOf(level) === -1) throw new Error(levelError); // Support signale logger and other loggers that use `logLevel`
-
-    if (isString(this.config.logger.logLevel)) this.config.logger.logLevel = level;else this.config.logger.level = level; // Adjusts `this.config.levels` array
+    if (!isString(level) || levels.indexOf(level) === -1) throw new Error(levelError);
+    // Support signale logger and other loggers that use `logLevel`
+    if (isString(this.config.logger.logLevel)) this.config.logger.logLevel = level;else this.config.logger.level = level;
+    // Adjusts `this.config.levels` array
     // so that it has all proceeding (inclusive)
-
     this.config.levels = levels.slice(levels.indexOf(level));
   }
-
   getNormalizedLevel(level) {
     if (!isString(level)) return 'info';
     if (isString(aliases[level])) return aliases[level];
     if (levels.indexOf(level) === -1) return 'info';
     return level;
   }
-
   setName(name) {
-    if (!isString(name)) throw new Error('`name` must be a String'); // Support signale logger and other loggers that use `scope`
-
+    if (!isString(name)) throw new Error('`name` must be a String');
+    // Support signale logger and other loggers that use `scope`
     if (isString(this.config.logger.scope)) this.config.logger.scope = name;else this.config.logger.name = name;
-  } // eslint-disable-next-line complexity
-
+  }
 
+  // eslint-disable-next-line complexity
   log(level, message, meta) {
     const originalArgs = [];
     const errors = [];
     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);
     }
-
     const {
       config
     } = this;
     let modifier = 0;
-
     if (isString(level) && isString(aliases[level])) {
       level = aliases[level];
     } else if (isError(level)) {
@@ -1673,24 +1428,25 @@ class Axe {
       message = level;
       level = this.getNormalizedLevel(level);
       modifier = -1;
-    } // Return early if it is not a valid logging level
-
+    }
 
-    if (config.levels.indexOf(level) === -1) return; // Bunyan support (meta, message, ...args)
+    // Return early if it is not a valid logging level
+    if (config.levels.indexOf(level) === -1) return;
 
+    // Bunyan support (meta, message, ...args)
     let isBunyan = false;
-
     if ((isObject(message) || Array.isArray(message)) && isString(meta)) {
       isBunyan = true;
       const _meta = meta;
       meta = message;
       message = isString(_meta) && originalArgs.length >= 3 + modifier ? format(...originalArgs.slice(2 + modifier)) : _meta;
-    } // If message was undefined then set it to level
+    }
 
+    // If message was undefined then set it to level
+    if (isUndefined(message)) message = level;
 
-    if (isUndefined(message)) message = level; // If only `message` was passed then if it was an Object
+    // If only `message` was passed then if it was an Object
     // preserve it as an Object by setting it as meta
-
     if (originalArgs.slice(1 + modifier).length === 1 && !isString(message) && !isError(message)) {
       meta = {
         message
@@ -1700,11 +1456,9 @@ class Axe {
       message = undefined;
       meta = {};
       const messages = [];
-
       for (const arg of originalArgs) {
         if (isError(arg)) errors.push(arg);else if (isString(arg)) messages.push(arg);
       }
-
       if (errors.length === 0 && messages.length > 0) message = format(...messages);else if (errors.length > 0 && level === 'log') level = 'error';
     } else if (!isBunyan && originalArgs.length === 3 + modifier && isString(message) && formatSpecifiers.some(t => message.indexOf(t) !== -1)) {
       // Otherwise if there are three args and if the `message` contains
@@ -1727,49 +1481,48 @@ class Axe {
         message = format(message);
       }
     } else if (isError(meta)) {
-      errors.push(meta); // handle additional args
-
+      errors.push(meta);
+      // handle additional args
       for (const arg of originalArgs.slice(2 + modifier)) {
         // should skip this better with slice and modifier adjustment
         if (meta === arg) continue;
         if (isError(arg)) errors.push(arg);
       }
-
       meta = {};
     }
-
     if (!isUndefined(meta) && !isObject(meta)) meta = {
       original_meta: meta
     };else if (!isObject(meta)) meta = {};
-
     if (isError(message)) {
       errors.unshift(message);
       message = undefined;
-    } //
+    }
+
+    //
     // rewrite `meta.err` to `meta.original_err` for consistency
     // (in case someone has an object with `.err` property on it with an error)
     //
-
-
     if (isObject(meta.err)) {
       if (isError(meta.err)) errors.push(meta.err);
       meta.original_err = isError(meta.err) ? parseErr(meta.err) : meta.err;
     }
-
     let err;
-
     if (errors.length > 0) {
       err = combine(errors);
       meta.err = parseErr(err);
       if (!isString(message)) message = err.message;
-    } // Set `args` prop with original arguments passed
+    }
 
+    // Set `args` prop with original arguments passed
+    meta.args = originalArgs;
 
-    meta.args = originalArgs; // Set default level on meta
+    // Set default level on meta
+    meta.level = level;
 
-    meta.level = level; // Add `app` object to metadata
+    // Add `app` object to metadata
+    if (this.appInfo) meta.app = this.appInfo;
 
-    if (this.appInfo) meta.app = this.appInfo; //
+    //
     // determine log method to use
     //
     // if we didn't pass a level as a method
@@ -1778,8 +1531,9 @@ class Axe {
     //
     // and fatal should use error (e.g. in browser)
     //
+    const method = modifier === -1 ? 'log' : level;
 
-    const method = modifier === -1 ? 'log' : level; //
+    //
     // NOTE: using lodash _.omit and _.pick would have been _very slow_
     //
     // const omittedAndPickedFields = {
@@ -1795,8 +1549,8 @@ class Axe {
     if (!isEmpty(this.config.meta.remappedFields)) {
       for (const key of Object.keys(this.config.meta.remappedFields)) {
         set(meta, this.config.meta.remappedFields[key], get(meta, key));
-        unset(meta, key); // cleanup empty objects after remapping
-
+        unset(meta, key);
+        // cleanup empty objects after remapping
         if (this.config.meta.cleanupRemapping) {
           const index = key.lastIndexOf('.');
           if (index === -1) continue;
@@ -1805,9 +1559,9 @@ class Axe {
         }
       }
     }
-
     if (!isEmpty(this.config.meta.omittedFields) || !isEmpty(this.config.meta.pickedFields)) {
-      const dotified = dotifyToArray(meta); // dotified = [
+      const dotified = dotifyToArray(meta);
+      // dotified = [
       //   'err.name',
       //   'err.message',
       //   'err.stack',
@@ -1823,13 +1577,11 @@ class Axe {
         for (const prop of this.config.meta.omittedFields) {
           // <https://stackoverflow.com/a/9882349>
           let i = dotified.length;
-
           while (i--) {
             if (dotified[i] === prop || dotified[i].indexOf(`${prop}.`) === 0) dotified.splice(i, 1);
           }
         }
       }
-
       if (!isEmpty(this.config.meta.pickedFields)) {
         for (const prop of this.config.meta.pickedFields) {
           // response.headers.boop
@@ -1841,30 +1593,28 @@ class Axe {
           // so we need to split by the first period and omit any keys from dotified starting with it
           const index = prop.indexOf('.');
           const key = prop.slice(0, index + 1);
-
           if (index !== -1) {
             let i = dotified.length;
-
             while (i--) {
               if (dotified[i].indexOf(key) === 0) dotified.splice(i, 1);
             }
-          } // finally add it if it did not already exist
-
+          }
 
+          // finally add it if it did not already exist
           if (dotified.indexOf(prop) === -1) dotified.push(prop);
         }
-      } // now we call pick-deep using the final array
-
+      }
 
+      // now we call pick-deep using the final array
       meta = pickDeep(meta, dotified);
-    } // pre-hooks
-
+    }
 
+    // pre-hooks
     for (const hook of this.config.hooks.pre) {
       [err, message, meta] = hook(method, err, message, meta);
-    } // only invoke logger methods if it was not silent
-
+    }
 
+    // only invoke logger methods if it was not silent
     if (!config.silent) {
       // Show stack trace if necessary (along with any metadata)
       if (isError(err) && config.showStack) {
@@ -1878,16 +1628,14 @@ class Axe {
       } else {
         this.config.logger[method](message, meta);
       }
-    } // post-hooks
-
+    }
 
+    // post-hooks
     pMapSeries(this.config.hooks.post, hook => hook(method, err, message, meta)).then().catch(err => {
       this.config.logger.error(err);
     });
   }
-
 }
-
 module.exports = Axe;
 
 }).call(this)}).call(this,require('_process'))