@donmahallem/lerna2codecov 0.1.8 → 0.1.9

package/dist/esm/index.js

@@ -759,7 +759,7 @@ const naiveLength = () => 1;
 //
 // cache is a Map (or PseudoMap) that matches the keys to
 // the Yallist.Node object.
-class LRUCache {
+class LRUCache$1 {
   constructor (options) {
     if (typeof options === 'number')
       options = { max: options };
@@ -1066,12 +1066,12 @@ const forEachStep = (self, fn, node, thisp) => {
     fn.call(thisp, hit.value, hit.key, self);
 };
 
-var lruCache = LRUCache;
+var lruCache$1 = LRUCache$1;
 
 const url$1 = require$$0$1;
 const gitHosts = gitHostInfo;
 const GitHost = hostedGitInfo.exports = gitHost;
-const LRU$1 = lruCache;
+const LRU$1 = lruCache$1;
 const cache$1 = new LRU$1({ max: 1000 });
 
 const protocolToRepresentationMap = {
@@ -1313,7 +1313,7 @@ const SEMVER_SPEC_VERSION = '2.0.0';
 
 const MAX_LENGTH$2 = 256;
 const MAX_SAFE_INTEGER$1 = Number.MAX_SAFE_INTEGER ||
-  /* istanbul ignore next */ 9007199254740991;
+/* istanbul ignore next */ 9007199254740991;
 
 // Max safe segment length for coercion.
 const MAX_SAFE_COMPONENT_LENGTH = 16;
@@ -1322,7 +1322,7 @@ var constants$1 = {
   SEMVER_SPEC_VERSION,
   MAX_LENGTH: MAX_LENGTH$2,
   MAX_SAFE_INTEGER: MAX_SAFE_INTEGER$1,
-  MAX_SAFE_COMPONENT_LENGTH
+  MAX_SAFE_COMPONENT_LENGTH,
 };
 
 const debug$4 = (
@@ -1348,7 +1348,7 @@ let R = 0;
 
 const createToken = (name, value, isGlobal) => {
   const index = R++;
-  debug(index, value);
+  debug(name, index, value);
   t[name] = index;
   src[index] = value;
   re[index] = new RegExp(value, isGlobal ? 'g' : undefined);
@@ -1516,8 +1516,8 @@ createToken('HYPHENRANGELOOSE', `^\\s*(${src[t.XRANGEPLAINLOOSE]})` +
 // Star ranges basically just allow anything at all.
 createToken('STAR', '(<|>)?=?\\s*\\*');
 // >=0.0.0 is like a star
-createToken('GTE0', '^\\s*>=\\s*0\.0\.0\\s*$');
-createToken('GTE0PRE', '^\\s*>=\\s*0\.0\.0-0\\s*$');
+createToken('GTE0', '^\\s*>=\\s*0\\.0\\.0\\s*$');
+createToken('GTE0PRE', '^\\s*>=\\s*0\\.0\\.0-0\\s*$');
 }(re$5, re$5.exports));
 
 // parse out just the options we care about so we always get a consistent
@@ -1526,9 +1526,9 @@ const opts = ['includePrerelease', 'loose', 'rtl'];
 const parseOptions$4 = options =>
   !options ? {}
   : typeof options !== 'object' ? { loose: true }
-  : opts.filter(k => options[k]).reduce((options, k) => {
-    options[k] = true;
-    return options
+  : opts.filter(k => options[k]).reduce((o, k) => {
+    o[k] = true;
+    return o
   }, {});
 var parseOptions_1 = parseOptions$4;
 
@@ -1553,7 +1553,7 @@ const rcompareIdentifiers = (a, b) => compareIdentifiers$1(b, a);
 
 var identifiers = {
   compareIdentifiers: compareIdentifiers$1,
-  rcompareIdentifiers
+  rcompareIdentifiers,
 };
 
 const debug$3 = debug_1;
@@ -1844,7 +1844,7 @@ class SemVer$e {
 
 var semver$4 = SemVer$e;
 
-const {MAX_LENGTH} = constants$1;
+const { MAX_LENGTH } = constants$1;
 const { re: re$3, t: t$3 } = re$5.exports;
 const SemVer$d = semver$4;
 
@@ -2015,17 +2015,21 @@ const lte$1 = lte_1;
 const cmp$1 = (a, op, b, loose) => {
   switch (op) {
     case '===':
-      if (typeof a === 'object')
+      if (typeof a === 'object') {
         a = a.version;
-      if (typeof b === 'object')
+      }
+      if (typeof b === 'object') {
         b = b.version;
+      }
       return a === b
 
     case '!==':
-      if (typeof a === 'object')
+      if (typeof a === 'object') {
         a = a.version;
-      if (typeof b === 'object')
+      }
+      if (typeof b === 'object') {
         b = b.version;
+      }
       return a !== b
 
     case '':
@@ -2056,7 +2060,7 @@ var cmp_1 = cmp$1;
 
 const SemVer$6 = semver$4;
 const parse$1 = parse_1;
-const {re: re$2, t: t$2} = re$5.exports;
+const { re: re$2, t: t$2 } = re$5.exports;
 
 const coerce = (version, options) => {
   if (version instanceof SemVer$6) {
@@ -2099,13 +2103,838 @@ const coerce = (version, options) => {
     re$2[t$2.COERCERTL].lastIndex = -1;
   }
 
-  if (match === null)
+  if (match === null) {
     return null
+  }
 
   return parse$1(`${match[2]}.${match[3] || '0'}.${match[4] || '0'}`, options)
 };
 var coerce_1 = coerce;
 
+const perf = typeof performance === 'object' && performance &&
+  typeof performance.now === 'function' ? performance : Date;
+
+const hasAbortController = typeof AbortController !== 'undefined';
+
+// minimal backwards-compatibility polyfill
+const AC = hasAbortController ? AbortController : Object.assign(
+  class AbortController {
+    constructor () { this.signal = new AC.AbortSignal; }
+    abort () { this.signal.aborted = true; }
+  },
+  { AbortSignal: class AbortSignal { constructor () { this.aborted = false; }}}
+);
+
+const warned = new Set();
+const deprecatedOption = (opt, instead) => {
+  const code = `LRU_CACHE_OPTION_${opt}`;
+  if (shouldWarn(code)) {
+    warn(code, `${opt} option`, `options.${instead}`, LRUCache);
+  }
+};
+const deprecatedMethod = (method, instead) => {
+  const code = `LRU_CACHE_METHOD_${method}`;
+  if (shouldWarn(code)) {
+    const { prototype } = LRUCache;
+    const { get } = Object.getOwnPropertyDescriptor(prototype, method);
+    warn(code, `${method} method`, `cache.${instead}()`, get);
+  }
+};
+const deprecatedProperty = (field, instead) => {
+  const code = `LRU_CACHE_PROPERTY_${field}`;
+  if (shouldWarn(code)) {
+    const { prototype } = LRUCache;
+    const { get } = Object.getOwnPropertyDescriptor(prototype, field);
+    warn(code, `${field} property`, `cache.${instead}`, get);
+  }
+};
+
+const emitWarning = (...a) => {
+  typeof process === 'object' &&
+    process &&
+    typeof process.emitWarning === 'function'
+  ? process.emitWarning(...a)
+  : console.error(...a);
+};
+
+const shouldWarn = code => !warned.has(code);
+
+const warn = (code, what, instead, fn) => {
+  warned.add(code);
+  const msg = `The ${what} is deprecated. Please use ${instead} instead.`;
+  emitWarning(msg, 'DeprecationWarning', code, fn);
+};
+
+const isPosInt = n => n && n === Math.floor(n) && n > 0 && isFinite(n);
+
+/* istanbul ignore next - This is a little bit ridiculous, tbh.
+ * The maximum array length is 2^32-1 or thereabouts on most JS impls.
+ * And well before that point, you're caching the entire world, I mean,
+ * that's ~32GB of just integers for the next/prev links, plus whatever
+ * else to hold that many keys and values.  Just filling the memory with
+ * zeroes at init time is brutal when you get that big.
+ * But why not be complete?
+ * Maybe in the future, these limits will have expanded. */
+const getUintArray = max => !isPosInt(max) ? null
+: max <= Math.pow(2, 8) ? Uint8Array
+: max <= Math.pow(2, 16) ? Uint16Array
+: max <= Math.pow(2, 32) ? Uint32Array
+: max <= Number.MAX_SAFE_INTEGER ? ZeroArray
+: null;
+
+class ZeroArray extends Array {
+  constructor (size) {
+    super(size);
+    this.fill(0);
+  }
+}
+
+class Stack {
+  constructor (max) {
+    if (max === 0) {
+      return []
+    }
+    const UintArray = getUintArray(max);
+    this.heap = new UintArray(max);
+    this.length = 0;
+  }
+  push (n) {
+    this.heap[this.length++] = n;
+  }
+  pop () {
+    return this.heap[--this.length]
+  }
+}
+
+class LRUCache {
+  constructor (options = {}) {
+    const {
+      max = 0,
+      ttl,
+      ttlResolution = 1,
+      ttlAutopurge,
+      updateAgeOnGet,
+      updateAgeOnHas,
+      allowStale,
+      dispose,
+      disposeAfter,
+      noDisposeOnSet,
+      noUpdateTTL,
+      maxSize = 0,
+      sizeCalculation,
+      fetchMethod,
+    } = options;
+
+    // deprecated options, don't trigger a warning for getting them if
+    // the thing being passed in is another LRUCache we're copying.
+    const {
+      length,
+      maxAge,
+      stale,
+    } = options instanceof LRUCache ? {} : options;
+
+    if (max !== 0 && !isPosInt(max)) {
+      throw new TypeError('max option must be a nonnegative integer')
+    }
+
+    const UintArray = max ? getUintArray(max) : Array;
+    if (!UintArray) {
+      throw new Error('invalid max value: ' + max)
+    }
+
+    this.max = max;
+    this.maxSize = maxSize;
+    this.sizeCalculation = sizeCalculation || length;
+    if (this.sizeCalculation) {
+      if (!this.maxSize) {
+        throw new TypeError('cannot set sizeCalculation without setting maxSize')
+      }
+      if (typeof this.sizeCalculation !== 'function') {
+        throw new TypeError('sizeCalculation set to non-function')
+      }
+    }
+
+    this.fetchMethod = fetchMethod || null;
+    if (this.fetchMethod && typeof this.fetchMethod !== 'function') {
+      throw new TypeError('fetchMethod must be a function if specified')
+    }
+
+    this.keyMap = new Map();
+    this.keyList = new Array(max).fill(null);
+    this.valList = new Array(max).fill(null);
+    this.next = new UintArray(max);
+    this.prev = new UintArray(max);
+    this.head = 0;
+    this.tail = 0;
+    this.free = new Stack(max);
+    this.initialFill = 1;
+    this.size = 0;
+
+    if (typeof dispose === 'function') {
+      this.dispose = dispose;
+    }
+    if (typeof disposeAfter === 'function') {
+      this.disposeAfter = disposeAfter;
+      this.disposed = [];
+    } else {
+      this.disposeAfter = null;
+      this.disposed = null;
+    }
+    this.noDisposeOnSet = !!noDisposeOnSet;
+    this.noUpdateTTL = !!noUpdateTTL;
+
+    if (this.maxSize !== 0) {
+      if (!isPosInt(this.maxSize)) {
+        throw new TypeError('maxSize must be a positive integer if specified')
+      }
+      this.initializeSizeTracking();
+    }
+
+    this.allowStale = !!allowStale || !!stale;
+    this.updateAgeOnGet = !!updateAgeOnGet;
+    this.updateAgeOnHas = !!updateAgeOnHas;
+    this.ttlResolution = isPosInt(ttlResolution) || ttlResolution === 0
+      ? ttlResolution : 1;
+    this.ttlAutopurge = !!ttlAutopurge;
+    this.ttl = ttl || maxAge || 0;
+    if (this.ttl) {
+      if (!isPosInt(this.ttl)) {
+        throw new TypeError('ttl must be a positive integer if specified')
+      }
+      this.initializeTTLTracking();
+    }
+
+    // do not allow completely unbounded caches
+    if (this.max === 0 && this.ttl === 0 && this.maxSize === 0) {
+      throw new TypeError('At least one of max, maxSize, or ttl is required')
+    }
+    if (!this.ttlAutopurge && !this.max && !this.maxSize) {
+      const code = 'LRU_CACHE_UNBOUNDED';
+      if (shouldWarn(code)) {
+        warned.add(code);
+        const msg = 'TTL caching without ttlAutopurge, max, or maxSize can ' +
+          'result in unbounded memory consumption.';
+        emitWarning(msg, 'UnboundedCacheWarning', code, LRUCache);
+      }
+    }
+
+    if (stale) {
+      deprecatedOption('stale', 'allowStale');
+    }
+    if (maxAge) {
+      deprecatedOption('maxAge', 'ttl');
+    }
+    if (length) {
+      deprecatedOption('length', 'sizeCalculation');
+    }
+  }
+
+  getRemainingTTL (key) {
+    return this.has(key, { updateAgeOnHas: false }) ? Infinity : 0
+  }
+
+  initializeTTLTracking () {
+    this.ttls = new ZeroArray(this.max);
+    this.starts = new ZeroArray(this.max);
+
+    this.setItemTTL = (index, ttl) => {
+      this.starts[index] = ttl !== 0 ? perf.now() : 0;
+      this.ttls[index] = ttl;
+      if (ttl !== 0 && this.ttlAutopurge) {
+        const t = setTimeout(() => {
+          if (this.isStale(index)) {
+            this.delete(this.keyList[index]);
+          }
+        }, ttl + 1);
+        /* istanbul ignore else - unref() not supported on all platforms */
+        if (t.unref) {
+          t.unref();
+        }
+      }
+    };
+
+    this.updateItemAge = (index) => {
+      this.starts[index] = this.ttls[index] !== 0 ? perf.now() : 0;
+    };
+
+    // debounce calls to perf.now() to 1s so we're not hitting
+    // that costly call repeatedly.
+    let cachedNow = 0;
+    const getNow = () => {
+      const n = perf.now();
+      if (this.ttlResolution > 0) {
+        cachedNow = n;
+        const t = setTimeout(() => cachedNow = 0, this.ttlResolution);
+        /* istanbul ignore else - not available on all platforms */
+        if (t.unref) {
+          t.unref();
+        }
+      }
+      return n
+    };
+
+    this.getRemainingTTL = (key) => {
+      const index = this.keyMap.get(key);
+      if (index === undefined) {
+        return 0
+      }
+      return this.ttls[index] === 0 || this.starts[index] === 0 ? Infinity
+        : ((this.starts[index] + this.ttls[index]) - (cachedNow || getNow()))
+    };
+
+    this.isStale = (index) => {
+      return this.ttls[index] !== 0 && this.starts[index] !== 0 &&
+        ((cachedNow || getNow()) - this.starts[index] > this.ttls[index])
+    };
+  }
+  updateItemAge (index) {}
+  setItemTTL (index, ttl) {}
+  isStale (index) { return false }
+
+  initializeSizeTracking () {
+    this.calculatedSize = 0;
+    this.sizes = new ZeroArray(this.max);
+    this.removeItemSize = index => this.calculatedSize -= this.sizes[index];
+    this.requireSize = (k, v, size, sizeCalculation) => {
+      if (!isPosInt(size)) {
+        if (sizeCalculation) {
+          if (typeof sizeCalculation !== 'function') {
+            throw new TypeError('sizeCalculation must be a function')
+          }
+          size = sizeCalculation(v, k);
+          if (!isPosInt(size)) {
+            throw new TypeError('sizeCalculation return invalid (expect positive integer)')
+          }
+        } else {
+          throw new TypeError('invalid size value (must be positive integer)')
+        }
+      }
+      return size
+    };
+    this.addItemSize = (index, v, k, size) => {
+      this.sizes[index] = size;
+      const maxSize = this.maxSize - this.sizes[index];
+      while (this.calculatedSize > maxSize) {
+        this.evict(true);
+      }
+      this.calculatedSize += this.sizes[index];
+    };
+    this.delete = k => {
+      if (this.size !== 0) {
+        const index = this.keyMap.get(k);
+        if (index !== undefined) {
+          this.calculatedSize -= this.sizes[index];
+        }
+      }
+      return LRUCache.prototype.delete.call(this, k)
+    };
+  }
+  removeItemSize (index) {}
+  addItemSize (index, v, k, size) {}
+  requireSize (k, v, size, sizeCalculation) {
+    if (size || sizeCalculation) {
+      throw new TypeError('cannot set size without setting maxSize on cache')
+    }
+  }
+
+  *indexes ({ allowStale = this.allowStale } = {}) {
+    if (this.size) {
+      for (let i = this.tail; true; ) {
+        if (!this.isValidIndex(i)) {
+          break
+        }
+        if (allowStale || !this.isStale(i)) {
+          yield i;
+        }
+        if (i === this.head) {
+          break
+        } else {
+          i = this.prev[i];
+        }
+      }
+    }
+  }
+
+  *rindexes ({ allowStale = this.allowStale } = {}) {
+    if (this.size) {
+      for (let i = this.head; true; ) {
+        if (!this.isValidIndex(i)) {
+          break
+        }
+        if (allowStale || !this.isStale(i)) {
+          yield i;
+        }
+        if (i === this.tail) {
+          break
+        } else {
+          i = this.next[i];
+        }
+      }
+    }
+  }
+
+  isValidIndex (index) {
+    return this.keyMap.get(this.keyList[index]) === index
+  }
+
+  *entries () {
+    for (const i of this.indexes()) {
+      yield [this.keyList[i], this.valList[i]];
+    }
+  }
+  *rentries () {
+    for (const i of this.rindexes()) {
+      yield [this.keyList[i], this.valList[i]];
+    }
+  }
+
+  *keys () {
+    for (const i of this.indexes()) {
+      yield this.keyList[i];
+    }
+  }
+  *rkeys () {
+    for (const i of this.rindexes()) {
+      yield this.keyList[i];
+    }
+  }
+
+  *values () {
+    for (const i of this.indexes()) {
+      yield this.valList[i];
+    }
+  }
+  *rvalues () {
+    for (const i of this.rindexes()) {
+      yield this.valList[i];
+    }
+  }
+
+  [Symbol.iterator] () {
+    return this.entries()
+  }
+
+  find (fn, getOptions = {}) {
+    for (const i of this.indexes()) {
+      if (fn(this.valList[i], this.keyList[i], this)) {
+        return this.get(this.keyList[i], getOptions)
+      }
+    }
+  }
+
+  forEach (fn, thisp = this) {
+    for (const i of this.indexes()) {
+      fn.call(thisp, this.valList[i], this.keyList[i], this);
+    }
+  }
+
+  rforEach (fn, thisp = this) {
+    for (const i of this.rindexes()) {
+      fn.call(thisp, this.valList[i], this.keyList[i], this);
+    }
+  }
+
+  get prune () {
+    deprecatedMethod('prune', 'purgeStale');
+    return this.purgeStale
+  }
+
+  purgeStale () {
+    let deleted = false;
+    for (const i of this.rindexes({ allowStale: true })) {
+      if (this.isStale(i)) {
+        this.delete(this.keyList[i]);
+        deleted = true;
+      }
+    }
+    return deleted
+  }
+
+  dump () {
+    const arr = [];
+    for (const i of this.indexes()) {
+      const key = this.keyList[i];
+      const value = this.valList[i];
+      const entry = { value };
+      if (this.ttls) {
+        entry.ttl = this.ttls[i];
+      }
+      if (this.sizes) {
+        entry.size = this.sizes[i];
+      }
+      arr.unshift([key, entry]);
+    }
+    return arr
+  }
+
+  load (arr) {
+    this.clear();
+    for (const [key, entry] of arr) {
+      this.set(key, entry.value, entry);
+    }
+  }
+
+  dispose (v, k, reason) {}
+
+  set (k, v, {
+    ttl = this.ttl,
+    noDisposeOnSet = this.noDisposeOnSet,
+    size = 0,
+    sizeCalculation = this.sizeCalculation,
+    noUpdateTTL = this.noUpdateTTL,
+  } = {}) {
+    size = this.requireSize(k, v, size, sizeCalculation);
+    let index = this.size === 0 ? undefined : this.keyMap.get(k);
+    if (index === undefined) {
+      // addition
+      index = this.newIndex();
+      this.keyList[index] = k;
+      this.valList[index] = v;
+      this.keyMap.set(k, index);
+      this.next[this.tail] = index;
+      this.prev[index] = this.tail;
+      this.tail = index;
+      this.size ++;
+      this.addItemSize(index, v, k, size);
+      noUpdateTTL = false;
+    } else {
+      // update
+      const oldVal = this.valList[index];
+      if (v !== oldVal) {
+        if (this.isBackgroundFetch(oldVal)) {
+          oldVal.__abortController.abort();
+        } else {
+          if (!noDisposeOnSet) {
+            this.dispose(oldVal, k, 'set');
+            if (this.disposeAfter) {
+              this.disposed.push([oldVal, k, 'set']);
+            }
+          }
+        }
+        this.removeItemSize(index);
+        this.valList[index] = v;
+        this.addItemSize(index, v, k, size);
+      }
+      this.moveToTail(index);
+    }
+    if (ttl !== 0 && this.ttl === 0 && !this.ttls) {
+      this.initializeTTLTracking();
+    }
+    if (!noUpdateTTL) {
+      this.setItemTTL(index, ttl);
+    }
+    if (this.disposeAfter) {
+      while (this.disposed.length) {
+        this.disposeAfter(...this.disposed.shift());
+      }
+    }
+    return this
+  }
+
+  newIndex () {
+    if (this.size === 0) {
+      return this.tail
+    }
+    if (this.size === this.max && this.max !== 0) {
+      return this.evict(false)
+    }
+    if (this.free.length !== 0) {
+      return this.free.pop()
+    }
+    // initial fill, just keep writing down the list
+    return this.initialFill++
+  }
+
+  pop () {
+    if (this.size) {
+      const val = this.valList[this.head];
+      this.evict(true);
+      return val
+    }
+  }
+
+  evict (free) {
+    const head = this.head;
+    const k = this.keyList[head];
+    const v = this.valList[head];
+    if (this.isBackgroundFetch(v)) {
+      v.__abortController.abort();
+    } else {
+      this.dispose(v, k, 'evict');
+      if (this.disposeAfter) {
+        this.disposed.push([v, k, 'evict']);
+      }
+    }
+    this.removeItemSize(head);
+    // if we aren't about to use the index, then null these out
+    if (free) {
+      this.keyList[head] = null;
+      this.valList[head] = null;
+      this.free.push(head);
+    }
+    this.head = this.next[head];
+    this.keyMap.delete(k);
+    this.size --;
+    return head
+  }
+
+  has (k, { updateAgeOnHas = this.updateAgeOnHas } = {}) {
+    const index = this.keyMap.get(k);
+    if (index !== undefined) {
+      if (!this.isStale(index)) {
+        if (updateAgeOnHas) {
+          this.updateItemAge(index);
+        }
+        return true
+      }
+    }
+    return false
+  }
+
+  // like get(), but without any LRU updating or TTL expiration
+  peek (k, { allowStale = this.allowStale } = {}) {
+    const index = this.keyMap.get(k);
+    if (index !== undefined && (allowStale || !this.isStale(index))) {
+      return this.valList[index]
+    }
+  }
+
+  backgroundFetch (k, index, options) {
+    const v = index === undefined ? undefined : this.valList[index];
+    if (this.isBackgroundFetch(v)) {
+      return v
+    }
+    const ac = new AC();
+    const fetchOpts = {
+      signal: ac.signal,
+      options,
+    };
+    const p = Promise.resolve(this.fetchMethod(k, v, fetchOpts)).then(v => {
+      if (!ac.signal.aborted) {
+        this.set(k, v, fetchOpts.options);
+      }
+      return v
+    });
+    p.__abortController = ac;
+    p.__staleWhileFetching = v;
+    if (index === undefined) {
+      this.set(k, p, fetchOpts.options);
+      index = this.keyMap.get(k);
+    } else {
+      this.valList[index] = p;
+    }
+    return p
+  }
+
+  isBackgroundFetch (p) {
+    return p && typeof p === 'object' && typeof p.then === 'function' &&
+      Object.prototype.hasOwnProperty.call(p, '__staleWhileFetching')
+  }
+
+  // this takes the union of get() and set() opts, because it does both
+  async fetch (k, {
+    allowStale = this.allowStale,
+    updateAgeOnGet = this.updateAgeOnGet,
+    ttl = this.ttl,
+    noDisposeOnSet = this.noDisposeOnSet,
+    size = 0,
+    sizeCalculation = this.sizeCalculation,
+    noUpdateTTL = this.noUpdateTTL,
+  } = {}) {
+    if (!this.fetchMethod) {
+      return this.get(k, {allowStale, updateAgeOnGet})
+    }
+
+    const options = {
+      allowStale,
+      updateAgeOnGet,
+      ttl,
+      noDisposeOnSet,
+      size,
+      sizeCalculation,
+      noUpdateTTL,
+    };
+
+    let index = this.keyMap.get(k);
+    if (index === undefined) {
+      return this.backgroundFetch(k, index, options)
+    } else {
+      // in cache, maybe already fetching
+      const v = this.valList[index];
+      if (this.isBackgroundFetch(v)) {
+        return allowStale && v.__staleWhileFetching !== undefined
+          ? v.__staleWhileFetching : v
+      }
+
+      if (!this.isStale(index)) {
+        this.moveToTail(index);
+        if (updateAgeOnGet) {
+          this.updateItemAge(index);
+        }
+        return v
+      }
+
+      // ok, it is stale, and not already fetching
+      // refresh the cache.
+      const p = this.backgroundFetch(k, index, options);
+      return allowStale && p.__staleWhileFetching !== undefined
+        ? p.__staleWhileFetching : p
+    }
+  }
+
+  get (k, {
+    allowStale = this.allowStale,
+    updateAgeOnGet = this.updateAgeOnGet,
+  } = {}) {
+    const index = this.keyMap.get(k);
+    if (index !== undefined) {
+      const value = this.valList[index];
+      const fetching = this.isBackgroundFetch(value);
+      if (this.isStale(index)) {
+        // delete only if not an in-flight background fetch
+        if (!fetching) {
+          this.delete(k);
+          return allowStale ? value : undefined
+        } else {
+          return allowStale ? value.__staleWhileFetching : undefined
+        }
+      } else {
+        // if we're currently fetching it, we don't actually have it yet
+        // it's not stale, which means this isn't a staleWhileRefetching,
+        // so we just return undefined
+        if (fetching) {
+          return undefined
+        }
+        this.moveToTail(index);
+        if (updateAgeOnGet) {
+          this.updateItemAge(index);
+        }
+        return value
+      }
+    }
+  }
+
+  connect (p, n) {
+    this.prev[n] = p;
+    this.next[p] = n;
+  }
+
+  moveToTail (index) {
+    // if tail already, nothing to do
+    // if head, move head to next[index]
+    // else
+    //   move next[prev[index]] to next[index] (head has no prev)
+    //   move prev[next[index]] to prev[index]
+    // prev[index] = tail
+    // next[tail] = index
+    // tail = index
+    if (index !== this.tail) {
+      if (index === this.head) {
+        this.head = this.next[index];
+      } else {
+        this.connect(this.prev[index], this.next[index]);
+      }
+      this.connect(this.tail, index);
+      this.tail = index;
+    }
+  }
+
+  get del () {
+    deprecatedMethod('del', 'delete');
+    return this.delete
+  }
+  delete (k) {
+    let deleted = false;
+    if (this.size !== 0) {
+      const index = this.keyMap.get(k);
+      if (index !== undefined) {
+        deleted = true;
+        if (this.size === 1) {
+          this.clear();
+        } else {
+          this.removeItemSize(index);
+          const v = this.valList[index];
+          if (this.isBackgroundFetch(v)) {
+            v.__abortController.abort();
+          } else {
+            this.dispose(v, k, 'delete');
+            if (this.disposeAfter) {
+              this.disposed.push([v, k, 'delete']);
+            }
+          }
+          this.keyMap.delete(k);
+          this.keyList[index] = null;
+          this.valList[index] = null;
+          if (index === this.tail) {
+            this.tail = this.prev[index];
+          } else if (index === this.head) {
+            this.head = this.next[index];
+          } else {
+            this.next[this.prev[index]] = this.next[index];
+            this.prev[this.next[index]] = this.prev[index];
+          }
+          this.size --;
+          this.free.push(index);
+        }
+      }
+    }
+    if (this.disposed) {
+      while (this.disposed.length) {
+        this.disposeAfter(...this.disposed.shift());
+      }
+    }
+    return deleted
+  }
+
+  clear () {
+    for (const index of this.rindexes({ allowStale: true })) {
+      const v = this.valList[index];
+      if (this.isBackgroundFetch(v)) {
+        v.__abortController.abort();
+      } else {
+        const k = this.keyList[index];
+        this.dispose(v, k, 'delete');
+        if (this.disposeAfter) {
+          this.disposed.push([v, k, 'delete']);
+        }
+      }
+    }
+
+    this.keyMap.clear();
+    this.valList.fill(null);
+    this.keyList.fill(null);
+    if (this.ttls) {
+      this.ttls.fill(0);
+      this.starts.fill(0);
+    }
+    if (this.sizes) {
+      this.sizes.fill(0);
+    }
+    this.head = 0;
+    this.tail = 0;
+    this.initialFill = 1;
+    this.free.length = 0;
+    this.calculatedSize = 0;
+    this.size = 0;
+    if (this.disposed) {
+      while (this.disposed.length) {
+        this.disposeAfter(...this.disposed.shift());
+      }
+    }
+  }
+  get reset () {
+    deprecatedMethod('reset', 'clear');
+    return this.clear
+  }
+
+  get length () {
+    deprecatedProperty('length', 'size');
+    return this.size
+  }
+}
+
+var lruCache = LRUCache;
+
 // hoisted class for cyclic dependency
 class Range$a {
   constructor (range, options) {
@@ -2137,9 +2966,9 @@ class Range$a {
     // First, split based on boolean or ||
     this.raw = range;
     this.set = range
-      .split(/\s*\|\|\s*/)
+      .split('||')
       // map the range to a 2d array of comparators
-      .map(range => this.parseRange(range.trim()))
+      .map(r => this.parseRange(r.trim()))
       // throw out any comparator lists that are empty
       // this generally means that it was not a valid range, which is allowed
       // in loose mode, but will still throw if the WHOLE range is invalid.
@@ -2154,9 +2983,9 @@ class Range$a {
       // keep the first one, in case they're all null sets
       const first = this.set[0];
       this.set = this.set.filter(c => !isNullSet(c[0]));
-      if (this.set.length === 0)
+      if (this.set.length === 0) {
         this.set = [first];
-      else if (this.set.length > 1) {
+      } else if (this.set.length > 1) {
         // if we have any that are *, then the range is just *
         for (const c of this.set) {
           if (c.length === 1 && isAny(c[0])) {
@@ -2192,8 +3021,9 @@ class Range$a {
     const memoOpts = Object.keys(this.options).join(',');
     const memoKey = `parseRange:${memoOpts}:${range}`;
     const cached = cache.get(memoKey);
-    if (cached)
+    if (cached) {
       return cached
+    }
 
     const loose = this.options.loose;
     // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`
@@ -2202,7 +3032,7 @@ class Range$a {
     debug$2('hyphen replace', range);
     // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`
     range = range.replace(re$1[t$1.COMPARATORTRIM], comparatorTrimReplace);
-    debug$2('comparator trim', range, re$1[t$1.COMPARATORTRIM]);
+    debug$2('comparator trim', range);
 
     // `~ 1.2.3` => `~1.2.3`
     range = range.replace(re$1[t$1.TILDETRIM], tildeTrimReplace);
@@ -2216,30 +3046,37 @@ class Range$a {
     // At this point, the range is completely trimmed and
     // ready to be split into comparators.
 
-    const compRe = loose ? re$1[t$1.COMPARATORLOOSE] : re$1[t$1.COMPARATOR];
-    const rangeList = range
+    let rangeList = range
       .split(' ')
       .map(comp => parseComparator(comp, this.options))
       .join(' ')
       .split(/\s+/)
       // >=0.0.0 is equivalent to *
-      .map(comp => replaceGTE0(comp, this.options))
+      .map(comp => replaceGTE0(comp, this.options));
+
+    if (loose) {
       // in loose mode, throw out any that are not valid comparators
-      .filter(this.options.loose ? comp => !!comp.match(compRe) : () => true)
-      .map(comp => new Comparator$3(comp, this.options));
+      rangeList = rangeList.filter(comp => {
+        debug$2('loose invalid filter', comp, this.options);
+        return !!comp.match(re$1[t$1.COMPARATORLOOSE])
+      });
+    }
+    debug$2('range list', rangeList);
 
     // if any comparators are the null set, then replace with JUST null set
     // if more than one comparator, remove any * comparators
     // also, don't include the same comparator more than once
-    rangeList.length;
     const rangeMap = new Map();
-    for (const comp of rangeList) {
-      if (isNullSet(comp))
+    const comparators = rangeList.map(comp => new Comparator$3(comp, this.options));
+    for (const comp of comparators) {
+      if (isNullSet(comp)) {
         return [comp]
+      }
       rangeMap.set(comp.value, comp);
     }
-    if (rangeMap.size > 1 && rangeMap.has(''))
+    if (rangeMap.size > 1 && rangeMap.has('')) {
       rangeMap.delete('');
+    }
 
     const result = [...rangeMap.values()];
     cache.set(memoKey, result);
@@ -2304,7 +3141,7 @@ const {
   t: t$1,
   comparatorTrimReplace,
   tildeTrimReplace,
-  caretTrimReplace
+  caretTrimReplace,
 } = re$5.exports;
 
 const isNullSet = c => c.value === '<0.0.0-0';
@@ -2353,8 +3190,8 @@ const isX = id => !id || id.toLowerCase() === 'x' || id === '*';
 // ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0-0
 // ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0-0
 const replaceTildes = (comp, options) =>
-  comp.trim().split(/\s+/).map((comp) => {
-    return replaceTilde(comp, options)
+  comp.trim().split(/\s+/).map((c) => {
+    return replaceTilde(c, options)
   }).join(' ');
 
 const replaceTilde = (comp, options) => {
@@ -2392,8 +3229,8 @@ const replaceTilde = (comp, options) => {
 // ^1.2.3 --> >=1.2.3 <2.0.0-0
 // ^1.2.0 --> >=1.2.0 <2.0.0-0
 const replaceCarets = (comp, options) =>
-  comp.trim().split(/\s+/).map((comp) => {
-    return replaceCaret(comp, options)
+  comp.trim().split(/\s+/).map((c) => {
+    return replaceCaret(c, options)
   }).join(' ');
 
 const replaceCaret = (comp, options) => {
@@ -2451,8 +3288,8 @@ const replaceCaret = (comp, options) => {
 
 const replaceXRanges = (comp, options) => {
   debug$2('replaceXRanges', comp, options);
-  return comp.split(/\s+/).map((comp) => {
-    return replaceXRange(comp, options)
+  return comp.split(/\s+/).map((c) => {
+    return replaceXRange(c, options)
   }).join(' ')
 };
 
@@ -2513,8 +3350,9 @@ const replaceXRange = (comp, options) => {
         }
       }
 
-      if (gtlt === '<')
+      if (gtlt === '<') {
         pr = '-0';
+      }
 
       ret = `${gtlt + M}.${m}.${p}${pr}`;
     } else if (xm) {
@@ -2623,6 +3461,7 @@ class Comparator$2 {
   static get ANY () {
     return ANY$2
   }
+
   constructor (comp, options) {
     options = parseOptions(options);
 
@@ -2699,7 +3538,7 @@ class Comparator$2 {
     if (!options || typeof options !== 'object') {
       options = {
         loose: !!options,
-        includePrerelease: false
+        includePrerelease: false,
       };
     }
 
@@ -2747,7 +3586,7 @@ class Comparator$2 {
 var comparator = Comparator$2;
 
 const parseOptions = parseOptions_1;
-const {re, t} = re$5.exports;
+const { re, t } = re$5.exports;
 const cmp = cmp_1;
 const debug$1 = debug_1;
 const SemVer$4 = semver$4;
@@ -2873,8 +3712,9 @@ const minVersion = (range, loose) => {
           throw new Error(`Unexpected operation: ${comparator.operator}`)
       }
     });
-    if (setMin && (!minver || gt$1(minver, setMin)))
+    if (setMin && (!minver || gt$1(minver, setMin))) {
       minver = setMin;
+    }
   }
 
   if (minver && range.test(minver)) {
@@ -2899,7 +3739,7 @@ var valid = validRange;
 
 const SemVer = semver$4;
 const Comparator$1 = comparator;
-const {ANY: ANY$1} = Comparator$1;
+const { ANY: ANY$1 } = Comparator$1;
 const Range$2 = range;
 const satisfies$2 = satisfies_1;
 const gt = gt_1;
@@ -3003,38 +3843,41 @@ const satisfies$1 = satisfies_1;
 const compare$1 = compare_1;
 var simplify = (versions, range, options) => {
   const set = [];
-  let min = null;
+  let first = null;
   let prev = null;
   const v = versions.sort((a, b) => compare$1(a, b, options));
   for (const version of v) {
     const included = satisfies$1(version, range, options);
     if (included) {
       prev = version;
-      if (!min)
-        min = version;
+      if (!first) {
+        first = version;
+      }
     } else {
       if (prev) {
-        set.push([min, prev]);
+        set.push([first, prev]);
       }
       prev = null;
-      min = null;
+      first = null;
     }
   }
-  if (min)
-    set.push([min, null]);
+  if (first) {
+    set.push([first, null]);
+  }
 
   const ranges = [];
   for (const [min, max] of set) {
-    if (min === max)
+    if (min === max) {
       ranges.push(min);
-    else if (!max && min === v[0])
+    } else if (!max && min === v[0]) {
       ranges.push('*');
-    else if (!max)
+    } else if (!max) {
       ranges.push(`>=${min}`);
-    else if (min === v[0])
+    } else if (min === v[0]) {
       ranges.push(`<=${max}`);
-    else
+    } else {
       ranges.push(`${min} - ${max}`);
+    }
   }
   const simplified = ranges.join(' || ');
   const original = typeof range.raw === 'string' ? range.raw : String(range);
@@ -3084,8 +3927,9 @@ const compare = compare_1;
 // - Else return true
 
 const subset = (sub, dom, options = {}) => {
-  if (sub === dom)
+  if (sub === dom) {
     return true
+  }
 
   sub = new Range(sub, options);
   dom = new Range(dom, options);
@@ -3095,73 +3939,84 @@ const subset = (sub, dom, options = {}) => {
     for (const simpleDom of dom.set) {
       const isSub = simpleSubset(simpleSub, simpleDom, options);
       sawNonNull = sawNonNull || isSub !== null;
-      if (isSub)
+      if (isSub) {
         continue OUTER
+      }
     }
     // the null set is a subset of everything, but null simple ranges in
     // a complex range should be ignored.  so if we saw a non-null range,
     // then we know this isn't a subset, but if EVERY simple range was null,
     // then it is a subset.
-    if (sawNonNull)
+    if (sawNonNull) {
       return false
+    }
   }
   return true
 };
 
 const simpleSubset = (sub, dom, options) => {
-  if (sub === dom)
+  if (sub === dom) {
     return true
+  }
 
   if (sub.length === 1 && sub[0].semver === ANY) {
-    if (dom.length === 1 && dom[0].semver === ANY)
+    if (dom.length === 1 && dom[0].semver === ANY) {
       return true
-    else if (options.includePrerelease)
-      sub = [ new Comparator('>=0.0.0-0') ];
-    else
-      sub = [ new Comparator('>=0.0.0') ];
+    } else if (options.includePrerelease) {
+      sub = [new Comparator('>=0.0.0-0')];
+    } else {
+      sub = [new Comparator('>=0.0.0')];
+    }
   }
 
   if (dom.length === 1 && dom[0].semver === ANY) {
-    if (options.includePrerelease)
+    if (options.includePrerelease) {
       return true
-    else
-      dom = [ new Comparator('>=0.0.0') ];
+    } else {
+      dom = [new Comparator('>=0.0.0')];
+    }
   }
 
   const eqSet = new Set();
   let gt, lt;
   for (const c of sub) {
-    if (c.operator === '>' || c.operator === '>=')
+    if (c.operator === '>' || c.operator === '>=') {
       gt = higherGT(gt, c, options);
-    else if (c.operator === '<' || c.operator === '<=')
+    } else if (c.operator === '<' || c.operator === '<=') {
       lt = lowerLT(lt, c, options);
-    else
+    } else {
       eqSet.add(c.semver);
+    }
   }
 
-  if (eqSet.size > 1)
+  if (eqSet.size > 1) {
     return null
+  }
 
   let gtltComp;
   if (gt && lt) {
     gtltComp = compare(gt.semver, lt.semver, options);
-    if (gtltComp > 0)
+    if (gtltComp > 0) {
       return null
-    else if (gtltComp === 0 && (gt.operator !== '>=' || lt.operator !== '<='))
+    } else if (gtltComp === 0 && (gt.operator !== '>=' || lt.operator !== '<=')) {
       return null
+    }
   }
 
   // will iterate one or zero times
   for (const eq of eqSet) {
-    if (gt && !satisfies(eq, String(gt), options))
+    if (gt && !satisfies(eq, String(gt), options)) {
       return null
+    }
 
-    if (lt && !satisfies(eq, String(lt), options))
+    if (lt && !satisfies(eq, String(lt), options)) {
       return null
+    }
 
     for (const c of dom) {
-      if (!satisfies(eq, String(c), options))
+      if (!satisfies(eq, String(c), options)) {
         return false
+      }
     }
 
     return true
@@ -3197,10 +4052,12 @@ const simpleSubset = (sub, dom, options) => {
       }
       if (c.operator === '>' || c.operator === '>=') {
         higher = higherGT(gt, c, options);
-        if (higher === c && higher !== gt)
+        if (higher === c && higher !== gt) {
           return false
-      } else if (gt.operator === '>=' && !satisfies(gt.semver, String(c), options))
+        }
+      } else if (gt.operator === '>=' && !satisfies(gt.semver, String(c), options)) {
         return false
+      }
     }
     if (lt) {
       if (needDomLTPre) {
@@ -3213,37 +4070,44 @@ const simpleSubset = (sub, dom, options) => {
       }
       if (c.operator === '<' || c.operator === '<=') {
         lower = lowerLT(lt, c, options);
-        if (lower === c && lower !== lt)
+        if (lower === c && lower !== lt) {
           return false
-      } else if (lt.operator === '<=' && !satisfies(lt.semver, String(c), options))
+        }
+      } else if (lt.operator === '<=' && !satisfies(lt.semver, String(c), options)) {
         return false
+      }
     }
-    if (!c.operator && (lt || gt) && gtltComp !== 0)
+    if (!c.operator && (lt || gt) && gtltComp !== 0) {
       return false
+    }
   }
 
   // if there was a < or >, and nothing in the dom, then must be false
   // UNLESS it was limited by another range in the other direction.
   // Eg, >1.0.0 <1.0.1 is still a subset of <2.0.0
-  if (gt && hasDomLT && !lt && gtltComp !== 0)
+  if (gt && hasDomLT && !lt && gtltComp !== 0) {
     return false
+  }
 
-  if (lt && hasDomGT && !gt && gtltComp !== 0)
+  if (lt && hasDomGT && !gt && gtltComp !== 0) {
     return false
+  }
 
   // we needed a prerelease range in a specific tuple, but didn't get one
   // then this isn't a subset.  eg >=1.2.3-pre is not a subset of >=1.0.0,
   // because it includes prereleases in the 1.2.3 tuple
-  if (needDomGTPre || needDomLTPre)
+  if (needDomGTPre || needDomLTPre) {
     return false
+  }
 
   return true
 };
 
 // >=1.2.3 is lower than >1.2.3
 const higherGT = (a, b, options) => {
-  if (!a)
+  if (!a) {
     return b
+  }
   const comp = compare(a.semver, b.semver, options);
   return comp > 0 ? a
     : comp < 0 ? b
@@ -3253,8 +4117,9 @@ const higherGT = (a, b, options) => {
 
 // <=1.2.3 is higher than <1.2.3
 const lowerLT = (a, b, options) => {
-  if (!a)
+  if (!a) {
     return b
+  }
   const comp = compare(a.semver, b.semver, options);
   return comp < 0 ? a
     : comp > 0 ? b
@@ -3844,13 +4709,13 @@ function patch$1 (fs) {
   fs.lstatSync = statFixSync(fs.lstatSync);
 
   // if lchmod/lchown do not exist, then make them no-ops
-  if (!fs.lchmod) {
+  if (fs.chmod && !fs.lchmod) {
     fs.lchmod = function (path, mode, cb) {
       if (cb) process.nextTick(cb);
     };
     fs.lchmodSync = function () {};
   }
-  if (!fs.lchown) {
+  if (fs.chown && !fs.lchown) {
     fs.lchown = function (path, uid, gid, cb) {
       if (cb) process.nextTick(cb);
     };
@@ -3867,32 +4732,38 @@ function patch$1 (fs) {
   // CPU to a busy looping process, which can cause the program causing the lock
   // contention to be starved of CPU by node, so the contention doesn't resolve.
   if (platform === "win32") {
-    fs.rename = (function (fs$rename) { return function (from, to, cb) {
-      var start = Date.now();
-      var backoff = 0;
-      fs$rename(from, to, function CB (er) {
-        if (er
-            && (er.code === "EACCES" || er.code === "EPERM")
-            && Date.now() - start < 60000) {
-          setTimeout(function() {
-            fs.stat(to, function (stater, st) {
-              if (stater && stater.code === "ENOENT")
-                fs$rename(from, to, CB);
-              else
-                cb(er);
-            });
-          }, backoff);
-          if (backoff < 100)
-            backoff += 10;
-          return;
-        }
-        if (cb) cb(er);
-      });
-    }})(fs.rename);
+    fs.rename = typeof fs.rename !== 'function' ? fs.rename
+    : (function (fs$rename) {
+      function rename (from, to, cb) {
+        var start = Date.now();
+        var backoff = 0;
+        fs$rename(from, to, function CB (er) {
+          if (er
+              && (er.code === "EACCES" || er.code === "EPERM")
+              && Date.now() - start < 60000) {
+            setTimeout(function() {
+              fs.stat(to, function (stater, st) {
+                if (stater && stater.code === "ENOENT")
+                  fs$rename(from, to, CB);
+                else
+                  cb(er);
+              });
+            }, backoff);
+            if (backoff < 100)
+              backoff += 10;
+            return;
+          }
+          if (cb) cb(er);
+        });
+      }
+      if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
+      return rename
+    })(fs.rename);
   }
 
   // if read() returns EAGAIN, then just try it again.
-  fs.read = (function (fs$read) {
+  fs.read = typeof fs.read !== 'function' ? fs.read
+  : (function (fs$read) {
     function read (fd, buffer, offset, length, position, callback_) {
       var callback;
       if (callback_ && typeof callback_ === 'function') {
@@ -3913,7 +4784,8 @@ function patch$1 (fs) {
     return read
   })(fs.read);
 
-  fs.readSync = (function (fs$readSync) { return function (fd, buffer, offset, length, position) {
+  fs.readSync = typeof fs.readSync !== 'function' ? fs.readSync
+  : (function (fs$readSync) { return function (fd, buffer, offset, length, position) {
     var eagCounter = 0;
     while (true) {
       try {
@@ -3972,7 +4844,7 @@ function patch$1 (fs) {
   }
 
   function patchLutimes (fs) {
-    if (constants.hasOwnProperty("O_SYMLINK")) {
+    if (constants.hasOwnProperty("O_SYMLINK") && fs.futimes) {
       fs.lutimes = function (path, at, mt, cb) {
         fs.open(path, constants.O_SYMLINK, function (er, fd) {
           if (er) {
@@ -4006,7 +4878,7 @@ function patch$1 (fs) {
         return ret
       };
 
-    } else {
+    } else if (fs.futimes) {
       fs.lutimes = function (_a, _b, _c, cb) { if (cb) process.nextTick(cb); };
       fs.lutimesSync = function () {};
     }
@@ -4454,16 +5326,35 @@ function patch (fs) {
 
   var fs$readdir = fs.readdir;
   fs.readdir = readdir;
+  var noReaddirOptionVersions = /^v[0-5]\./;
   function readdir (path, options, cb) {
     if (typeof options === 'function')
       cb = options, options = null;
 
+    var go$readdir = noReaddirOptionVersions.test(process.version)
+      ? function go$readdir (path, options, cb, startTime) {
+        return fs$readdir(path, fs$readdirCallback(
+          path, options, cb, startTime
+        ))
+      }
+      : function go$readdir (path, options, cb, startTime) {
+        return fs$readdir(path, options, fs$readdirCallback(
+          path, options, cb, startTime
+        ))
+      };
+
     return go$readdir(path, options, cb)
 
-    function go$readdir (path, options, cb, startTime) {
-      return fs$readdir(path, options, function (err, files) {
+    function fs$readdirCallback (path, options, cb, startTime) {
+      return function (err, files) {
         if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
-          enqueue([go$readdir, [path, options, cb], err, startTime || Date.now(), Date.now()]);
+          enqueue([
+            go$readdir,
+            [path, options, cb],
+            err,
+            startTime || Date.now(),
+            Date.now()
+          ]);
         else {
           if (files && files.sort)
             files.sort();
@@ -4471,7 +5362,7 @@ function patch (fs) {
           if (typeof cb === 'function')
             cb.call(this, err, files);
         }
-      })
+      }
     }
   }
 
@@ -7173,7 +8064,7 @@ let tokenize;
         return "keyword";
       }
 
-      if (JSX_TAG.test(token.value) && (text[offset - 1] === "<" || text.substr(offset - 2, 2) == "</")) {
+      if (JSX_TAG.test(token.value) && (text[offset - 1] === "<" || text.slice(offset - 2, offset) == "</")) {
         return "jsxIdentifier";
       }
 
@@ -10498,6 +11389,6 @@ async function updateConfig(project, codecovCfg, opts) {
 }
 
 export { updateConfig };
-// BUILD: Wed Apr 06 2022 13:05:12 GMT+0000 (Coordinated Universal Time)
+// BUILD: Mon Apr 11 2022 12:12:53 GMT+0000 (Coordinated Universal Time)
 
 //# sourceMappingURL=index.js.map