@bigbinary/neeto-audit-frontend 2.0.1 → 2.0.3

package/dist/index.js

@@ -811,6 +811,7 @@ function _curryN(length, received, fn) {
     var argsIdx = 0;
     var left = length;
     var combinedIdx = 0;
+    var hasPlaceholder = false;
 
     while (combinedIdx < received.length || argsIdx < arguments.length) {
       var result;
@@ -826,12 +827,14 @@ function _curryN(length, received, fn) {
 
       if (!_isPlaceholder(result)) {
         left -= 1;
+      } else {
+        hasPlaceholder = true;
       }
 
       combinedIdx += 1;
     }
 
-    return left <= 0 ? fn.apply(this, combined) : _arity(left, _curryN(length, combined, fn));
+    return !hasPlaceholder && left <= 0 ? fn.apply(this, combined) : _arity(Math.max(0, left), _curryN(length, combined, fn));
   };
 }
 
@@ -1062,18 +1065,20 @@ function _objectIs(a, b) {
 
 var _objectIs$1 = typeof Object.is === 'function' ? Object.is : _objectIs;
 
-var toString$1 = Object.prototype.toString;
+var toString$2 = Object.prototype.toString;
 
 var _isArguments =
 /*#__PURE__*/
 function () {
-  return toString$1.call(arguments) === '[object Arguments]' ? function _isArguments(x) {
-    return toString$1.call(x) === '[object Arguments]';
+  return toString$2.call(arguments) === '[object Arguments]' ? function _isArguments(x) {
+    return toString$2.call(x) === '[object Arguments]';
   } : function _isArguments(x) {
     return _has('callee', x);
   };
 }();
 
+var _isArguments$1 = _isArguments;
+
 var hasEnumBug = !
 /*#__PURE__*/
 {
@@ -1135,7 +1140,7 @@ _curry1(function keys(obj) {
   var prop, nIdx;
   var ks = [];
 
-  var checkArgsLength = hasArgsEnumBug && _isArguments(obj);
+  var checkArgsLength = hasArgsEnumBug && _isArguments$1(obj);
 
   for (prop in obj) {
     if (_has(prop, obj) && (!checkArgsLength || prop !== 'length')) {
@@ -1159,6 +1164,7 @@ _curry1(function keys(obj) {
 
   return ks;
 });
+var keys$1 = keys;
 
 /**
  * Gives a single-word string description of the (native) type of a value,
@@ -1183,6 +1189,7 @@ _curry1(function keys(obj) {
  *      R.type([]); //=> "Array"
  *      R.type(/[A-z]/); //=> "RegExp"
  *      R.type(() => {}); //=> "Function"
+ *      R.type(async () => {}); //=> "AsyncFunction"
  *      R.type(undefined); //=> "Undefined"
  */
 
@@ -1192,6 +1199,8 @@ _curry1(function type(val) {
   return val === null ? 'Null' : val === undefined ? 'Undefined' : Object.prototype.toString.call(val).slice(8, -1);
 });
 
+var type$1 = type;
+
 /**
  * private _uniqContentEquals function.
  * That function is checking equality of 2 iterator contents with 2 assumptions
@@ -1223,9 +1232,9 @@ function _equals(a, b, stackA, stackB) {
     return true;
   }
 
-  var typeA = type(a);
+  var typeA = type$1(a);
 
-  if (typeA !== type(b)) {
+  if (typeA !== type$1(b)) {
     return false;
   }
 
@@ -1325,9 +1334,9 @@ function _equals(a, b, stackA, stackB) {
       return false;
   }
 
-  var keysA = keys(a);
+  var keysA = keys$1(a);
 
-  if (keysA.length !== keys(b).length) {
+  if (keysA.length !== keys$1(b).length) {
     return false;
   }
 
@@ -1380,6 +1389,8 @@ _curry2(function equals(a, b) {
   return _equals(a, b, [], []);
 });
 
+var equals$1 = equals;
+
 function _indexOf(list, a, idx) {
   var inf, item; // Array.prototype.indexOf doesn't exist below IE9
 
@@ -1437,7 +1448,7 @@ function _indexOf(list, a, idx) {
 
 
   while (idx < list.length) {
-    if (equals(list[idx], a)) {
+    if (equals$1(list[idx], a)) {
       return idx;
     }
 
@@ -1483,6 +1494,8 @@ var _toISOString = typeof Date.prototype.toISOString === 'function' ? function _
   return d.getUTCFullYear() + '-' + pad(d.getUTCMonth() + 1) + '-' + pad(d.getUTCDate()) + 'T' + pad(d.getUTCHours()) + ':' + pad(d.getUTCMinutes()) + ':' + pad(d.getUTCSeconds()) + '.' + (d.getUTCMilliseconds() / 1000).toFixed(3).slice(2, 5) + 'Z';
 };
 
+var _toISOString$1 = _toISOString;
+
 function _complement(f) {
   return function () {
     return !f.apply(this, arguments);
@@ -1585,10 +1598,12 @@ _dispatchable(['fantasy-land/filter', 'filter'], _xfilter, function (pred, filte
     }
 
     return acc;
-  }, {}, keys(filterable)) : // else
+  }, {}, keys$1(filterable)) : // else
   _filter(pred, filterable);
 }));
 
+var filter$1 = filter;
+
 /**
  * The complement of [`filter`](#filter).
  *
@@ -1617,9 +1632,11 @@ _dispatchable(['fantasy-land/filter', 'filter'], _xfilter, function (pred, filte
 var reject =
 /*#__PURE__*/
 _curry2(function reject(pred, filterable) {
-  return filter(_complement(pred), filterable);
+  return filter$1(_complement(pred), filterable);
 });
 
+var reject$1 = reject;
+
 function _toString(x, seen) {
   var recur = function recur(y) {
     var xs = seen.concat([x]);
@@ -1638,15 +1655,15 @@ function _toString(x, seen) {
       return '(function() { return arguments; }(' + _map(recur, x).join(', ') + '))';
 
     case '[object Array]':
-      return '[' + _map(recur, x).concat(mapPairs(x, reject(function (k) {
+      return '[' + _map(recur, x).concat(mapPairs(x, reject$1(function (k) {
         return /^\d+$/.test(k);
-      }, keys(x)))).join(', ') + ']';
+      }, keys$1(x)))).join(', ') + ']';
 
     case '[object Boolean]':
       return typeof x === 'object' ? 'new Boolean(' + recur(x.valueOf()) + ')' : x.toString();
 
     case '[object Date]':
-      return 'new Date(' + (isNaN(x.valueOf()) ? recur(NaN) : _quote(_toISOString(x))) + ')';
+      return 'new Date(' + (isNaN(x.valueOf()) ? recur(NaN) : _quote(_toISOString$1(x))) + ')';
 
     case '[object Map]':
       return 'new Map(' + recur(Array.from(x)) + ')';
@@ -1675,7 +1692,7 @@ function _toString(x, seen) {
         }
       }
 
-      return '{' + mapPairs(x, keys(x)).join(', ') + '}';
+      return '{' + mapPairs(x, keys$1(x)).join(', ') + '}';
   }
 }
 
@@ -1722,6 +1739,8 @@ _curry1(function toString(val) {
   return _toString(val, []);
 });
 
+var toString$1 = toString;
+
 var XMap =
 /*#__PURE__*/
 function () {
@@ -1746,6 +1765,8 @@ var _xmap = function _xmap(f) {
   };
 };
 
+var _xmap$1 = _xmap;
+
 /**
  * Takes a function and
  * a [functor](https://github.com/fantasyland/fantasy-land#functor),
@@ -1786,7 +1807,7 @@ var map =
 /*#__PURE__*/
 _curry2(
 /*#__PURE__*/
-_dispatchable(['fantasy-land/map', 'map'], _xmap, function map(fn, functor) {
+_dispatchable(['fantasy-land/map', 'map'], _xmap$1, function map(fn, functor) {
   switch (Object.prototype.toString.call(functor)) {
     case '[object Function]':
       return curryN$1(functor.length, function () {
@@ -1797,13 +1818,15 @@ _dispatchable(['fantasy-land/map', 'map'], _xmap, function map(fn, functor) {
       return _arrayReduce(function (acc, key) {
         acc[key] = fn(functor[key]);
         return acc;
-      }, {}, keys(functor));
+      }, {}, keys$1(functor));
 
     default:
       return _map(fn, functor);
   }
 }));
 
+var map$1 = map;
+
 function _isString(x) {
   return Object.prototype.toString.call(x) === '[object String]';
 }
@@ -1893,10 +1916,12 @@ _curry1(function isArrayLike(x) {
   return false;
 });
 
+var _isArrayLike$1 = _isArrayLike;
+
 var symIterator = typeof Symbol !== 'undefined' ? Symbol.iterator : '@@iterator';
 function _createReduce(arrayReduce, methodReduce, iterableReduce) {
   return function _reduce(xf, acc, list) {
-    if (_isArrayLike(list)) {
+    if (_isArrayLike$1(list)) {
       return arrayReduce(xf, acc, list);
     }
 
@@ -1943,6 +1968,8 @@ var _reduce =
 /*#__PURE__*/
 _createReduce(_arrayReduce, _methodReduce, _iterableReduce);
 
+var _reduce$1 = _reduce;
+
 /**
  * ap applies a list of functions to a list of values.
  *
@@ -1975,11 +2002,13 @@ var ap =
 _curry2(function ap(applyF, applyX) {
   return typeof applyX['fantasy-land/ap'] === 'function' ? applyX['fantasy-land/ap'](applyF) : typeof applyF.ap === 'function' ? applyF.ap(applyX) : typeof applyF === 'function' ? function (x) {
     return applyF(x)(applyX(x));
-  } : _reduce(function (acc, f) {
-    return _concat(acc, map(f, applyX));
+  } : _reduce$1(function (acc, f) {
+    return _concat(acc, map$1(f, applyX));
   }, [], applyF);
 });
 
+var ap$1 = ap;
+
 /**
  * Checks if the input value is `null` or `undefined`.
  *
@@ -2034,10 +2063,12 @@ var liftN =
 _curry2(function liftN(arity, fn) {
   var lifted = curryN$1(arity, fn);
   return curryN$1(arity, function () {
-    return _arrayReduce(ap, map(lifted, arguments[0]), Array.prototype.slice.call(arguments, 1));
+    return _arrayReduce(ap$1, map$1(lifted, arguments[0]), Array.prototype.slice.call(arguments, 1));
   });
 });
 
+var liftN$1 = liftN;
+
 /**
  * "lifts" a function of arity >= 1 so that it may "map over" a list, Function or other
  * object that satisfies the [FantasyLand Apply spec](https://github.com/fantasyland/fantasy-land#apply).
@@ -2064,7 +2095,7 @@ _curry2(function liftN(arity, fn) {
 var lift =
 /*#__PURE__*/
 _curry1(function lift(fn) {
-  return liftN(fn.length, fn);
+  return liftN$1(fn.length, fn);
 });
 
 var lift$1 = lift;
@@ -2095,6 +2126,8 @@ _curry1(function not(a) {
   return !a;
 });
 
+var not$1 = not;
+
 /**
  * Takes a function `f` and returns a function `g` such that if called with the same arguments
  * when `f` returns a "truthy" value, `g` returns `false` and when `f` returns a "falsy" value `g` returns `true`.
@@ -2120,7 +2153,7 @@ _curry1(function not(a) {
 
 var complement =
 /*#__PURE__*/
-lift$1(not);
+lift$1(not$1);
 var complement$1 = complement;
 
 function _identity(x) {
@@ -2178,23 +2211,7 @@ var identity$1 = identity;
  *   - `g(_, 2)(_, 3)(1)`
  *
  * Please note that default parameters don't count towards a [function arity](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/length)
- * and therefore `curry` won't work well with those:
- *
- * ```
- * const h = R.curry((a, b, c = 2) => a + b + c);
- *
- * h(40);
- * //=> function (waits for `b`)
- *
- * h(39)(1);
- * //=> 42
- *
- * h(1)(2, 3);
- * //=> 6
- *
- * h(1)(2)(7);
- * //=> Error! (`3` is not a function!)
- * ```
+ * and therefore `curry` won't work well with those.
  *
  * @func
  * @memberOf R
@@ -2207,11 +2224,14 @@ var identity$1 = identity;
  * @example
  *
  *      const addFourNumbers = (a, b, c, d) => a + b + c + d;
- *
  *      const curriedAddFourNumbers = R.curry(addFourNumbers);
  *      const f = curriedAddFourNumbers(1, 2);
  *      const g = f(3);
  *      g(4); //=> 10
+ *
+ *      // R.curry not working well with default parameters
+ *      const h = R.curry((a, b, c = 2) => a + b + c);
+ *      h(1)(2)(7); //=> Error! (`3` is not a function!)
  */
 
 var curry =
@@ -2296,12 +2316,14 @@ function _isTypedArray(val) {
 var empty =
 /*#__PURE__*/
 _curry1(function empty(x) {
-  return x != null && typeof x['fantasy-land/empty'] === 'function' ? x['fantasy-land/empty']() : x != null && x.constructor != null && typeof x.constructor['fantasy-land/empty'] === 'function' ? x.constructor['fantasy-land/empty']() : x != null && typeof x.empty === 'function' ? x.empty() : x != null && x.constructor != null && typeof x.constructor.empty === 'function' ? x.constructor.empty() : _isArray(x) ? [] : _isString(x) ? '' : _isObject(x) ? {} : _isArguments(x) ? function () {
+  return x != null && typeof x['fantasy-land/empty'] === 'function' ? x['fantasy-land/empty']() : x != null && x.constructor != null && typeof x.constructor['fantasy-land/empty'] === 'function' ? x.constructor['fantasy-land/empty']() : x != null && typeof x.empty === 'function' ? x.empty() : x != null && x.constructor != null && typeof x.constructor.empty === 'function' ? x.constructor.empty() : _isArray(x) ? [] : _isString(x) ? '' : _isObject(x) ? {} : _isArguments$1(x) ? function () {
     return arguments;
   }() : _isTypedArray(x) ? x.constructor.from('') : void 0 // else
   ;
 });
 
+var empty$1 = empty;
+
 /**
  * Reports whether two objects have the same value, in [`R.equals`](#equals)
  * terms, for the specified property. Useful as a curried predicate.
@@ -2327,7 +2349,7 @@ _curry1(function empty(x) {
 var eqProps =
 /*#__PURE__*/
 _curry3(function eqProps(prop, obj1, obj2) {
-  return equals(obj1[prop], obj2[prop]);
+  return equals$1(obj1[prop], obj2[prop]);
 });
 
 var eqProps$1 = eqProps;
@@ -2449,7 +2471,7 @@ _curry2(function invoker(arity, method) {
       return target[method].apply(target, Array.prototype.slice.call(arguments, 0, arity));
     }
 
-    throw new TypeError(toString(target) + ' does not have a method named "' + method + '"');
+    throw new TypeError(toString$1(target) + ' does not have a method named "' + method + '"');
   });
 });
 
@@ -2480,13 +2502,13 @@ var invoker$1 = invoker;
  *      R.is(Number, {}); //=> false
  */
 
-var is =
+var is$1 =
 /*#__PURE__*/
 _curry2(function is(Ctor, val) {
   return val instanceof Ctor || val != null && (val.constructor === Ctor || Ctor.name === 'Object' && typeof val === 'object');
 });
 
-var is$1 = is;
+var is$2 = is$1;
 
 /**
  * Returns `true` if the given value is its type's empty value; `false`
@@ -2514,7 +2536,7 @@ var is$1 = is;
 var isEmpty =
 /*#__PURE__*/
 _curry1(function isEmpty(x) {
-  return x != null && equals(x, empty(x));
+  return x != null && equals$1(x, empty$1(x));
 });
 
 var isEmpty$1 = isEmpty;
@@ -2547,7 +2569,7 @@ _curry2(function mapObjIndexed(fn, obj) {
   return _arrayReduce(function (acc, key) {
     acc[key] = fn(obj[key], key, obj);
     return acc;
-  }, {}, keys(obj));
+  }, {}, keys$1(obj));
 });
 
 var mapObjIndexed$1 = mapObjIndexed;
@@ -2601,6 +2623,8 @@ _curry3(function mergeWithKey(fn, l, r) {
   return result;
 });
 
+var mergeWithKey$1 = mergeWithKey;
+
 /**
  * Creates a new object with the own properties of the two provided objects.
  * If a key exists in both objects:
@@ -2633,7 +2657,7 @@ _curry3(function mergeWithKey(fn, l, r) {
 var mergeDeepWithKey =
 /*#__PURE__*/
 _curry3(function mergeDeepWithKey(fn, lObj, rObj) {
-  return mergeWithKey(function (k, lVal, rVal) {
+  return mergeWithKey$1(function (k, lVal, rVal) {
     if (_isObject(lVal) && _isObject(rVal)) {
       return mergeDeepWithKey(fn, lVal, rVal);
     } else {
@@ -2642,6 +2666,8 @@ _curry3(function mergeDeepWithKey(fn, lObj, rObj) {
   }, lObj, rObj);
 });
 
+var mergeDeepWithKey$1 = mergeDeepWithKey;
+
 /**
  * Creates a new object with the own properties of the first object merged with
  * the own properties of the second object. If a key exists in both objects:
@@ -2667,7 +2693,7 @@ _curry3(function mergeDeepWithKey(fn, lObj, rObj) {
 var mergeDeepRight =
 /*#__PURE__*/
 _curry2(function mergeDeepRight(lObj, rObj) {
-  return mergeDeepWithKey(function (k, lVal, rVal) {
+  return mergeDeepWithKey$1(function (k, lVal, rVal) {
     return rVal;
   }, lObj, rObj);
 });
@@ -2837,6 +2863,708 @@ function _typeof(obj) {
   }, _typeof(obj);
 }
 
+// src/utils/env.ts
+var NOTHING = Symbol.for("immer-nothing");
+var DRAFTABLE = Symbol.for("immer-draftable");
+var DRAFT_STATE = Symbol.for("immer-state");
+
+// src/utils/errors.ts
+var errors$1 = process.env.NODE_ENV !== "production" ? [
+  // All error codes, starting by 0:
+  function(plugin) {
+    return `The plugin for '${plugin}' has not been loaded into Immer. To enable the plugin, import and call \`enable${plugin}()\` when initializing your application.`;
+  },
+  function(thing) {
+    return `produce can only be called on things that are draftable: plain objects, arrays, Map, Set or classes that are marked with '[immerable]: true'. Got '${thing}'`;
+  },
+  "This object has been frozen and should not be mutated",
+  function(data) {
+    return "Cannot use a proxy that has been revoked. Did you pass an object from inside an immer function to an async process? " + data;
+  },
+  "An immer producer returned a new value *and* modified its draft. Either return a new value *or* modify the draft.",
+  "Immer forbids circular references",
+  "The first or second argument to `produce` must be a function",
+  "The third argument to `produce` must be a function or undefined",
+  "First argument to `createDraft` must be a plain object, an array, or an immerable object",
+  "First argument to `finishDraft` must be a draft returned by `createDraft`",
+  function(thing) {
+    return `'current' expects a draft, got: ${thing}`;
+  },
+  "Object.defineProperty() cannot be used on an Immer draft",
+  "Object.setPrototypeOf() cannot be used on an Immer draft",
+  "Immer only supports deleting array indices",
+  "Immer only supports setting array indices and the 'length' property",
+  function(thing) {
+    return `'original' expects a draft, got: ${thing}`;
+  }
+  // Note: if more errors are added, the errorOffset in Patches.ts should be increased
+  // See Patches.ts for additional errors
+] : [];
+function die(error, ...args) {
+  if (process.env.NODE_ENV !== "production") {
+    const e = errors$1[error];
+    const msg = typeof e === "function" ? e.apply(null, args) : e;
+    throw new Error(`[Immer] ${msg}`);
+  }
+  throw new Error(
+    `[Immer] minified error nr: ${error}. Full error at: https://bit.ly/3cXEKWf`
+  );
+}
+
+// src/utils/common.ts
+var getPrototypeOf = Object.getPrototypeOf;
+function isDraft(value) {
+  return !!value && !!value[DRAFT_STATE];
+}
+function isDraftable(value) {
+  if (!value)
+    return false;
+  return isPlainObject(value) || Array.isArray(value) || !!value[DRAFTABLE] || !!value.constructor?.[DRAFTABLE] || isMap(value) || isSet(value);
+}
+var objectCtorString = Object.prototype.constructor.toString();
+function isPlainObject(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const proto = getPrototypeOf(value);
+  if (proto === null) {
+    return true;
+  }
+  const Ctor = Object.hasOwnProperty.call(proto, "constructor") && proto.constructor;
+  if (Ctor === Object)
+    return true;
+  return typeof Ctor == "function" && Function.toString.call(Ctor) === objectCtorString;
+}
+function each(obj, iter) {
+  if (getArchtype(obj) === 0 /* Object */) {
+    Object.entries(obj).forEach(([key, value]) => {
+      iter(key, value, obj);
+    });
+  } else {
+    obj.forEach((entry, index) => iter(index, entry, obj));
+  }
+}
+function getArchtype(thing) {
+  const state = thing[DRAFT_STATE];
+  return state ? state.type_ : Array.isArray(thing) ? 1 /* Array */ : isMap(thing) ? 2 /* Map */ : isSet(thing) ? 3 /* Set */ : 0 /* Object */;
+}
+function has(thing, prop) {
+  return getArchtype(thing) === 2 /* Map */ ? thing.has(prop) : Object.prototype.hasOwnProperty.call(thing, prop);
+}
+function set(thing, propOrOldValue, value) {
+  const t = getArchtype(thing);
+  if (t === 2 /* Map */)
+    thing.set(propOrOldValue, value);
+  else if (t === 3 /* Set */) {
+    thing.add(value);
+  } else
+    thing[propOrOldValue] = value;
+}
+function is(x, y) {
+  if (x === y) {
+    return x !== 0 || 1 / x === 1 / y;
+  } else {
+    return x !== x && y !== y;
+  }
+}
+function isMap(target) {
+  return target instanceof Map;
+}
+function isSet(target) {
+  return target instanceof Set;
+}
+function latest(state) {
+  return state.copy_ || state.base_;
+}
+function shallowCopy(base, strict) {
+  if (isMap(base)) {
+    return new Map(base);
+  }
+  if (isSet(base)) {
+    return new Set(base);
+  }
+  if (Array.isArray(base))
+    return Array.prototype.slice.call(base);
+  if (!strict && isPlainObject(base)) {
+    if (!getPrototypeOf(base)) {
+      const obj = /* @__PURE__ */ Object.create(null);
+      return Object.assign(obj, base);
+    }
+    return { ...base };
+  }
+  const descriptors = Object.getOwnPropertyDescriptors(base);
+  delete descriptors[DRAFT_STATE];
+  let keys = Reflect.ownKeys(descriptors);
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    const desc = descriptors[key];
+    if (desc.writable === false) {
+      desc.writable = true;
+      desc.configurable = true;
+    }
+    if (desc.get || desc.set)
+      descriptors[key] = {
+        configurable: true,
+        writable: true,
+        // could live with !!desc.set as well here...
+        enumerable: desc.enumerable,
+        value: base[key]
+      };
+  }
+  return Object.create(getPrototypeOf(base), descriptors);
+}
+function freeze(obj, deep = false) {
+  if (isFrozen(obj) || isDraft(obj) || !isDraftable(obj))
+    return obj;
+  if (getArchtype(obj) > 1) {
+    obj.set = obj.add = obj.clear = obj.delete = dontMutateFrozenCollections;
+  }
+  Object.freeze(obj);
+  if (deep)
+    each(obj, (_key, value) => freeze(value, true));
+  return obj;
+}
+function dontMutateFrozenCollections() {
+  die(2);
+}
+function isFrozen(obj) {
+  return Object.isFrozen(obj);
+}
+
+// src/utils/plugins.ts
+var plugins = {};
+function getPlugin(pluginKey) {
+  const plugin = plugins[pluginKey];
+  if (!plugin) {
+    die(0, pluginKey);
+  }
+  return plugin;
+}
+
+// src/core/scope.ts
+var currentScope;
+function getCurrentScope() {
+  return currentScope;
+}
+function createScope(parent_, immer_) {
+  return {
+    drafts_: [],
+    parent_,
+    immer_,
+    // Whenever the modified draft contains a draft from another scope, we
+    // need to prevent auto-freezing so the unowned draft can be finalized.
+    canAutoFreeze_: true,
+    unfinalizedDrafts_: 0
+  };
+}
+function usePatchesInScope(scope, patchListener) {
+  if (patchListener) {
+    getPlugin("Patches");
+    scope.patches_ = [];
+    scope.inversePatches_ = [];
+    scope.patchListener_ = patchListener;
+  }
+}
+function revokeScope(scope) {
+  leaveScope(scope);
+  scope.drafts_.forEach(revokeDraft);
+  scope.drafts_ = null;
+}
+function leaveScope(scope) {
+  if (scope === currentScope) {
+    currentScope = scope.parent_;
+  }
+}
+function enterScope(immer2) {
+  return currentScope = createScope(currentScope, immer2);
+}
+function revokeDraft(draft) {
+  const state = draft[DRAFT_STATE];
+  if (state.type_ === 0 /* Object */ || state.type_ === 1 /* Array */)
+    state.revoke_();
+  else
+    state.revoked_ = true;
+}
+
+// src/core/finalize.ts
+function processResult(result, scope) {
+  scope.unfinalizedDrafts_ = scope.drafts_.length;
+  const baseDraft = scope.drafts_[0];
+  const isReplaced = result !== void 0 && result !== baseDraft;
+  if (isReplaced) {
+    if (baseDraft[DRAFT_STATE].modified_) {
+      revokeScope(scope);
+      die(4);
+    }
+    if (isDraftable(result)) {
+      result = finalize(scope, result);
+      if (!scope.parent_)
+        maybeFreeze(scope, result);
+    }
+    if (scope.patches_) {
+      getPlugin("Patches").generateReplacementPatches_(
+        baseDraft[DRAFT_STATE].base_,
+        result,
+        scope.patches_,
+        scope.inversePatches_
+      );
+    }
+  } else {
+    result = finalize(scope, baseDraft, []);
+  }
+  revokeScope(scope);
+  if (scope.patches_) {
+    scope.patchListener_(scope.patches_, scope.inversePatches_);
+  }
+  return result !== NOTHING ? result : void 0;
+}
+function finalize(rootScope, value, path) {
+  if (isFrozen(value))
+    return value;
+  const state = value[DRAFT_STATE];
+  if (!state) {
+    each(
+      value,
+      (key, childValue) => finalizeProperty(rootScope, state, value, key, childValue, path));
+    return value;
+  }
+  if (state.scope_ !== rootScope)
+    return value;
+  if (!state.modified_) {
+    maybeFreeze(rootScope, state.base_, true);
+    return state.base_;
+  }
+  if (!state.finalized_) {
+    state.finalized_ = true;
+    state.scope_.unfinalizedDrafts_--;
+    const result = state.copy_;
+    let resultEach = result;
+    let isSet2 = false;
+    if (state.type_ === 3 /* Set */) {
+      resultEach = new Set(result);
+      result.clear();
+      isSet2 = true;
+    }
+    each(
+      resultEach,
+      (key, childValue) => finalizeProperty(rootScope, state, result, key, childValue, path, isSet2)
+    );
+    maybeFreeze(rootScope, result, false);
+    if (path && rootScope.patches_) {
+      getPlugin("Patches").generatePatches_(
+        state,
+        path,
+        rootScope.patches_,
+        rootScope.inversePatches_
+      );
+    }
+  }
+  return state.copy_;
+}
+function finalizeProperty(rootScope, parentState, targetObject, prop, childValue, rootPath, targetIsSet) {
+  if (process.env.NODE_ENV !== "production" && childValue === targetObject)
+    die(5);
+  if (isDraft(childValue)) {
+    const path = rootPath && parentState && parentState.type_ !== 3 /* Set */ && // Set objects are atomic since they have no keys.
+    !has(parentState.assigned_, prop) ? rootPath.concat(prop) : void 0;
+    const res = finalize(rootScope, childValue, path);
+    set(targetObject, prop, res);
+    if (isDraft(res)) {
+      rootScope.canAutoFreeze_ = false;
+    } else
+      return;
+  } else if (targetIsSet) {
+    targetObject.add(childValue);
+  }
+  if (isDraftable(childValue) && !isFrozen(childValue)) {
+    if (!rootScope.immer_.autoFreeze_ && rootScope.unfinalizedDrafts_ < 1) {
+      return;
+    }
+    finalize(rootScope, childValue);
+    if (!parentState || !parentState.scope_.parent_)
+      maybeFreeze(rootScope, childValue);
+  }
+}
+function maybeFreeze(scope, value, deep = false) {
+  if (!scope.parent_ && scope.immer_.autoFreeze_ && scope.canAutoFreeze_) {
+    freeze(value, deep);
+  }
+}
+
+// src/core/proxy.ts
+function createProxyProxy(base, parent) {
+  const isArray = Array.isArray(base);
+  const state = {
+    type_: isArray ? 1 /* Array */ : 0 /* Object */,
+    // Track which produce call this is associated with.
+    scope_: parent ? parent.scope_ : getCurrentScope(),
+    // True for both shallow and deep changes.
+    modified_: false,
+    // Used during finalization.
+    finalized_: false,
+    // Track which properties have been assigned (true) or deleted (false).
+    assigned_: {},
+    // The parent draft state.
+    parent_: parent,
+    // The base state.
+    base_: base,
+    // The base proxy.
+    draft_: null,
+    // set below
+    // The base copy with any updated values.
+    copy_: null,
+    // Called by the `produce` function.
+    revoke_: null,
+    isManual_: false
+  };
+  let target = state;
+  let traps = objectTraps;
+  if (isArray) {
+    target = [state];
+    traps = arrayTraps;
+  }
+  const { revoke, proxy } = Proxy.revocable(target, traps);
+  state.draft_ = proxy;
+  state.revoke_ = revoke;
+  return proxy;
+}
+var objectTraps = {
+  get(state, prop) {
+    if (prop === DRAFT_STATE)
+      return state;
+    const source = latest(state);
+    if (!has(source, prop)) {
+      return readPropFromProto(state, source, prop);
+    }
+    const value = source[prop];
+    if (state.finalized_ || !isDraftable(value)) {
+      return value;
+    }
+    if (value === peek(state.base_, prop)) {
+      prepareCopy(state);
+      return state.copy_[prop] = createProxy(value, state);
+    }
+    return value;
+  },
+  has(state, prop) {
+    return prop in latest(state);
+  },
+  ownKeys(state) {
+    return Reflect.ownKeys(latest(state));
+  },
+  set(state, prop, value) {
+    const desc = getDescriptorFromProto(latest(state), prop);
+    if (desc?.set) {
+      desc.set.call(state.draft_, value);
+      return true;
+    }
+    if (!state.modified_) {
+      const current2 = peek(latest(state), prop);
+      const currentState = current2?.[DRAFT_STATE];
+      if (currentState && currentState.base_ === value) {
+        state.copy_[prop] = value;
+        state.assigned_[prop] = false;
+        return true;
+      }
+      if (is(value, current2) && (value !== void 0 || has(state.base_, prop)))
+        return true;
+      prepareCopy(state);
+      markChanged(state);
+    }
+    if (state.copy_[prop] === value && // special case: handle new props with value 'undefined'
+    (value !== void 0 || prop in state.copy_) || // special case: NaN
+    Number.isNaN(value) && Number.isNaN(state.copy_[prop]))
+      return true;
+    state.copy_[prop] = value;
+    state.assigned_[prop] = true;
+    return true;
+  },
+  deleteProperty(state, prop) {
+    if (peek(state.base_, prop) !== void 0 || prop in state.base_) {
+      state.assigned_[prop] = false;
+      prepareCopy(state);
+      markChanged(state);
+    } else {
+      delete state.assigned_[prop];
+    }
+    if (state.copy_) {
+      delete state.copy_[prop];
+    }
+    return true;
+  },
+  // Note: We never coerce `desc.value` into an Immer draft, because we can't make
+  // the same guarantee in ES5 mode.
+  getOwnPropertyDescriptor(state, prop) {
+    const owner = latest(state);
+    const desc = Reflect.getOwnPropertyDescriptor(owner, prop);
+    if (!desc)
+      return desc;
+    return {
+      writable: true,
+      configurable: state.type_ !== 1 /* Array */ || prop !== "length",
+      enumerable: desc.enumerable,
+      value: owner[prop]
+    };
+  },
+  defineProperty() {
+    die(11);
+  },
+  getPrototypeOf(state) {
+    return getPrototypeOf(state.base_);
+  },
+  setPrototypeOf() {
+    die(12);
+  }
+};
+var arrayTraps = {};
+each(objectTraps, (key, fn) => {
+  arrayTraps[key] = function() {
+    arguments[0] = arguments[0][0];
+    return fn.apply(this, arguments);
+  };
+});
+arrayTraps.deleteProperty = function(state, prop) {
+  if (process.env.NODE_ENV !== "production" && isNaN(parseInt(prop)))
+    die(13);
+  return arrayTraps.set.call(this, state, prop, void 0);
+};
+arrayTraps.set = function(state, prop, value) {
+  if (process.env.NODE_ENV !== "production" && prop !== "length" && isNaN(parseInt(prop)))
+    die(14);
+  return objectTraps.set.call(this, state[0], prop, value, state[0]);
+};
+function peek(draft, prop) {
+  const state = draft[DRAFT_STATE];
+  const source = state ? latest(state) : draft;
+  return source[prop];
+}
+function readPropFromProto(state, source, prop) {
+  const desc = getDescriptorFromProto(source, prop);
+  return desc ? `value` in desc ? desc.value : (
+    // This is a very special case, if the prop is a getter defined by the
+    // prototype, we should invoke it with the draft as context!
+    desc.get?.call(state.draft_)
+  ) : void 0;
+}
+function getDescriptorFromProto(source, prop) {
+  if (!(prop in source))
+    return void 0;
+  let proto = getPrototypeOf(source);
+  while (proto) {
+    const desc = Object.getOwnPropertyDescriptor(proto, prop);
+    if (desc)
+      return desc;
+    proto = getPrototypeOf(proto);
+  }
+  return void 0;
+}
+function markChanged(state) {
+  if (!state.modified_) {
+    state.modified_ = true;
+    if (state.parent_) {
+      markChanged(state.parent_);
+    }
+  }
+}
+function prepareCopy(state) {
+  if (!state.copy_) {
+    state.copy_ = shallowCopy(
+      state.base_,
+      state.scope_.immer_.useStrictShallowCopy_
+    );
+  }
+}
+
+// src/core/immerClass.ts
+var Immer2 = class {
+  constructor(config) {
+    this.autoFreeze_ = true;
+    this.useStrictShallowCopy_ = false;
+    /**
+     * The `produce` function takes a value and a "recipe function" (whose
+     * return value often depends on the base state). The recipe function is
+     * free to mutate its first argument however it wants. All mutations are
+     * only ever applied to a __copy__ of the base state.
+     *
+     * Pass only a function to create a "curried producer" which relieves you
+     * from passing the recipe function every time.
+     *
+     * Only plain objects and arrays are made mutable. All other objects are
+     * considered uncopyable.
+     *
+     * Note: This function is __bound__ to its `Immer` instance.
+     *
+     * @param {any} base - the initial state
+     * @param {Function} recipe - function that receives a proxy of the base state as first argument and which can be freely modified
+     * @param {Function} patchListener - optional function that will be called with all the patches produced here
+     * @returns {any} a new state, or the initial state if nothing was modified
+     */
+    this.produce = (base, recipe, patchListener) => {
+      if (typeof base === "function" && typeof recipe !== "function") {
+        const defaultBase = recipe;
+        recipe = base;
+        const self = this;
+        return function curriedProduce(base2 = defaultBase, ...args) {
+          return self.produce(base2, (draft) => recipe.call(this, draft, ...args));
+        };
+      }
+      if (typeof recipe !== "function")
+        die(6);
+      if (patchListener !== void 0 && typeof patchListener !== "function")
+        die(7);
+      let result;
+      if (isDraftable(base)) {
+        const scope = enterScope(this);
+        const proxy = createProxy(base, void 0);
+        let hasError = true;
+        try {
+          result = recipe(proxy);
+          hasError = false;
+        } finally {
+          if (hasError)
+            revokeScope(scope);
+          else
+            leaveScope(scope);
+        }
+        usePatchesInScope(scope, patchListener);
+        return processResult(result, scope);
+      } else if (!base || typeof base !== "object") {
+        result = recipe(base);
+        if (result === void 0)
+          result = base;
+        if (result === NOTHING)
+          result = void 0;
+        if (this.autoFreeze_)
+          freeze(result, true);
+        if (patchListener) {
+          const p = [];
+          const ip = [];
+          getPlugin("Patches").generateReplacementPatches_(base, result, p, ip);
+          patchListener(p, ip);
+        }
+        return result;
+      } else
+        die(1, base);
+    };
+    this.produceWithPatches = (base, recipe) => {
+      if (typeof base === "function") {
+        return (state, ...args) => this.produceWithPatches(state, (draft) => base(draft, ...args));
+      }
+      let patches, inversePatches;
+      const result = this.produce(base, recipe, (p, ip) => {
+        patches = p;
+        inversePatches = ip;
+      });
+      return [result, patches, inversePatches];
+    };
+    if (typeof config?.autoFreeze === "boolean")
+      this.setAutoFreeze(config.autoFreeze);
+    if (typeof config?.useStrictShallowCopy === "boolean")
+      this.setUseStrictShallowCopy(config.useStrictShallowCopy);
+  }
+  createDraft(base) {
+    if (!isDraftable(base))
+      die(8);
+    if (isDraft(base))
+      base = current(base);
+    const scope = enterScope(this);
+    const proxy = createProxy(base, void 0);
+    proxy[DRAFT_STATE].isManual_ = true;
+    leaveScope(scope);
+    return proxy;
+  }
+  finishDraft(draft, patchListener) {
+    const state = draft && draft[DRAFT_STATE];
+    if (!state || !state.isManual_)
+      die(9);
+    const { scope_: scope } = state;
+    usePatchesInScope(scope, patchListener);
+    return processResult(void 0, scope);
+  }
+  /**
+   * Pass true to automatically freeze all copies created by Immer.
+   *
+   * By default, auto-freezing is enabled.
+   */
+  setAutoFreeze(value) {
+    this.autoFreeze_ = value;
+  }
+  /**
+   * Pass true to enable strict shallow copy.
+   *
+   * By default, immer does not copy the object descriptors such as getter, setter and non-enumrable properties.
+   */
+  setUseStrictShallowCopy(value) {
+    this.useStrictShallowCopy_ = value;
+  }
+  applyPatches(base, patches) {
+    let i;
+    for (i = patches.length - 1; i >= 0; i--) {
+      const patch = patches[i];
+      if (patch.path.length === 0 && patch.op === "replace") {
+        base = patch.value;
+        break;
+      }
+    }
+    if (i > -1) {
+      patches = patches.slice(i + 1);
+    }
+    const applyPatchesImpl = getPlugin("Patches").applyPatches_;
+    if (isDraft(base)) {
+      return applyPatchesImpl(base, patches);
+    }
+    return this.produce(
+      base,
+      (draft) => applyPatchesImpl(draft, patches)
+    );
+  }
+};
+function createProxy(value, parent) {
+  const draft = isMap(value) ? getPlugin("MapSet").proxyMap_(value, parent) : isSet(value) ? getPlugin("MapSet").proxySet_(value, parent) : createProxyProxy(value, parent);
+  const scope = parent ? parent.scope_ : getCurrentScope();
+  scope.drafts_.push(draft);
+  return draft;
+}
+
+// src/core/current.ts
+function current(value) {
+  if (!isDraft(value))
+    die(10, value);
+  return currentImpl(value);
+}
+function currentImpl(value) {
+  if (!isDraftable(value) || isFrozen(value))
+    return value;
+  const state = value[DRAFT_STATE];
+  let copy;
+  if (state) {
+    if (!state.modified_)
+      return state.base_;
+    state.finalized_ = true;
+    copy = shallowCopy(value, state.scope_.immer_.useStrictShallowCopy_);
+  } else {
+    copy = shallowCopy(value, true);
+  }
+  each(copy, (key, childValue) => {
+    set(copy, key, currentImpl(childValue));
+  });
+  if (state) {
+    state.finalized_ = false;
+  }
+  return copy;
+}
+
+// src/immer.ts
+var immer = new Immer2();
+immer.produce;
+immer.produceWithPatches.bind(
+  immer
+);
+immer.setAutoFreeze.bind(immer);
+immer.setUseStrictShallowCopy.bind(immer);
+immer.applyPatches.bind(immer);
+immer.createDraft.bind(immer);
+immer.finishDraft.bind(immer);
+
 /* eslint-disable @bigbinary/neeto/neetocommons-tips */
 
 /**
@@ -2904,12 +3632,11 @@ var argument = {};
 
 var error = {};
 
-// @ts-check
-
 /**
  * CommanderError class
  * @class
  */
+
 let CommanderError$2 = class CommanderError extends Error {
   /**
    * Constructs the CommanderError class
@@ -2952,8 +3679,6 @@ error.InvalidArgumentError = InvalidArgumentError$3;
 
 const { InvalidArgumentError: InvalidArgumentError$2 } = error;
 
-// @ts-check
-
 let Argument$2 = class Argument {
   /**
    * Initialize a new command argument with the given name and description.
@@ -3018,7 +3743,7 @@ let Argument$2 = class Argument {
   /**
    * Set the default value, and optionally supply the description to be displayed in the help.
    *
-   * @param {any} value
+   * @param {*} value
    * @param {string} [description]
    * @return {Argument}
    */
@@ -3112,8 +3837,6 @@ const { humanReadableArgName: humanReadableArgName$1 } = argument;
  * @typedef { import("./option.js").Option } Option
  */
 
-// @ts-check
-
 // Although this is a class, methods are static in style to allow override using subclass or just functions.
 let Help$2 = class Help {
   constructor() {
@@ -3205,8 +3928,8 @@ let Help$2 = class Help {
     if (!this.showGlobalOptions) return [];
 
     const globalOptions = [];
-    for (let parentCmd = cmd.parent; parentCmd; parentCmd = parentCmd.parent) {
-      const visibleOptions = parentCmd.options.filter((option) => !option.hidden);
+    for (let ancestorCmd = cmd.parent; ancestorCmd; ancestorCmd = ancestorCmd.parent) {
+      const visibleOptions = ancestorCmd.options.filter((option) => !option.hidden);
       globalOptions.push(...visibleOptions);
     }
     if (this.sortOptions) {
@@ -3225,14 +3948,14 @@ let Help$2 = class Help {
   visibleArguments(cmd) {
     // Side effect! Apply the legacy descriptions before the arguments are displayed.
     if (cmd._argsDescription) {
-      cmd._args.forEach(argument => {
+      cmd.registeredArguments.forEach(argument => {
         argument.description = argument.description || cmd._argsDescription[argument.name()] || '';
       });
     }
 
     // If there are any arguments with a description then return all the arguments.
-    if (cmd._args.find(argument => argument.description)) {
-      return cmd._args;
+    if (cmd.registeredArguments.find(argument => argument.description)) {
+      return cmd.registeredArguments;
     }
     return [];
   }
@@ -3246,7 +3969,7 @@ let Help$2 = class Help {
 
   subcommandTerm(cmd) {
     // Legacy. Ignores custom usage string, and nested commands.
-    const args = cmd._args.map(arg => humanReadableArgName$1(arg)).join(' ');
+    const args = cmd.registeredArguments.map(arg => humanReadableArgName$1(arg)).join(' ');
     return cmd._name +
       (cmd._aliases[0] ? '|' + cmd._aliases[0] : '') +
       (cmd.options.length ? ' [options]' : '') + // simplistic check for non-help option
@@ -3344,11 +4067,11 @@ let Help$2 = class Help {
     if (cmd._aliases[0]) {
       cmdName = cmdName + '|' + cmd._aliases[0];
     }
-    let parentCmdNames = '';
-    for (let parentCmd = cmd.parent; parentCmd; parentCmd = parentCmd.parent) {
-      parentCmdNames = parentCmd.name() + ' ' + parentCmdNames;
+    let ancestorCmdNames = '';
+    for (let ancestorCmd = cmd.parent; ancestorCmd; ancestorCmd = ancestorCmd.parent) {
+      ancestorCmdNames = ancestorCmd.name() + ' ' + ancestorCmdNames;
     }
-    return parentCmdNames + cmdName + ' ' + cmd.usage();
+    return ancestorCmdNames + cmdName + ' ' + cmd.usage();
   }
 
   /**
@@ -3571,8 +4294,6 @@ var option = {};
 
 const { InvalidArgumentError: InvalidArgumentError$1 } = error;
 
-// @ts-check
-
 let Option$2 = class Option {
   /**
    * Initialize a new `Option` with the given `flags` and `description`.
@@ -3611,7 +4332,7 @@ let Option$2 = class Option {
   /**
    * Set the default value, and optionally supply the description to be displayed in the help.
    *
-   * @param {any} value
+   * @param {*} value
    * @param {string} [description]
    * @return {Option}
    */
@@ -3630,7 +4351,7 @@ let Option$2 = class Option {
    * new Option('--color').default('GREYSCALE').preset('RGB');
    * new Option('--donate [amount]').preset('20').argParser(parseFloat);
    *
-   * @param {any} arg
+   * @param {*} arg
    * @return {Option}
    */
 
@@ -3846,7 +4567,7 @@ let DualOptions$1 = class DualOptions {
   /**
    * Did the value come from the option, and not from possible matching dual option?
    *
-   * @param {any} value
+   * @param {*} value
    * @param {Option} option
    * @returns {boolean}
    */
@@ -4016,8 +4737,6 @@ const { Help: Help$1 } = help;
 const { Option: Option$1, splitOptionFlags, DualOptions } = option;
 const { suggestSimilar } = suggestSimilar$2;
 
-// @ts-check
-
 let Command$1 = class Command extends EventEmitter {
   /**
    * Initialize a new `Command`.
@@ -4035,7 +4754,8 @@ let Command$1 = class Command extends EventEmitter {
     this._allowUnknownOption = false;
     this._allowExcessArguments = true;
     /** @type {Argument[]} */
-    this._args = [];
+    this.registeredArguments = [];
+    this._args = this.registeredArguments; // deprecated old name
     /** @type {string[]} */
     this.args = []; // cli args with options removed
     this.rawArgs = [];
@@ -4115,6 +4835,19 @@ let Command$1 = class Command extends EventEmitter {
     return this;
   }
 
+  /**
+   * @returns {Command[]}
+   * @api private
+   */
+
+  _getCommandAndAncestors() {
+    const result = [];
+    for (let command = this; command; command = command.parent) {
+      result.push(command);
+    }
+    return result;
+  }
+
   /**
    * Define a command.
    *
@@ -4349,14 +5082,14 @@ let Command$1 = class Command extends EventEmitter {
    * @return {Command} `this` command for chaining
    */
   addArgument(argument) {
-    const previousArgument = this._args.slice(-1)[0];
+    const previousArgument = this.registeredArguments.slice(-1)[0];
     if (previousArgument && previousArgument.variadic) {
       throw new Error(`only the last argument can be variadic '${previousArgument.name()}'`);
     }
     if (argument.required && argument.defaultValue !== undefined && argument.parseArg === undefined) {
       throw new Error(`a default value for a required argument is never used: '${argument.name()}'`);
     }
-    this._args.push(argument);
+    this.registeredArguments.push(argument);
     return this;
   }
 
@@ -4474,7 +5207,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
   action(fn) {
     const listener = (args) => {
       // The .action callback takes an extra parameter which is the command or options.
-      const expectedArgsCount = this._args.length;
+      const expectedArgsCount = this.registeredArguments.length;
       const actionArgs = args.slice(0, expectedArgsCount);
       if (this._storeOptionsAsProperties) {
         actionArgs[expectedArgsCount] = this; // backwards compatible "options"
@@ -4504,6 +5237,28 @@ Expecting one of '${allowedValues.join("', '")}'`);
     return new Option$1(flags, description);
   }
 
+  /**
+   * Wrap parseArgs to catch 'commander.invalidArgument'.
+   *
+   * @param {Option | Argument} target
+   * @param {string} value
+   * @param {*} previous
+   * @param {string} invalidArgumentMessage
+   * @api private
+   */
+
+  _callParseArg(target, value, previous, invalidArgumentMessage) {
+    try {
+      return target.parseArg(value, previous);
+    } catch (err) {
+      if (err.code === 'commander.invalidArgument') {
+        const message = `${invalidArgumentMessage} ${err.message}`;
+        this.error(message, { exitCode: err.exitCode, code: err.code });
+      }
+      throw err;
+    }
+  }
+
   /**
    * Add an option.
    *
@@ -4539,15 +5294,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
       // custom processing
       const oldValue = this.getOptionValue(name);
       if (val !== null && option.parseArg) {
-        try {
-          val = option.parseArg(val, oldValue);
-        } catch (err) {
-          if (err.code === 'commander.invalidArgument') {
-            const message = `${invalidValueMessage} ${err.message}`;
-            this.error(message, { exitCode: err.exitCode, code: err.code });
-          }
-          throw err;
-        }
+        val = this._callParseArg(option, val, oldValue, invalidValueMessage);
       } else if (val !== null && option.variadic) {
         val = option._concatValue(val, oldValue);
       }
@@ -4609,57 +5356,29 @@ Expecting one of '${allowedValues.join("', '")}'`);
   }
 
   /**
-   * Define option with `flags`, `description` and optional
-   * coercion `fn`.
+   * Define option with `flags`, `description`, and optional argument parsing function or `defaultValue` or both.
    *
-   * The `flags` string contains the short and/or long flags,
-   * separated by comma, a pipe or space. The following are all valid
-   * all will output this way when `--help` is used.
+   * The `flags` string contains the short and/or long flags, separated by comma, a pipe or space. A required
+   * option-argument is indicated by `<>` and an optional option-argument by `[]`.
    *
-   *     "-p, --pepper"
-   *     "-p|--pepper"
-   *     "-p --pepper"
+   * See the README for more details, and see also addOption() and requiredOption().
    *
    * @example
-   * // simple boolean defaulting to undefined
-   * program.option('-p, --pepper', 'add pepper');
-   *
-   * program.pepper
-   * // => undefined
-   *
-   * --pepper
-   * program.pepper
-   * // => true
-   *
-   * // simple boolean defaulting to true (unless non-negated option is also defined)
-   * program.option('-C, --no-cheese', 'remove cheese');
-   *
-   * program.cheese
-   * // => true
-   *
-   * --no-cheese
-   * program.cheese
-   * // => false
-   *
-   * // required argument
-   * program.option('-C, --chdir <path>', 'change the working directory');
-   *
-   * --chdir /tmp
-   * program.chdir
-   * // => "/tmp"
-   *
-   * // optional argument
-   * program.option('-c, --cheese [type]', 'add cheese [marble]');
+   * program
+   *     .option('-p, --pepper', 'add pepper')
+   *     .option('-p, --pizza-type <TYPE>', 'type of pizza') // required option-argument
+   *     .option('-c, --cheese [CHEESE]', 'add extra cheese', 'mozzarella') // optional option-argument with default
+   *     .option('-t, --tip <VALUE>', 'add tip to purchase cost', parseFloat) // custom parse function
    *
    * @param {string} flags
    * @param {string} [description]
-   * @param {Function|*} [fn] - custom option processing function or default value
+   * @param {Function|*} [parseArg] - custom option processing function or default value
    * @param {*} [defaultValue]
    * @return {Command} `this` command for chaining
    */
 
-  option(flags, description, fn, defaultValue) {
-    return this._optionEx({}, flags, description, fn, defaultValue);
+  option(flags, description, parseArg, defaultValue) {
+    return this._optionEx({}, flags, description, parseArg, defaultValue);
   }
 
   /**
@@ -4670,13 +5389,13 @@ Expecting one of '${allowedValues.join("', '")}'`);
   *
   * @param {string} flags
   * @param {string} [description]
-  * @param {Function|*} [fn] - custom option processing function or default value
+  * @param {Function|*} [parseArg] - custom option processing function or default value
   * @param {*} [defaultValue]
   * @return {Command} `this` command for chaining
   */
 
-  requiredOption(flags, description, fn, defaultValue) {
-    return this._optionEx({ mandatory: true }, flags, description, fn, defaultValue);
+  requiredOption(flags, description, parseArg, defaultValue) {
+    return this._optionEx({ mandatory: true }, flags, description, parseArg, defaultValue);
   }
 
   /**
@@ -4754,10 +5473,13 @@ Expecting one of '${allowedValues.join("', '")}'`);
     */
 
   storeOptionsAsProperties(storeAsProperties = true) {
-    this._storeOptionsAsProperties = !!storeAsProperties;
     if (this.options.length) {
       throw new Error('call .storeOptionsAsProperties() before adding options');
     }
+    // if (Object.keys(this._optionValues).length) {
+    //   throw new Error('call .storeOptionsAsProperties() before setting option values');
+    // }
+    this._storeOptionsAsProperties = !!storeAsProperties;
     return this;
   }
 
@@ -4829,7 +5551,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
   getOptionValueSourceWithGlobals(key) {
     // global overwrites local, like optsWithGlobals
     let source;
-    getCommandAndParents(this).forEach((cmd) => {
+    this._getCommandAndAncestors().forEach((cmd) => {
       if (cmd.getOptionValueSource(key) !== undefined) {
         source = cmd.getOptionValueSource(key);
       }
@@ -5076,16 +5798,16 @@ Expecting one of '${allowedValues.join("', '")}'`);
     const subCommand = this._findCommand(commandName);
     if (!subCommand) this.help({ error: true });
 
-    let hookResult;
-    hookResult = this._chainOrCallSubCommandHook(hookResult, subCommand, 'preSubcommand');
-    hookResult = this._chainOrCall(hookResult, () => {
+    let promiseChain;
+    promiseChain = this._chainOrCallSubCommandHook(promiseChain, subCommand, 'preSubcommand');
+    promiseChain = this._chainOrCall(promiseChain, () => {
       if (subCommand._executableHandler) {
         this._executeSubCommand(subCommand, operands.concat(unknown));
       } else {
         return subCommand._parseCommand(operands, unknown);
       }
     });
-    return hookResult;
+    return promiseChain;
   }
 
   /**
@@ -5105,33 +5827,35 @@ Expecting one of '${allowedValues.join("', '")}'`);
     }
 
     // Fallback to parsing the help flag to invoke the help.
-    return this._dispatchSubcommand(subcommandName, [], [this._helpLongFlag]);
+    return this._dispatchSubcommand(subcommandName, [], [
+      this._helpLongFlag || this._helpShortFlag
+    ]);
   }
 
   /**
-   * Check this.args against expected this._args.
+   * Check this.args against expected this.registeredArguments.
    *
    * @api private
    */
 
   _checkNumberOfArguments() {
     // too few
-    this._args.forEach((arg, i) => {
+    this.registeredArguments.forEach((arg, i) => {
       if (arg.required && this.args[i] == null) {
         this.missingArgument(arg.name());
       }
     });
     // too many
-    if (this._args.length > 0 && this._args[this._args.length - 1].variadic) {
+    if (this.registeredArguments.length > 0 && this.registeredArguments[this.registeredArguments.length - 1].variadic) {
       return;
     }
-    if (this.args.length > this._args.length) {
+    if (this.args.length > this.registeredArguments.length) {
       this._excessArguments(this.args);
     }
   }
 
   /**
-   * Process this.args using this._args and save as this.processedArgs!
+   * Process this.args using this.registeredArguments and save as this.processedArgs!
    *
    * @api private
    */
@@ -5141,15 +5865,8 @@ Expecting one of '${allowedValues.join("', '")}'`);
       // Extra processing for nice error message on parsing failure.
       let parsedValue = value;
       if (value !== null && argument.parseArg) {
-        try {
-          parsedValue = argument.parseArg(value, previous);
-        } catch (err) {
-          if (err.code === 'commander.invalidArgument') {
-            const message = `error: command-argument value '${value}' is invalid for argument '${argument.name()}'. ${err.message}`;
-            this.error(message, { exitCode: err.exitCode, code: err.code });
-          }
-          throw err;
-        }
+        const invalidValueMessage = `error: command-argument value '${value}' is invalid for argument '${argument.name()}'.`;
+        parsedValue = this._callParseArg(argument, value, previous, invalidValueMessage);
       }
       return parsedValue;
     };
@@ -5157,7 +5874,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
     this._checkNumberOfArguments();
 
     const processedArgs = [];
-    this._args.forEach((declaredArg, index) => {
+    this.registeredArguments.forEach((declaredArg, index) => {
       let value = declaredArg.defaultValue;
       if (declaredArg.variadic) {
         // Collect together remaining arguments for passing together as an array.
@@ -5212,7 +5929,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
   _chainOrCallHooks(promise, event) {
     let result = promise;
     const hooks = [];
-    getCommandAndParents(this)
+    this._getCommandAndAncestors()
       .reverse()
       .filter(cmd => cmd._lifeCycleHooks[event] !== undefined)
       .forEach(hookedCommand => {
@@ -5299,16 +6016,16 @@ Expecting one of '${allowedValues.join("', '")}'`);
       checkForUnknownOptions();
       this._processArguments();
 
-      let actionResult;
-      actionResult = this._chainOrCallHooks(actionResult, 'preAction');
-      actionResult = this._chainOrCall(actionResult, () => this._actionHandler(this.processedArgs));
+      let promiseChain;
+      promiseChain = this._chainOrCallHooks(promiseChain, 'preAction');
+      promiseChain = this._chainOrCall(promiseChain, () => this._actionHandler(this.processedArgs));
       if (this.parent) {
-        actionResult = this._chainOrCall(actionResult, () => {
+        promiseChain = this._chainOrCall(promiseChain, () => {
           this.parent.emit(commandEvent, operands, unknown); // legacy
         });
       }
-      actionResult = this._chainOrCallHooks(actionResult, 'postAction');
-      return actionResult;
+      promiseChain = this._chainOrCallHooks(promiseChain, 'postAction');
+      return promiseChain;
     }
     if (this.parent && this.parent.listenerCount(commandEvent)) {
       checkForUnknownOptions();
@@ -5369,13 +6086,13 @@ Expecting one of '${allowedValues.join("', '")}'`);
 
   _checkForMissingMandatoryOptions() {
     // Walk up hierarchy so can call in subcommand after checking for displaying help.
-    for (let cmd = this; cmd; cmd = cmd.parent) {
+    this._getCommandAndAncestors().forEach((cmd) => {
       cmd.options.forEach((anOption) => {
         if (anOption.mandatory && (cmd.getOptionValue(anOption.attributeName()) === undefined)) {
           cmd.missingMandatoryOptionValue(anOption);
         }
       });
-    }
+    });
   }
 
   /**
@@ -5416,9 +6133,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
    */
   _checkForConflictingOptions() {
     // Walk up hierarchy so can call in subcommand after checking for displaying help.
-    for (let cmd = this; cmd; cmd = cmd.parent) {
+    this._getCommandAndAncestors().forEach((cmd) => {
       cmd._checkForConflictingLocalOptions();
-    }
+    });
   }
 
   /**
@@ -5581,7 +6298,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
    */
   optsWithGlobals() {
     // globals overwrite locals
-    return getCommandAndParents(this).reduce(
+    return this._getCommandAndAncestors().reduce(
       (combinedOptions, cmd) => Object.assign(combinedOptions, cmd.opts()),
       {}
     );
@@ -5772,7 +6489,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
   _excessArguments(receivedArgs) {
     if (this._allowExcessArguments) return;
 
-    const expected = this._args.length;
+    const expected = this.registeredArguments.length;
     const s = (expected === 1) ? '' : 's';
     const forSubcommand = this.parent ? ` for '${this.name()}'` : '';
     const message = `error: too many arguments${forSubcommand}. Expected ${expected} argument${s} but got ${receivedArgs.length}.`;
@@ -5804,17 +6521,16 @@ Expecting one of '${allowedValues.join("', '")}'`);
   }
 
   /**
-   * Set the program version to `str`.
+   * Get or set the program version.
    *
-   * This method auto-registers the "-V, --version" flag
-   * which will print the version number when passed.
+   * This method auto-registers the "-V, --version" option which will print the version number.
    *
-   * You can optionally supply the  flags and description to override the defaults.
+   * You can optionally supply the flags and description to override the defaults.
    *
-   * @param {string} str
+   * @param {string} [str]
    * @param {string} [flags]
    * @param {string} [description]
-   * @return {this | string} `this` command for chaining, or version string if no arguments
+   * @return {this | string | undefined} `this` command for chaining, or version string if no arguments
    */
 
   version(str, flags, description) {
@@ -5823,7 +6539,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
     flags = flags || '-V, --version';
     description = description || 'output the version number';
     const versionOption = this.createOption(flags, description);
-    this._versionOptionName = versionOption.attributeName();
+    this._versionOptionName = versionOption.attributeName(); // [sic] not defined in constructor, partly legacy, partly only needed at root
     this.options.push(versionOption);
     this.on('option:' + versionOption.name(), () => {
       this._outputConfiguration.writeOut(`${str}\n`);
@@ -5913,13 +6629,13 @@ Expecting one of '${allowedValues.join("', '")}'`);
     if (str === undefined) {
       if (this._usage) return this._usage;
 
-      const args = this._args.map((arg) => {
+      const args = this.registeredArguments.map((arg) => {
         return humanReadableArgName(arg);
       });
       return [].concat(
         (this.options.length || this._hasHelpOption ? '[options]' : []),
         (this.commands.length ? '[command]' : []),
-        (this._args.length ? args : [])
+        (this.registeredArguments.length ? args : [])
       ).join(' ');
     }
 
@@ -5968,7 +6684,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
    * program.executableDir('subcommands');
    *
    * @param {string} [path]
-   * @return {string|Command}
+   * @return {string|null|Command}
    */
 
   executableDir(path) {
@@ -6026,7 +6742,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
     }
     const context = this._getHelpContext(contextOptions);
 
-    getCommandAndParents(this).reverse().forEach(command => command.emit('beforeAllHelp', context));
+    this._getCommandAndAncestors().reverse().forEach(command => command.emit('beforeAllHelp', context));
     this.emit('beforeHelp', context);
 
     let helpInformation = this.helpInformation(context);
@@ -6038,9 +6754,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
     }
     context.write(helpInformation);
 
-    this.emit(this._helpLongFlag); // deprecated
+    if (this._helpLongFlag) {
+      this.emit(this._helpLongFlag); // deprecated
+    }
     this.emit('afterHelp', context);
-    getCommandAndParents(this).forEach(command => command.emit('afterAllHelp', context));
+    this._getCommandAndAncestors().forEach(command => command.emit('afterAllHelp', context));
   }
 
   /**
@@ -6183,20 +6901,6 @@ function incrementNodeInspectorPort(args) {
   });
 }
 
-/**
- * @param {Command} startCommand
- * @returns {Command[]}
- * @api private
- */
-
-function getCommandAndParents(startCommand) {
-  const result = [];
-  for (let command = startCommand; command; command = command.parent) {
-    result.push(command);
-  }
-  return result;
-}
-
 command.Command = Command$1;
 
 (function (module, exports) {
@@ -6206,27 +6910,26 @@ command.Command = Command$1;
 	const { Help } = help;
 	const { Option } = option;
 
-	// @ts-check
-
 	/**
 	 * Expose the root command.
 	 */
 
 	exports = module.exports = new Command();
 	exports.program = exports; // More explicit access to global command.
-	// Implicit export of createArgument, createCommand, and createOption.
+	// createArgument, createCommand, and createOption are implicitly available as they are methods on program.
 
 	/**
 	 * Expose classes
 	 */
 
-	exports.Argument = Argument;
 	exports.Command = Command;
-	exports.CommanderError = CommanderError;
+	exports.Option = Option;
+	exports.Argument = Argument;
 	exports.Help = Help;
+
+	exports.CommanderError = CommanderError;
 	exports.InvalidArgumentError = InvalidArgumentError;
-	exports.InvalidOptionArgumentError = InvalidArgumentError; // Deprecated
-	exports.Option = Option; 
+	exports.InvalidOptionArgumentError = InvalidArgumentError; // Deprecated 
 } (commander$1, commander$1.exports));
 
 var commanderExports = commander$1.exports;
@@ -8404,339 +9107,389 @@ function stripAnsi(string) {
 	return string.replace(regex, '');
 }
 
-var wcwidth$2 = {exports: {}};
-
-var clone$1 = {exports: {}};
+var eastasianwidth = {exports: {}};
 
 (function (module) {
-	var clone = (function() {
+	var eaw = {};
 
-	/**
-	 * Clones (copies) an Object using deep copying.
-	 *
-	 * This function supports circular references by default, but if you are certain
-	 * there are no circular references in your object, you can save some CPU time
-	 * by calling clone(obj, false).
-	 *
-	 * Caution: if `circular` is false and `parent` contains circular references,
-	 * your program may enter an infinite loop and crash.
-	 *
-	 * @param `parent` - the object to be cloned
-	 * @param `circular` - set to true if the object to be cloned may contain
-	 *    circular references. (optional - true by default)
-	 * @param `depth` - set to a number if the object is only to be cloned to
-	 *    a particular depth. (optional - defaults to Infinity)
-	 * @param `prototype` - sets the prototype to be used when cloning an object.
-	 *    (optional - defaults to parent prototype).
-	*/
-	function clone(parent, circular, depth, prototype) {
-	  if (typeof circular === 'object') {
-	    depth = circular.depth;
-	    prototype = circular.prototype;
-	    circular.filter;
-	    circular = circular.circular;
-	  }
-	  // maintain two arrays for circular references, where corresponding parents
-	  // and children have the same index
-	  var allParents = [];
-	  var allChildren = [];
+	{
+	  module.exports = eaw;
+	}
 
-	  var useBuffer = typeof Buffer != 'undefined';
+	eaw.eastAsianWidth = function(character) {
+	  var x = character.charCodeAt(0);
+	  var y = (character.length == 2) ? character.charCodeAt(1) : 0;
+	  var codePoint = x;
+	  if ((0xD800 <= x && x <= 0xDBFF) && (0xDC00 <= y && y <= 0xDFFF)) {
+	    x &= 0x3FF;
+	    y &= 0x3FF;
+	    codePoint = (x << 10) | y;
+	    codePoint += 0x10000;
+	  }
 
-	  if (typeof circular == 'undefined')
-	    circular = true;
+	  if ((0x3000 == codePoint) ||
+	      (0xFF01 <= codePoint && codePoint <= 0xFF60) ||
+	      (0xFFE0 <= codePoint && codePoint <= 0xFFE6)) {
+	    return 'F';
+	  }
+	  if ((0x20A9 == codePoint) ||
+	      (0xFF61 <= codePoint && codePoint <= 0xFFBE) ||
+	      (0xFFC2 <= codePoint && codePoint <= 0xFFC7) ||
+	      (0xFFCA <= codePoint && codePoint <= 0xFFCF) ||
+	      (0xFFD2 <= codePoint && codePoint <= 0xFFD7) ||
+	      (0xFFDA <= codePoint && codePoint <= 0xFFDC) ||
+	      (0xFFE8 <= codePoint && codePoint <= 0xFFEE)) {
+	    return 'H';
+	  }
+	  if ((0x1100 <= codePoint && codePoint <= 0x115F) ||
+	      (0x11A3 <= codePoint && codePoint <= 0x11A7) ||
+	      (0x11FA <= codePoint && codePoint <= 0x11FF) ||
+	      (0x2329 <= codePoint && codePoint <= 0x232A) ||
+	      (0x2E80 <= codePoint && codePoint <= 0x2E99) ||
+	      (0x2E9B <= codePoint && codePoint <= 0x2EF3) ||
+	      (0x2F00 <= codePoint && codePoint <= 0x2FD5) ||
+	      (0x2FF0 <= codePoint && codePoint <= 0x2FFB) ||
+	      (0x3001 <= codePoint && codePoint <= 0x303E) ||
+	      (0x3041 <= codePoint && codePoint <= 0x3096) ||
+	      (0x3099 <= codePoint && codePoint <= 0x30FF) ||
+	      (0x3105 <= codePoint && codePoint <= 0x312D) ||
+	      (0x3131 <= codePoint && codePoint <= 0x318E) ||
+	      (0x3190 <= codePoint && codePoint <= 0x31BA) ||
+	      (0x31C0 <= codePoint && codePoint <= 0x31E3) ||
+	      (0x31F0 <= codePoint && codePoint <= 0x321E) ||
+	      (0x3220 <= codePoint && codePoint <= 0x3247) ||
+	      (0x3250 <= codePoint && codePoint <= 0x32FE) ||
+	      (0x3300 <= codePoint && codePoint <= 0x4DBF) ||
+	      (0x4E00 <= codePoint && codePoint <= 0xA48C) ||
+	      (0xA490 <= codePoint && codePoint <= 0xA4C6) ||
+	      (0xA960 <= codePoint && codePoint <= 0xA97C) ||
+	      (0xAC00 <= codePoint && codePoint <= 0xD7A3) ||
+	      (0xD7B0 <= codePoint && codePoint <= 0xD7C6) ||
+	      (0xD7CB <= codePoint && codePoint <= 0xD7FB) ||
+	      (0xF900 <= codePoint && codePoint <= 0xFAFF) ||
+	      (0xFE10 <= codePoint && codePoint <= 0xFE19) ||
+	      (0xFE30 <= codePoint && codePoint <= 0xFE52) ||
+	      (0xFE54 <= codePoint && codePoint <= 0xFE66) ||
+	      (0xFE68 <= codePoint && codePoint <= 0xFE6B) ||
+	      (0x1B000 <= codePoint && codePoint <= 0x1B001) ||
+	      (0x1F200 <= codePoint && codePoint <= 0x1F202) ||
+	      (0x1F210 <= codePoint && codePoint <= 0x1F23A) ||
+	      (0x1F240 <= codePoint && codePoint <= 0x1F248) ||
+	      (0x1F250 <= codePoint && codePoint <= 0x1F251) ||
+	      (0x20000 <= codePoint && codePoint <= 0x2F73F) ||
+	      (0x2B740 <= codePoint && codePoint <= 0x2FFFD) ||
+	      (0x30000 <= codePoint && codePoint <= 0x3FFFD)) {
+	    return 'W';
+	  }
+	  if ((0x0020 <= codePoint && codePoint <= 0x007E) ||
+	      (0x00A2 <= codePoint && codePoint <= 0x00A3) ||
+	      (0x00A5 <= codePoint && codePoint <= 0x00A6) ||
+	      (0x00AC == codePoint) ||
+	      (0x00AF == codePoint) ||
+	      (0x27E6 <= codePoint && codePoint <= 0x27ED) ||
+	      (0x2985 <= codePoint && codePoint <= 0x2986)) {
+	    return 'Na';
+	  }
+	  if ((0x00A1 == codePoint) ||
+	      (0x00A4 == codePoint) ||
+	      (0x00A7 <= codePoint && codePoint <= 0x00A8) ||
+	      (0x00AA == codePoint) ||
+	      (0x00AD <= codePoint && codePoint <= 0x00AE) ||
+	      (0x00B0 <= codePoint && codePoint <= 0x00B4) ||
+	      (0x00B6 <= codePoint && codePoint <= 0x00BA) ||
+	      (0x00BC <= codePoint && codePoint <= 0x00BF) ||
+	      (0x00C6 == codePoint) ||
+	      (0x00D0 == codePoint) ||
+	      (0x00D7 <= codePoint && codePoint <= 0x00D8) ||
+	      (0x00DE <= codePoint && codePoint <= 0x00E1) ||
+	      (0x00E6 == codePoint) ||
+	      (0x00E8 <= codePoint && codePoint <= 0x00EA) ||
+	      (0x00EC <= codePoint && codePoint <= 0x00ED) ||
+	      (0x00F0 == codePoint) ||
+	      (0x00F2 <= codePoint && codePoint <= 0x00F3) ||
+	      (0x00F7 <= codePoint && codePoint <= 0x00FA) ||
+	      (0x00FC == codePoint) ||
+	      (0x00FE == codePoint) ||
+	      (0x0101 == codePoint) ||
+	      (0x0111 == codePoint) ||
+	      (0x0113 == codePoint) ||
+	      (0x011B == codePoint) ||
+	      (0x0126 <= codePoint && codePoint <= 0x0127) ||
+	      (0x012B == codePoint) ||
+	      (0x0131 <= codePoint && codePoint <= 0x0133) ||
+	      (0x0138 == codePoint) ||
+	      (0x013F <= codePoint && codePoint <= 0x0142) ||
+	      (0x0144 == codePoint) ||
+	      (0x0148 <= codePoint && codePoint <= 0x014B) ||
+	      (0x014D == codePoint) ||
+	      (0x0152 <= codePoint && codePoint <= 0x0153) ||
+	      (0x0166 <= codePoint && codePoint <= 0x0167) ||
+	      (0x016B == codePoint) ||
+	      (0x01CE == codePoint) ||
+	      (0x01D0 == codePoint) ||
+	      (0x01D2 == codePoint) ||
+	      (0x01D4 == codePoint) ||
+	      (0x01D6 == codePoint) ||
+	      (0x01D8 == codePoint) ||
+	      (0x01DA == codePoint) ||
+	      (0x01DC == codePoint) ||
+	      (0x0251 == codePoint) ||
+	      (0x0261 == codePoint) ||
+	      (0x02C4 == codePoint) ||
+	      (0x02C7 == codePoint) ||
+	      (0x02C9 <= codePoint && codePoint <= 0x02CB) ||
+	      (0x02CD == codePoint) ||
+	      (0x02D0 == codePoint) ||
+	      (0x02D8 <= codePoint && codePoint <= 0x02DB) ||
+	      (0x02DD == codePoint) ||
+	      (0x02DF == codePoint) ||
+	      (0x0300 <= codePoint && codePoint <= 0x036F) ||
+	      (0x0391 <= codePoint && codePoint <= 0x03A1) ||
+	      (0x03A3 <= codePoint && codePoint <= 0x03A9) ||
+	      (0x03B1 <= codePoint && codePoint <= 0x03C1) ||
+	      (0x03C3 <= codePoint && codePoint <= 0x03C9) ||
+	      (0x0401 == codePoint) ||
+	      (0x0410 <= codePoint && codePoint <= 0x044F) ||
+	      (0x0451 == codePoint) ||
+	      (0x2010 == codePoint) ||
+	      (0x2013 <= codePoint && codePoint <= 0x2016) ||
+	      (0x2018 <= codePoint && codePoint <= 0x2019) ||
+	      (0x201C <= codePoint && codePoint <= 0x201D) ||
+	      (0x2020 <= codePoint && codePoint <= 0x2022) ||
+	      (0x2024 <= codePoint && codePoint <= 0x2027) ||
+	      (0x2030 == codePoint) ||
+	      (0x2032 <= codePoint && codePoint <= 0x2033) ||
+	      (0x2035 == codePoint) ||
+	      (0x203B == codePoint) ||
+	      (0x203E == codePoint) ||
+	      (0x2074 == codePoint) ||
+	      (0x207F == codePoint) ||
+	      (0x2081 <= codePoint && codePoint <= 0x2084) ||
+	      (0x20AC == codePoint) ||
+	      (0x2103 == codePoint) ||
+	      (0x2105 == codePoint) ||
+	      (0x2109 == codePoint) ||
+	      (0x2113 == codePoint) ||
+	      (0x2116 == codePoint) ||
+	      (0x2121 <= codePoint && codePoint <= 0x2122) ||
+	      (0x2126 == codePoint) ||
+	      (0x212B == codePoint) ||
+	      (0x2153 <= codePoint && codePoint <= 0x2154) ||
+	      (0x215B <= codePoint && codePoint <= 0x215E) ||
+	      (0x2160 <= codePoint && codePoint <= 0x216B) ||
+	      (0x2170 <= codePoint && codePoint <= 0x2179) ||
+	      (0x2189 == codePoint) ||
+	      (0x2190 <= codePoint && codePoint <= 0x2199) ||
+	      (0x21B8 <= codePoint && codePoint <= 0x21B9) ||
+	      (0x21D2 == codePoint) ||
+	      (0x21D4 == codePoint) ||
+	      (0x21E7 == codePoint) ||
+	      (0x2200 == codePoint) ||
+	      (0x2202 <= codePoint && codePoint <= 0x2203) ||
+	      (0x2207 <= codePoint && codePoint <= 0x2208) ||
+	      (0x220B == codePoint) ||
+	      (0x220F == codePoint) ||
+	      (0x2211 == codePoint) ||
+	      (0x2215 == codePoint) ||
+	      (0x221A == codePoint) ||
+	      (0x221D <= codePoint && codePoint <= 0x2220) ||
+	      (0x2223 == codePoint) ||
+	      (0x2225 == codePoint) ||
+	      (0x2227 <= codePoint && codePoint <= 0x222C) ||
+	      (0x222E == codePoint) ||
+	      (0x2234 <= codePoint && codePoint <= 0x2237) ||
+	      (0x223C <= codePoint && codePoint <= 0x223D) ||
+	      (0x2248 == codePoint) ||
+	      (0x224C == codePoint) ||
+	      (0x2252 == codePoint) ||
+	      (0x2260 <= codePoint && codePoint <= 0x2261) ||
+	      (0x2264 <= codePoint && codePoint <= 0x2267) ||
+	      (0x226A <= codePoint && codePoint <= 0x226B) ||
+	      (0x226E <= codePoint && codePoint <= 0x226F) ||
+	      (0x2282 <= codePoint && codePoint <= 0x2283) ||
+	      (0x2286 <= codePoint && codePoint <= 0x2287) ||
+	      (0x2295 == codePoint) ||
+	      (0x2299 == codePoint) ||
+	      (0x22A5 == codePoint) ||
+	      (0x22BF == codePoint) ||
+	      (0x2312 == codePoint) ||
+	      (0x2460 <= codePoint && codePoint <= 0x24E9) ||
+	      (0x24EB <= codePoint && codePoint <= 0x254B) ||
+	      (0x2550 <= codePoint && codePoint <= 0x2573) ||
+	      (0x2580 <= codePoint && codePoint <= 0x258F) ||
+	      (0x2592 <= codePoint && codePoint <= 0x2595) ||
+	      (0x25A0 <= codePoint && codePoint <= 0x25A1) ||
+	      (0x25A3 <= codePoint && codePoint <= 0x25A9) ||
+	      (0x25B2 <= codePoint && codePoint <= 0x25B3) ||
+	      (0x25B6 <= codePoint && codePoint <= 0x25B7) ||
+	      (0x25BC <= codePoint && codePoint <= 0x25BD) ||
+	      (0x25C0 <= codePoint && codePoint <= 0x25C1) ||
+	      (0x25C6 <= codePoint && codePoint <= 0x25C8) ||
+	      (0x25CB == codePoint) ||
+	      (0x25CE <= codePoint && codePoint <= 0x25D1) ||
+	      (0x25E2 <= codePoint && codePoint <= 0x25E5) ||
+	      (0x25EF == codePoint) ||
+	      (0x2605 <= codePoint && codePoint <= 0x2606) ||
+	      (0x2609 == codePoint) ||
+	      (0x260E <= codePoint && codePoint <= 0x260F) ||
+	      (0x2614 <= codePoint && codePoint <= 0x2615) ||
+	      (0x261C == codePoint) ||
+	      (0x261E == codePoint) ||
+	      (0x2640 == codePoint) ||
+	      (0x2642 == codePoint) ||
+	      (0x2660 <= codePoint && codePoint <= 0x2661) ||
+	      (0x2663 <= codePoint && codePoint <= 0x2665) ||
+	      (0x2667 <= codePoint && codePoint <= 0x266A) ||
+	      (0x266C <= codePoint && codePoint <= 0x266D) ||
+	      (0x266F == codePoint) ||
+	      (0x269E <= codePoint && codePoint <= 0x269F) ||
+	      (0x26BE <= codePoint && codePoint <= 0x26BF) ||
+	      (0x26C4 <= codePoint && codePoint <= 0x26CD) ||
+	      (0x26CF <= codePoint && codePoint <= 0x26E1) ||
+	      (0x26E3 == codePoint) ||
+	      (0x26E8 <= codePoint && codePoint <= 0x26FF) ||
+	      (0x273D == codePoint) ||
+	      (0x2757 == codePoint) ||
+	      (0x2776 <= codePoint && codePoint <= 0x277F) ||
+	      (0x2B55 <= codePoint && codePoint <= 0x2B59) ||
+	      (0x3248 <= codePoint && codePoint <= 0x324F) ||
+	      (0xE000 <= codePoint && codePoint <= 0xF8FF) ||
+	      (0xFE00 <= codePoint && codePoint <= 0xFE0F) ||
+	      (0xFFFD == codePoint) ||
+	      (0x1F100 <= codePoint && codePoint <= 0x1F10A) ||
+	      (0x1F110 <= codePoint && codePoint <= 0x1F12D) ||
+	      (0x1F130 <= codePoint && codePoint <= 0x1F169) ||
+	      (0x1F170 <= codePoint && codePoint <= 0x1F19A) ||
+	      (0xE0100 <= codePoint && codePoint <= 0xE01EF) ||
+	      (0xF0000 <= codePoint && codePoint <= 0xFFFFD) ||
+	      (0x100000 <= codePoint && codePoint <= 0x10FFFD)) {
+	    return 'A';
+	  }
 
-	  if (typeof depth == 'undefined')
-	    depth = Infinity;
+	  return 'N';
+	};
 
-	  // recurse this function so we don't reset allParents and allChildren
-	  function _clone(parent, depth) {
-	    // cloning null always returns null
-	    if (parent === null)
-	      return null;
+	eaw.characterLength = function(character) {
+	  var code = this.eastAsianWidth(character);
+	  if (code == 'F' || code == 'W' || code == 'A') {
+	    return 2;
+	  } else {
+	    return 1;
+	  }
+	};
 
-	    if (depth == 0)
-	      return parent;
+	// Split a string considering surrogate-pairs.
+	function stringToArray(string) {
+	  return string.match(/[\uD800-\uDBFF][\uDC00-\uDFFF]|[^\uD800-\uDFFF]/g) || [];
+	}
 
-	    var child;
-	    var proto;
-	    if (typeof parent != 'object') {
-	      return parent;
-	    }
-
-	    if (clone.__isArray(parent)) {
-	      child = [];
-	    } else if (clone.__isRegExp(parent)) {
-	      child = new RegExp(parent.source, __getRegExpFlags(parent));
-	      if (parent.lastIndex) child.lastIndex = parent.lastIndex;
-	    } else if (clone.__isDate(parent)) {
-	      child = new Date(parent.getTime());
-	    } else if (useBuffer && Buffer.isBuffer(parent)) {
-	      if (Buffer.allocUnsafe) {
-	        // Node.js >= 4.5.0
-	        child = Buffer.allocUnsafe(parent.length);
-	      } else {
-	        // Older Node.js versions
-	        child = new Buffer(parent.length);
-	      }
-	      parent.copy(child);
-	      return child;
-	    } else {
-	      if (typeof prototype == 'undefined') {
-	        proto = Object.getPrototypeOf(parent);
-	        child = Object.create(proto);
-	      }
-	      else {
-	        child = Object.create(prototype);
-	        proto = prototype;
-	      }
-	    }
-
-	    if (circular) {
-	      var index = allParents.indexOf(parent);
+	eaw.length = function(string) {
+	  var characters = stringToArray(string);
+	  var len = 0;
+	  for (var i = 0; i < characters.length; i++) {
+	    len = len + this.characterLength(characters[i]);
+	  }
+	  return len;
+	};
 
-	      if (index != -1) {
-	        return allChildren[index];
-	      }
-	      allParents.push(parent);
-	      allChildren.push(child);
+	eaw.slice = function(text, start, end) {
+	  textLen = eaw.length(text);
+	  start = start ? start : 0;
+	  end = end ? end : 1;
+	  if (start < 0) {
+	      start = textLen + start;
+	  }
+	  if (end < 0) {
+	      end = textLen + end;
+	  }
+	  var result = '';
+	  var eawLen = 0;
+	  var chars = stringToArray(text);
+	  for (var i = 0; i < chars.length; i++) {
+	    var char = chars[i];
+	    var charLen = eaw.length(char);
+	    if (eawLen >= start - (charLen == 2 ? 1 : 0)) {
+	        if (eawLen + charLen <= end) {
+	            result += char;
+	        } else {
+	            break;
+	        }
 	    }
+	    eawLen += charLen;
+	  }
+	  return result;
+	}; 
+} (eastasianwidth));
 
-	    for (var i in parent) {
-	      var attrs;
-	      if (proto) {
-	        attrs = Object.getOwnPropertyDescriptor(proto, i);
-	      }
-
-	      if (attrs && attrs.set == null) {
-	        continue;
-	      }
-	      child[i] = _clone(parent[i], depth - 1);
-	    }
+var eastasianwidthExports = eastasianwidth.exports;
+var eastAsianWidth = /*@__PURE__*/getDefaultExportFromCjs(eastasianwidthExports);
 
-	    return child;
-	  }
+var emojiRegex = () => {
+	// https://mths.be/emoji
+	return /[#*0-9]\uFE0F?\u20E3|[\xA9\xAE\u203C\u2049\u2122\u2139\u2194-\u2199\u21A9\u21AA\u231A\u231B\u2328\u23CF\u23ED-\u23EF\u23F1\u23F2\u23F8-\u23FA\u24C2\u25AA\u25AB\u25B6\u25C0\u25FB\u25FC\u25FE\u2600-\u2604\u260E\u2611\u2614\u2615\u2618\u2620\u2622\u2623\u2626\u262A\u262E\u262F\u2638-\u263A\u2640\u2642\u2648-\u2653\u265F\u2660\u2663\u2665\u2666\u2668\u267B\u267E\u267F\u2692\u2694-\u2697\u2699\u269B\u269C\u26A0\u26A7\u26AA\u26B0\u26B1\u26BD\u26BE\u26C4\u26C8\u26CF\u26D1\u26E9\u26F0-\u26F5\u26F7\u26F8\u26FA\u2702\u2708\u2709\u270F\u2712\u2714\u2716\u271D\u2721\u2733\u2734\u2744\u2747\u2757\u2763\u27A1\u2934\u2935\u2B05-\u2B07\u2B1B\u2B1C\u2B55\u3030\u303D\u3297\u3299]\uFE0F?|[\u261D\u270C\u270D](?:\uFE0F|\uD83C[\uDFFB-\uDFFF])?|[\u270A\u270B](?:\uD83C[\uDFFB-\uDFFF])?|[\u23E9-\u23EC\u23F0\u23F3\u25FD\u2693\u26A1\u26AB\u26C5\u26CE\u26D4\u26EA\u26FD\u2705\u2728\u274C\u274E\u2753-\u2755\u2795-\u2797\u27B0\u27BF\u2B50]|\u26D3\uFE0F?(?:\u200D\uD83D\uDCA5)?|\u26F9(?:\uFE0F|\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|\u2764\uFE0F?(?:\u200D(?:\uD83D\uDD25|\uD83E\uDE79))?|\uD83C(?:[\uDC04\uDD70\uDD71\uDD7E\uDD7F\uDE02\uDE37\uDF21\uDF24-\uDF2C\uDF36\uDF7D\uDF96\uDF97\uDF99-\uDF9B\uDF9E\uDF9F\uDFCD\uDFCE\uDFD4-\uDFDF\uDFF5\uDFF7]\uFE0F?|[\uDF85\uDFC2\uDFC7](?:\uD83C[\uDFFB-\uDFFF])?|[\uDFC4\uDFCA](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDFCB\uDFCC](?:\uFE0F|\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDCCF\uDD8E\uDD91-\uDD9A\uDE01\uDE1A\uDE2F\uDE32-\uDE36\uDE38-\uDE3A\uDE50\uDE51\uDF00-\uDF20\uDF2D-\uDF35\uDF37-\uDF43\uDF45-\uDF4A\uDF4C-\uDF7C\uDF7E-\uDF84\uDF86-\uDF93\uDFA0-\uDFC1\uDFC5\uDFC6\uDFC8\uDFC9\uDFCF-\uDFD3\uDFE0-\uDFF0\uDFF8-\uDFFF]|\uDDE6\uD83C[\uDDE8-\uDDEC\uDDEE\uDDF1\uDDF2\uDDF4\uDDF6-\uDDFA\uDDFC\uDDFD\uDDFF]|\uDDE7\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEF\uDDF1-\uDDF4\uDDF6-\uDDF9\uDDFB\uDDFC\uDDFE\uDDFF]|\uDDE8\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDEE\uDDF0-\uDDF5\uDDF7\uDDFA-\uDDFF]|\uDDE9\uD83C[\uDDEA\uDDEC\uDDEF\uDDF0\uDDF2\uDDF4\uDDFF]|\uDDEA\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDED\uDDF7-\uDDFA]|\uDDEB\uD83C[\uDDEE-\uDDF0\uDDF2\uDDF4\uDDF7]|\uDDEC\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEE\uDDF1-\uDDF3\uDDF5-\uDDFA\uDDFC\uDDFE]|\uDDED\uD83C[\uDDF0\uDDF2\uDDF3\uDDF7\uDDF9\uDDFA]|\uDDEE\uD83C[\uDDE8-\uDDEA\uDDF1-\uDDF4\uDDF6-\uDDF9]|\uDDEF\uD83C[\uDDEA\uDDF2\uDDF4\uDDF5]|\uDDF0\uD83C[\uDDEA\uDDEC-\uDDEE\uDDF2\uDDF3\uDDF5\uDDF7\uDDFC\uDDFE\uDDFF]|\uDDF1\uD83C[\uDDE6-\uDDE8\uDDEE\uDDF0\uDDF7-\uDDFB\uDDFE]|\uDDF2\uD83C[\uDDE6\uDDE8-\uDDED\uDDF0-\uDDFF]|\uDDF3\uD83C[\uDDE6\uDDE8\uDDEA-\uDDEC\uDDEE\uDDF1\uDDF4\uDDF5\uDDF7\uDDFA\uDDFF]|\uDDF4\uD83C\uDDF2|\uDDF5\uD83C[\uDDE6\uDDEA-\uDDED\uDDF0-\uDDF3\uDDF7-\uDDF9\uDDFC\uDDFE]|\uDDF6\uD83C\uDDE6|\uDDF7\uD83C[\uDDEA\uDDF4\uDDF8\uDDFA\uDDFC]|\uDDF8\uD83C[\uDDE6-\uDDEA\uDDEC-\uDDF4\uDDF7-\uDDF9\uDDFB\uDDFD-\uDDFF]|\uDDF9\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDED\uDDEF-\uDDF4\uDDF7\uDDF9\uDDFB\uDDFC\uDDFF]|\uDDFA\uD83C[\uDDE6\uDDEC\uDDF2\uDDF3\uDDF8\uDDFE\uDDFF]|\uDDFB\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDEE\uDDF3\uDDFA]|\uDDFC\uD83C[\uDDEB\uDDF8]|\uDDFD\uD83C\uDDF0|\uDDFE\uD83C[\uDDEA\uDDF9]|\uDDFF\uD83C[\uDDE6\uDDF2\uDDFC]|\uDF44(?:\u200D\uD83D\uDFEB)?|\uDF4B(?:\u200D\uD83D\uDFE9)?|\uDFC3(?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D(?:[\u2640\u2642]\uFE0F?(?:\u200D\u27A1\uFE0F?)?|\u27A1\uFE0F?))?|\uDFF3\uFE0F?(?:\u200D(?:\u26A7\uFE0F?|\uD83C\uDF08))?|\uDFF4(?:\u200D\u2620\uFE0F?|\uDB40\uDC67\uDB40\uDC62\uDB40(?:\uDC65\uDB40\uDC6E\uDB40\uDC67|\uDC73\uDB40\uDC63\uDB40\uDC74|\uDC77\uDB40\uDC6C\uDB40\uDC73)\uDB40\uDC7F)?)|\uD83D(?:[\uDC3F\uDCFD\uDD49\uDD4A\uDD6F\uDD70\uDD73\uDD76-\uDD79\uDD87\uDD8A-\uDD8D\uDDA5\uDDA8\uDDB1\uDDB2\uDDBC\uDDC2-\uDDC4\uDDD1-\uDDD3\uDDDC-\uDDDE\uDDE1\uDDE3\uDDE8\uDDEF\uDDF3\uDDFA\uDECB\uDECD-\uDECF\uDEE0-\uDEE5\uDEE9\uDEF0\uDEF3]\uFE0F?|[\uDC42\uDC43\uDC46-\uDC50\uDC66\uDC67\uDC6B-\uDC6D\uDC72\uDC74-\uDC76\uDC78\uDC7C\uDC83\uDC85\uDC8F\uDC91\uDCAA\uDD7A\uDD95\uDD96\uDE4C\uDE4F\uDEC0\uDECC](?:\uD83C[\uDFFB-\uDFFF])?|[\uDC6E\uDC70\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4\uDEB5](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDD74\uDD90](?:\uFE0F|\uD83C[\uDFFB-\uDFFF])?|[\uDC00-\uDC07\uDC09-\uDC14\uDC16-\uDC25\uDC27-\uDC3A\uDC3C-\uDC3E\uDC40\uDC44\uDC45\uDC51-\uDC65\uDC6A\uDC79-\uDC7B\uDC7D-\uDC80\uDC84\uDC88-\uDC8E\uDC90\uDC92-\uDCA9\uDCAB-\uDCFC\uDCFF-\uDD3D\uDD4B-\uDD4E\uDD50-\uDD67\uDDA4\uDDFB-\uDE2D\uDE2F-\uDE34\uDE37-\uDE41\uDE43\uDE44\uDE48-\uDE4A\uDE80-\uDEA2\uDEA4-\uDEB3\uDEB7-\uDEBF\uDEC1-\uDEC5\uDED0-\uDED2\uDED5-\uDED7\uDEDC-\uDEDF\uDEEB\uDEEC\uDEF4-\uDEFC\uDFE0-\uDFEB\uDFF0]|\uDC08(?:\u200D\u2B1B)?|\uDC15(?:\u200D\uD83E\uDDBA)?|\uDC26(?:\u200D(?:\u2B1B|\uD83D\uDD25))?|\uDC3B(?:\u200D\u2744\uFE0F?)?|\uDC41\uFE0F?(?:\u200D\uD83D\uDDE8\uFE0F?)?|\uDC68(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDC68\uDC69]\u200D\uD83D(?:\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?)|[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?)|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]))|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFC-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB\uDFFD-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB-\uDFFD\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB-\uDFFE])))?))?|\uDC69(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?[\uDC68\uDC69]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?|\uDC69\u200D\uD83D(?:\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?))|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]))|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFC-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB\uDFFD-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB-\uDFFD\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB-\uDFFE])))?))?|\uDC6F(?:\u200D[\u2640\u2642]\uFE0F?)?|\uDD75(?:\uFE0F|\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|\uDE2E(?:\u200D\uD83D\uDCA8)?|\uDE35(?:\u200D\uD83D\uDCAB)?|\uDE36(?:\u200D\uD83C\uDF2B\uFE0F?)?|\uDE42(?:\u200D[\u2194\u2195]\uFE0F?)?|\uDEB6(?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D(?:[\u2640\u2642]\uFE0F?(?:\u200D\u27A1\uFE0F?)?|\u27A1\uFE0F?))?)|\uD83E(?:[\uDD0C\uDD0F\uDD18-\uDD1F\uDD30-\uDD34\uDD36\uDD77\uDDB5\uDDB6\uDDBB\uDDD2\uDDD3\uDDD5\uDEC3-\uDEC5\uDEF0\uDEF2-\uDEF8](?:\uD83C[\uDFFB-\uDFFF])?|[\uDD26\uDD35\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD\uDDCF\uDDD4\uDDD6-\uDDDD](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDDDE\uDDDF](?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDD0D\uDD0E\uDD10-\uDD17\uDD20-\uDD25\uDD27-\uDD2F\uDD3A\uDD3F-\uDD45\uDD47-\uDD76\uDD78-\uDDB4\uDDB7\uDDBA\uDDBC-\uDDCC\uDDD0\uDDE0-\uDDFF\uDE70-\uDE7C\uDE80-\uDE88\uDE90-\uDEBD\uDEBF-\uDEC2\uDECE-\uDEDB\uDEE0-\uDEE8]|\uDD3C(?:\u200D[\u2640\u2642]\uFE0F?|\uD83C[\uDFFB-\uDFFF])?|\uDDCE(?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D(?:[\u2640\u2642]\uFE0F?(?:\u200D\u27A1\uFE0F?)?|\u27A1\uFE0F?))?|\uDDD1(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1|\uDDD1\u200D\uD83E\uDDD2(?:\u200D\uD83E\uDDD2)?|\uDDD2(?:\u200D\uD83E\uDDD2)?))|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFC-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB\uDFFD-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB-\uDFFD\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB-\uDFFE]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?))?|\uDEF1(?:\uD83C(?:\uDFFB(?:\u200D\uD83E\uDEF2\uD83C[\uDFFC-\uDFFF])?|\uDFFC(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB\uDFFD-\uDFFF])?|\uDFFD(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])?|\uDFFE(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB-\uDFFD\uDFFF])?|\uDFFF(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB-\uDFFE])?))?)/g;
+};
 
-	  return _clone(parent, depth);
+function stringWidth(string, options) {
+	if (typeof string !== 'string' || string.length === 0) {
+		return 0;
 	}
 
-	/**
-	 * Simple flat clone using prototype, accepts only objects, usefull for property
-	 * override on FLAT configuration object (no nested props).
-	 *
-	 * USE WITH CAUTION! This may not behave as you wish if you do not know how this
-	 * works.
-	 */
-	clone.clonePrototype = function clonePrototype(parent) {
-	  if (parent === null)
-	    return null;
-
-	  var c = function () {};
-	  c.prototype = parent;
-	  return new c();
+	options = {
+		ambiguousIsNarrow: true,
+		countAnsiEscapeCodes: false,
+		...options,
 	};
 
-	// private utility functions
-
-	function __objToStr(o) {
-	  return Object.prototype.toString.call(o);
-	}	clone.__objToStr = __objToStr;
-
-	function __isDate(o) {
-	  return typeof o === 'object' && __objToStr(o) === '[object Date]';
-	}	clone.__isDate = __isDate;
-
-	function __isArray(o) {
-	  return typeof o === 'object' && __objToStr(o) === '[object Array]';
-	}	clone.__isArray = __isArray;
-
-	function __isRegExp(o) {
-	  return typeof o === 'object' && __objToStr(o) === '[object RegExp]';
-	}	clone.__isRegExp = __isRegExp;
-
-	function __getRegExpFlags(re) {
-	  var flags = '';
-	  if (re.global) flags += 'g';
-	  if (re.ignoreCase) flags += 'i';
-	  if (re.multiline) flags += 'm';
-	  return flags;
-	}	clone.__getRegExpFlags = __getRegExpFlags;
-
-	return clone;
-	})();
-
-	if (module.exports) {
-	  module.exports = clone;
-	} 
-} (clone$1));
-
-var cloneExports = clone$1.exports;
+	if (!options.countAnsiEscapeCodes) {
+		string = stripAnsi(string);
+	}
 
-var clone = cloneExports;
+	if (string.length === 0) {
+		return 0;
+	}
 
-var defaults$1 = function(options, defaults) {
-  options = options || {};
+	const ambiguousCharacterWidth = options.ambiguousIsNarrow ? 1 : 2;
+	let width = 0;
 
-  Object.keys(defaults).forEach(function(key) {
-    if (typeof options[key] === 'undefined') {
-      options[key] = clone(defaults[key]);
-    }
-  });
+	for (const {segment: character} of new Intl.Segmenter().segment(string)) {
+		const codePoint = character.codePointAt(0);
 
-  return options;
-};
+		// Ignore control characters
+		if (codePoint <= 0x1F || (codePoint >= 0x7F && codePoint <= 0x9F)) {
+			continue;
+		}
 
-var combining$1 = [
-    [ 0x0300, 0x036F ], [ 0x0483, 0x0486 ], [ 0x0488, 0x0489 ],
-    [ 0x0591, 0x05BD ], [ 0x05BF, 0x05BF ], [ 0x05C1, 0x05C2 ],
-    [ 0x05C4, 0x05C5 ], [ 0x05C7, 0x05C7 ], [ 0x0600, 0x0603 ],
-    [ 0x0610, 0x0615 ], [ 0x064B, 0x065E ], [ 0x0670, 0x0670 ],
-    [ 0x06D6, 0x06E4 ], [ 0x06E7, 0x06E8 ], [ 0x06EA, 0x06ED ],
-    [ 0x070F, 0x070F ], [ 0x0711, 0x0711 ], [ 0x0730, 0x074A ],
-    [ 0x07A6, 0x07B0 ], [ 0x07EB, 0x07F3 ], [ 0x0901, 0x0902 ],
-    [ 0x093C, 0x093C ], [ 0x0941, 0x0948 ], [ 0x094D, 0x094D ],
-    [ 0x0951, 0x0954 ], [ 0x0962, 0x0963 ], [ 0x0981, 0x0981 ],
-    [ 0x09BC, 0x09BC ], [ 0x09C1, 0x09C4 ], [ 0x09CD, 0x09CD ],
-    [ 0x09E2, 0x09E3 ], [ 0x0A01, 0x0A02 ], [ 0x0A3C, 0x0A3C ],
-    [ 0x0A41, 0x0A42 ], [ 0x0A47, 0x0A48 ], [ 0x0A4B, 0x0A4D ],
-    [ 0x0A70, 0x0A71 ], [ 0x0A81, 0x0A82 ], [ 0x0ABC, 0x0ABC ],
-    [ 0x0AC1, 0x0AC5 ], [ 0x0AC7, 0x0AC8 ], [ 0x0ACD, 0x0ACD ],
-    [ 0x0AE2, 0x0AE3 ], [ 0x0B01, 0x0B01 ], [ 0x0B3C, 0x0B3C ],
-    [ 0x0B3F, 0x0B3F ], [ 0x0B41, 0x0B43 ], [ 0x0B4D, 0x0B4D ],
-    [ 0x0B56, 0x0B56 ], [ 0x0B82, 0x0B82 ], [ 0x0BC0, 0x0BC0 ],
-    [ 0x0BCD, 0x0BCD ], [ 0x0C3E, 0x0C40 ], [ 0x0C46, 0x0C48 ],
-    [ 0x0C4A, 0x0C4D ], [ 0x0C55, 0x0C56 ], [ 0x0CBC, 0x0CBC ],
-    [ 0x0CBF, 0x0CBF ], [ 0x0CC6, 0x0CC6 ], [ 0x0CCC, 0x0CCD ],
-    [ 0x0CE2, 0x0CE3 ], [ 0x0D41, 0x0D43 ], [ 0x0D4D, 0x0D4D ],
-    [ 0x0DCA, 0x0DCA ], [ 0x0DD2, 0x0DD4 ], [ 0x0DD6, 0x0DD6 ],
-    [ 0x0E31, 0x0E31 ], [ 0x0E34, 0x0E3A ], [ 0x0E47, 0x0E4E ],
-    [ 0x0EB1, 0x0EB1 ], [ 0x0EB4, 0x0EB9 ], [ 0x0EBB, 0x0EBC ],
-    [ 0x0EC8, 0x0ECD ], [ 0x0F18, 0x0F19 ], [ 0x0F35, 0x0F35 ],
-    [ 0x0F37, 0x0F37 ], [ 0x0F39, 0x0F39 ], [ 0x0F71, 0x0F7E ],
-    [ 0x0F80, 0x0F84 ], [ 0x0F86, 0x0F87 ], [ 0x0F90, 0x0F97 ],
-    [ 0x0F99, 0x0FBC ], [ 0x0FC6, 0x0FC6 ], [ 0x102D, 0x1030 ],
-    [ 0x1032, 0x1032 ], [ 0x1036, 0x1037 ], [ 0x1039, 0x1039 ],
-    [ 0x1058, 0x1059 ], [ 0x1160, 0x11FF ], [ 0x135F, 0x135F ],
-    [ 0x1712, 0x1714 ], [ 0x1732, 0x1734 ], [ 0x1752, 0x1753 ],
-    [ 0x1772, 0x1773 ], [ 0x17B4, 0x17B5 ], [ 0x17B7, 0x17BD ],
-    [ 0x17C6, 0x17C6 ], [ 0x17C9, 0x17D3 ], [ 0x17DD, 0x17DD ],
-    [ 0x180B, 0x180D ], [ 0x18A9, 0x18A9 ], [ 0x1920, 0x1922 ],
-    [ 0x1927, 0x1928 ], [ 0x1932, 0x1932 ], [ 0x1939, 0x193B ],
-    [ 0x1A17, 0x1A18 ], [ 0x1B00, 0x1B03 ], [ 0x1B34, 0x1B34 ],
-    [ 0x1B36, 0x1B3A ], [ 0x1B3C, 0x1B3C ], [ 0x1B42, 0x1B42 ],
-    [ 0x1B6B, 0x1B73 ], [ 0x1DC0, 0x1DCA ], [ 0x1DFE, 0x1DFF ],
-    [ 0x200B, 0x200F ], [ 0x202A, 0x202E ], [ 0x2060, 0x2063 ],
-    [ 0x206A, 0x206F ], [ 0x20D0, 0x20EF ], [ 0x302A, 0x302F ],
-    [ 0x3099, 0x309A ], [ 0xA806, 0xA806 ], [ 0xA80B, 0xA80B ],
-    [ 0xA825, 0xA826 ], [ 0xFB1E, 0xFB1E ], [ 0xFE00, 0xFE0F ],
-    [ 0xFE20, 0xFE23 ], [ 0xFEFF, 0xFEFF ], [ 0xFFF9, 0xFFFB ],
-    [ 0x10A01, 0x10A03 ], [ 0x10A05, 0x10A06 ], [ 0x10A0C, 0x10A0F ],
-    [ 0x10A38, 0x10A3A ], [ 0x10A3F, 0x10A3F ], [ 0x1D167, 0x1D169 ],
-    [ 0x1D173, 0x1D182 ], [ 0x1D185, 0x1D18B ], [ 0x1D1AA, 0x1D1AD ],
-    [ 0x1D242, 0x1D244 ], [ 0xE0001, 0xE0001 ], [ 0xE0020, 0xE007F ],
-    [ 0xE0100, 0xE01EF ]
-];
+		// Ignore combining characters
+		if (codePoint >= 0x3_00 && codePoint <= 0x3_6F) {
+			continue;
+		}
 
-var defaults = defaults$1;
-var combining = combining$1;
+		if (emojiRegex().test(character)) {
+			width += 2;
+			continue;
+		}
 
-var DEFAULTS = {
-  nul: 0,
-  control: 0
-};
+		const code = eastAsianWidth.eastAsianWidth(character);
+		switch (code) {
+			case 'F':
+			case 'W': {
+				width += 2;
+				break;
+			}
 
-wcwidth$2.exports = function wcwidth(str) {
-  return wcswidth(str, DEFAULTS)
-};
+			case 'A': {
+				width += ambiguousCharacterWidth;
+				break;
+			}
 
-wcwidth$2.exports.config = function(opts) {
-  opts = defaults(opts || {}, DEFAULTS);
-  return function wcwidth(str) {
-    return wcswidth(str, opts)
-  }
-};
+			default: {
+				width += 1;
+			}
+		}
+	}
 
-/*
- *  The following functions define the column width of an ISO 10646
- *  character as follows:
- *  - The null character (U+0000) has a column width of 0.
- *  - Other C0/C1 control characters and DEL will lead to a return value
- *    of -1.
- *  - Non-spacing and enclosing combining characters (general category
- *    code Mn or Me in the
- *    Unicode database) have a column width of 0.
- *  - SOFT HYPHEN (U+00AD) has a column width of 1.
- *  - Other format characters (general category code Cf in the Unicode
- *    database) and ZERO WIDTH
- *    SPACE (U+200B) have a column width of 0.
- *  - Hangul Jamo medial vowels and final consonants (U+1160-U+11FF)
- *    have a column width of 0.
- *  - Spacing characters in the East Asian Wide (W) or East Asian
- *    Full-width (F) category as
- *    defined in Unicode Technical Report #11 have a column width of 2.
- *  - All remaining characters (including all printable ISO 8859-1 and
- *    WGL4 characters, Unicode control characters, etc.) have a column
- *    width of 1.
- *  This implementation assumes that characters are encoded in ISO 10646.
-*/
-
-function wcswidth(str, opts) {
-  if (typeof str !== 'string') return wcwidth(str, opts)
-
-  var s = 0;
-  for (var i = 0; i < str.length; i++) {
-    var n = wcwidth(str.charCodeAt(i), opts);
-    if (n < 0) return -1
-    s += n;
-  }
-
-  return s
-}
-
-function wcwidth(ucs, opts) {
-  // test for 8-bit control characters
-  if (ucs === 0) return opts.nul
-  if (ucs < 32 || (ucs >= 0x7f && ucs < 0xa0)) return opts.control
-
-  // binary search in table of non-spacing characters
-  if (bisearch(ucs)) return 0
-
-  // if we arrive here, ucs is not a combining or C0/C1 control character
-  return 1 +
-      (ucs >= 0x1100 &&
-       (ucs <= 0x115f ||                       // Hangul Jamo init. consonants
-        ucs == 0x2329 || ucs == 0x232a ||
-        (ucs >= 0x2e80 && ucs <= 0xa4cf &&
-         ucs != 0x303f) ||                     // CJK ... Yi
-        (ucs >= 0xac00 && ucs <= 0xd7a3) ||    // Hangul Syllables
-        (ucs >= 0xf900 && ucs <= 0xfaff) ||    // CJK Compatibility Ideographs
-        (ucs >= 0xfe10 && ucs <= 0xfe19) ||    // Vertical forms
-        (ucs >= 0xfe30 && ucs <= 0xfe6f) ||    // CJK Compatibility Forms
-        (ucs >= 0xff00 && ucs <= 0xff60) ||    // Fullwidth Forms
-        (ucs >= 0xffe0 && ucs <= 0xffe6) ||
-        (ucs >= 0x20000 && ucs <= 0x2fffd) ||
-        (ucs >= 0x30000 && ucs <= 0x3fffd)));
-}
-
-function bisearch(ucs) {
-  var min = 0;
-  var max = combining.length - 1;
-  var mid;
-
-  if (ucs < combining[0][0] || ucs > combining[max][1]) return false
-
-  while (max >= min) {
-    mid = Math.floor((min + max) / 2);
-    if (ucs > combining[mid][1]) min = mid + 1;
-    else if (ucs < combining[mid][0]) max = mid - 1;
-    else return true
-  }
-
-  return false
-}
-
-var wcwidthExports = wcwidth$2.exports;
-var wcwidth$1 = /*@__PURE__*/getDefaultExportFromCjs(wcwidthExports);
+	return width;
+}
 
 function isInteractive({stream = process.stdout} = {}) {
 	return Boolean(
@@ -12631,11 +13384,11 @@ class Ora {
 		}
 
 		this.#indent = indent;
-		this.updateLineCount();
+		this.#updateLineCount();
 	}
 
 	get interval() {
-		return this.#initialInterval || this.#spinner.interval || 100;
+		return this.#initialInterval ?? this.#spinner.interval ?? 100;
 	}
 
 	get spinner() {
@@ -12668,35 +13421,34 @@ class Ora {
 		return this.#text;
 	}
 
-	set text(value) {
-		this.#text = value || '';
-		this.updateLineCount();
+	set text(value = '') {
+		this.#text = value;
+		this.#updateLineCount();
 	}
 
 	get prefixText() {
 		return this.#prefixText;
 	}
 
-	set prefixText(value) {
-		this.#prefixText = value || '';
-		this.updateLineCount();
+	set prefixText(value = '') {
+		this.#prefixText = value;
+		this.#updateLineCount();
 	}
 
 	get suffixText() {
 		return this.#suffixText;
 	}
 
-	set suffixText(value) {
-		this.#suffixText = value || '';
-		this.updateLineCount();
+	set suffixText(value = '') {
+		this.#suffixText = value;
+		this.#updateLineCount();
 	}
 
 	get isSpinning() {
 		return this.#id !== undefined;
 	}
 
-	// TODO: Use private methods when targeting Node.js 14.
-	getFullPrefixText(prefixText = this.#prefixText, postfix = ' ') {
+	#getFullPrefixText(prefixText = this.#prefixText, postfix = ' ') {
 		if (typeof prefixText === 'string' && prefixText !== '') {
 			return prefixText + postfix;
 		}
@@ -12708,7 +13460,7 @@ class Ora {
 		return '';
 	}
 
-	getFullSuffixText(suffixText = this.#suffixText, prefix = ' ') {
+	#getFullSuffixText(suffixText = this.#suffixText, prefix = ' ') {
 		if (typeof suffixText === 'string' && suffixText !== '') {
 			return prefix + suffixText;
 		}
@@ -12720,15 +13472,15 @@ class Ora {
 		return '';
 	}
 
-	updateLineCount() {
-		const columns = this.#stream.columns || 80;
-		const fullPrefixText = this.getFullPrefixText(this.#prefixText, '-');
-		const fullSuffixText = this.getFullSuffixText(this.#suffixText, '-');
+	#updateLineCount() {
+		const columns = this.#stream.columns ?? 80;
+		const fullPrefixText = this.#getFullPrefixText(this.#prefixText, '-');
+		const fullSuffixText = this.#getFullSuffixText(this.#suffixText, '-');
 		const fullText = ' '.repeat(this.#indent) + fullPrefixText + '--' + this.#text + '--' + fullSuffixText;
 
 		this.#lineCount = 0;
 		for (const line of stripAnsi(fullText).split('\n')) {
-			this.#lineCount += Math.max(1, Math.ceil(wcwidth$1(line) / columns));
+			this.#lineCount += Math.max(1, Math.ceil(stringWidth(line, {countAnsiEscapeCodes: true}) / columns));
 		}
 	}
 
@@ -12887,16 +13639,16 @@ class Ora {
 			return this;
 		}
 
-		const prefixText = options.prefixText || this.#prefixText;
-		const fullPrefixText = this.getFullPrefixText(prefixText, ' ');
+		const prefixText = options.prefixText ?? this.#prefixText;
+		const fullPrefixText = this.#getFullPrefixText(prefixText, ' ');
 
-		const symbolText = options.symbol || ' ';
+		const symbolText = options.symbol ?? ' ';
 
-		const text = options.text || this.text;
+		const text = options.text ?? this.text;
 		const fullText = (typeof text === 'string') ? ' ' + text : '';
 
-		const suffixText = options.suffixText !== undefined ? options.suffixText : this.#suffixText;
-		const fullSuffixText = this.getFullSuffixText(suffixText, ' ');
+		const suffixText = options.suffixText ?? this.#suffixText;
+		const fullSuffixText = this.#getFullSuffixText(suffixText, ' ');
 
 		const textToWrite = fullPrefixText + symbolText + fullText + fullSuffixText + '\n';
 
@@ -12917,7 +13669,183 @@ var src$1 = {};
 
 var src = {exports: {}};
 
-var browser = {exports: {}};
+var node = {exports: {}};
+
+var hasFlag;
+var hasRequiredHasFlag;
+
+function requireHasFlag () {
+	if (hasRequiredHasFlag) return hasFlag;
+	hasRequiredHasFlag = 1;
+
+	hasFlag = (flag, argv = process.argv) => {
+		const prefix = flag.startsWith('-') ? '' : (flag.length === 1 ? '-' : '--');
+		const position = argv.indexOf(prefix + flag);
+		const terminatorPosition = argv.indexOf('--');
+		return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+	};
+	return hasFlag;
+}
+
+var supportsColor_1;
+var hasRequiredSupportsColor;
+
+function requireSupportsColor () {
+	if (hasRequiredSupportsColor) return supportsColor_1;
+	hasRequiredSupportsColor = 1;
+	const os = require$$0$5;
+	const tty = require$$1$2;
+	const hasFlag = requireHasFlag();
+
+	const {env} = process;
+
+	let flagForceColor;
+	if (hasFlag('no-color') ||
+		hasFlag('no-colors') ||
+		hasFlag('color=false') ||
+		hasFlag('color=never')) {
+		flagForceColor = 0;
+	} else if (hasFlag('color') ||
+		hasFlag('colors') ||
+		hasFlag('color=true') ||
+		hasFlag('color=always')) {
+		flagForceColor = 1;
+	}
+
+	function envForceColor() {
+		if ('FORCE_COLOR' in env) {
+			if (env.FORCE_COLOR === 'true') {
+				return 1;
+			}
+
+			if (env.FORCE_COLOR === 'false') {
+				return 0;
+			}
+
+			return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+		}
+	}
+
+	function translateLevel(level) {
+		if (level === 0) {
+			return false;
+		}
+
+		return {
+			level,
+			hasBasic: true,
+			has256: level >= 2,
+			has16m: level >= 3
+		};
+	}
+
+	function supportsColor(haveStream, {streamIsTTY, sniffFlags = true} = {}) {
+		const noFlagForceColor = envForceColor();
+		if (noFlagForceColor !== undefined) {
+			flagForceColor = noFlagForceColor;
+		}
+
+		const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+
+		if (forceColor === 0) {
+			return 0;
+		}
+
+		if (sniffFlags) {
+			if (hasFlag('color=16m') ||
+				hasFlag('color=full') ||
+				hasFlag('color=truecolor')) {
+				return 3;
+			}
+
+			if (hasFlag('color=256')) {
+				return 2;
+			}
+		}
+
+		if (haveStream && !streamIsTTY && forceColor === undefined) {
+			return 0;
+		}
+
+		const min = forceColor || 0;
+
+		if (env.TERM === 'dumb') {
+			return min;
+		}
+
+		if (process.platform === 'win32') {
+			// Windows 10 build 10586 is the first Windows release that supports 256 colors.
+			// Windows 10 build 14931 is the first release that supports 16m/TrueColor.
+			const osRelease = os.release().split('.');
+			if (
+				Number(osRelease[0]) >= 10 &&
+				Number(osRelease[2]) >= 10586
+			) {
+				return Number(osRelease[2]) >= 14931 ? 3 : 2;
+			}
+
+			return 1;
+		}
+
+		if ('CI' in env) {
+			if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI', 'GITHUB_ACTIONS', 'BUILDKITE', 'DRONE'].some(sign => sign in env) || env.CI_NAME === 'codeship') {
+				return 1;
+			}
+
+			return min;
+		}
+
+		if ('TEAMCITY_VERSION' in env) {
+			return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+		}
+
+		if (env.COLORTERM === 'truecolor') {
+			return 3;
+		}
+
+		if ('TERM_PROGRAM' in env) {
+			const version = Number.parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
+
+			switch (env.TERM_PROGRAM) {
+				case 'iTerm.app':
+					return version >= 3 ? 3 : 2;
+				case 'Apple_Terminal':
+					return 2;
+				// No default
+			}
+		}
+
+		if (/-256(color)?$/i.test(env.TERM)) {
+			return 2;
+		}
+
+		if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+			return 1;
+		}
+
+		if ('COLORTERM' in env) {
+			return 1;
+		}
+
+		return min;
+	}
+
+	function getSupportLevel(stream, options = {}) {
+		const level = supportsColor(stream, {
+			streamIsTTY: stream && stream.isTTY,
+			...options
+		});
+
+		return translateLevel(level);
+	}
+
+	supportsColor_1 = {
+		supportsColor: getSupportLevel,
+		stdout: getSupportLevel({isTTY: tty.isatty(1)}),
+		stderr: getSupportLevel({isTTY: tty.isatty(2)})
+	};
+	return supportsColor_1;
+}
 
 /**
  * Helpers.
@@ -13372,478 +14300,21 @@ function requireCommon () {
 	return common$1;
 }
 
-/* eslint-env browser */
+/**
+ * Module dependencies.
+ */
 
-var hasRequiredBrowser;
+var hasRequiredNode;
 
-function requireBrowser () {
-	if (hasRequiredBrowser) return browser.exports;
-	hasRequiredBrowser = 1;
+function requireNode () {
+	if (hasRequiredNode) return node.exports;
+	hasRequiredNode = 1;
 	(function (module, exports) {
+		const tty = require$$1$2;
+		const util = require$$1$1;
+
 		/**
-		 * This is the web browser implementation of `debug()`.
-		 */
-
-		exports.formatArgs = formatArgs;
-		exports.save = save;
-		exports.load = load;
-		exports.useColors = useColors;
-		exports.storage = localstorage();
-		exports.destroy = (() => {
-			let warned = false;
-
-			return () => {
-				if (!warned) {
-					warned = true;
-					console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
-				}
-			};
-		})();
-
-		/**
-		 * Colors.
-		 */
-
-		exports.colors = [
-			'#0000CC',
-			'#0000FF',
-			'#0033CC',
-			'#0033FF',
-			'#0066CC',
-			'#0066FF',
-			'#0099CC',
-			'#0099FF',
-			'#00CC00',
-			'#00CC33',
-			'#00CC66',
-			'#00CC99',
-			'#00CCCC',
-			'#00CCFF',
-			'#3300CC',
-			'#3300FF',
-			'#3333CC',
-			'#3333FF',
-			'#3366CC',
-			'#3366FF',
-			'#3399CC',
-			'#3399FF',
-			'#33CC00',
-			'#33CC33',
-			'#33CC66',
-			'#33CC99',
-			'#33CCCC',
-			'#33CCFF',
-			'#6600CC',
-			'#6600FF',
-			'#6633CC',
-			'#6633FF',
-			'#66CC00',
-			'#66CC33',
-			'#9900CC',
-			'#9900FF',
-			'#9933CC',
-			'#9933FF',
-			'#99CC00',
-			'#99CC33',
-			'#CC0000',
-			'#CC0033',
-			'#CC0066',
-			'#CC0099',
-			'#CC00CC',
-			'#CC00FF',
-			'#CC3300',
-			'#CC3333',
-			'#CC3366',
-			'#CC3399',
-			'#CC33CC',
-			'#CC33FF',
-			'#CC6600',
-			'#CC6633',
-			'#CC9900',
-			'#CC9933',
-			'#CCCC00',
-			'#CCCC33',
-			'#FF0000',
-			'#FF0033',
-			'#FF0066',
-			'#FF0099',
-			'#FF00CC',
-			'#FF00FF',
-			'#FF3300',
-			'#FF3333',
-			'#FF3366',
-			'#FF3399',
-			'#FF33CC',
-			'#FF33FF',
-			'#FF6600',
-			'#FF6633',
-			'#FF9900',
-			'#FF9933',
-			'#FFCC00',
-			'#FFCC33'
-		];
-
-		/**
-		 * Currently only WebKit-based Web Inspectors, Firefox >= v31,
-		 * and the Firebug extension (any Firefox version) are known
-		 * to support "%c" CSS customizations.
-		 *
-		 * TODO: add a `localStorage` variable to explicitly enable/disable colors
-		 */
-
-		// eslint-disable-next-line complexity
-		function useColors() {
-			// NB: In an Electron preload script, document will be defined but not fully
-			// initialized. Since we know we're in Chrome, we'll just detect this case
-			// explicitly
-			if (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) {
-				return true;
-			}
-
-			// Internet Explorer and Edge do not support colors.
-			if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
-				return false;
-			}
-
-			// Is webkit? http://stackoverflow.com/a/16459606/376773
-			// document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
-			return (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) ||
-				// Is firebug? http://stackoverflow.com/a/398120/376773
-				(typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||
-				// Is firefox >= v31?
-				// https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
-				(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||
-				// Double check webkit in userAgent just in case we are in a worker
-				(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/));
-		}
-
-		/**
-		 * Colorize log arguments if enabled.
-		 *
-		 * @api public
-		 */
-
-		function formatArgs(args) {
-			args[0] = (this.useColors ? '%c' : '') +
-				this.namespace +
-				(this.useColors ? ' %c' : ' ') +
-				args[0] +
-				(this.useColors ? '%c ' : ' ') +
-				'+' + module.exports.humanize(this.diff);
-
-			if (!this.useColors) {
-				return;
-			}
-
-			const c = 'color: ' + this.color;
-			args.splice(1, 0, c, 'color: inherit');
-
-			// The final "%c" is somewhat tricky, because there could be other
-			// arguments passed either before or after the %c, so we need to
-			// figure out the correct index to insert the CSS into
-			let index = 0;
-			let lastC = 0;
-			args[0].replace(/%[a-zA-Z%]/g, match => {
-				if (match === '%%') {
-					return;
-				}
-				index++;
-				if (match === '%c') {
-					// We only are interested in the *last* %c
-					// (the user may have provided their own)
-					lastC = index;
-				}
-			});
-
-			args.splice(lastC, 0, c);
-		}
-
-		/**
-		 * Invokes `console.debug()` when available.
-		 * No-op when `console.debug` is not a "function".
-		 * If `console.debug` is not available, falls back
-		 * to `console.log`.
-		 *
-		 * @api public
-		 */
-		exports.log = console.debug || console.log || (() => {});
-
-		/**
-		 * Save `namespaces`.
-		 *
-		 * @param {String} namespaces
-		 * @api private
-		 */
-		function save(namespaces) {
-			try {
-				if (namespaces) {
-					exports.storage.setItem('debug', namespaces);
-				} else {
-					exports.storage.removeItem('debug');
-				}
-			} catch (error) {
-				// Swallow
-				// XXX (@Qix-) should we be logging these?
-			}
-		}
-
-		/**
-		 * Load `namespaces`.
-		 *
-		 * @return {String} returns the previously persisted debug modes
-		 * @api private
-		 */
-		function load() {
-			let r;
-			try {
-				r = exports.storage.getItem('debug');
-			} catch (error) {
-				// Swallow
-				// XXX (@Qix-) should we be logging these?
-			}
-
-			// If debug isn't set in LS, and we're in Electron, try to load $DEBUG
-			if (!r && typeof process !== 'undefined' && 'env' in process) {
-				r = process.env.DEBUG;
-			}
-
-			return r;
-		}
-
-		/**
-		 * Localstorage attempts to return the localstorage.
-		 *
-		 * This is necessary because safari throws
-		 * when a user disables cookies/localstorage
-		 * and you attempt to access it.
-		 *
-		 * @return {LocalStorage}
-		 * @api private
-		 */
-
-		function localstorage() {
-			try {
-				// TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context
-				// The Browser also has localStorage in the global context.
-				return localStorage;
-			} catch (error) {
-				// Swallow
-				// XXX (@Qix-) should we be logging these?
-			}
-		}
-
-		module.exports = requireCommon()(exports);
-
-		const {formatters} = module.exports;
-
-		/**
-		 * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
-		 */
-
-		formatters.j = function (v) {
-			try {
-				return JSON.stringify(v);
-			} catch (error) {
-				return '[UnexpectedJSONParseError]: ' + error.message;
-			}
-		}; 
-	} (browser, browser.exports));
-	return browser.exports;
-}
-
-var node = {exports: {}};
-
-var hasFlag;
-var hasRequiredHasFlag;
-
-function requireHasFlag () {
-	if (hasRequiredHasFlag) return hasFlag;
-	hasRequiredHasFlag = 1;
-
-	hasFlag = (flag, argv = process.argv) => {
-		const prefix = flag.startsWith('-') ? '' : (flag.length === 1 ? '-' : '--');
-		const position = argv.indexOf(prefix + flag);
-		const terminatorPosition = argv.indexOf('--');
-		return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
-	};
-	return hasFlag;
-}
-
-var supportsColor_1;
-var hasRequiredSupportsColor;
-
-function requireSupportsColor () {
-	if (hasRequiredSupportsColor) return supportsColor_1;
-	hasRequiredSupportsColor = 1;
-	const os = require$$0$5;
-	const tty = require$$1$2;
-	const hasFlag = requireHasFlag();
-
-	const {env} = process;
-
-	let flagForceColor;
-	if (hasFlag('no-color') ||
-		hasFlag('no-colors') ||
-		hasFlag('color=false') ||
-		hasFlag('color=never')) {
-		flagForceColor = 0;
-	} else if (hasFlag('color') ||
-		hasFlag('colors') ||
-		hasFlag('color=true') ||
-		hasFlag('color=always')) {
-		flagForceColor = 1;
-	}
-
-	function envForceColor() {
-		if ('FORCE_COLOR' in env) {
-			if (env.FORCE_COLOR === 'true') {
-				return 1;
-			}
-
-			if (env.FORCE_COLOR === 'false') {
-				return 0;
-			}
-
-			return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
-		}
-	}
-
-	function translateLevel(level) {
-		if (level === 0) {
-			return false;
-		}
-
-		return {
-			level,
-			hasBasic: true,
-			has256: level >= 2,
-			has16m: level >= 3
-		};
-	}
-
-	function supportsColor(haveStream, {streamIsTTY, sniffFlags = true} = {}) {
-		const noFlagForceColor = envForceColor();
-		if (noFlagForceColor !== undefined) {
-			flagForceColor = noFlagForceColor;
-		}
-
-		const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
-
-		if (forceColor === 0) {
-			return 0;
-		}
-
-		if (sniffFlags) {
-			if (hasFlag('color=16m') ||
-				hasFlag('color=full') ||
-				hasFlag('color=truecolor')) {
-				return 3;
-			}
-
-			if (hasFlag('color=256')) {
-				return 2;
-			}
-		}
-
-		if (haveStream && !streamIsTTY && forceColor === undefined) {
-			return 0;
-		}
-
-		const min = forceColor || 0;
-
-		if (env.TERM === 'dumb') {
-			return min;
-		}
-
-		if (process.platform === 'win32') {
-			// Windows 10 build 10586 is the first Windows release that supports 256 colors.
-			// Windows 10 build 14931 is the first release that supports 16m/TrueColor.
-			const osRelease = os.release().split('.');
-			if (
-				Number(osRelease[0]) >= 10 &&
-				Number(osRelease[2]) >= 10586
-			) {
-				return Number(osRelease[2]) >= 14931 ? 3 : 2;
-			}
-
-			return 1;
-		}
-
-		if ('CI' in env) {
-			if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI', 'GITHUB_ACTIONS', 'BUILDKITE', 'DRONE'].some(sign => sign in env) || env.CI_NAME === 'codeship') {
-				return 1;
-			}
-
-			return min;
-		}
-
-		if ('TEAMCITY_VERSION' in env) {
-			return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
-		}
-
-		if (env.COLORTERM === 'truecolor') {
-			return 3;
-		}
-
-		if ('TERM_PROGRAM' in env) {
-			const version = Number.parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
-
-			switch (env.TERM_PROGRAM) {
-				case 'iTerm.app':
-					return version >= 3 ? 3 : 2;
-				case 'Apple_Terminal':
-					return 2;
-				// No default
-			}
-		}
-
-		if (/-256(color)?$/i.test(env.TERM)) {
-			return 2;
-		}
-
-		if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
-			return 1;
-		}
-
-		if ('COLORTERM' in env) {
-			return 1;
-		}
-
-		return min;
-	}
-
-	function getSupportLevel(stream, options = {}) {
-		const level = supportsColor(stream, {
-			streamIsTTY: stream && stream.isTTY,
-			...options
-		});
-
-		return translateLevel(level);
-	}
-
-	supportsColor_1 = {
-		supportsColor: getSupportLevel,
-		stdout: getSupportLevel({isTTY: tty.isatty(1)}),
-		stderr: getSupportLevel({isTTY: tty.isatty(2)})
-	};
-	return supportsColor_1;
-}
-
-/**
- * Module dependencies.
- */
-
-var hasRequiredNode;
-
-function requireNode () {
-	if (hasRequiredNode) return node.exports;
-	hasRequiredNode = 1;
-	(function (module, exports) {
-		const tty = require$$1$2;
-		const util = require$$1$1;
-
-		/**
-		 * This is the Node.js implementation of `debug()`.
+		 * This is the Node.js implementation of `debug()`.
 		 */
 
 		exports.init = init;
@@ -13953,83 +14424,352 @@ function requireNode () {
 		}
 
 		/**
-		 * Build up the default `inspectOpts` object from the environment variables.
+		 * Build up the default `inspectOpts` object from the environment variables.
+		 *
+		 *   $ DEBUG_COLORS=no DEBUG_DEPTH=10 DEBUG_SHOW_HIDDEN=enabled node script.js
+		 */
+
+		exports.inspectOpts = Object.keys(process.env).filter(key => {
+			return /^debug_/i.test(key);
+		}).reduce((obj, key) => {
+			// Camel-case
+			const prop = key
+				.substring(6)
+				.toLowerCase()
+				.replace(/_([a-z])/g, (_, k) => {
+					return k.toUpperCase();
+				});
+
+			// Coerce string value into JS value
+			let val = process.env[key];
+			if (/^(yes|on|true|enabled)$/i.test(val)) {
+				val = true;
+			} else if (/^(no|off|false|disabled)$/i.test(val)) {
+				val = false;
+			} else if (val === 'null') {
+				val = null;
+			} else {
+				val = Number(val);
+			}
+
+			obj[prop] = val;
+			return obj;
+		}, {});
+
+		/**
+		 * Is stdout a TTY? Colored output is enabled when `true`.
+		 */
+
+		function useColors() {
+			return 'colors' in exports.inspectOpts ?
+				Boolean(exports.inspectOpts.colors) :
+				tty.isatty(process.stderr.fd);
+		}
+
+		/**
+		 * Adds ANSI color escape codes if enabled.
+		 *
+		 * @api public
+		 */
+
+		function formatArgs(args) {
+			const {namespace: name, useColors} = this;
+
+			if (useColors) {
+				const c = this.color;
+				const colorCode = '\u001B[3' + (c < 8 ? c : '8;5;' + c);
+				const prefix = `  ${colorCode};1m${name} \u001B[0m`;
+
+				args[0] = prefix + args[0].split('\n').join('\n' + prefix);
+				args.push(colorCode + 'm+' + module.exports.humanize(this.diff) + '\u001B[0m');
+			} else {
+				args[0] = getDate() + name + ' ' + args[0];
+			}
+		}
+
+		function getDate() {
+			if (exports.inspectOpts.hideDate) {
+				return '';
+			}
+			return new Date().toISOString() + ' ';
+		}
+
+		/**
+		 * Invokes `util.format()` with the specified arguments and writes to stderr.
+		 */
+
+		function log(...args) {
+			return process.stderr.write(util.format(...args) + '\n');
+		}
+
+		/**
+		 * Save `namespaces`.
+		 *
+		 * @param {String} namespaces
+		 * @api private
+		 */
+		function save(namespaces) {
+			if (namespaces) {
+				process.env.DEBUG = namespaces;
+			} else {
+				// If you set a process.env field to null or undefined, it gets cast to the
+				// string 'null' or 'undefined'. Just delete instead.
+				delete process.env.DEBUG;
+			}
+		}
+
+		/**
+		 * Load `namespaces`.
+		 *
+		 * @return {String} returns the previously persisted debug modes
+		 * @api private
+		 */
+
+		function load() {
+			return process.env.DEBUG;
+		}
+
+		/**
+		 * Init logic for `debug` instances.
+		 *
+		 * Create a new `inspectOpts` object in case `useColors` is set
+		 * differently for a particular `debug` instance.
+		 */
+
+		function init(debug) {
+			debug.inspectOpts = {};
+
+			const keys = Object.keys(exports.inspectOpts);
+			for (let i = 0; i < keys.length; i++) {
+				debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
+			}
+		}
+
+		module.exports = requireCommon()(exports);
+
+		const {formatters} = module.exports;
+
+		/**
+		 * Map %o to `util.inspect()`, all on a single line.
+		 */
+
+		formatters.o = function (v) {
+			this.inspectOpts.colors = this.useColors;
+			return util.inspect(v, this.inspectOpts)
+				.split('\n')
+				.map(str => str.trim())
+				.join(' ');
+		};
+
+		/**
+		 * Map %O to `util.inspect()`, allowing multiple lines if needed.
+		 */
+
+		formatters.O = function (v) {
+			this.inspectOpts.colors = this.useColors;
+			return util.inspect(v, this.inspectOpts);
+		}; 
+	} (node, node.exports));
+	return node.exports;
+}
+
+var browser = {exports: {}};
+
+/* eslint-env browser */
+
+var hasRequiredBrowser;
+
+function requireBrowser () {
+	if (hasRequiredBrowser) return browser.exports;
+	hasRequiredBrowser = 1;
+	(function (module, exports) {
+		/**
+		 * This is the web browser implementation of `debug()`.
+		 */
+
+		exports.formatArgs = formatArgs;
+		exports.save = save;
+		exports.load = load;
+		exports.useColors = useColors;
+		exports.storage = localstorage();
+		exports.destroy = (() => {
+			let warned = false;
+
+			return () => {
+				if (!warned) {
+					warned = true;
+					console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
+				}
+			};
+		})();
+
+		/**
+		 * Colors.
+		 */
+
+		exports.colors = [
+			'#0000CC',
+			'#0000FF',
+			'#0033CC',
+			'#0033FF',
+			'#0066CC',
+			'#0066FF',
+			'#0099CC',
+			'#0099FF',
+			'#00CC00',
+			'#00CC33',
+			'#00CC66',
+			'#00CC99',
+			'#00CCCC',
+			'#00CCFF',
+			'#3300CC',
+			'#3300FF',
+			'#3333CC',
+			'#3333FF',
+			'#3366CC',
+			'#3366FF',
+			'#3399CC',
+			'#3399FF',
+			'#33CC00',
+			'#33CC33',
+			'#33CC66',
+			'#33CC99',
+			'#33CCCC',
+			'#33CCFF',
+			'#6600CC',
+			'#6600FF',
+			'#6633CC',
+			'#6633FF',
+			'#66CC00',
+			'#66CC33',
+			'#9900CC',
+			'#9900FF',
+			'#9933CC',
+			'#9933FF',
+			'#99CC00',
+			'#99CC33',
+			'#CC0000',
+			'#CC0033',
+			'#CC0066',
+			'#CC0099',
+			'#CC00CC',
+			'#CC00FF',
+			'#CC3300',
+			'#CC3333',
+			'#CC3366',
+			'#CC3399',
+			'#CC33CC',
+			'#CC33FF',
+			'#CC6600',
+			'#CC6633',
+			'#CC9900',
+			'#CC9933',
+			'#CCCC00',
+			'#CCCC33',
+			'#FF0000',
+			'#FF0033',
+			'#FF0066',
+			'#FF0099',
+			'#FF00CC',
+			'#FF00FF',
+			'#FF3300',
+			'#FF3333',
+			'#FF3366',
+			'#FF3399',
+			'#FF33CC',
+			'#FF33FF',
+			'#FF6600',
+			'#FF6633',
+			'#FF9900',
+			'#FF9933',
+			'#FFCC00',
+			'#FFCC33'
+		];
+
+		/**
+		 * Currently only WebKit-based Web Inspectors, Firefox >= v31,
+		 * and the Firebug extension (any Firefox version) are known
+		 * to support "%c" CSS customizations.
 		 *
-		 *   $ DEBUG_COLORS=no DEBUG_DEPTH=10 DEBUG_SHOW_HIDDEN=enabled node script.js
+		 * TODO: add a `localStorage` variable to explicitly enable/disable colors
 		 */
 
-		exports.inspectOpts = Object.keys(process.env).filter(key => {
-			return /^debug_/i.test(key);
-		}).reduce((obj, key) => {
-			// Camel-case
-			const prop = key
-				.substring(6)
-				.toLowerCase()
-				.replace(/_([a-z])/g, (_, k) => {
-					return k.toUpperCase();
-				});
-
-			// Coerce string value into JS value
-			let val = process.env[key];
-			if (/^(yes|on|true|enabled)$/i.test(val)) {
-				val = true;
-			} else if (/^(no|off|false|disabled)$/i.test(val)) {
-				val = false;
-			} else if (val === 'null') {
-				val = null;
-			} else {
-				val = Number(val);
+		// eslint-disable-next-line complexity
+		function useColors() {
+			// NB: In an Electron preload script, document will be defined but not fully
+			// initialized. Since we know we're in Chrome, we'll just detect this case
+			// explicitly
+			if (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) {
+				return true;
 			}
 
-			obj[prop] = val;
-			return obj;
-		}, {});
-
-		/**
-		 * Is stdout a TTY? Colored output is enabled when `true`.
-		 */
+			// Internet Explorer and Edge do not support colors.
+			if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
+				return false;
+			}
 
-		function useColors() {
-			return 'colors' in exports.inspectOpts ?
-				Boolean(exports.inspectOpts.colors) :
-				tty.isatty(process.stderr.fd);
+			// Is webkit? http://stackoverflow.com/a/16459606/376773
+			// document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
+			return (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) ||
+				// Is firebug? http://stackoverflow.com/a/398120/376773
+				(typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||
+				// Is firefox >= v31?
+				// https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
+				(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||
+				// Double check webkit in userAgent just in case we are in a worker
+				(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/));
 		}
 
 		/**
-		 * Adds ANSI color escape codes if enabled.
+		 * Colorize log arguments if enabled.
 		 *
 		 * @api public
 		 */
 
 		function formatArgs(args) {
-			const {namespace: name, useColors} = this;
-
-			if (useColors) {
-				const c = this.color;
-				const colorCode = '\u001B[3' + (c < 8 ? c : '8;5;' + c);
-				const prefix = `  ${colorCode};1m${name} \u001B[0m`;
+			args[0] = (this.useColors ? '%c' : '') +
+				this.namespace +
+				(this.useColors ? ' %c' : ' ') +
+				args[0] +
+				(this.useColors ? '%c ' : ' ') +
+				'+' + module.exports.humanize(this.diff);
 
-				args[0] = prefix + args[0].split('\n').join('\n' + prefix);
-				args.push(colorCode + 'm+' + module.exports.humanize(this.diff) + '\u001B[0m');
-			} else {
-				args[0] = getDate() + name + ' ' + args[0];
+			if (!this.useColors) {
+				return;
 			}
-		}
 
-		function getDate() {
-			if (exports.inspectOpts.hideDate) {
-				return '';
-			}
-			return new Date().toISOString() + ' ';
+			const c = 'color: ' + this.color;
+			args.splice(1, 0, c, 'color: inherit');
+
+			// The final "%c" is somewhat tricky, because there could be other
+			// arguments passed either before or after the %c, so we need to
+			// figure out the correct index to insert the CSS into
+			let index = 0;
+			let lastC = 0;
+			args[0].replace(/%[a-zA-Z%]/g, match => {
+				if (match === '%%') {
+					return;
+				}
+				index++;
+				if (match === '%c') {
+					// We only are interested in the *last* %c
+					// (the user may have provided their own)
+					lastC = index;
+				}
+			});
+
+			args.splice(lastC, 0, c);
 		}
 
 		/**
-		 * Invokes `util.format()` with the specified arguments and writes to stderr.
+		 * Invokes `console.debug()` when available.
+		 * No-op when `console.debug` is not a "function".
+		 * If `console.debug` is not available, falls back
+		 * to `console.log`.
+		 *
+		 * @api public
 		 */
-
-		function log(...args) {
-			return process.stderr.write(util.format(...args) + '\n');
-		}
+		exports.log = console.debug || console.log || (() => {});
 
 		/**
 		 * Save `namespaces`.
@@ -14038,12 +14778,15 @@ function requireNode () {
 		 * @api private
 		 */
 		function save(namespaces) {
-			if (namespaces) {
-				process.env.DEBUG = namespaces;
-			} else {
-				// If you set a process.env field to null or undefined, it gets cast to the
-				// string 'null' or 'undefined'. Just delete instead.
-				delete process.env.DEBUG;
+			try {
+				if (namespaces) {
+					exports.storage.setItem('debug', namespaces);
+				} else {
+					exports.storage.removeItem('debug');
+				}
+			} catch (error) {
+				// Swallow
+				// XXX (@Qix-) should we be logging these?
 			}
 		}
 
@@ -14053,24 +14796,42 @@ function requireNode () {
 		 * @return {String} returns the previously persisted debug modes
 		 * @api private
 		 */
-
 		function load() {
-			return process.env.DEBUG;
+			let r;
+			try {
+				r = exports.storage.getItem('debug');
+			} catch (error) {
+				// Swallow
+				// XXX (@Qix-) should we be logging these?
+			}
+
+			// If debug isn't set in LS, and we're in Electron, try to load $DEBUG
+			if (!r && typeof process !== 'undefined' && 'env' in process) {
+				r = process.env.DEBUG;
+			}
+
+			return r;
 		}
 
 		/**
-		 * Init logic for `debug` instances.
+		 * Localstorage attempts to return the localstorage.
 		 *
-		 * Create a new `inspectOpts` object in case `useColors` is set
-		 * differently for a particular `debug` instance.
+		 * This is necessary because safari throws
+		 * when a user disables cookies/localstorage
+		 * and you attempt to access it.
+		 *
+		 * @return {LocalStorage}
+		 * @api private
 		 */
 
-		function init(debug) {
-			debug.inspectOpts = {};
-
-			const keys = Object.keys(exports.inspectOpts);
-			for (let i = 0; i < keys.length; i++) {
-				debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
+		function localstorage() {
+			try {
+				// TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context
+				// The Browser also has localStorage in the global context.
+				return localStorage;
+			} catch (error) {
+				// Swallow
+				// XXX (@Qix-) should we be logging these?
 			}
 		}
 
@@ -14079,27 +14840,18 @@ function requireNode () {
 		const {formatters} = module.exports;
 
 		/**
-		 * Map %o to `util.inspect()`, all on a single line.
-		 */
-
-		formatters.o = function (v) {
-			this.inspectOpts.colors = this.useColors;
-			return util.inspect(v, this.inspectOpts)
-				.split('\n')
-				.map(str => str.trim())
-				.join(' ');
-		};
-
-		/**
-		 * Map %O to `util.inspect()`, allowing multiple lines if needed.
+		 * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
 		 */
 
-		formatters.O = function (v) {
-			this.inspectOpts.colors = this.useColors;
-			return util.inspect(v, this.inspectOpts);
+		formatters.j = function (v) {
+			try {
+				return JSON.stringify(v);
+			} catch (error) {
+				return '[UnexpectedJSONParseError]: ' + error.message;
+			}
 		}; 
-	} (node, node.exports));
-	return node.exports;
+	} (browser, browser.exports));
+	return browser.exports;
 }
 
 /**
@@ -14307,6 +15059,13 @@ var __async = (__this, __arguments, generator) => {
     step((generator = generator.apply(__this, __arguments)).next());
   });
 };
+
+// src/lib/args/pathspec.ts
+function pathspec(...paths) {
+  const key = new String(paths);
+  cache.set(key, paths);
+  return key;
+}
 function isPathSpec(path) {
   return path instanceof String && cache.has(path);
 }
@@ -16109,7 +16868,7 @@ function parseLogOptions(opt = {}, customArgs = []) {
     suffix.push(`${opt.from || ""}${rangeOperator}${opt.to || ""}`);
   }
   if (filterString(opt.file)) {
-    suffix.push("--follow", opt.file);
+    command.push("--follow", pathspec(opt.file));
   }
   appendTaskOptions(userOptions(opt), command);
   return {
@@ -16146,6 +16905,7 @@ var excludeOptions;
 var init_log = __esm({
   "src/lib/tasks/log.ts"() {
     init_log_format();
+    init_pathspec();
     init_parse_list_log_summary();
     init_utils();
     init_task();
@@ -18243,6 +19003,7 @@ const NANO_TYPE_MAP = {
   nano: "nano",
   frontend: "frontend",
   extension: "extension",
+  widget: "widget",
   editor: "frontend",
   molecules: "frontend",
 };
@@ -18531,7 +19292,11 @@ const currentNodeVersion = async (debug) => {
   });
 
   if (!nodeVersionFileContent) {
-    return { error: "No file or content found in the .nvmrc file.", fix };
+    return {
+      error: "No file or content found in the .nvmrc file.",
+      status: STATUSES.FAIL,
+      fix,
+    };
   }
 
   const [major = 0, minor = 0, patch = 0] = getSemVer(nodeVersionFileContent);
@@ -18554,7 +19319,7 @@ const currentNodeVersion = async (debug) => {
 
 const ESLINT_DESTINATION_DIRECTORY = path$1.resolve("./");
 
-const NANOS_TO_OVERRIDE = ["nano", "extension"];
+const NANOS_TO_OVERRIDE$1 = ["nano", "extension", "widget"];
 
 const eslint = async (debug) => {
   const { type, repoName } = await getNanoType();
@@ -18565,7 +19330,7 @@ const eslint = async (debug) => {
     return { isSuccess: true, status: STATUSES.SKIPPED };
   }
 
-  const eslintCommonSource = NANOS_TO_OVERRIDE.includes(type) ? type : "common";
+  const eslintCommonSource = NANOS_TO_OVERRIDE$1.includes(type) ? type : "common";
 
   const eslintSourceDirectory = path$1.resolve(
     `./node_modules/@bigbinary/neeto-audit-frontend/common/eslint/${eslintCommonSource}`
@@ -18671,6 +19436,8 @@ const husky = async (debug) => {
 
 const PRETTIER_DESTINATION_PATH = path$1.resolve("./");
 
+const NANOS_TO_OVERRIDE = ["extension", "widget"];
+
 const prettier = async (debug) => {
   const { type, repoName } = await getNanoType();
 
@@ -18680,7 +19447,9 @@ const prettier = async (debug) => {
     return { isSuccess: true, status: STATUSES.SKIPPED };
   }
 
-  const prettierCommonSource = type === "extension" ? type : "common";
+  const prettierCommonSource = NANOS_TO_OVERRIDE.includes(type)
+    ? type
+    : "common";
 
   const prettierSourceDirectory = path$1.resolve(
     `./node_modules/@bigbinary/neeto-audit-frontend/common/prettier/${prettierCommonSource}`
@@ -18727,7 +19496,11 @@ const DEV_DEPENDENCIES$4 = {
   "@babel/runtime": "7.22.6",
   "@bigbinary/babel-preset-neeto": "1.0.3",
   "@bigbinary/eslint-plugin-neeto": "1.1.2",
-  "@bigbinary/neeto-audit-frontend": "1.0.7",
+  "@bigbinary/neeto-audit-frontend": "2.0.2",
+  "@bigbinary/neeto-cist": "1.0.0",
+  "@bigbinary/neeto-commons-frontend": "2.0.99",
+  "@bigbinary/neeto-icons": "1.13.0",
+  "@bigbinary/neetoui": "5.0.15",
   autoprefixer: "10.4.14",
   "babel-loader": "9.1.3",
   "babel-plugin-istanbul": "6.1.1",
@@ -18766,10 +19539,8 @@ var common = {
 };
 
 const DEPENDENCIES$3 = {
-  "@bigbinary/neeto-commons-frontend": "2.0.99",
-  "@bigbinary/neeto-icons": "1.13.0",
-  "@bigbinary/neetoui": "5.0.15",
-  "@honeybadger-io/react": "2.0.1",
+  "@honeybadger-io/js": "6.5.3",
+  "@honeybadger-io/react": "6.1.9",
   antd: "4.24.10",
   axios: "1.4.0",
   i18next: "23.2.11",
@@ -18797,13 +19568,11 @@ var extension = {
 const DEPENDENCIES$2 = {};
 
 const DEV_DEPENDENCIES$2 = {
-  "@bigbinary/neeto-commons-frontend": "2.0.99",
   "@bigbinary/neeto-filters-frontend": "2.12.1",
   "@bigbinary/neeto-molecules": "1.0.34",
-  "@bigbinary/neeto-icons": "1.13.0",
-  "@bigbinary/neetoui": "5.0.15",
   "@faker-js/faker": "8.0.2",
-  "@honeybadger-io/react": "2.0.1",
+  "@honeybadger-io/js": "6.5.3",
+  "@honeybadger-io/react": "6.1.9",
   "@rollup/plugin-alias": "5.0.0",
   "@rollup/plugin-babel": "6.0.3",
   "@rollup/plugin-commonjs": "25.0.3",
@@ -18844,7 +19613,8 @@ const PEER_DEPENDENCIES$2 = {
   "@bigbinary/neeto-icons": "^1.9.22",
   "@bigbinary/neeto-molecules": "^1.0.9",
   "@bigbinary/neetoui": "^5.0.4",
-  "@honeybadger-io/react": "^2.0.1",
+  "@honeybadger-io/js": "^6.5.3",
+  "@honeybadger-io/react": "^6.1.9",
   axios: "^0.27.2",
   classnames: "^2.3.2",
   formik: "^2.2.9",
@@ -18871,13 +19641,11 @@ var frontend = {
 const DEPENDENCIES$1 = {};
 
 const DEV_DEPENDENCIES$1 = {
-  "@bigbinary/neeto-commons-frontend": "2.0.99",
   "@bigbinary/neeto-filters-frontend": "2.12.1",
   "@bigbinary/neeto-molecules": "1.0.34",
-  "@bigbinary/neeto-icons": "1.13.0",
-  "@bigbinary/neetoui": "5.0.15",
   "@faker-js/faker": "8.0.2",
-  "@honeybadger-io/react": "2.0.1",
+  "@honeybadger-io/js": "6.5.3",
+  "@honeybadger-io/react": "6.1.9",
   "@rollup/plugin-alias": "5.0.0",
   "@rollup/plugin-babel": "6.0.3",
   "@rollup/plugin-commonjs": "25.0.3",
@@ -18918,7 +19686,8 @@ const PEER_DEPENDENCIES$1 = {
   "@bigbinary/neeto-icons": "^1.9.22",
   "@bigbinary/neeto-molecules": "^1.0.9",
   "@bigbinary/neetoui": "^5.0.4",
-  "@honeybadger-io/react": "^2.0.1",
+  "@honeybadger-io/js": "^6.5.3",
+  "@honeybadger-io/react": "^6.1.9",
   axios: "^0.27.2",
   classnames: "^2.3.2",
   formik: "^2.2.9",
@@ -18975,15 +19744,15 @@ const getOutdatedPackages = (recommendedVersions, packageJson) =>
       recommendedList
     );
 
-    const outdatedPackages = pickBy$1(not, packages);
+    const outdatedPackages = pickBy$1(not$1, packages);
 
     return { type, outdatedPackages: Object.keys(outdatedPackages) };
   });
 
 const sortByKey = (object) =>
-  map(
+  map$1(
     (value) =>
-      is$1(Object, value) && !Array.isArray(value)
+      is$2(Object, value) && !Array.isArray(value)
         ? fromPairs$1(toPairs$1(value).sort())
         : value,
     object
@@ -19009,6 +19778,10 @@ const recommendedPackageVersions = async (debug) => {
 
   const { type } = await getNanoType();
 
+  if (type === NANO_TYPE_MAP.widget) {
+    return { isSuccess: true, status: STATUSES.SKIPPED };
+  }
+
   const recommendedVersions = mergeDeepRight$1(
     recommendedDependencies["common"],
     recommendedDependencies[type]