@sanity/pkg-utils 1.11.0 → 1.13.0

package/dist/index.esm.js

@@ -10,19 +10,18 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va
 
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
-import path$1 from 'path';
+import path from 'path';
 import { register } from 'esbuild-register/dist/node';
 import pkgUp from 'pkg-up';
-import fs$1, { stat, readFile } from 'fs/promises';
+import fs, { stat, readFile } from 'fs/promises';
 import findConfig from 'find-config';
 import { z, ZodError } from 'zod';
 import chalk from 'chalk';
 import ts from 'typescript';
-import fs$2, { statSync } from 'fs';
+import fs$1, { statSync } from 'fs';
 import { Observable, switchMap } from 'rxjs';
 import { promisify } from 'util';
-import require$$5 from 'assert';
-import require$$3 from 'events';
+import rimrafCallback from 'rimraf';
 import { ExtractorConfig, Extractor } from '@microsoft/api-extractor';
 import mkdirp from 'mkdirp';
 import prettier from 'prettier';
@@ -69,10 +68,10 @@ async function _findConfigFile(cwd) {
     cwd
   });
   if (!pkgJsonPath) return void 0;
-  const pkgPath = path$1.dirname(pkgJsonPath);
+  const pkgPath = path.dirname(pkgJsonPath);
 
   for (const fileName of CONFIG_FILE_NAMES) {
-    const configPath = path$1.resolve(pkgPath, fileName);
+    const configPath = path.resolve(pkgPath, fileName);
     const exists = await _fileExists$1(configPath);
 
     if (exists) {
@@ -100,7 +99,7 @@ async function _loadConfig(options) {
     cwd
   });
   if (!pkgPath) return void 0;
-  const root = path$1.dirname(pkgPath);
+  const root = path.dirname(pkgPath);
   const configFile = await _findConfigFile(root);
 
   if (!configFile) {
@@ -190,7 +189,7 @@ async function _loadPkg(options) {
     cwd
   });
   if (!pkgPath) throw new Error("no package.json found");
-  const buf = await fs$1.readFile(pkgPath);
+  const buf = await fs.readFile(pkgPath);
   return _validatePkg(JSON.parse(buf.toString()));
 }
 
@@ -364,7 +363,7 @@ function _resolveBuildTasks(ctx) {
   }
 
   for (const exp of exports) {
-    const importId = path$1.join(pkg.name, exp._path);
+    const importId = path.join(pkg.name, exp._path);
 
     if (exp.types) {
       dtsTask.entries.push({
@@ -450,7 +449,7 @@ function _resolveBuildTasks(ctx) {
         const relativeTargetPath = (((_e = exp.browser) == null ? void 0 : _e.import) || exp.import || "").replace(/\.[^/.]+$/, "");
 
         if (relativeTargetPath) {
-          fs$2.writeFileSync(path$1.resolve(cwd, "".concat(exp._path, ".js")), ["// AUTO-GENERATED \u2013 DO NOT EDIT", "export * from '".concat(relativeTargetPath, "'"), ""].join("\n"));
+          fs$1.writeFileSync(path.resolve(cwd, "".concat(exp._path, ".js")), ["// AUTO-GENERATED \u2013 DO NOT EDIT", "export * from '".concat(relativeTargetPath, "'"), ""].join("\n"));
         }
       }
     }
@@ -471,7 +470,7 @@ function _printExtractMessages(ctx, messages) {
   }
 
   for (const msg of warnings) {
-    const sourceFilePath = msg.sourceFilePath && path$1.relative(cwd, msg.sourceFilePath);
+    const sourceFilePath = msg.sourceFilePath && path.relative(cwd, msg.sourceFilePath);
 
     if (msg.messageId === "TS6307") {
       continue;
@@ -487,7 +486,7 @@ function _printExtractMessages(ctx, messages) {
   }
 
   for (const msg of errors) {
-    const sourceFilePath = msg.sourceFilePath && path$1.relative(cwd, msg.sourceFilePath);
+    const sourceFilePath = msg.sourceFilePath && path.relative(cwd, msg.sourceFilePath);
     logger.log(["".concat(chalk.cyan(sourceFilePath || "?")), ":".concat(chalk.yellow(msg.sourceFileLine), ":").concat(chalk.yellow(msg.sourceFileColumn)), " - ".concat(chalk.red("error"), " ").concat(chalk.gray(msg.messageId), "\n"), msg.text, "\n"].join(""));
   }
 
@@ -496,3475 +495,6 @@ function _printExtractMessages(ctx, messages) {
   }
 }
 
-var old = {};
-var hasRequiredOld;
-
-function requireOld() {
-  if (hasRequiredOld) return old;
-  hasRequiredOld = 1; // Copyright Joyent, Inc. and other Node contributors.
-  //
-  // Permission is hereby granted, free of charge, to any person obtaining a
-  // copy of this software and associated documentation files (the
-  // "Software"), to deal in the Software without restriction, including
-  // without limitation the rights to use, copy, modify, merge, publish,
-  // distribute, sublicense, and/or sell copies of the Software, and to permit
-  // persons to whom the Software is furnished to do so, subject to the
-  // following conditions:
-  //
-  // The above copyright notice and this permission notice shall be included
-  // in all copies or substantial portions of the Software.
-  //
-  // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-  // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-  // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-  // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-  // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-  // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-  // USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-  var pathModule = path$1;
-  var isWindows = process.platform === 'win32';
-  var fs = fs$2; // JavaScript implementation of realpath, ported from node pre-v6
-
-  var DEBUG = process.env.NODE_DEBUG && /fs/.test(process.env.NODE_DEBUG);
-
-  function rethrow() {
-    // Only enable in debug mode. A backtrace uses ~1000 bytes of heap space and
-    // is fairly slow to generate.
-    var callback;
-
-    if (DEBUG) {
-      var backtrace = new Error();
-      callback = debugCallback;
-    } else callback = missingCallback;
-
-    return callback;
-
-    function debugCallback(err) {
-      if (err) {
-        backtrace.message = err.message;
-        err = backtrace;
-        missingCallback(err);
-      }
-    }
-
-    function missingCallback(err) {
-      if (err) {
-        if (process.throwDeprecation) throw err; // Forgot a callback but don't know where? Use NODE_DEBUG=fs
-        else if (!process.noDeprecation) {
-          var msg = 'fs: missing callback ' + (err.stack || err.message);
-          if (process.traceDeprecation) console.trace(msg);else console.error(msg);
-        }
-      }
-    }
-  }
-
-  function maybeCallback(cb) {
-    return typeof cb === 'function' ? cb : rethrow();
-  } // Regexp that finds the next partion of a (partial) path
-  // result is [base_with_slash, base], e.g. ['somedir/', 'somedir']
-
-
-  if (isWindows) {
-    var nextPartRe = /(.*?)(?:[\/\\]+|$)/g;
-  } else {
-    var nextPartRe = /(.*?)(?:[\/]+|$)/g;
-  } // Regex to find the device root, including trailing slash. E.g. 'c:\\'.
-
-
-  if (isWindows) {
-    var splitRootRe = /^(?:[a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/][^\\\/]+)?[\\\/]*/;
-  } else {
-    var splitRootRe = /^[\/]*/;
-  }
-
-  old.realpathSync = function realpathSync(p, cache) {
-    // make p is absolute
-    p = pathModule.resolve(p);
-
-    if (cache && Object.prototype.hasOwnProperty.call(cache, p)) {
-      return cache[p];
-    }
-
-    var original = p,
-        seenLinks = {},
-        knownHard = {}; // current character position in p
-
-    var pos; // the partial path so far, including a trailing slash if any
-
-    var current; // the partial path without a trailing slash (except when pointing at a root)
-
-    var base; // the partial path scanned in the previous round, with slash
-
-    var previous;
-    start();
-
-    function start() {
-      // Skip over roots
-      var m = splitRootRe.exec(p);
-      pos = m[0].length;
-      current = m[0];
-      base = m[0];
-      previous = ''; // On windows, check that the root exists. On unix there is no need.
-
-      if (isWindows && !knownHard[base]) {
-        fs.lstatSync(base);
-        knownHard[base] = true;
-      }
-    } // walk down the path, swapping out linked pathparts for their real
-    // values
-    // NB: p.length changes.
-
-
-    while (pos < p.length) {
-      // find the next part
-      nextPartRe.lastIndex = pos;
-      var result = nextPartRe.exec(p);
-      previous = current;
-      current += result[0];
-      base = previous + result[1];
-      pos = nextPartRe.lastIndex; // continue if not a symlink
-
-      if (knownHard[base] || cache && cache[base] === base) {
-        continue;
-      }
-
-      var resolvedLink;
-
-      if (cache && Object.prototype.hasOwnProperty.call(cache, base)) {
-        // some known symbolic link.  no need to stat again.
-        resolvedLink = cache[base];
-      } else {
-        var stat = fs.lstatSync(base);
-
-        if (!stat.isSymbolicLink()) {
-          knownHard[base] = true;
-          if (cache) cache[base] = base;
-          continue;
-        } // read the link if it wasn't read before
-        // dev/ino always return 0 on windows, so skip the check.
-
-
-        var linkTarget = null;
-
-        if (!isWindows) {
-          var id = stat.dev.toString(32) + ':' + stat.ino.toString(32);
-
-          if (seenLinks.hasOwnProperty(id)) {
-            linkTarget = seenLinks[id];
-          }
-        }
-
-        if (linkTarget === null) {
-          fs.statSync(base);
-          linkTarget = fs.readlinkSync(base);
-        }
-
-        resolvedLink = pathModule.resolve(previous, linkTarget); // track this, if given a cache.
-
-        if (cache) cache[base] = resolvedLink;
-        if (!isWindows) seenLinks[id] = linkTarget;
-      } // resolve the link, then start over
-
-
-      p = pathModule.resolve(resolvedLink, p.slice(pos));
-      start();
-    }
-
-    if (cache) cache[original] = p;
-    return p;
-  };
-
-  old.realpath = function realpath(p, cache, cb) {
-    if (typeof cb !== 'function') {
-      cb = maybeCallback(cache);
-      cache = null;
-    } // make p is absolute
-
-
-    p = pathModule.resolve(p);
-
-    if (cache && Object.prototype.hasOwnProperty.call(cache, p)) {
-      return process.nextTick(cb.bind(null, null, cache[p]));
-    }
-
-    var original = p,
-        seenLinks = {},
-        knownHard = {}; // current character position in p
-
-    var pos; // the partial path so far, including a trailing slash if any
-
-    var current; // the partial path without a trailing slash (except when pointing at a root)
-
-    var base; // the partial path scanned in the previous round, with slash
-
-    var previous;
-    start();
-
-    function start() {
-      // Skip over roots
-      var m = splitRootRe.exec(p);
-      pos = m[0].length;
-      current = m[0];
-      base = m[0];
-      previous = ''; // On windows, check that the root exists. On unix there is no need.
-
-      if (isWindows && !knownHard[base]) {
-        fs.lstat(base, function (err) {
-          if (err) return cb(err);
-          knownHard[base] = true;
-          LOOP();
-        });
-      } else {
-        process.nextTick(LOOP);
-      }
-    } // walk down the path, swapping out linked pathparts for their real
-    // values
-
-
-    function LOOP() {
-      // stop if scanned past end of path
-      if (pos >= p.length) {
-        if (cache) cache[original] = p;
-        return cb(null, p);
-      } // find the next part
-
-
-      nextPartRe.lastIndex = pos;
-      var result = nextPartRe.exec(p);
-      previous = current;
-      current += result[0];
-      base = previous + result[1];
-      pos = nextPartRe.lastIndex; // continue if not a symlink
-
-      if (knownHard[base] || cache && cache[base] === base) {
-        return process.nextTick(LOOP);
-      }
-
-      if (cache && Object.prototype.hasOwnProperty.call(cache, base)) {
-        // known symbolic link.  no need to stat again.
-        return gotResolvedLink(cache[base]);
-      }
-
-      return fs.lstat(base, gotStat);
-    }
-
-    function gotStat(err, stat) {
-      if (err) return cb(err); // if not a symlink, skip to the next path part
-
-      if (!stat.isSymbolicLink()) {
-        knownHard[base] = true;
-        if (cache) cache[base] = base;
-        return process.nextTick(LOOP);
-      } // stat & read the link if not read before
-      // call gotTarget as soon as the link target is known
-      // dev/ino always return 0 on windows, so skip the check.
-
-
-      if (!isWindows) {
-        var id = stat.dev.toString(32) + ':' + stat.ino.toString(32);
-
-        if (seenLinks.hasOwnProperty(id)) {
-          return gotTarget(null, seenLinks[id], base);
-        }
-      }
-
-      fs.stat(base, function (err) {
-        if (err) return cb(err);
-        fs.readlink(base, function (err, target) {
-          if (!isWindows) seenLinks[id] = target;
-          gotTarget(err, target);
-        });
-      });
-    }
-
-    function gotTarget(err, target, base) {
-      if (err) return cb(err);
-      var resolvedLink = pathModule.resolve(previous, target);
-      if (cache) cache[base] = resolvedLink;
-      gotResolvedLink(resolvedLink);
-    }
-
-    function gotResolvedLink(resolvedLink) {
-      // resolve the link, then start over
-      p = pathModule.resolve(resolvedLink, p.slice(pos));
-      start();
-    }
-  };
-
-  return old;
-}
-
-var fs_realpath;
-var hasRequiredFs_realpath;
-
-function requireFs_realpath() {
-  if (hasRequiredFs_realpath) return fs_realpath;
-  hasRequiredFs_realpath = 1;
-  fs_realpath = realpath;
-  realpath.realpath = realpath;
-  realpath.sync = realpathSync;
-  realpath.realpathSync = realpathSync;
-  realpath.monkeypatch = monkeypatch;
-  realpath.unmonkeypatch = unmonkeypatch;
-  var fs = fs$2;
-  var origRealpath = fs.realpath;
-  var origRealpathSync = fs.realpathSync;
-  var version = process.version;
-  var ok = /^v[0-5]\./.test(version);
-  var old = requireOld();
-
-  function newError(er) {
-    return er && er.syscall === 'realpath' && (er.code === 'ELOOP' || er.code === 'ENOMEM' || er.code === 'ENAMETOOLONG');
-  }
-
-  function realpath(p, cache, cb) {
-    if (ok) {
-      return origRealpath(p, cache, cb);
-    }
-
-    if (typeof cache === 'function') {
-      cb = cache;
-      cache = null;
-    }
-
-    origRealpath(p, cache, function (er, result) {
-      if (newError(er)) {
-        old.realpath(p, cache, cb);
-      } else {
-        cb(er, result);
-      }
-    });
-  }
-
-  function realpathSync(p, cache) {
-    if (ok) {
-      return origRealpathSync(p, cache);
-    }
-
-    try {
-      return origRealpathSync(p, cache);
-    } catch (er) {
-      if (newError(er)) {
-        return old.realpathSync(p, cache);
-      } else {
-        throw er;
-      }
-    }
-  }
-
-  function monkeypatch() {
-    fs.realpath = realpath;
-    fs.realpathSync = realpathSync;
-  }
-
-  function unmonkeypatch() {
-    fs.realpath = origRealpath;
-    fs.realpathSync = origRealpathSync;
-  }
-
-  return fs_realpath;
-}
-
-var concatMap;
-var hasRequiredConcatMap;
-
-function requireConcatMap() {
-  if (hasRequiredConcatMap) return concatMap;
-  hasRequiredConcatMap = 1;
-
-  concatMap = function (xs, fn) {
-    var res = [];
-
-    for (var i = 0; i < xs.length; i++) {
-      var x = fn(xs[i], i);
-      if (isArray(x)) res.push.apply(res, x);else res.push(x);
-    }
-
-    return res;
-  };
-
-  var isArray = Array.isArray || function (xs) {
-    return Object.prototype.toString.call(xs) === '[object Array]';
-  };
-
-  return concatMap;
-}
-
-var balancedMatch;
-var hasRequiredBalancedMatch;
-
-function requireBalancedMatch() {
-  if (hasRequiredBalancedMatch) return balancedMatch;
-  hasRequiredBalancedMatch = 1;
-  balancedMatch = balanced;
-
-  function balanced(a, b, str) {
-    if (a instanceof RegExp) a = maybeMatch(a, str);
-    if (b instanceof RegExp) b = maybeMatch(b, str);
-    var r = range(a, b, str);
-    return r && {
-      start: r[0],
-      end: r[1],
-      pre: str.slice(0, r[0]),
-      body: str.slice(r[0] + a.length, r[1]),
-      post: str.slice(r[1] + b.length)
-    };
-  }
-
-  function maybeMatch(reg, str) {
-    var m = str.match(reg);
-    return m ? m[0] : null;
-  }
-
-  balanced.range = range;
-
-  function range(a, b, str) {
-    var begs, beg, left, right, result;
-    var ai = str.indexOf(a);
-    var bi = str.indexOf(b, ai + 1);
-    var i = ai;
-
-    if (ai >= 0 && bi > 0) {
-      if (a === b) {
-        return [ai, bi];
-      }
-
-      begs = [];
-      left = str.length;
-
-      while (i >= 0 && !result) {
-        if (i == ai) {
-          begs.push(i);
-          ai = str.indexOf(a, i + 1);
-        } else if (begs.length == 1) {
-          result = [begs.pop(), bi];
-        } else {
-          beg = begs.pop();
-
-          if (beg < left) {
-            left = beg;
-            right = bi;
-          }
-
-          bi = str.indexOf(b, i + 1);
-        }
-
-        i = ai < bi && ai >= 0 ? ai : bi;
-      }
-
-      if (begs.length) {
-        result = [left, right];
-      }
-    }
-
-    return result;
-  }
-
-  return balancedMatch;
-}
-
-var braceExpansion;
-var hasRequiredBraceExpansion;
-
-function requireBraceExpansion() {
-  if (hasRequiredBraceExpansion) return braceExpansion;
-  hasRequiredBraceExpansion = 1;
-  var concatMap = requireConcatMap();
-  var balanced = requireBalancedMatch();
-  braceExpansion = expandTop;
-  var escSlash = '\0SLASH' + Math.random() + '\0';
-  var escOpen = '\0OPEN' + Math.random() + '\0';
-  var escClose = '\0CLOSE' + Math.random() + '\0';
-  var escComma = '\0COMMA' + Math.random() + '\0';
-  var escPeriod = '\0PERIOD' + Math.random() + '\0';
-
-  function numeric(str) {
-    return parseInt(str, 10) == str ? parseInt(str, 10) : str.charCodeAt(0);
-  }
-
-  function escapeBraces(str) {
-    return str.split('\\\\').join(escSlash).split('\\{').join(escOpen).split('\\}').join(escClose).split('\\,').join(escComma).split('\\.').join(escPeriod);
-  }
-
-  function unescapeBraces(str) {
-    return str.split(escSlash).join('\\').split(escOpen).join('{').split(escClose).join('}').split(escComma).join(',').split(escPeriod).join('.');
-  } // Basically just str.split(","), but handling cases
-  // where we have nested braced sections, which should be
-  // treated as individual members, like {a,{b,c},d}
-
-
-  function parseCommaParts(str) {
-    if (!str) return [''];
-    var parts = [];
-    var m = balanced('{', '}', str);
-    if (!m) return str.split(',');
-    var pre = m.pre;
-    var body = m.body;
-    var post = m.post;
-    var p = pre.split(',');
-    p[p.length - 1] += '{' + body + '}';
-    var postParts = parseCommaParts(post);
-
-    if (post.length) {
-      p[p.length - 1] += postParts.shift();
-      p.push.apply(p, postParts);
-    }
-
-    parts.push.apply(parts, p);
-    return parts;
-  }
-
-  function expandTop(str) {
-    if (!str) return []; // I don't know why Bash 4.3 does this, but it does.
-    // Anything starting with {} will have the first two bytes preserved
-    // but *only* at the top level, so {},a}b will not expand to anything,
-    // but a{},b}c will be expanded to [a}c,abc].
-    // One could argue that this is a bug in Bash, but since the goal of
-    // this module is to match Bash's rules, we escape a leading {}
-
-    if (str.substr(0, 2) === '{}') {
-      str = '\\{\\}' + str.substr(2);
-    }
-
-    return expand(escapeBraces(str), true).map(unescapeBraces);
-  }
-
-  function embrace(str) {
-    return '{' + str + '}';
-  }
-
-  function isPadded(el) {
-    return /^-?0\d/.test(el);
-  }
-
-  function lte(i, y) {
-    return i <= y;
-  }
-
-  function gte(i, y) {
-    return i >= y;
-  }
-
-  function expand(str, isTop) {
-    var expansions = [];
-    var m = balanced('{', '}', str);
-    if (!m || /\$$/.test(m.pre)) return [str];
-    var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
-    var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
-    var isSequence = isNumericSequence || isAlphaSequence;
-    var isOptions = m.body.indexOf(',') >= 0;
-
-    if (!isSequence && !isOptions) {
-      // {a},b}
-      if (m.post.match(/,.*\}/)) {
-        str = m.pre + '{' + m.body + escClose + m.post;
-        return expand(str);
-      }
-
-      return [str];
-    }
-
-    var n;
-
-    if (isSequence) {
-      n = m.body.split(/\.\./);
-    } else {
-      n = parseCommaParts(m.body);
-
-      if (n.length === 1) {
-        // x{{a,b}}y ==> x{a}y x{b}y
-        n = expand(n[0], false).map(embrace);
-
-        if (n.length === 1) {
-          var post = m.post.length ? expand(m.post, false) : [''];
-          return post.map(function (p) {
-            return m.pre + n[0] + p;
-          });
-        }
-      }
-    } // at this point, n is the parts, and we know it's not a comma set
-    // with a single entry.
-    // no need to expand pre, since it is guaranteed to be free of brace-sets
-
-
-    var pre = m.pre;
-    var post = m.post.length ? expand(m.post, false) : [''];
-    var N;
-
-    if (isSequence) {
-      var x = numeric(n[0]);
-      var y = numeric(n[1]);
-      var width = Math.max(n[0].length, n[1].length);
-      var incr = n.length == 3 ? Math.abs(numeric(n[2])) : 1;
-      var test = lte;
-      var reverse = y < x;
-
-      if (reverse) {
-        incr *= -1;
-        test = gte;
-      }
-
-      var pad = n.some(isPadded);
-      N = [];
-
-      for (var i = x; test(i, y); i += incr) {
-        var c;
-
-        if (isAlphaSequence) {
-          c = String.fromCharCode(i);
-          if (c === '\\') c = '';
-        } else {
-          c = String(i);
-
-          if (pad) {
-            var need = width - c.length;
-
-            if (need > 0) {
-              var z = new Array(need + 1).join('0');
-              if (i < 0) c = '-' + z + c.slice(1);else c = z + c;
-            }
-          }
-        }
-
-        N.push(c);
-      }
-    } else {
-      N = concatMap(n, function (el) {
-        return expand(el, false);
-      });
-    }
-
-    for (var j = 0; j < N.length; j++) {
-      for (var k = 0; k < post.length; k++) {
-        var expansion = pre + N[j] + post[k];
-        if (!isTop || isSequence || expansion) expansions.push(expansion);
-      }
-    }
-
-    return expansions;
-  }
-
-  return braceExpansion;
-}
-
-var minimatch_1;
-var hasRequiredMinimatch;
-
-function requireMinimatch() {
-  if (hasRequiredMinimatch) return minimatch_1;
-  hasRequiredMinimatch = 1;
-  minimatch_1 = minimatch;
-  minimatch.Minimatch = Minimatch;
-
-  var path = function () {
-    try {
-      return require('path');
-    } catch (e) {}
-  }() || {
-    sep: '/'
-  };
-
-  minimatch.sep = path.sep;
-  var GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {};
-  var expand = requireBraceExpansion();
-  var plTypes = {
-    '!': {
-      open: '(?:(?!(?:',
-      close: '))[^/]*?)'
-    },
-    '?': {
-      open: '(?:',
-      close: ')?'
-    },
-    '+': {
-      open: '(?:',
-      close: ')+'
-    },
-    '*': {
-      open: '(?:',
-      close: ')*'
-    },
-    '@': {
-      open: '(?:',
-      close: ')'
-    }
-  }; // any single thing other than /
-  // don't need to escape / when using new RegExp()
-
-  var qmark = '[^/]'; // * => any number of characters
-
-  var star = qmark + '*?'; // ** when dots are allowed.  Anything goes, except .. and .
-  // not (^ or / followed by one or two dots followed by $ or /),
-  // followed by anything, any number of times.
-
-  var twoStarDot = '(?:(?!(?:\\\/|^)(?:\\.{1,2})($|\\\/)).)*?'; // not a ^ or / followed by a dot,
-  // followed by anything, any number of times.
-
-  var twoStarNoDot = '(?:(?!(?:\\\/|^)\\.).)*?'; // characters that need to be escaped in RegExp.
-
-  var reSpecials = charSet('().*{}+?[]^$\\!'); // "abc" -> { a:true, b:true, c:true }
-
-  function charSet(s) {
-    return s.split('').reduce(function (set, c) {
-      set[c] = true;
-      return set;
-    }, {});
-  } // normalizes slashes.
-
-
-  var slashSplit = /\/+/;
-  minimatch.filter = filter;
-
-  function filter(pattern, options) {
-    options = options || {};
-    return function (p, i, list) {
-      return minimatch(p, pattern, options);
-    };
-  }
-
-  function ext(a, b) {
-    b = b || {};
-    var t = {};
-    Object.keys(a).forEach(function (k) {
-      t[k] = a[k];
-    });
-    Object.keys(b).forEach(function (k) {
-      t[k] = b[k];
-    });
-    return t;
-  }
-
-  minimatch.defaults = function (def) {
-    if (!def || typeof def !== 'object' || !Object.keys(def).length) {
-      return minimatch;
-    }
-
-    var orig = minimatch;
-
-    var m = function minimatch(p, pattern, options) {
-      return orig(p, pattern, ext(def, options));
-    };
-
-    m.Minimatch = function Minimatch(pattern, options) {
-      return new orig.Minimatch(pattern, ext(def, options));
-    };
-
-    m.Minimatch.defaults = function defaults(options) {
-      return orig.defaults(ext(def, options)).Minimatch;
-    };
-
-    m.filter = function filter(pattern, options) {
-      return orig.filter(pattern, ext(def, options));
-    };
-
-    m.defaults = function defaults(options) {
-      return orig.defaults(ext(def, options));
-    };
-
-    m.makeRe = function makeRe(pattern, options) {
-      return orig.makeRe(pattern, ext(def, options));
-    };
-
-    m.braceExpand = function braceExpand(pattern, options) {
-      return orig.braceExpand(pattern, ext(def, options));
-    };
-
-    m.match = function (list, pattern, options) {
-      return orig.match(list, pattern, ext(def, options));
-    };
-
-    return m;
-  };
-
-  Minimatch.defaults = function (def) {
-    return minimatch.defaults(def).Minimatch;
-  };
-
-  function minimatch(p, pattern, options) {
-    assertValidPattern(pattern);
-    if (!options) options = {}; // shortcut: comments match nothing.
-
-    if (!options.nocomment && pattern.charAt(0) === '#') {
-      return false;
-    }
-
-    return new Minimatch(pattern, options).match(p);
-  }
-
-  function Minimatch(pattern, options) {
-    if (!(this instanceof Minimatch)) {
-      return new Minimatch(pattern, options);
-    }
-
-    assertValidPattern(pattern);
-    if (!options) options = {};
-    pattern = pattern.trim(); // windows support: need to use /, not \
-
-    if (!options.allowWindowsEscape && path.sep !== '/') {
-      pattern = pattern.split(path.sep).join('/');
-    }
-
-    this.options = options;
-    this.set = [];
-    this.pattern = pattern;
-    this.regexp = null;
-    this.negate = false;
-    this.comment = false;
-    this.empty = false;
-    this.partial = !!options.partial; // make the set of regexps etc.
-
-    this.make();
-  }
-
-  Minimatch.prototype.debug = function () {};
-
-  Minimatch.prototype.make = make;
-
-  function make() {
-    var pattern = this.pattern;
-    var options = this.options; // empty patterns and comments match nothing.
-
-    if (!options.nocomment && pattern.charAt(0) === '#') {
-      this.comment = true;
-      return;
-    }
-
-    if (!pattern) {
-      this.empty = true;
-      return;
-    } // step 1: figure out negation, etc.
-
-
-    this.parseNegate(); // step 2: expand braces
-
-    var set = this.globSet = this.braceExpand();
-    if (options.debug) this.debug = function debug() {
-      console.error.apply(console, arguments);
-    };
-    this.debug(this.pattern, set); // step 3: now we have a set, so turn each one into a series of path-portion
-    // matching patterns.
-    // These will be regexps, except in the case of "**", which is
-    // set to the GLOBSTAR object for globstar behavior,
-    // and will not contain any / characters
-
-    set = this.globParts = set.map(function (s) {
-      return s.split(slashSplit);
-    });
-    this.debug(this.pattern, set); // glob --> regexps
-
-    set = set.map(function (s, si, set) {
-      return s.map(this.parse, this);
-    }, this);
-    this.debug(this.pattern, set); // filter out everything that didn't compile properly.
-
-    set = set.filter(function (s) {
-      return s.indexOf(false) === -1;
-    });
-    this.debug(this.pattern, set);
-    this.set = set;
-  }
-
-  Minimatch.prototype.parseNegate = parseNegate;
-
-  function parseNegate() {
-    var pattern = this.pattern;
-    var negate = false;
-    var options = this.options;
-    var negateOffset = 0;
-    if (options.nonegate) return;
-
-    for (var i = 0, l = pattern.length; i < l && pattern.charAt(i) === '!'; i++) {
-      negate = !negate;
-      negateOffset++;
-    }
-
-    if (negateOffset) this.pattern = pattern.substr(negateOffset);
-    this.negate = negate;
-  } // Brace expansion:
-  // a{b,c}d -> abd acd
-  // a{b,}c -> abc ac
-  // a{0..3}d -> a0d a1d a2d a3d
-  // a{b,c{d,e}f}g -> abg acdfg acefg
-  // a{b,c}d{e,f}g -> abdeg acdeg abdeg abdfg
-  //
-  // Invalid sets are not expanded.
-  // a{2..}b -> a{2..}b
-  // a{b}c -> a{b}c
-
-
-  minimatch.braceExpand = function (pattern, options) {
-    return braceExpand(pattern, options);
-  };
-
-  Minimatch.prototype.braceExpand = braceExpand;
-
-  function braceExpand(pattern, options) {
-    if (!options) {
-      if (this instanceof Minimatch) {
-        options = this.options;
-      } else {
-        options = {};
-      }
-    }
-
-    pattern = typeof pattern === 'undefined' ? this.pattern : pattern;
-    assertValidPattern(pattern); // Thanks to Yeting Li <https://github.com/yetingli> for
-    // improving this regexp to avoid a ReDOS vulnerability.
-
-    if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) {
-      // shortcut. no need to expand.
-      return [pattern];
-    }
-
-    return expand(pattern);
-  }
-
-  var MAX_PATTERN_LENGTH = 1024 * 64;
-
-  var assertValidPattern = function (pattern) {
-    if (typeof pattern !== 'string') {
-      throw new TypeError('invalid pattern');
-    }
-
-    if (pattern.length > MAX_PATTERN_LENGTH) {
-      throw new TypeError('pattern is too long');
-    }
-  }; // parse a component of the expanded set.
-  // At this point, no pattern may contain "/" in it
-  // so we're going to return a 2d array, where each entry is the full
-  // pattern, split on '/', and then turned into a regular expression.
-  // A regexp is made at the end which joins each array with an
-  // escaped /, and another full one which joins each regexp with |.
-  //
-  // Following the lead of Bash 4.1, note that "**" only has special meaning
-  // when it is the *only* thing in a path portion.  Otherwise, any series
-  // of * is equivalent to a single *.  Globstar behavior is enabled by
-  // default, and can be disabled by setting options.noglobstar.
-
-
-  Minimatch.prototype.parse = parse;
-  var SUBPARSE = {};
-
-  function parse(pattern, isSub) {
-    assertValidPattern(pattern);
-    var options = this.options; // shortcuts
-
-    if (pattern === '**') {
-      if (!options.noglobstar) return GLOBSTAR;else pattern = '*';
-    }
-
-    if (pattern === '') return '';
-    var re = '';
-    var hasMagic = !!options.nocase;
-    var escaping = false; // ? => one single character
-
-    var patternListStack = [];
-    var negativeLists = [];
-    var stateChar;
-    var inClass = false;
-    var reClassStart = -1;
-    var classStart = -1; // . and .. never match anything that doesn't start with .,
-    // even when options.dot is set.
-
-    var patternStart = pattern.charAt(0) === '.' ? '' // anything
-    // not (start or / followed by . or .. followed by / or end)
-    : options.dot ? '(?!(?:^|\\\/)\\.{1,2}(?:$|\\\/))' : '(?!\\.)';
-    var self = this;
-
-    function clearStateChar() {
-      if (stateChar) {
-        // we had some state-tracking character
-        // that wasn't consumed by this pass.
-        switch (stateChar) {
-          case '*':
-            re += star;
-            hasMagic = true;
-            break;
-
-          case '?':
-            re += qmark;
-            hasMagic = true;
-            break;
-
-          default:
-            re += '\\' + stateChar;
-            break;
-        }
-
-        self.debug('clearStateChar %j %j', stateChar, re);
-        stateChar = false;
-      }
-    }
-
-    for (var i = 0, len = pattern.length, c; i < len && (c = pattern.charAt(i)); i++) {
-      this.debug('%s\t%s %s %j', pattern, i, re, c); // skip over any that are escaped.
-
-      if (escaping && reSpecials[c]) {
-        re += '\\' + c;
-        escaping = false;
-        continue;
-      }
-
-      switch (c) {
-        /* istanbul ignore next */
-        case '/':
-          {
-            // completely not allowed, even escaped.
-            // Should already be path-split by now.
-            return false;
-          }
-
-        case '\\':
-          clearStateChar();
-          escaping = true;
-          continue;
-        // the various stateChar values
-        // for the "extglob" stuff.
-
-        case '?':
-        case '*':
-        case '+':
-        case '@':
-        case '!':
-          this.debug('%s\t%s %s %j <-- stateChar', pattern, i, re, c); // all of those are literals inside a class, except that
-          // the glob [!a] means [^a] in regexp
-
-          if (inClass) {
-            this.debug('  in class');
-            if (c === '!' && i === classStart + 1) c = '^';
-            re += c;
-            continue;
-          } // if we already have a stateChar, then it means
-          // that there was something like ** or +? in there.
-          // Handle the stateChar, then proceed with this one.
-
-
-          self.debug('call clearStateChar %j', stateChar);
-          clearStateChar();
-          stateChar = c; // if extglob is disabled, then +(asdf|foo) isn't a thing.
-          // just clear the statechar *now*, rather than even diving into
-          // the patternList stuff.
-
-          if (options.noext) clearStateChar();
-          continue;
-
-        case '(':
-          if (inClass) {
-            re += '(';
-            continue;
-          }
-
-          if (!stateChar) {
-            re += '\\(';
-            continue;
-          }
-
-          patternListStack.push({
-            type: stateChar,
-            start: i - 1,
-            reStart: re.length,
-            open: plTypes[stateChar].open,
-            close: plTypes[stateChar].close
-          }); // negation is (?:(?!js)[^/]*)
-
-          re += stateChar === '!' ? '(?:(?!(?:' : '(?:';
-          this.debug('plType %j %j', stateChar, re);
-          stateChar = false;
-          continue;
-
-        case ')':
-          if (inClass || !patternListStack.length) {
-            re += '\\)';
-            continue;
-          }
-
-          clearStateChar();
-          hasMagic = true;
-          var pl = patternListStack.pop(); // negation is (?:(?!js)[^/]*)
-          // The others are (?:<pattern>)<type>
-
-          re += pl.close;
-
-          if (pl.type === '!') {
-            negativeLists.push(pl);
-          }
-
-          pl.reEnd = re.length;
-          continue;
-
-        case '|':
-          if (inClass || !patternListStack.length || escaping) {
-            re += '\\|';
-            escaping = false;
-            continue;
-          }
-
-          clearStateChar();
-          re += '|';
-          continue;
-        // these are mostly the same in regexp and glob
-
-        case '[':
-          // swallow any state-tracking char before the [
-          clearStateChar();
-
-          if (inClass) {
-            re += '\\' + c;
-            continue;
-          }
-
-          inClass = true;
-          classStart = i;
-          reClassStart = re.length;
-          re += c;
-          continue;
-
-        case ']':
-          //  a right bracket shall lose its special
-          //  meaning and represent itself in
-          //  a bracket expression if it occurs
-          //  first in the list.  -- POSIX.2 2.8.3.2
-          if (i === classStart + 1 || !inClass) {
-            re += '\\' + c;
-            escaping = false;
-            continue;
-          } // handle the case where we left a class open.
-          // "[z-a]" is valid, equivalent to "\[z-a\]"
-          // split where the last [ was, make sure we don't have
-          // an invalid re. if so, re-walk the contents of the
-          // would-be class to re-translate any characters that
-          // were passed through as-is
-          // TODO: It would probably be faster to determine this
-          // without a try/catch and a new RegExp, but it's tricky
-          // to do safely.  For now, this is safe and works.
-
-
-          var cs = pattern.substring(classStart + 1, i);
-
-          try {
-            RegExp('[' + cs + ']');
-          } catch (er) {
-            // not a valid class!
-            var sp = this.parse(cs, SUBPARSE);
-            re = re.substr(0, reClassStart) + '\\[' + sp[0] + '\\]';
-            hasMagic = hasMagic || sp[1];
-            inClass = false;
-            continue;
-          } // finish up the class.
-
-
-          hasMagic = true;
-          inClass = false;
-          re += c;
-          continue;
-
-        default:
-          // swallow any state char that wasn't consumed
-          clearStateChar();
-
-          if (escaping) {
-            // no need
-            escaping = false;
-          } else if (reSpecials[c] && !(c === '^' && inClass)) {
-            re += '\\';
-          }
-
-          re += c;
-      } // switch
-
-    } // for
-    // handle the case where we left a class open.
-    // "[abc" is valid, equivalent to "\[abc"
-
-
-    if (inClass) {
-      // split where the last [ was, and escape it
-      // this is a huge pita.  We now have to re-walk
-      // the contents of the would-be class to re-translate
-      // any characters that were passed through as-is
-      cs = pattern.substr(classStart + 1);
-      sp = this.parse(cs, SUBPARSE);
-      re = re.substr(0, reClassStart) + '\\[' + sp[0];
-      hasMagic = hasMagic || sp[1];
-    } // handle the case where we had a +( thing at the *end*
-    // of the pattern.
-    // each pattern list stack adds 3 chars, and we need to go through
-    // and escape any | chars that were passed through as-is for the regexp.
-    // Go through and escape them, taking care not to double-escape any
-    // | chars that were already escaped.
-
-
-    for (pl = patternListStack.pop(); pl; pl = patternListStack.pop()) {
-      var tail = re.slice(pl.reStart + pl.open.length);
-      this.debug('setting tail', re, pl); // maybe some even number of \, then maybe 1 \, followed by a |
-
-      tail = tail.replace(/((?:\\{2}){0,64})(\\?)\|/g, function (_, $1, $2) {
-        if (!$2) {
-          // the | isn't already escaped, so escape it.
-          $2 = '\\';
-        } // need to escape all those slashes *again*, without escaping the
-        // one that we need for escaping the | character.  As it works out,
-        // escaping an even number of slashes can be done by simply repeating
-        // it exactly after itself.  That's why this trick works.
-        //
-        // I am sorry that you have to see this.
-
-
-        return $1 + $1 + $2 + '|';
-      });
-      this.debug('tail=%j\n   %s', tail, tail, pl, re);
-      var t = pl.type === '*' ? star : pl.type === '?' ? qmark : '\\' + pl.type;
-      hasMagic = true;
-      re = re.slice(0, pl.reStart) + t + '\\(' + tail;
-    } // handle trailing things that only matter at the very end.
-
-
-    clearStateChar();
-
-    if (escaping) {
-      // trailing \\
-      re += '\\\\';
-    } // only need to apply the nodot start if the re starts with
-    // something that could conceivably capture a dot
-
-
-    var addPatternStart = false;
-
-    switch (re.charAt(0)) {
-      case '[':
-      case '.':
-      case '(':
-        addPatternStart = true;
-    } // Hack to work around lack of negative lookbehind in JS
-    // A pattern like: *.!(x).!(y|z) needs to ensure that a name
-    // like 'a.xyz.yz' doesn't match.  So, the first negative
-    // lookahead, has to look ALL the way ahead, to the end of
-    // the pattern.
-
-
-    for (var n = negativeLists.length - 1; n > -1; n--) {
-      var nl = negativeLists[n];
-      var nlBefore = re.slice(0, nl.reStart);
-      var nlFirst = re.slice(nl.reStart, nl.reEnd - 8);
-      var nlLast = re.slice(nl.reEnd - 8, nl.reEnd);
-      var nlAfter = re.slice(nl.reEnd);
-      nlLast += nlAfter; // Handle nested stuff like *(*.js|!(*.json)), where open parens
-      // mean that we should *not* include the ) in the bit that is considered
-      // "after" the negated section.
-
-      var openParensBefore = nlBefore.split('(').length - 1;
-      var cleanAfter = nlAfter;
-
-      for (i = 0; i < openParensBefore; i++) {
-        cleanAfter = cleanAfter.replace(/\)[+*?]?/, '');
-      }
-
-      nlAfter = cleanAfter;
-      var dollar = '';
-
-      if (nlAfter === '' && isSub !== SUBPARSE) {
-        dollar = '$';
-      }
-
-      var newRe = nlBefore + nlFirst + nlAfter + dollar + nlLast;
-      re = newRe;
-    } // if the re is not "" at this point, then we need to make sure
-    // it doesn't match against an empty path part.
-    // Otherwise a/* will match a/, which it should not.
-
-
-    if (re !== '' && hasMagic) {
-      re = '(?=.)' + re;
-    }
-
-    if (addPatternStart) {
-      re = patternStart + re;
-    } // parsing just a piece of a larger pattern.
-
-
-    if (isSub === SUBPARSE) {
-      return [re, hasMagic];
-    } // skip the regexp for non-magical patterns
-    // unescape anything in it, though, so that it'll be
-    // an exact match against a file etc.
-
-
-    if (!hasMagic) {
-      return globUnescape(pattern);
-    }
-
-    var flags = options.nocase ? 'i' : '';
-
-    try {
-      var regExp = new RegExp('^' + re + '$', flags);
-    } catch (er)
-    /* istanbul ignore next - should be impossible */
-    {
-      // If it was an invalid regular expression, then it can't match
-      // anything.  This trick looks for a character after the end of
-      // the string, which is of course impossible, except in multi-line
-      // mode, but it's not a /m regex.
-      return new RegExp('$.');
-    }
-
-    regExp._glob = pattern;
-    regExp._src = re;
-    return regExp;
-  }
-
-  minimatch.makeRe = function (pattern, options) {
-    return new Minimatch(pattern, options || {}).makeRe();
-  };
-
-  Minimatch.prototype.makeRe = makeRe;
-
-  function makeRe() {
-    if (this.regexp || this.regexp === false) return this.regexp; // at this point, this.set is a 2d array of partial
-    // pattern strings, or "**".
-    //
-    // It's better to use .match().  This function shouldn't
-    // be used, really, but it's pretty convenient sometimes,
-    // when you just want to work with a regex.
-
-    var set = this.set;
-
-    if (!set.length) {
-      this.regexp = false;
-      return this.regexp;
-    }
-
-    var options = this.options;
-    var twoStar = options.noglobstar ? star : options.dot ? twoStarDot : twoStarNoDot;
-    var flags = options.nocase ? 'i' : '';
-    var re = set.map(function (pattern) {
-      return pattern.map(function (p) {
-        return p === GLOBSTAR ? twoStar : typeof p === 'string' ? regExpEscape(p) : p._src;
-      }).join('\\\/');
-    }).join('|'); // must match entire pattern
-    // ending in a * or ** will make it less strict.
-
-    re = '^(?:' + re + ')$'; // can match anything, as long as it's not this.
-
-    if (this.negate) re = '^(?!' + re + ').*$';
-
-    try {
-      this.regexp = new RegExp(re, flags);
-    } catch (ex)
-    /* istanbul ignore next - should be impossible */
-    {
-      this.regexp = false;
-    }
-
-    return this.regexp;
-  }
-
-  minimatch.match = function (list, pattern, options) {
-    options = options || {};
-    var mm = new Minimatch(pattern, options);
-    list = list.filter(function (f) {
-      return mm.match(f);
-    });
-
-    if (mm.options.nonull && !list.length) {
-      list.push(pattern);
-    }
-
-    return list;
-  };
-
-  Minimatch.prototype.match = function match(f, partial) {
-    if (typeof partial === 'undefined') partial = this.partial;
-    this.debug('match', f, this.pattern); // short-circuit in the case of busted things.
-    // comments, etc.
-
-    if (this.comment) return false;
-    if (this.empty) return f === '';
-    if (f === '/' && partial) return true;
-    var options = this.options; // windows: need to use /, not \
-
-    if (path.sep !== '/') {
-      f = f.split(path.sep).join('/');
-    } // treat the test path as a set of pathparts.
-
-
-    f = f.split(slashSplit);
-    this.debug(this.pattern, 'split', f); // just ONE of the pattern sets in this.set needs to match
-    // in order for it to be valid.  If negating, then just one
-    // match means that we have failed.
-    // Either way, return on the first hit.
-
-    var set = this.set;
-    this.debug(this.pattern, 'set', set); // Find the basename of the path by looking for the last non-empty segment
-
-    var filename;
-    var i;
-
-    for (i = f.length - 1; i >= 0; i--) {
-      filename = f[i];
-      if (filename) break;
-    }
-
-    for (i = 0; i < set.length; i++) {
-      var pattern = set[i];
-      var file = f;
-
-      if (options.matchBase && pattern.length === 1) {
-        file = [filename];
-      }
-
-      var hit = this.matchOne(file, pattern, partial);
-
-      if (hit) {
-        if (options.flipNegate) return true;
-        return !this.negate;
-      }
-    } // didn't get any hits.  this is success if it's a negative
-    // pattern, failure otherwise.
-
-
-    if (options.flipNegate) return false;
-    return this.negate;
-  }; // set partial to true to test if, for example,
-  // "/a/b" matches the start of "/*/b/*/d"
-  // Partial means, if you run out of file before you run
-  // out of pattern, then that's fine, as long as all
-  // the parts match.
-
-
-  Minimatch.prototype.matchOne = function (file, pattern, partial) {
-    var options = this.options;
-    this.debug('matchOne', {
-      'this': this,
-      file: file,
-      pattern: pattern
-    });
-    this.debug('matchOne', file.length, pattern.length);
-
-    for (var fi = 0, pi = 0, fl = file.length, pl = pattern.length; fi < fl && pi < pl; fi++, pi++) {
-      this.debug('matchOne loop');
-      var p = pattern[pi];
-      var f = file[fi];
-      this.debug(pattern, p, f); // should be impossible.
-      // some invalid regexp stuff in the set.
-
-      /* istanbul ignore if */
-
-      if (p === false) return false;
-
-      if (p === GLOBSTAR) {
-        this.debug('GLOBSTAR', [pattern, p, f]); // "**"
-        // a/**/b/**/c would match the following:
-        // a/b/x/y/z/c
-        // a/x/y/z/b/c
-        // a/b/x/b/x/c
-        // a/b/c
-        // To do this, take the rest of the pattern after
-        // the **, and see if it would match the file remainder.
-        // If so, return success.
-        // If not, the ** "swallows" a segment, and try again.
-        // This is recursively awful.
-        //
-        // a/**/b/**/c matching a/b/x/y/z/c
-        // - a matches a
-        // - doublestar
-        //   - matchOne(b/x/y/z/c, b/**/c)
-        //     - b matches b
-        //     - doublestar
-        //       - matchOne(x/y/z/c, c) -> no
-        //       - matchOne(y/z/c, c) -> no
-        //       - matchOne(z/c, c) -> no
-        //       - matchOne(c, c) yes, hit
-
-        var fr = fi;
-        var pr = pi + 1;
-
-        if (pr === pl) {
-          this.debug('** at the end'); // a ** at the end will just swallow the rest.
-          // We have found a match.
-          // however, it will not swallow /.x, unless
-          // options.dot is set.
-          // . and .. are *never* matched by **, for explosively
-          // exponential reasons.
-
-          for (; fi < fl; fi++) {
-            if (file[fi] === '.' || file[fi] === '..' || !options.dot && file[fi].charAt(0) === '.') return false;
-          }
-
-          return true;
-        } // ok, let's see if we can swallow whatever we can.
-
-
-        while (fr < fl) {
-          var swallowee = file[fr];
-          this.debug('\nglobstar while', file, fr, pattern, pr, swallowee); // XXX remove this slice.  Just pass the start index.
-
-          if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {
-            this.debug('globstar found match!', fr, fl, swallowee); // found a match.
-
-            return true;
-          } else {
-            // can't swallow "." or ".." ever.
-            // can only swallow ".foo" when explicitly asked.
-            if (swallowee === '.' || swallowee === '..' || !options.dot && swallowee.charAt(0) === '.') {
-              this.debug('dot detected!', file, fr, pattern, pr);
-              break;
-            } // ** swallows a segment, and continue.
-
-
-            this.debug('globstar swallow a segment, and continue');
-            fr++;
-          }
-        } // no match was found.
-        // However, in partial mode, we can't say this is necessarily over.
-        // If there's more *pattern* left, then
-
-        /* istanbul ignore if */
-
-
-        if (partial) {
-          // ran out of file
-          this.debug('\n>>> no match, partial?', file, fr, pattern, pr);
-          if (fr === fl) return true;
-        }
-
-        return false;
-      } // something other than **
-      // non-magic patterns just have to match exactly
-      // patterns with magic have been turned into regexps.
-
-
-      var hit;
-
-      if (typeof p === 'string') {
-        hit = f === p;
-        this.debug('string match', p, f, hit);
-      } else {
-        hit = f.match(p);
-        this.debug('pattern match', p, f, hit);
-      }
-
-      if (!hit) return false;
-    } // Note: ending in / means that we'll get a final ""
-    // at the end of the pattern.  This can only match a
-    // corresponding "" at the end of the file.
-    // If the file ends in /, then it can only match a
-    // a pattern that ends in /, unless the pattern just
-    // doesn't have any more for it. But, a/b/ should *not*
-    // match "a/b/*", even though "" matches against the
-    // [^/]*? pattern, except in partial mode, where it might
-    // simply not be reached yet.
-    // However, a/b/ should still satisfy a/*
-    // now either we fell off the end of the pattern, or we're done.
-
-
-    if (fi === fl && pi === pl) {
-      // ran out of pattern and filename at the same time.
-      // an exact hit!
-      return true;
-    } else if (fi === fl) {
-      // ran out of file, but still had pattern left.
-      // this is ok if we're doing the match as part of
-      // a glob fs traversal.
-      return partial;
-    } else
-      /* istanbul ignore else */
-      if (pi === pl) {
-        // ran out of pattern, still have file left.
-        // this is only acceptable if we're on the very last
-        // empty segment of a file with a trailing slash.
-        // a/* should match a/b/
-        return fi === fl - 1 && file[fi] === '';
-      } // should be unreachable.
-
-    /* istanbul ignore next */
-
-
-    throw new Error('wtf?');
-  }; // replace stuff like \* with *
-
-
-  function globUnescape(s) {
-    return s.replace(/\\(.)/g, '$1');
-  }
-
-  function regExpEscape(s) {
-    return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
-  }
-
-  return minimatch_1;
-}
-
-var inherits = {
-  exports: {}
-};
-var inherits_browser = {
-  exports: {}
-};
-var hasRequiredInherits_browser;
-
-function requireInherits_browser() {
-  if (hasRequiredInherits_browser) return inherits_browser.exports;
-  hasRequiredInherits_browser = 1;
-
-  if (typeof Object.create === 'function') {
-    // implementation from standard node.js 'util' module
-    inherits_browser.exports = function inherits(ctor, superCtor) {
-      if (superCtor) {
-        ctor.super_ = superCtor;
-        ctor.prototype = Object.create(superCtor.prototype, {
-          constructor: {
-            value: ctor,
-            enumerable: false,
-            writable: true,
-            configurable: true
-          }
-        });
-      }
-    };
-  } else {
-    // old school shim for old browsers
-    inherits_browser.exports = function inherits(ctor, superCtor) {
-      if (superCtor) {
-        ctor.super_ = superCtor;
-
-        var TempCtor = function () {};
-
-        TempCtor.prototype = superCtor.prototype;
-        ctor.prototype = new TempCtor();
-        ctor.prototype.constructor = ctor;
-      }
-    };
-  }
-
-  return inherits_browser.exports;
-}
-
-var hasRequiredInherits;
-
-function requireInherits() {
-  if (hasRequiredInherits) return inherits.exports;
-  hasRequiredInherits = 1;
-
-  (function (module) {
-    try {
-      var util = require('util');
-      /* istanbul ignore next */
-
-
-      if (typeof util.inherits !== 'function') throw '';
-      module.exports = util.inherits;
-    } catch (e) {
-      /* istanbul ignore next */
-      module.exports = requireInherits_browser();
-    }
-  })(inherits);
-
-  return inherits.exports;
-}
-
-var pathIsAbsolute = {
-  exports: {}
-};
-var hasRequiredPathIsAbsolute;
-
-function requirePathIsAbsolute() {
-  if (hasRequiredPathIsAbsolute) return pathIsAbsolute.exports;
-  hasRequiredPathIsAbsolute = 1;
-
-  function posix(path) {
-    return path.charAt(0) === '/';
-  }
-
-  function win32(path) {
-    // https://github.com/nodejs/node/blob/b3fcc245fb25539909ef1d5eaa01dbf92e168633/lib/path.js#L56
-    var splitDeviceRe = /^([a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?([\\\/])?([\s\S]*?)$/;
-    var result = splitDeviceRe.exec(path);
-    var device = result[1] || '';
-    var isUnc = Boolean(device && device.charAt(1) !== ':'); // UNC paths are always absolute
-
-    return Boolean(result[2] || isUnc);
-  }
-
-  pathIsAbsolute.exports = process.platform === 'win32' ? win32 : posix;
-  pathIsAbsolute.exports.posix = posix;
-  pathIsAbsolute.exports.win32 = win32;
-  return pathIsAbsolute.exports;
-}
-
-var common = {};
-var hasRequiredCommon;
-
-function requireCommon() {
-  if (hasRequiredCommon) return common;
-  hasRequiredCommon = 1;
-  common.setopts = setopts;
-  common.ownProp = ownProp;
-  common.makeAbs = makeAbs;
-  common.finish = finish;
-  common.mark = mark;
-  common.isIgnored = isIgnored;
-  common.childrenIgnored = childrenIgnored;
-
-  function ownProp(obj, field) {
-    return Object.prototype.hasOwnProperty.call(obj, field);
-  }
-
-  var fs = fs$2;
-  var path = path$1;
-  var minimatch = requireMinimatch();
-  var isAbsolute = requirePathIsAbsolute();
-  var Minimatch = minimatch.Minimatch;
-
-  function alphasort(a, b) {
-    return a.localeCompare(b, 'en');
-  }
-
-  function setupIgnores(self, options) {
-    self.ignore = options.ignore || [];
-    if (!Array.isArray(self.ignore)) self.ignore = [self.ignore];
-
-    if (self.ignore.length) {
-      self.ignore = self.ignore.map(ignoreMap);
-    }
-  } // ignore patterns are always in dot:true mode.
-
-
-  function ignoreMap(pattern) {
-    var gmatcher = null;
-
-    if (pattern.slice(-3) === '/**') {
-      var gpattern = pattern.replace(/(\/\*\*)+$/, '');
-      gmatcher = new Minimatch(gpattern, {
-        dot: true
-      });
-    }
-
-    return {
-      matcher: new Minimatch(pattern, {
-        dot: true
-      }),
-      gmatcher: gmatcher
-    };
-  }
-
-  function setopts(self, pattern, options) {
-    if (!options) options = {}; // base-matching: just use globstar for that.
-
-    if (options.matchBase && -1 === pattern.indexOf("/")) {
-      if (options.noglobstar) {
-        throw new Error("base matching requires globstar");
-      }
-
-      pattern = "**/" + pattern;
-    }
-
-    self.silent = !!options.silent;
-    self.pattern = pattern;
-    self.strict = options.strict !== false;
-    self.realpath = !!options.realpath;
-    self.realpathCache = options.realpathCache || Object.create(null);
-    self.follow = !!options.follow;
-    self.dot = !!options.dot;
-    self.mark = !!options.mark;
-    self.nodir = !!options.nodir;
-    if (self.nodir) self.mark = true;
-    self.sync = !!options.sync;
-    self.nounique = !!options.nounique;
-    self.nonull = !!options.nonull;
-    self.nosort = !!options.nosort;
-    self.nocase = !!options.nocase;
-    self.stat = !!options.stat;
-    self.noprocess = !!options.noprocess;
-    self.absolute = !!options.absolute;
-    self.fs = options.fs || fs;
-    self.maxLength = options.maxLength || Infinity;
-    self.cache = options.cache || Object.create(null);
-    self.statCache = options.statCache || Object.create(null);
-    self.symlinks = options.symlinks || Object.create(null);
-    setupIgnores(self, options);
-    self.changedCwd = false;
-    var cwd = process.cwd();
-    if (!ownProp(options, "cwd")) self.cwd = cwd;else {
-      self.cwd = path.resolve(options.cwd);
-      self.changedCwd = self.cwd !== cwd;
-    }
-    self.root = options.root || path.resolve(self.cwd, "/");
-    self.root = path.resolve(self.root);
-    if (process.platform === "win32") self.root = self.root.replace(/\\/g, "/"); // TODO: is an absolute `cwd` supposed to be resolved against `root`?
-    // e.g. { cwd: '/test', root: __dirname } === path.join(__dirname, '/test')
-
-    self.cwdAbs = isAbsolute(self.cwd) ? self.cwd : makeAbs(self, self.cwd);
-    if (process.platform === "win32") self.cwdAbs = self.cwdAbs.replace(/\\/g, "/");
-    self.nomount = !!options.nomount; // disable comments and negation in Minimatch.
-    // Note that they are not supported in Glob itself anyway.
-
-    options.nonegate = true;
-    options.nocomment = true; // always treat \ in patterns as escapes, not path separators
-
-    options.allowWindowsEscape = false;
-    self.minimatch = new Minimatch(pattern, options);
-    self.options = self.minimatch.options;
-  }
-
-  function finish(self) {
-    var nou = self.nounique;
-    var all = nou ? [] : Object.create(null);
-
-    for (var i = 0, l = self.matches.length; i < l; i++) {
-      var matches = self.matches[i];
-
-      if (!matches || Object.keys(matches).length === 0) {
-        if (self.nonull) {
-          // do like the shell, and spit out the literal glob
-          var literal = self.minimatch.globSet[i];
-          if (nou) all.push(literal);else all[literal] = true;
-        }
-      } else {
-        // had matches
-        var m = Object.keys(matches);
-        if (nou) all.push.apply(all, m);else m.forEach(function (m) {
-          all[m] = true;
-        });
-      }
-    }
-
-    if (!nou) all = Object.keys(all);
-    if (!self.nosort) all = all.sort(alphasort); // at *some* point we statted all of these
-
-    if (self.mark) {
-      for (var i = 0; i < all.length; i++) {
-        all[i] = self._mark(all[i]);
-      }
-
-      if (self.nodir) {
-        all = all.filter(function (e) {
-          var notDir = !/\/$/.test(e);
-          var c = self.cache[e] || self.cache[makeAbs(self, e)];
-          if (notDir && c) notDir = c !== 'DIR' && !Array.isArray(c);
-          return notDir;
-        });
-      }
-    }
-
-    if (self.ignore.length) all = all.filter(function (m) {
-      return !isIgnored(self, m);
-    });
-    self.found = all;
-  }
-
-  function mark(self, p) {
-    var abs = makeAbs(self, p);
-    var c = self.cache[abs];
-    var m = p;
-
-    if (c) {
-      var isDir = c === 'DIR' || Array.isArray(c);
-      var slash = p.slice(-1) === '/';
-      if (isDir && !slash) m += '/';else if (!isDir && slash) m = m.slice(0, -1);
-
-      if (m !== p) {
-        var mabs = makeAbs(self, m);
-        self.statCache[mabs] = self.statCache[abs];
-        self.cache[mabs] = self.cache[abs];
-      }
-    }
-
-    return m;
-  } // lotta situps...
-
-
-  function makeAbs(self, f) {
-    var abs = f;
-
-    if (f.charAt(0) === '/') {
-      abs = path.join(self.root, f);
-    } else if (isAbsolute(f) || f === '') {
-      abs = f;
-    } else if (self.changedCwd) {
-      abs = path.resolve(self.cwd, f);
-    } else {
-      abs = path.resolve(f);
-    }
-
-    if (process.platform === 'win32') abs = abs.replace(/\\/g, '/');
-    return abs;
-  } // Return true, if pattern ends with globstar '**', for the accompanying parent directory.
-  // Ex:- If node_modules/** is the pattern, add 'node_modules' to ignore list along with it's contents
-
-
-  function isIgnored(self, path) {
-    if (!self.ignore.length) return false;
-    return self.ignore.some(function (item) {
-      return item.matcher.match(path) || !!(item.gmatcher && item.gmatcher.match(path));
-    });
-  }
-
-  function childrenIgnored(self, path) {
-    if (!self.ignore.length) return false;
-    return self.ignore.some(function (item) {
-      return !!(item.gmatcher && item.gmatcher.match(path));
-    });
-  }
-
-  return common;
-}
-
-var sync;
-var hasRequiredSync;
-
-function requireSync() {
-  if (hasRequiredSync) return sync;
-  hasRequiredSync = 1;
-  sync = globSync;
-  globSync.GlobSync = GlobSync;
-  var rp = requireFs_realpath();
-  var minimatch = requireMinimatch();
-  requireGlob().Glob;
-  var path = path$1;
-  var assert = require$$5;
-  var isAbsolute = requirePathIsAbsolute();
-  var common = requireCommon();
-  var setopts = common.setopts;
-  var ownProp = common.ownProp;
-  var childrenIgnored = common.childrenIgnored;
-  var isIgnored = common.isIgnored;
-
-  function globSync(pattern, options) {
-    if (typeof options === 'function' || arguments.length === 3) throw new TypeError('callback provided to sync glob\n' + 'See: https://github.com/isaacs/node-glob/issues/167');
-    return new GlobSync(pattern, options).found;
-  }
-
-  function GlobSync(pattern, options) {
-    if (!pattern) throw new Error('must provide pattern');
-    if (typeof options === 'function' || arguments.length === 3) throw new TypeError('callback provided to sync glob\n' + 'See: https://github.com/isaacs/node-glob/issues/167');
-    if (!(this instanceof GlobSync)) return new GlobSync(pattern, options);
-    setopts(this, pattern, options);
-    if (this.noprocess) return this;
-    var n = this.minimatch.set.length;
-    this.matches = new Array(n);
-
-    for (var i = 0; i < n; i++) {
-      this._process(this.minimatch.set[i], i, false);
-    }
-
-    this._finish();
-  }
-
-  GlobSync.prototype._finish = function () {
-    assert.ok(this instanceof GlobSync);
-
-    if (this.realpath) {
-      var self = this;
-      this.matches.forEach(function (matchset, index) {
-        var set = self.matches[index] = Object.create(null);
-
-        for (var p in matchset) {
-          try {
-            p = self._makeAbs(p);
-            var real = rp.realpathSync(p, self.realpathCache);
-            set[real] = true;
-          } catch (er) {
-            if (er.syscall === 'stat') set[self._makeAbs(p)] = true;else throw er;
-          }
-        }
-      });
-    }
-
-    common.finish(this);
-  };
-
-  GlobSync.prototype._process = function (pattern, index, inGlobStar) {
-    assert.ok(this instanceof GlobSync); // Get the first [n] parts of pattern that are all strings.
-
-    var n = 0;
-
-    while (typeof pattern[n] === 'string') {
-      n++;
-    } // now n is the index of the first one that is *not* a string.
-    // See if there's anything else
-
-
-    var prefix;
-
-    switch (n) {
-      // if not, then this is rather simple
-      case pattern.length:
-        this._processSimple(pattern.join('/'), index);
-
-        return;
-
-      case 0:
-        // pattern *starts* with some non-trivial item.
-        // going to readdir(cwd), but not include the prefix in matches.
-        prefix = null;
-        break;
-
-      default:
-        // pattern has some string bits in the front.
-        // whatever it starts with, whether that's 'absolute' like /foo/bar,
-        // or 'relative' like '../baz'
-        prefix = pattern.slice(0, n).join('/');
-        break;
-    }
-
-    var remain = pattern.slice(n); // get the list of entries.
-
-    var read;
-    if (prefix === null) read = '.';else if (isAbsolute(prefix) || isAbsolute(pattern.map(function (p) {
-      return typeof p === 'string' ? p : '[*]';
-    }).join('/'))) {
-      if (!prefix || !isAbsolute(prefix)) prefix = '/' + prefix;
-      read = prefix;
-    } else read = prefix;
-
-    var abs = this._makeAbs(read); //if ignored, skip processing
-
-
-    if (childrenIgnored(this, read)) return;
-    var isGlobStar = remain[0] === minimatch.GLOBSTAR;
-    if (isGlobStar) this._processGlobStar(prefix, read, abs, remain, index, inGlobStar);else this._processReaddir(prefix, read, abs, remain, index, inGlobStar);
-  };
-
-  GlobSync.prototype._processReaddir = function (prefix, read, abs, remain, index, inGlobStar) {
-    var entries = this._readdir(abs, inGlobStar); // if the abs isn't a dir, then nothing can match!
-
-
-    if (!entries) return; // It will only match dot entries if it starts with a dot, or if
-    // dot is set.  Stuff like @(.foo|.bar) isn't allowed.
-
-    var pn = remain[0];
-    var negate = !!this.minimatch.negate;
-    var rawGlob = pn._glob;
-    var dotOk = this.dot || rawGlob.charAt(0) === '.';
-    var matchedEntries = [];
-
-    for (var i = 0; i < entries.length; i++) {
-      var e = entries[i];
-
-      if (e.charAt(0) !== '.' || dotOk) {
-        var m;
-
-        if (negate && !prefix) {
-          m = !e.match(pn);
-        } else {
-          m = e.match(pn);
-        }
-
-        if (m) matchedEntries.push(e);
-      }
-    }
-
-    var len = matchedEntries.length; // If there are no matched entries, then nothing matches.
-
-    if (len === 0) return; // if this is the last remaining pattern bit, then no need for
-    // an additional stat *unless* the user has specified mark or
-    // stat explicitly.  We know they exist, since readdir returned
-    // them.
-
-    if (remain.length === 1 && !this.mark && !this.stat) {
-      if (!this.matches[index]) this.matches[index] = Object.create(null);
-
-      for (var i = 0; i < len; i++) {
-        var e = matchedEntries[i];
-
-        if (prefix) {
-          if (prefix.slice(-1) !== '/') e = prefix + '/' + e;else e = prefix + e;
-        }
-
-        if (e.charAt(0) === '/' && !this.nomount) {
-          e = path.join(this.root, e);
-        }
-
-        this._emitMatch(index, e);
-      } // This was the last one, and no stats were needed
-
-
-      return;
-    } // now test all matched entries as stand-ins for that part
-    // of the pattern.
-
-
-    remain.shift();
-
-    for (var i = 0; i < len; i++) {
-      var e = matchedEntries[i];
-      var newPattern;
-      if (prefix) newPattern = [prefix, e];else newPattern = [e];
-
-      this._process(newPattern.concat(remain), index, inGlobStar);
-    }
-  };
-
-  GlobSync.prototype._emitMatch = function (index, e) {
-    if (isIgnored(this, e)) return;
-
-    var abs = this._makeAbs(e);
-
-    if (this.mark) e = this._mark(e);
-
-    if (this.absolute) {
-      e = abs;
-    }
-
-    if (this.matches[index][e]) return;
-
-    if (this.nodir) {
-      var c = this.cache[abs];
-      if (c === 'DIR' || Array.isArray(c)) return;
-    }
-
-    this.matches[index][e] = true;
-    if (this.stat) this._stat(e);
-  };
-
-  GlobSync.prototype._readdirInGlobStar = function (abs) {
-    // follow all symlinked directories forever
-    // just proceed as if this is a non-globstar situation
-    if (this.follow) return this._readdir(abs, false);
-    var entries;
-    var lstat;
-
-    try {
-      lstat = this.fs.lstatSync(abs);
-    } catch (er) {
-      if (er.code === 'ENOENT') {
-        // lstat failed, doesn't exist
-        return null;
-      }
-    }
-
-    var isSym = lstat && lstat.isSymbolicLink();
-    this.symlinks[abs] = isSym; // If it's not a symlink or a dir, then it's definitely a regular file.
-    // don't bother doing a readdir in that case.
-
-    if (!isSym && lstat && !lstat.isDirectory()) this.cache[abs] = 'FILE';else entries = this._readdir(abs, false);
-    return entries;
-  };
-
-  GlobSync.prototype._readdir = function (abs, inGlobStar) {
-    if (inGlobStar && !ownProp(this.symlinks, abs)) return this._readdirInGlobStar(abs);
-
-    if (ownProp(this.cache, abs)) {
-      var c = this.cache[abs];
-      if (!c || c === 'FILE') return null;
-      if (Array.isArray(c)) return c;
-    }
-
-    try {
-      return this._readdirEntries(abs, this.fs.readdirSync(abs));
-    } catch (er) {
-      this._readdirError(abs, er);
-
-      return null;
-    }
-  };
-
-  GlobSync.prototype._readdirEntries = function (abs, entries) {
-    // if we haven't asked to stat everything, then just
-    // assume that everything in there exists, so we can avoid
-    // having to stat it a second time.
-    if (!this.mark && !this.stat) {
-      for (var i = 0; i < entries.length; i++) {
-        var e = entries[i];
-        if (abs === '/') e = abs + e;else e = abs + '/' + e;
-        this.cache[e] = true;
-      }
-    }
-
-    this.cache[abs] = entries; // mark and cache dir-ness
-
-    return entries;
-  };
-
-  GlobSync.prototype._readdirError = function (f, er) {
-    // handle errors, and cache the information
-    switch (er.code) {
-      case 'ENOTSUP': // https://github.com/isaacs/node-glob/issues/205
-
-      case 'ENOTDIR':
-        // totally normal. means it *does* exist.
-        var abs = this._makeAbs(f);
-
-        this.cache[abs] = 'FILE';
-
-        if (abs === this.cwdAbs) {
-          var error = new Error(er.code + ' invalid cwd ' + this.cwd);
-          error.path = this.cwd;
-          error.code = er.code;
-          throw error;
-        }
-
-        break;
-
-      case 'ENOENT': // not terribly unusual
-
-      case 'ELOOP':
-      case 'ENAMETOOLONG':
-      case 'UNKNOWN':
-        this.cache[this._makeAbs(f)] = false;
-        break;
-
-      default:
-        // some unusual error.  Treat as failure.
-        this.cache[this._makeAbs(f)] = false;
-        if (this.strict) throw er;
-        if (!this.silent) console.error('glob error', er);
-        break;
-    }
-  };
-
-  GlobSync.prototype._processGlobStar = function (prefix, read, abs, remain, index, inGlobStar) {
-    var entries = this._readdir(abs, inGlobStar); // no entries means not a dir, so it can never have matches
-    // foo.txt/** doesn't match foo.txt
-
-
-    if (!entries) return; // test without the globstar, and with every child both below
-    // and replacing the globstar.
-
-    var remainWithoutGlobStar = remain.slice(1);
-    var gspref = prefix ? [prefix] : [];
-    var noGlobStar = gspref.concat(remainWithoutGlobStar); // the noGlobStar pattern exits the inGlobStar state
-
-    this._process(noGlobStar, index, false);
-
-    var len = entries.length;
-    var isSym = this.symlinks[abs]; // If it's a symlink, and we're in a globstar, then stop
-
-    if (isSym && inGlobStar) return;
-
-    for (var i = 0; i < len; i++) {
-      var e = entries[i];
-      if (e.charAt(0) === '.' && !this.dot) continue; // these two cases enter the inGlobStar state
-
-      var instead = gspref.concat(entries[i], remainWithoutGlobStar);
-
-      this._process(instead, index, true);
-
-      var below = gspref.concat(entries[i], remain);
-
-      this._process(below, index, true);
-    }
-  };
-
-  GlobSync.prototype._processSimple = function (prefix, index) {
-    // XXX review this.  Shouldn't it be doing the mounting etc
-    // before doing stat?  kinda weird?
-    var exists = this._stat(prefix);
-
-    if (!this.matches[index]) this.matches[index] = Object.create(null); // If it doesn't exist, then just mark the lack of results
-
-    if (!exists) return;
-
-    if (prefix && isAbsolute(prefix) && !this.nomount) {
-      var trail = /[\/\\]$/.test(prefix);
-
-      if (prefix.charAt(0) === '/') {
-        prefix = path.join(this.root, prefix);
-      } else {
-        prefix = path.resolve(this.root, prefix);
-        if (trail) prefix += '/';
-      }
-    }
-
-    if (process.platform === 'win32') prefix = prefix.replace(/\\/g, '/'); // Mark this as a match
-
-    this._emitMatch(index, prefix);
-  }; // Returns either 'DIR', 'FILE', or false
-
-
-  GlobSync.prototype._stat = function (f) {
-    var abs = this._makeAbs(f);
-
-    var needDir = f.slice(-1) === '/';
-    if (f.length > this.maxLength) return false;
-
-    if (!this.stat && ownProp(this.cache, abs)) {
-      var c = this.cache[abs];
-      if (Array.isArray(c)) c = 'DIR'; // It exists, but maybe not how we need it
-
-      if (!needDir || c === 'DIR') return c;
-      if (needDir && c === 'FILE') return false; // otherwise we have to stat, because maybe c=true
-      // if we know it exists, but not what it is.
-    }
-
-    var stat = this.statCache[abs];
-
-    if (!stat) {
-      var lstat;
-
-      try {
-        lstat = this.fs.lstatSync(abs);
-      } catch (er) {
-        if (er && (er.code === 'ENOENT' || er.code === 'ENOTDIR')) {
-          this.statCache[abs] = false;
-          return false;
-        }
-      }
-
-      if (lstat && lstat.isSymbolicLink()) {
-        try {
-          stat = this.fs.statSync(abs);
-        } catch (er) {
-          stat = lstat;
-        }
-      } else {
-        stat = lstat;
-      }
-    }
-
-    this.statCache[abs] = stat;
-    var c = true;
-    if (stat) c = stat.isDirectory() ? 'DIR' : 'FILE';
-    this.cache[abs] = this.cache[abs] || c;
-    if (needDir && c === 'FILE') return false;
-    return c;
-  };
-
-  GlobSync.prototype._mark = function (p) {
-    return common.mark(this, p);
-  };
-
-  GlobSync.prototype._makeAbs = function (f) {
-    return common.makeAbs(this, f);
-  };
-
-  return sync;
-}
-
-var wrappy_1;
-var hasRequiredWrappy;
-
-function requireWrappy() {
-  if (hasRequiredWrappy) return wrappy_1;
-  hasRequiredWrappy = 1; // Returns a wrapper function that returns a wrapped callback
-  // The wrapper function should do some stuff, and return a
-  // presumably different callback function.
-  // This makes sure that own properties are retained, so that
-  // decorations and such are not lost along the way.
-
-  wrappy_1 = wrappy;
-
-  function wrappy(fn, cb) {
-    if (fn && cb) return wrappy(fn)(cb);
-    if (typeof fn !== 'function') throw new TypeError('need wrapper function');
-    Object.keys(fn).forEach(function (k) {
-      wrapper[k] = fn[k];
-    });
-    return wrapper;
-
-    function wrapper() {
-      var args = new Array(arguments.length);
-
-      for (var i = 0; i < args.length; i++) {
-        args[i] = arguments[i];
-      }
-
-      var ret = fn.apply(this, args);
-      var cb = args[args.length - 1];
-
-      if (typeof ret === 'function' && ret !== cb) {
-        Object.keys(cb).forEach(function (k) {
-          ret[k] = cb[k];
-        });
-      }
-
-      return ret;
-    }
-  }
-
-  return wrappy_1;
-}
-
-var once = {
-  exports: {}
-};
-var hasRequiredOnce;
-
-function requireOnce() {
-  if (hasRequiredOnce) return once.exports;
-  hasRequiredOnce = 1;
-  var wrappy = requireWrappy();
-  once.exports = wrappy(once$1);
-  once.exports.strict = wrappy(onceStrict);
-  once$1.proto = once$1(function () {
-    Object.defineProperty(Function.prototype, 'once', {
-      value: function () {
-        return once$1(this);
-      },
-      configurable: true
-    });
-    Object.defineProperty(Function.prototype, 'onceStrict', {
-      value: function () {
-        return onceStrict(this);
-      },
-      configurable: true
-    });
-  });
-
-  function once$1(fn) {
-    var f = function () {
-      if (f.called) return f.value;
-      f.called = true;
-      return f.value = fn.apply(this, arguments);
-    };
-
-    f.called = false;
-    return f;
-  }
-
-  function onceStrict(fn) {
-    var f = function () {
-      if (f.called) throw new Error(f.onceError);
-      f.called = true;
-      return f.value = fn.apply(this, arguments);
-    };
-
-    var name = fn.name || 'Function wrapped with `once`';
-    f.onceError = name + " shouldn't be called more than once";
-    f.called = false;
-    return f;
-  }
-
-  return once.exports;
-}
-
-var inflight_1;
-var hasRequiredInflight;
-
-function requireInflight() {
-  if (hasRequiredInflight) return inflight_1;
-  hasRequiredInflight = 1;
-  var wrappy = requireWrappy();
-  var reqs = Object.create(null);
-  var once = requireOnce();
-  inflight_1 = wrappy(inflight);
-
-  function inflight(key, cb) {
-    if (reqs[key]) {
-      reqs[key].push(cb);
-      return null;
-    } else {
-      reqs[key] = [cb];
-      return makeres(key);
-    }
-  }
-
-  function makeres(key) {
-    return once(function RES() {
-      var cbs = reqs[key];
-      var len = cbs.length;
-      var args = slice(arguments); // XXX It's somewhat ambiguous whether a new callback added in this
-      // pass should be queued for later execution if something in the
-      // list of callbacks throws, or if it should just be discarded.
-      // However, it's such an edge case that it hardly matters, and either
-      // choice is likely as surprising as the other.
-      // As it happens, we do go ahead and schedule it for later execution.
-
-      try {
-        for (var i = 0; i < len; i++) {
-          cbs[i].apply(null, args);
-        }
-      } finally {
-        if (cbs.length > len) {
-          // added more in the interim.
-          // de-zalgo, just in case, but don't call again.
-          cbs.splice(0, len);
-          process.nextTick(function () {
-            RES.apply(null, args);
-          });
-        } else {
-          delete reqs[key];
-        }
-      }
-    });
-  }
-
-  function slice(args) {
-    var length = args.length;
-    var array = [];
-
-    for (var i = 0; i < length; i++) array[i] = args[i];
-
-    return array;
-  }
-
-  return inflight_1;
-}
-
-var glob_1;
-var hasRequiredGlob;
-
-function requireGlob() {
-  if (hasRequiredGlob) return glob_1;
-  hasRequiredGlob = 1; // Approach:
-  //
-  // 1. Get the minimatch set
-  // 2. For each pattern in the set, PROCESS(pattern, false)
-  // 3. Store matches per-set, then uniq them
-  //
-  // PROCESS(pattern, inGlobStar)
-  // Get the first [n] items from pattern that are all strings
-  // Join these together.  This is PREFIX.
-  //   If there is no more remaining, then stat(PREFIX) and
-  //   add to matches if it succeeds.  END.
-  //
-  // If inGlobStar and PREFIX is symlink and points to dir
-  //   set ENTRIES = []
-  // else readdir(PREFIX) as ENTRIES
-  //   If fail, END
-  //
-  // with ENTRIES
-  //   If pattern[n] is GLOBSTAR
-  //     // handle the case where the globstar match is empty
-  //     // by pruning it out, and testing the resulting pattern
-  //     PROCESS(pattern[0..n] + pattern[n+1 .. $], false)
-  //     // handle other cases.
-  //     for ENTRY in ENTRIES (not dotfiles)
-  //       // attach globstar + tail onto the entry
-  //       // Mark that this entry is a globstar match
-  //       PROCESS(pattern[0..n] + ENTRY + pattern[n .. $], true)
-  //
-  //   else // not globstar
-  //     for ENTRY in ENTRIES (not dotfiles, unless pattern[n] is dot)
-  //       Test ENTRY against pattern[n]
-  //       If fails, continue
-  //       If passes, PROCESS(pattern[0..n] + item + pattern[n+1 .. $])
-  //
-  // Caveat:
-  //   Cache all stats and readdirs results to minimize syscall.  Since all
-  //   we ever care about is existence and directory-ness, we can just keep
-  //   `true` for files, and [children,...] for directories, or `false` for
-  //   things that don't exist.
-
-  glob_1 = glob;
-  var rp = requireFs_realpath();
-  var minimatch = requireMinimatch();
-  var inherits = requireInherits();
-  var EE = require$$3.EventEmitter;
-  var path = path$1;
-  var assert = require$$5;
-  var isAbsolute = requirePathIsAbsolute();
-  var globSync = requireSync();
-  var common = requireCommon();
-  var setopts = common.setopts;
-  var ownProp = common.ownProp;
-  var inflight = requireInflight();
-  var childrenIgnored = common.childrenIgnored;
-  var isIgnored = common.isIgnored;
-  var once = requireOnce();
-
-  function glob(pattern, options, cb) {
-    if (typeof options === 'function') cb = options, options = {};
-    if (!options) options = {};
-
-    if (options.sync) {
-      if (cb) throw new TypeError('callback provided to sync glob');
-      return globSync(pattern, options);
-    }
-
-    return new Glob(pattern, options, cb);
-  }
-
-  glob.sync = globSync;
-  var GlobSync = glob.GlobSync = globSync.GlobSync; // old api surface
-
-  glob.glob = glob;
-
-  function extend(origin, add) {
-    if (add === null || typeof add !== 'object') {
-      return origin;
-    }
-
-    var keys = Object.keys(add);
-    var i = keys.length;
-
-    while (i--) {
-      origin[keys[i]] = add[keys[i]];
-    }
-
-    return origin;
-  }
-
-  glob.hasMagic = function (pattern, options_) {
-    var options = extend({}, options_);
-    options.noprocess = true;
-    var g = new Glob(pattern, options);
-    var set = g.minimatch.set;
-    if (!pattern) return false;
-    if (set.length > 1) return true;
-
-    for (var j = 0; j < set[0].length; j++) {
-      if (typeof set[0][j] !== 'string') return true;
-    }
-
-    return false;
-  };
-
-  glob.Glob = Glob;
-  inherits(Glob, EE);
-
-  function Glob(pattern, options, cb) {
-    if (typeof options === 'function') {
-      cb = options;
-      options = null;
-    }
-
-    if (options && options.sync) {
-      if (cb) throw new TypeError('callback provided to sync glob');
-      return new GlobSync(pattern, options);
-    }
-
-    if (!(this instanceof Glob)) return new Glob(pattern, options, cb);
-    setopts(this, pattern, options);
-    this._didRealPath = false; // process each pattern in the minimatch set
-
-    var n = this.minimatch.set.length; // The matches are stored as {<filename>: true,...} so that
-    // duplicates are automagically pruned.
-    // Later, we do an Object.keys() on these.
-    // Keep them as a list so we can fill in when nonull is set.
-
-    this.matches = new Array(n);
-
-    if (typeof cb === 'function') {
-      cb = once(cb);
-      this.on('error', cb);
-      this.on('end', function (matches) {
-        cb(null, matches);
-      });
-    }
-
-    var self = this;
-    this._processing = 0;
-    this._emitQueue = [];
-    this._processQueue = [];
-    this.paused = false;
-    if (this.noprocess) return this;
-    if (n === 0) return done();
-    var sync = true;
-
-    for (var i = 0; i < n; i++) {
-      this._process(this.minimatch.set[i], i, false, done);
-    }
-
-    sync = false;
-
-    function done() {
-      --self._processing;
-
-      if (self._processing <= 0) {
-        if (sync) {
-          process.nextTick(function () {
-            self._finish();
-          });
-        } else {
-          self._finish();
-        }
-      }
-    }
-  }
-
-  Glob.prototype._finish = function () {
-    assert(this instanceof Glob);
-    if (this.aborted) return;
-    if (this.realpath && !this._didRealpath) return this._realpath();
-    common.finish(this);
-    this.emit('end', this.found);
-  };
-
-  Glob.prototype._realpath = function () {
-    if (this._didRealpath) return;
-    this._didRealpath = true;
-    var n = this.matches.length;
-    if (n === 0) return this._finish();
-    var self = this;
-
-    for (var i = 0; i < this.matches.length; i++) this._realpathSet(i, next);
-
-    function next() {
-      if (--n === 0) self._finish();
-    }
-  };
-
-  Glob.prototype._realpathSet = function (index, cb) {
-    var matchset = this.matches[index];
-    if (!matchset) return cb();
-    var found = Object.keys(matchset);
-    var self = this;
-    var n = found.length;
-    if (n === 0) return cb();
-    var set = this.matches[index] = Object.create(null);
-    found.forEach(function (p, i) {
-      // If there's a problem with the stat, then it means that
-      // one or more of the links in the realpath couldn't be
-      // resolved.  just return the abs value in that case.
-      p = self._makeAbs(p);
-      rp.realpath(p, self.realpathCache, function (er, real) {
-        if (!er) set[real] = true;else if (er.syscall === 'stat') set[p] = true;else self.emit('error', er); // srsly wtf right here
-
-        if (--n === 0) {
-          self.matches[index] = set;
-          cb();
-        }
-      });
-    });
-  };
-
-  Glob.prototype._mark = function (p) {
-    return common.mark(this, p);
-  };
-
-  Glob.prototype._makeAbs = function (f) {
-    return common.makeAbs(this, f);
-  };
-
-  Glob.prototype.abort = function () {
-    this.aborted = true;
-    this.emit('abort');
-  };
-
-  Glob.prototype.pause = function () {
-    if (!this.paused) {
-      this.paused = true;
-      this.emit('pause');
-    }
-  };
-
-  Glob.prototype.resume = function () {
-    if (this.paused) {
-      this.emit('resume');
-      this.paused = false;
-
-      if (this._emitQueue.length) {
-        var eq = this._emitQueue.slice(0);
-
-        this._emitQueue.length = 0;
-
-        for (var i = 0; i < eq.length; i++) {
-          var e = eq[i];
-
-          this._emitMatch(e[0], e[1]);
-        }
-      }
-
-      if (this._processQueue.length) {
-        var pq = this._processQueue.slice(0);
-
-        this._processQueue.length = 0;
-
-        for (var i = 0; i < pq.length; i++) {
-          var p = pq[i];
-          this._processing--;
-
-          this._process(p[0], p[1], p[2], p[3]);
-        }
-      }
-    }
-  };
-
-  Glob.prototype._process = function (pattern, index, inGlobStar, cb) {
-    assert(this instanceof Glob);
-    assert(typeof cb === 'function');
-    if (this.aborted) return;
-    this._processing++;
-
-    if (this.paused) {
-      this._processQueue.push([pattern, index, inGlobStar, cb]);
-
-      return;
-    } //console.error('PROCESS %d', this._processing, pattern)
-    // Get the first [n] parts of pattern that are all strings.
-
-
-    var n = 0;
-
-    while (typeof pattern[n] === 'string') {
-      n++;
-    } // now n is the index of the first one that is *not* a string.
-    // see if there's anything else
-
-
-    var prefix;
-
-    switch (n) {
-      // if not, then this is rather simple
-      case pattern.length:
-        this._processSimple(pattern.join('/'), index, cb);
-
-        return;
-
-      case 0:
-        // pattern *starts* with some non-trivial item.
-        // going to readdir(cwd), but not include the prefix in matches.
-        prefix = null;
-        break;
-
-      default:
-        // pattern has some string bits in the front.
-        // whatever it starts with, whether that's 'absolute' like /foo/bar,
-        // or 'relative' like '../baz'
-        prefix = pattern.slice(0, n).join('/');
-        break;
-    }
-
-    var remain = pattern.slice(n); // get the list of entries.
-
-    var read;
-    if (prefix === null) read = '.';else if (isAbsolute(prefix) || isAbsolute(pattern.map(function (p) {
-      return typeof p === 'string' ? p : '[*]';
-    }).join('/'))) {
-      if (!prefix || !isAbsolute(prefix)) prefix = '/' + prefix;
-      read = prefix;
-    } else read = prefix;
-
-    var abs = this._makeAbs(read); //if ignored, skip _processing
-
-
-    if (childrenIgnored(this, read)) return cb();
-    var isGlobStar = remain[0] === minimatch.GLOBSTAR;
-    if (isGlobStar) this._processGlobStar(prefix, read, abs, remain, index, inGlobStar, cb);else this._processReaddir(prefix, read, abs, remain, index, inGlobStar, cb);
-  };
-
-  Glob.prototype._processReaddir = function (prefix, read, abs, remain, index, inGlobStar, cb) {
-    var self = this;
-
-    this._readdir(abs, inGlobStar, function (er, entries) {
-      return self._processReaddir2(prefix, read, abs, remain, index, inGlobStar, entries, cb);
-    });
-  };
-
-  Glob.prototype._processReaddir2 = function (prefix, read, abs, remain, index, inGlobStar, entries, cb) {
-    // if the abs isn't a dir, then nothing can match!
-    if (!entries) return cb(); // It will only match dot entries if it starts with a dot, or if
-    // dot is set.  Stuff like @(.foo|.bar) isn't allowed.
-
-    var pn = remain[0];
-    var negate = !!this.minimatch.negate;
-    var rawGlob = pn._glob;
-    var dotOk = this.dot || rawGlob.charAt(0) === '.';
-    var matchedEntries = [];
-
-    for (var i = 0; i < entries.length; i++) {
-      var e = entries[i];
-
-      if (e.charAt(0) !== '.' || dotOk) {
-        var m;
-
-        if (negate && !prefix) {
-          m = !e.match(pn);
-        } else {
-          m = e.match(pn);
-        }
-
-        if (m) matchedEntries.push(e);
-      }
-    } //console.error('prd2', prefix, entries, remain[0]._glob, matchedEntries)
-
-
-    var len = matchedEntries.length; // If there are no matched entries, then nothing matches.
-
-    if (len === 0) return cb(); // if this is the last remaining pattern bit, then no need for
-    // an additional stat *unless* the user has specified mark or
-    // stat explicitly.  We know they exist, since readdir returned
-    // them.
-
-    if (remain.length === 1 && !this.mark && !this.stat) {
-      if (!this.matches[index]) this.matches[index] = Object.create(null);
-
-      for (var i = 0; i < len; i++) {
-        var e = matchedEntries[i];
-
-        if (prefix) {
-          if (prefix !== '/') e = prefix + '/' + e;else e = prefix + e;
-        }
-
-        if (e.charAt(0) === '/' && !this.nomount) {
-          e = path.join(this.root, e);
-        }
-
-        this._emitMatch(index, e);
-      } // This was the last one, and no stats were needed
-
-
-      return cb();
-    } // now test all matched entries as stand-ins for that part
-    // of the pattern.
-
-
-    remain.shift();
-
-    for (var i = 0; i < len; i++) {
-      var e = matchedEntries[i];
-
-      if (prefix) {
-        if (prefix !== '/') e = prefix + '/' + e;else e = prefix + e;
-      }
-
-      this._process([e].concat(remain), index, inGlobStar, cb);
-    }
-
-    cb();
-  };
-
-  Glob.prototype._emitMatch = function (index, e) {
-    if (this.aborted) return;
-    if (isIgnored(this, e)) return;
-
-    if (this.paused) {
-      this._emitQueue.push([index, e]);
-
-      return;
-    }
-
-    var abs = isAbsolute(e) ? e : this._makeAbs(e);
-    if (this.mark) e = this._mark(e);
-    if (this.absolute) e = abs;
-    if (this.matches[index][e]) return;
-
-    if (this.nodir) {
-      var c = this.cache[abs];
-      if (c === 'DIR' || Array.isArray(c)) return;
-    }
-
-    this.matches[index][e] = true;
-    var st = this.statCache[abs];
-    if (st) this.emit('stat', e, st);
-    this.emit('match', e);
-  };
-
-  Glob.prototype._readdirInGlobStar = function (abs, cb) {
-    if (this.aborted) return; // follow all symlinked directories forever
-    // just proceed as if this is a non-globstar situation
-
-    if (this.follow) return this._readdir(abs, false, cb);
-    var lstatkey = 'lstat\0' + abs;
-    var self = this;
-    var lstatcb = inflight(lstatkey, lstatcb_);
-    if (lstatcb) self.fs.lstat(abs, lstatcb);
-
-    function lstatcb_(er, lstat) {
-      if (er && er.code === 'ENOENT') return cb();
-      var isSym = lstat && lstat.isSymbolicLink();
-      self.symlinks[abs] = isSym; // If it's not a symlink or a dir, then it's definitely a regular file.
-      // don't bother doing a readdir in that case.
-
-      if (!isSym && lstat && !lstat.isDirectory()) {
-        self.cache[abs] = 'FILE';
-        cb();
-      } else self._readdir(abs, false, cb);
-    }
-  };
-
-  Glob.prototype._readdir = function (abs, inGlobStar, cb) {
-    if (this.aborted) return;
-    cb = inflight('readdir\0' + abs + '\0' + inGlobStar, cb);
-    if (!cb) return; //console.error('RD %j %j', +inGlobStar, abs)
-
-    if (inGlobStar && !ownProp(this.symlinks, abs)) return this._readdirInGlobStar(abs, cb);
-
-    if (ownProp(this.cache, abs)) {
-      var c = this.cache[abs];
-      if (!c || c === 'FILE') return cb();
-      if (Array.isArray(c)) return cb(null, c);
-    }
-
-    var self = this;
-    self.fs.readdir(abs, readdirCb(this, abs, cb));
-  };
-
-  function readdirCb(self, abs, cb) {
-    return function (er, entries) {
-      if (er) self._readdirError(abs, er, cb);else self._readdirEntries(abs, entries, cb);
-    };
-  }
-
-  Glob.prototype._readdirEntries = function (abs, entries, cb) {
-    if (this.aborted) return; // if we haven't asked to stat everything, then just
-    // assume that everything in there exists, so we can avoid
-    // having to stat it a second time.
-
-    if (!this.mark && !this.stat) {
-      for (var i = 0; i < entries.length; i++) {
-        var e = entries[i];
-        if (abs === '/') e = abs + e;else e = abs + '/' + e;
-        this.cache[e] = true;
-      }
-    }
-
-    this.cache[abs] = entries;
-    return cb(null, entries);
-  };
-
-  Glob.prototype._readdirError = function (f, er, cb) {
-    if (this.aborted) return; // handle errors, and cache the information
-
-    switch (er.code) {
-      case 'ENOTSUP': // https://github.com/isaacs/node-glob/issues/205
-
-      case 'ENOTDIR':
-        // totally normal. means it *does* exist.
-        var abs = this._makeAbs(f);
-
-        this.cache[abs] = 'FILE';
-
-        if (abs === this.cwdAbs) {
-          var error = new Error(er.code + ' invalid cwd ' + this.cwd);
-          error.path = this.cwd;
-          error.code = er.code;
-          this.emit('error', error);
-          this.abort();
-        }
-
-        break;
-
-      case 'ENOENT': // not terribly unusual
-
-      case 'ELOOP':
-      case 'ENAMETOOLONG':
-      case 'UNKNOWN':
-        this.cache[this._makeAbs(f)] = false;
-        break;
-
-      default:
-        // some unusual error.  Treat as failure.
-        this.cache[this._makeAbs(f)] = false;
-
-        if (this.strict) {
-          this.emit('error', er); // If the error is handled, then we abort
-          // if not, we threw out of here
-
-          this.abort();
-        }
-
-        if (!this.silent) console.error('glob error', er);
-        break;
-    }
-
-    return cb();
-  };
-
-  Glob.prototype._processGlobStar = function (prefix, read, abs, remain, index, inGlobStar, cb) {
-    var self = this;
-
-    this._readdir(abs, inGlobStar, function (er, entries) {
-      self._processGlobStar2(prefix, read, abs, remain, index, inGlobStar, entries, cb);
-    });
-  };
-
-  Glob.prototype._processGlobStar2 = function (prefix, read, abs, remain, index, inGlobStar, entries, cb) {
-    //console.error('pgs2', prefix, remain[0], entries)
-    // no entries means not a dir, so it can never have matches
-    // foo.txt/** doesn't match foo.txt
-    if (!entries) return cb(); // test without the globstar, and with every child both below
-    // and replacing the globstar.
-
-    var remainWithoutGlobStar = remain.slice(1);
-    var gspref = prefix ? [prefix] : [];
-    var noGlobStar = gspref.concat(remainWithoutGlobStar); // the noGlobStar pattern exits the inGlobStar state
-
-    this._process(noGlobStar, index, false, cb);
-
-    var isSym = this.symlinks[abs];
-    var len = entries.length; // If it's a symlink, and we're in a globstar, then stop
-
-    if (isSym && inGlobStar) return cb();
-
-    for (var i = 0; i < len; i++) {
-      var e = entries[i];
-      if (e.charAt(0) === '.' && !this.dot) continue; // these two cases enter the inGlobStar state
-
-      var instead = gspref.concat(entries[i], remainWithoutGlobStar);
-
-      this._process(instead, index, true, cb);
-
-      var below = gspref.concat(entries[i], remain);
-
-      this._process(below, index, true, cb);
-    }
-
-    cb();
-  };
-
-  Glob.prototype._processSimple = function (prefix, index, cb) {
-    // XXX review this.  Shouldn't it be doing the mounting etc
-    // before doing stat?  kinda weird?
-    var self = this;
-
-    this._stat(prefix, function (er, exists) {
-      self._processSimple2(prefix, index, er, exists, cb);
-    });
-  };
-
-  Glob.prototype._processSimple2 = function (prefix, index, er, exists, cb) {
-    //console.error('ps2', prefix, exists)
-    if (!this.matches[index]) this.matches[index] = Object.create(null); // If it doesn't exist, then just mark the lack of results
-
-    if (!exists) return cb();
-
-    if (prefix && isAbsolute(prefix) && !this.nomount) {
-      var trail = /[\/\\]$/.test(prefix);
-
-      if (prefix.charAt(0) === '/') {
-        prefix = path.join(this.root, prefix);
-      } else {
-        prefix = path.resolve(this.root, prefix);
-        if (trail) prefix += '/';
-      }
-    }
-
-    if (process.platform === 'win32') prefix = prefix.replace(/\\/g, '/'); // Mark this as a match
-
-    this._emitMatch(index, prefix);
-
-    cb();
-  }; // Returns either 'DIR', 'FILE', or false
-
-
-  Glob.prototype._stat = function (f, cb) {
-    var abs = this._makeAbs(f);
-
-    var needDir = f.slice(-1) === '/';
-    if (f.length > this.maxLength) return cb();
-
-    if (!this.stat && ownProp(this.cache, abs)) {
-      var c = this.cache[abs];
-      if (Array.isArray(c)) c = 'DIR'; // It exists, but maybe not how we need it
-
-      if (!needDir || c === 'DIR') return cb(null, c);
-      if (needDir && c === 'FILE') return cb(); // otherwise we have to stat, because maybe c=true
-      // if we know it exists, but not what it is.
-    }
-
-    var stat = this.statCache[abs];
-
-    if (stat !== undefined) {
-      if (stat === false) return cb(null, stat);else {
-        var type = stat.isDirectory() ? 'DIR' : 'FILE';
-        if (needDir && type === 'FILE') return cb();else return cb(null, type, stat);
-      }
-    }
-
-    var self = this;
-    var statcb = inflight('stat\0' + abs, lstatcb_);
-    if (statcb) self.fs.lstat(abs, statcb);
-
-    function lstatcb_(er, lstat) {
-      if (lstat && lstat.isSymbolicLink()) {
-        // If it's a symlink, then treat it as the target, unless
-        // the target does not exist, then treat it as a file.
-        return self.fs.stat(abs, function (er, stat) {
-          if (er) self._stat2(f, abs, null, lstat, cb);else self._stat2(f, abs, er, stat, cb);
-        });
-      } else {
-        self._stat2(f, abs, er, lstat, cb);
-      }
-    }
-  };
-
-  Glob.prototype._stat2 = function (f, abs, er, stat, cb) {
-    if (er && (er.code === 'ENOENT' || er.code === 'ENOTDIR')) {
-      this.statCache[abs] = false;
-      return cb();
-    }
-
-    var needDir = f.slice(-1) === '/';
-    this.statCache[abs] = stat;
-    if (abs.slice(-1) === '/' && stat && !stat.isDirectory()) return cb(null, false, stat);
-    var c = true;
-    if (stat) c = stat.isDirectory() ? 'DIR' : 'FILE';
-    this.cache[abs] = this.cache[abs] || c;
-    if (needDir && c === 'FILE') return cb();
-    return cb(null, c, stat);
-  };
-
-  return glob_1;
-}
-
-const assert = require$$5;
-const path = path$1;
-const fs = fs$2;
-let glob = undefined;
-
-try {
-  glob = requireGlob();
-} catch (_err) {// treat glob as optional.
-}
-
-const defaultGlobOpts = {
-  nosort: true,
-  silent: true
-}; // for EMFILE handling
-
-let timeout = 0;
-const isWindows = process.platform === "win32";
-
-const defaults = options => {
-  const methods = ['unlink', 'chmod', 'stat', 'lstat', 'rmdir', 'readdir'];
-  methods.forEach(m => {
-    options[m] = options[m] || fs[m];
-    m = m + 'Sync';
-    options[m] = options[m] || fs[m];
-  });
-  options.maxBusyTries = options.maxBusyTries || 3;
-  options.emfileWait = options.emfileWait || 1000;
-
-  if (options.glob === false) {
-    options.disableGlob = true;
-  }
-
-  if (options.disableGlob !== true && glob === undefined) {
-    throw Error('glob dependency not found, set `options.disableGlob = true` if intentional');
-  }
-
-  options.disableGlob = options.disableGlob || false;
-  options.glob = options.glob || defaultGlobOpts;
-};
-
-const rimraf$1 = (p, options, cb) => {
-  if (typeof options === 'function') {
-    cb = options;
-    options = {};
-  }
-
-  assert(p, 'rimraf: missing path');
-  assert.equal(typeof p, 'string', 'rimraf: path should be a string');
-  assert.equal(typeof cb, 'function', 'rimraf: callback function required');
-  assert(options, 'rimraf: invalid options argument provided');
-  assert.equal(typeof options, 'object', 'rimraf: options should be object');
-  defaults(options);
-  let busyTries = 0;
-  let errState = null;
-  let n = 0;
-
-  const next = er => {
-    errState = errState || er;
-    if (--n === 0) cb(errState);
-  };
-
-  const afterGlob = (er, results) => {
-    if (er) return cb(er);
-    n = results.length;
-    if (n === 0) return cb();
-    results.forEach(p => {
-      const CB = er => {
-        if (er) {
-          if ((er.code === "EBUSY" || er.code === "ENOTEMPTY" || er.code === "EPERM") && busyTries < options.maxBusyTries) {
-            busyTries++; // try again, with the same exact callback as this one.
-
-            return setTimeout(() => rimraf_(p, options, CB), busyTries * 100);
-          } // this one won't happen if graceful-fs is used.
-
-
-          if (er.code === "EMFILE" && timeout < options.emfileWait) {
-            return setTimeout(() => rimraf_(p, options, CB), timeout++);
-          } // already gone
-
-
-          if (er.code === "ENOENT") er = null;
-        }
-
-        timeout = 0;
-        next(er);
-      };
-
-      rimraf_(p, options, CB);
-    });
-  };
-
-  if (options.disableGlob || !glob.hasMagic(p)) return afterGlob(null, [p]);
-  options.lstat(p, (er, stat) => {
-    if (!er) return afterGlob(null, [p]);
-    glob(p, options.glob, afterGlob);
-  });
-}; // Two possible strategies.
-// 1. Assume it's a file.  unlink it, then do the dir stuff on EPERM or EISDIR
-// 2. Assume it's a directory.  readdir, then do the file stuff on ENOTDIR
-//
-// Both result in an extra syscall when you guess wrong.  However, there
-// are likely far more normal files in the world than directories.  This
-// is based on the assumption that a the average number of files per
-// directory is >= 1.
-//
-// If anyone ever complains about this, then I guess the strategy could
-// be made configurable somehow.  But until then, YAGNI.
-
-
-const rimraf_ = (p, options, cb) => {
-  assert(p);
-  assert(options);
-  assert(typeof cb === 'function'); // sunos lets the root user unlink directories, which is... weird.
-  // so we have to lstat here and make sure it's not a dir.
-
-  options.lstat(p, (er, st) => {
-    if (er && er.code === "ENOENT") return cb(null); // Windows can EPERM on stat.  Life is suffering.
-
-    if (er && er.code === "EPERM" && isWindows) fixWinEPERM(p, options, er, cb);
-    if (st && st.isDirectory()) return rmdir(p, options, er, cb);
-    options.unlink(p, er => {
-      if (er) {
-        if (er.code === "ENOENT") return cb(null);
-        if (er.code === "EPERM") return isWindows ? fixWinEPERM(p, options, er, cb) : rmdir(p, options, er, cb);
-        if (er.code === "EISDIR") return rmdir(p, options, er, cb);
-      }
-
-      return cb(er);
-    });
-  });
-};
-
-const fixWinEPERM = (p, options, er, cb) => {
-  assert(p);
-  assert(options);
-  assert(typeof cb === 'function');
-  options.chmod(p, 0o666, er2 => {
-    if (er2) cb(er2.code === "ENOENT" ? null : er);else options.stat(p, (er3, stats) => {
-      if (er3) cb(er3.code === "ENOENT" ? null : er);else if (stats.isDirectory()) rmdir(p, options, er, cb);else options.unlink(p, cb);
-    });
-  });
-};
-
-const fixWinEPERMSync = (p, options, er) => {
-  assert(p);
-  assert(options);
-
-  try {
-    options.chmodSync(p, 0o666);
-  } catch (er2) {
-    if (er2.code === "ENOENT") return;else throw er;
-  }
-
-  let stats;
-
-  try {
-    stats = options.statSync(p);
-  } catch (er3) {
-    if (er3.code === "ENOENT") return;else throw er;
-  }
-
-  if (stats.isDirectory()) rmdirSync(p, options, er);else options.unlinkSync(p);
-};
-
-const rmdir = (p, options, originalEr, cb) => {
-  assert(p);
-  assert(options);
-  assert(typeof cb === 'function'); // try to rmdir first, and only readdir on ENOTEMPTY or EEXIST (SunOS)
-  // if we guessed wrong, and it's not a directory, then
-  // raise the original error.
-
-  options.rmdir(p, er => {
-    if (er && (er.code === "ENOTEMPTY" || er.code === "EEXIST" || er.code === "EPERM")) rmkids(p, options, cb);else if (er && er.code === "ENOTDIR") cb(originalEr);else cb(er);
-  });
-};
-
-const rmkids = (p, options, cb) => {
-  assert(p);
-  assert(options);
-  assert(typeof cb === 'function');
-  options.readdir(p, (er, files) => {
-    if (er) return cb(er);
-    let n = files.length;
-    if (n === 0) return options.rmdir(p, cb);
-    let errState;
-    files.forEach(f => {
-      rimraf$1(path.join(p, f), options, er => {
-        if (errState) return;
-        if (er) return cb(errState = er);
-        if (--n === 0) options.rmdir(p, cb);
-      });
-    });
-  });
-}; // this looks simpler, and is strictly *faster*, but will
-// tie up the JavaScript thread and fail on excessively
-// deep directory trees.
-
-
-const rimrafSync = (p, options) => {
-  options = options || {};
-  defaults(options);
-  assert(p, 'rimraf: missing path');
-  assert.equal(typeof p, 'string', 'rimraf: path should be a string');
-  assert(options, 'rimraf: missing options');
-  assert.equal(typeof options, 'object', 'rimraf: options should be object');
-  let results;
-
-  if (options.disableGlob || !glob.hasMagic(p)) {
-    results = [p];
-  } else {
-    try {
-      options.lstatSync(p);
-      results = [p];
-    } catch (er) {
-      results = glob.sync(p, options.glob);
-    }
-  }
-
-  if (!results.length) return;
-
-  for (let i = 0; i < results.length; i++) {
-    const p = results[i];
-    let st;
-
-    try {
-      st = options.lstatSync(p);
-    } catch (er) {
-      if (er.code === "ENOENT") return; // Windows can EPERM on stat.  Life is suffering.
-
-      if (er.code === "EPERM" && isWindows) fixWinEPERMSync(p, options, er);
-    }
-
-    try {
-      // sunos lets the root user unlink directories, which is... weird.
-      if (st && st.isDirectory()) rmdirSync(p, options, null);else options.unlinkSync(p);
-    } catch (er) {
-      if (er.code === "ENOENT") return;
-      if (er.code === "EPERM") return isWindows ? fixWinEPERMSync(p, options, er) : rmdirSync(p, options, er);
-      if (er.code !== "EISDIR") throw er;
-      rmdirSync(p, options, er);
-    }
-  }
-};
-
-const rmdirSync = (p, options, originalEr) => {
-  assert(p);
-  assert(options);
-
-  try {
-    options.rmdirSync(p);
-  } catch (er) {
-    if (er.code === "ENOENT") return;
-    if (er.code === "ENOTDIR") throw originalEr;
-    if (er.code === "ENOTEMPTY" || er.code === "EEXIST" || er.code === "EPERM") rmkidsSync(p, options);
-  }
-};
-
-const rmkidsSync = (p, options) => {
-  assert(p);
-  assert(options);
-  options.readdirSync(p).forEach(f => rimrafSync(path.join(p, f), options)); // We only end up here once we got ENOTEMPTY at least once, and
-  // at this point, we are guaranteed to have removed all the kids.
-  // So, we know that it won't be ENOENT or ENOTDIR or anything else.
-  // try really hard to delete stuff on windows, because it has a
-  // PROFOUNDLY annoying habit of not closing handles promptly when
-  // files are deleted, resulting in spurious ENOTEMPTY errors.
-
-  const retries = isWindows ? 100 : 1;
-  let i = 0;
-
-  do {
-    let threw = true;
-
-    try {
-      const ret = options.rmdirSync(p, options);
-      threw = false;
-      return ret;
-    } finally {
-      if (++i < retries && threw) continue;
-    }
-  } while (true);
-};
-
-var rimraf_1 = rimraf$1;
-rimraf$1.sync = rimrafSync;
 const formatHost = {
   getCurrentDirectory: () => ts.sys.getCurrentDirectory(),
   getNewLine: () => ts.sys.newLine,
@@ -4039,11 +569,11 @@ function _createApiExtractorConfig(options) {
     },
     docModel: {
       enabled: false,
-      apiJsonFilePath: path$1.resolve(distPath, "".concat(exportPath, ".api.json"))
+      apiJsonFilePath: path.resolve(distPath, "".concat(exportPath, ".api.json"))
     },
     dtsRollup: {
       enabled: true,
-      untrimmedFilePath: path$1.resolve(distPath, filePath)
+      untrimmedFilePath: path.resolve(distPath, filePath)
     },
     tsdocMetadata: {
       enabled: false
@@ -4147,6 +677,18 @@ async function _extractTypes(options) {
       default: {
         logLevel: "warning",
         addToApiReportFile: false
+      },
+      "tsdoc-link-tag-unescaped-text": {
+        logLevel: _ruleToLogLevel("tsdoc-link-tag-unescaped-text", "warning"),
+        addToApiReportFile: false
+      },
+      "tsdoc-undefined-tag": {
+        logLevel: _ruleToLogLevel("tsdoc-undefined-tag", "error"),
+        addToApiReportFile: false
+      },
+      "tsdoc-unsupported-tag": {
+        logLevel: _ruleToLogLevel("tsdoc-unsupported-tag", "none"),
+        addToApiReportFile: false
       }
     }
   };
@@ -4162,7 +704,7 @@ async function _extractTypes(options) {
     }),
     configObjectFullPath: void 0,
     tsdocConfigFile,
-    packageJsonFullPath: path$1.resolve(projectPath, "package.json")
+    packageJsonFullPath: path.resolve(projectPath, "package.json")
   });
   const messages = [];
   const extractorResult = Extractor.invoke(extractorConfig, {
@@ -4175,11 +717,11 @@ async function _extractTypes(options) {
     }
 
   });
-  const typesPath = path$1.resolve(distPath, filePath);
-  const typesBuf = await fs$1.readFile(typesPath);
+  const typesPath = path.resolve(distPath, filePath);
+  const typesBuf = await fs.readFile(typesPath);
   const prettierConfig = await prettier.resolveConfig(typesPath);
-  await mkdirp(path$1.dirname(typesPath));
-  await fs$1.writeFile(typesPath, prettier.format(typesBuf.toString(), _objectSpread(_objectSpread({}, prettierConfig), {}, {
+  await mkdirp(path.dirname(typesPath));
+  await fs.writeFile(typesPath, prettier.format(typesBuf.toString(), _objectSpread(_objectSpread({}, prettierConfig), {}, {
     filepath: typesPath
   })));
   files.push({
@@ -4192,7 +734,7 @@ async function _extractTypes(options) {
   };
 }
 
-const rimraf = promisify(rimraf_1);
+const rimraf = promisify(rimrafCallback);
 
 async function _doExtract(ctx, task) {
   var _a;
@@ -4221,7 +763,7 @@ async function _doExtract(ctx, task) {
     throw new Error("tsconfig.json is missing `compilerOptions.outDir`");
   }
 
-  const tmpPath = path$1.resolve(outDir, "__tmp__");
+  const tmpPath = path.resolve(outDir, "__tmp__");
   await _buildTypes({
     cwd,
     outDir: tmpPath,
@@ -4232,17 +774,17 @@ async function _doExtract(ctx, task) {
 
   for (const entry of task.entries) {
     const exportPath = entry.exportPath === "." ? "./index" : entry.exportPath;
-    const sourceTypesPath = path$1.resolve(tmpPath, path$1.relative(rootDir, path$1.resolve(cwd, entry.sourcePath)).replace(/\.ts$/, ".d.ts"));
-    const targetPath = path$1.resolve(cwd, entry.targetPath);
+    const sourceTypesPath = path.resolve(tmpPath, path.relative(rootDir, path.resolve(cwd, entry.sourcePath)).replace(/\.ts$/, ".d.ts"));
+    const targetPath = path.resolve(cwd, entry.targetPath);
     const result = await _extractTypes({
       cwd,
       exportPath,
       files,
-      filePath: path$1.relative(outDir, targetPath),
+      filePath: path.relative(outDir, targetPath),
       projectPath: cwd,
       rules: (_a = config == null ? void 0 : config.extract) == null ? void 0 : _a.rules,
       sourceTypesPath,
-      tsconfigPath: path$1.resolve(cwd, ts.configPath || "tsconfig.json"),
+      tsconfigPath: path.resolve(cwd, ts.configPath || "tsconfig.json"),
       distPath: outDir
     });
     messages.push(...result.messages);
@@ -4253,7 +795,7 @@ async function _doExtract(ctx, task) {
     }
 
     results.push({
-      sourcePath: path$1.resolve(cwd, entry.sourcePath),
+      sourcePath: path.resolve(cwd, entry.sourcePath),
       filePath: targetPath
     });
   }
@@ -4329,7 +871,7 @@ const _dtsWatchTask = {
 function _resolveRollupConfig(ctx, buildTask) {
   var _ref2, _ref4, _ref5, _ref6, _ref7, _ref8;
 
-  var _a;
+  var _a, _b;
 
   const {
     format,
@@ -4341,29 +883,30 @@ function _resolveRollupConfig(ctx, buildTask) {
     cwd,
     exports: _exports,
     external,
-    dist: outDir,
+    distPath,
     logger,
     pkg,
     ts
   } = ctx;
   const outputExt = _MODULE_EXT[pkg.type][format];
   const minify = (_ref2 = config == null ? void 0 : config.minify) !== null && _ref2 !== void 0 ? _ref2 : true;
+  const outDir = path.relative(cwd, distPath);
   const pathAliases = Object.fromEntries(Object.entries(((_a = ts.config) == null ? void 0 : _a.options.paths) || {}).map(_ref3 => {
     let [key, val] = _ref3;
 
     var _a2;
 
-    return [key, path$1.resolve(cwd, ((_a2 = ts.config) == null ? void 0 : _a2.options.baseUrl) || ".", val[0])];
+    return [key, path.resolve(cwd, ((_a2 = ts.config) == null ? void 0 : _a2.options.baseUrl) || ".", val[0])];
   }));
   const entries = buildTask.entries.map(entry => {
     return _objectSpread(_objectSpread({}, entry), {}, {
-      name: path$1.relative(outDir, entry.output).replace(/\.[^/.]+$/, "")
+      name: path.relative(outDir, entry.output).replace(/\.[^/.]+$/, "")
     });
   }, {});
 
-  const exportIds = _exports && Object.keys(_exports).map(exportPath => path$1.join(pkg.name, exportPath));
+  const exportIds = _exports && Object.keys(_exports).map(exportPath => path.join(pkg.name, exportPath));
 
-  const sourcePaths = _exports && Object.values(_exports).map(e => path$1.resolve(cwd, e.source));
+  const sourcePaths = _exports && Object.values(_exports).map(e => path.resolve(cwd, e.source));
 
   return {
     inputOptions: {
@@ -4374,10 +917,10 @@ function _resolveRollupConfig(ctx, buildTask) {
         }
 
         if (importer && (id.startsWith(".") || id.startsWith("/"))) {
-          const idPath = path$1.resolve(path$1.dirname(importer), id);
+          const idPath = path.resolve(path.dirname(importer), id);
 
           if (sourcePaths == null ? void 0 : sourcePaths.includes(idPath)) {
-            logger.warn("detected self-referencing import \u2013 treating as external: ".concat(path$1.relative(cwd, idPath)));
+            logger.warn("detected self-referencing import \u2013 treating as external: ".concat(path.relative(cwd, idPath)));
             return true;
           }
         }
@@ -4407,14 +950,14 @@ function _resolveRollupConfig(ctx, buildTask) {
         preventAssignment: true,
         values: _objectSpread({}, pkg.name === "@sanity/pkg-utils" ? {} : {
           "process.env.PKG_FILE_PATH": arg => {
-            const sourcePath = "./" + path$1.relative(cwd, arg);
+            const sourcePath = "./" + path.relative(cwd, arg);
             const entry = entries.find(e => e.source === sourcePath);
 
             if (!entry) {
               throw new Error("could not find source entry: ".concat(sourcePath));
             }
 
-            return JSON.stringify(path$1.relative(cwd, path$1.resolve(outDir, entry.name + outputExt)));
+            return JSON.stringify(path.relative(cwd, path.resolve(outDir, entry.name + outputExt)));
           },
           "process.env.PKG_FORMAT": JSON.stringify(format),
           "process.env.PKG_RUNTIME": JSON.stringify(runtime),
@@ -4455,13 +998,13 @@ function _resolveRollupConfig(ctx, buildTask) {
             return false;
           }
         }
-      })].filter(Boolean),
+      }), ...(((_b = config == null ? void 0 : config.rollup) == null ? void 0 : _b.plugins) || [])].filter(Boolean),
       treeshake: {
         propertyReadSideEffects: false
       }
     },
     outputOptions: {
-      chunkFileNames: () => "_[name]-[hash]".concat(outputExt),
+      chunkFileNames: () => "_chunks/[name]-[hash]".concat(outputExt),
       dir: outDir,
       entryFileNames: () => outputExt === ".esm.js" ? "[name].js" : "[name]".concat(outputExt),
       format,
@@ -4472,7 +1015,7 @@ function _resolveRollupConfig(ctx, buildTask) {
 }
 
 const _rollupTask = {
-  name: (ctx, task) => "build javascript files (target ".concat(task.target.join(" + "), ", format ").concat(task.format, ")\n       ").concat(task.entries.map(e => "".concat(chalk.blue(path$1.join(ctx.pkg.name, e.path)), ": ").concat(e.source, " -> ").concat(e.output)).join("\n       ")),
+  name: (ctx, task) => "build javascript files (target ".concat(task.target.join(" + "), ", format ").concat(task.format, ")\n       ").concat(task.entries.map(e => "".concat(chalk.blue(path.join(ctx.pkg.name, e.path)), ": ").concat(e.source, " -> ").concat(e.output)).join("\n       ")),
   exec: (ctx, task) => {
     return new Observable(observer => {
       _execPromise(ctx, task).then(result => {
@@ -4492,8 +1035,9 @@ const _rollupTask = {
 async function _execPromise(ctx, task) {
   const {
     files,
-    dist: outDir
+    distPath
   } = ctx;
+  const outDir = path.relative(ctx.cwd, distPath);
 
   const {
     inputOptions,
@@ -4509,12 +1053,12 @@ async function _execPromise(ctx, task) {
     if (chunkOrAsset.type === "asset") {
       files.push({
         type: "asset",
-        path: path$1.resolve(outDir, chunkOrAsset.fileName)
+        path: path.resolve(outDir, chunkOrAsset.fileName)
       });
     } else {
       files.push({
         type: "chunk",
-        path: path$1.resolve(outDir, chunkOrAsset.fileName)
+        path: path.resolve(outDir, chunkOrAsset.fileName)
       });
     }
   }
@@ -4524,7 +1068,7 @@ async function _execPromise(ctx, task) {
 }
 
 const _rollupWatchTask = {
-  name: (ctx, task) => "build javascript files (target ".concat(task.target.join(" + "), ", format ").concat(task.format, ")\n       ").concat(task.entries.map(e => "".concat(chalk.blue(path$1.join(ctx.pkg.name, e.path)), ": ").concat(e.source, " -> ").concat(e.output)).join("\n       ")),
+  name: (ctx, task) => "build javascript files (target ".concat(task.target.join(" + "), ", format ").concat(task.format, ")\n       ").concat(task.entries.map(e => "".concat(chalk.blue(path.join(ctx.pkg.name, e.path)), ": ").concat(e.source, " -> ").concat(e.output)).join("\n       ")),
   exec: (ctx, task) => {
     const {
       inputOptions,
@@ -4551,7 +1095,7 @@ const _rollupWatchTask = {
     } = ctx;
 
     if (event.code === "BUNDLE_END") {
-      logger.success("build javascript files (target ".concat(task.target.join(" + "), ", format ").concat(task.format, ")\n       ").concat(task.entries.map(e => "".concat(chalk.blue(path$1.join(ctx.pkg.name, e.path)), ": ").concat(e.source, " -> ").concat(e.output)).join("\n       ")));
+      logger.success("build javascript files (target ".concat(task.target.join(" + "), ", format ").concat(task.format, ")\n       ").concat(task.entries.map(e => "".concat(chalk.blue(path.join(ctx.pkg.name, e.path)), ": ").concat(e.source, " -> ").concat(e.output)).join("\n       ")));
       logger.log("");
       return;
     }
@@ -4592,6 +1136,40 @@ const _watchTaskHandlers = {
   "watch:js": _rollupWatchTask
 };
 
+function _pathContains(containerPath, itemPath) {
+  return !path.relative(containerPath, itemPath).startsWith("..");
+}
+
+function _findCommonDirPath(filePaths) {
+  let ret = void 0;
+
+  for (const filePath of filePaths) {
+    let dirPath = path.dirname(filePath);
+
+    if (!ret) {
+      ret = dirPath;
+      continue;
+    }
+
+    while (dirPath !== ret) {
+      dirPath = path.dirname(dirPath);
+
+      if (dirPath === ret) {
+        break;
+      }
+
+      if (_pathContains(dirPath, ret)) {
+        ret = dirPath;
+        break;
+      }
+
+      if (dirPath === ".") return void 0;
+    }
+  }
+
+  return ret;
+}
+
 function _sortAsNumber(a, b) {
   const aVersion = Number(a);
   const bVersion = Number(b);
@@ -4683,6 +1261,42 @@ function _resolveNodeTarget(versions) {
   return target;
 }
 
+function _createLogger() {
+  return {
+    log: function () {
+      console.log(...arguments);
+    },
+    info: function () {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+
+      console.log(chalk.blue("  info"), ...args);
+    },
+    warn: function () {
+      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        args[_key2] = arguments[_key2];
+      }
+
+      console.log(chalk.yellow("  warn"), ...args);
+    },
+    error: function () {
+      for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+        args[_key3] = arguments[_key3];
+      }
+
+      console.log(chalk.red("  fail"), ...args);
+    },
+    success: function () {
+      for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+        args[_key4] = arguments[_key4];
+      }
+
+      console.log(chalk.green("  ok  "), ...args);
+    }
+  };
+}
+
 async function _resolveBuildContext(options) {
   var _ref9;
 
@@ -4692,6 +1306,9 @@ async function _resolveBuildContext(options) {
     pkg,
     tsconfig: tsconfigPath
   } = options;
+
+  const logger = _createLogger();
+
   const tsconfig = await _loadTSConfig({
     cwd,
     tsconfigPath
@@ -4699,9 +1316,6 @@ async function _resolveBuildContext(options) {
 
   const targetVersions = _resolveBrowserslistVersions(pkg.browserslist || _DEFAULTS.browserslist);
 
-  const srcPath = path$1.resolve(cwd, (config == null ? void 0 : config.src) || "src");
-  const distPath = path$1.resolve(cwd, (config == null ? void 0 : config.dist) || "dist");
-
   const nodeTarget = _resolveNodeTarget(targetVersions);
 
   const webTarget = _resolveBrowserTarget(targetVersions);
@@ -4739,48 +1353,44 @@ async function _resolveBuildContext(options) {
 
   const external = _resolveConfigProperty(config == null ? void 0 : config.external, parsedExternal);
 
+  const outputPaths = Object.values(exports).flatMap(exportEntry => {
+    var _a, _b, _c, _d;
+
+    return [exportEntry.import, exportEntry.require, (_a = exportEntry.browser) == null ? void 0 : _a.import, (_b = exportEntry.browser) == null ? void 0 : _b.require, (_c = exportEntry.node) == null ? void 0 : _c.import, (_d = exportEntry.node) == null ? void 0 : _d.require].filter(Boolean);
+  }).map(p => path.resolve(cwd, p));
+
+  const commonDistPath = _findCommonDirPath(outputPaths);
+
+  if (commonDistPath === cwd) {
+    throw new Error("all output files must share a common parent directory which is not the root package directory");
+  }
+
+  if (commonDistPath && !_pathContains(cwd, commonDistPath)) {
+    throw new Error("all output files must be located within the package");
+  }
+
+  const configDistPath = (config == null ? void 0 : config.dist) ? path.resolve(cwd, config.dist) : void 0;
+
+  if (configDistPath && commonDistPath && configDistPath !== commonDistPath && !_pathContains(configDistPath, commonDistPath)) {
+    logger.log("did you mean to configure `dist: './".concat(path.relative(cwd, commonDistPath), "'`?"));
+    throw new Error("all output files must be located with the configured `dist` path");
+  }
+
+  const distPath = configDistPath || commonDistPath;
+
+  if (!distPath) {
+    throw new Error("could not detect `dist` path");
+  }
+
   const ctx = {
     config,
     cwd,
-    dist: path$1.relative(cwd, distPath),
+    distPath,
     exports,
     external,
     files: [],
-    logger: {
-      log: function () {
-        console.log(...arguments);
-      },
-      info: function () {
-        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-          args[_key] = arguments[_key];
-        }
-
-        console.log(chalk.blue("  info"), ...args);
-      },
-      warn: function () {
-        for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
-          args[_key2] = arguments[_key2];
-        }
-
-        console.log(chalk.yellow("  warn"), ...args);
-      },
-      error: function () {
-        for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
-          args[_key3] = arguments[_key3];
-        }
-
-        console.log(chalk.red("  fail"), ...args);
-      },
-      success: function () {
-        for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
-          args[_key4] = arguments[_key4];
-        }
-
-        console.log(chalk.green("  ok  "), ...args);
-      }
-    },
+    logger,
     pkg,
-    src: path$1.relative(cwd, srcPath),
     runtime: (_ref9 = config == null ? void 0 : config.runtime) !== null && _ref9 !== void 0 ? _ref9 : "*",
     target,
     ts: {
@@ -4857,7 +1467,7 @@ function _getFilesize(file) {
 
 function _fileExists(file) {
   try {
-    fs$2.accessSync(file);
+    fs$1.accessSync(file);
     return true;
   } catch (_) {
     return false;
@@ -4865,7 +1475,7 @@ function _fileExists(file) {
 }
 
 function _getFileInfo(cwd, filePath) {
-  const p = path$1.resolve(cwd, filePath);
+  const p = path.resolve(cwd, filePath);
 
   const exists = _fileExists(p);
 
@@ -4955,7 +1565,7 @@ function _printPackageTree(ctx) {
     }
 
     exp.default = _fileInfo(entry.default);
-    return [chalk.green(path$1.join(pkg.name, exportPath)), exp];
+    return [chalk.green(path.join(pkg.name, exportPath)), exp];
   }));
   logger.log(treeify.asTree(tree, true, true));
 }
@@ -4988,19 +1598,19 @@ async function check(options) {
     const missingFiles = [];
 
     for (const [, exp] of Object.entries(ctx.exports || {})) {
-      if (exp.source && !_fileExists(path$1.resolve(cwd, exp.source))) {
+      if (exp.source && !_fileExists(path.resolve(cwd, exp.source))) {
         missingFiles.push(exp.source);
       }
 
-      if (exp.require && !_fileExists(path$1.resolve(cwd, exp.require))) {
+      if (exp.require && !_fileExists(path.resolve(cwd, exp.require))) {
         missingFiles.push(exp.require);
       }
 
-      if (exp.import && !_fileExists(path$1.resolve(cwd, exp.import))) {
+      if (exp.import && !_fileExists(path.resolve(cwd, exp.import))) {
         missingFiles.push(exp.import);
       }
 
-      if (exp.types && !_fileExists(path$1.resolve(cwd, exp.types))) {
+      if (exp.types && !_fileExists(path.resolve(cwd, exp.types))) {
         missingFiles.push(exp.types);
       }
     }
@@ -5133,7 +1743,7 @@ function _resolveWatchTasks(ctx) {
   }
 
   for (const exp of exports) {
-    const importId = path$1.join(pkg.name, exp._path);
+    const importId = path.join(pkg.name, exp._path);
 
     if (exp.types) {
       dtsTask.entries.push({
@@ -5201,7 +1811,7 @@ function _resolveWatchTasks(ctx) {
         const relativeTargetPath = (((_e = exp.browser) == null ? void 0 : _e.import) || exp.import || "").replace(/\.[^/.]+$/, "");
 
         if (relativeTargetPath) {
-          fs$2.writeFileSync(path$1.resolve(cwd, "".concat(exp._path, ".js")), ["// AUTO-GENERATED \u2013 DO NOT EDIT", "export * from '".concat(relativeTargetPath, "'"), ""].join("\n"));
+          fs$1.writeFileSync(path.resolve(cwd, "".concat(exp._path, ".js")), ["// AUTO-GENERATED \u2013 DO NOT EDIT", "export * from '".concat(relativeTargetPath, "'"), ""].join("\n"));
         }
       }
     }
@@ -5239,9 +1849,9 @@ async function _watchConfigFiles(options) {
   const {
     cwd
   } = options;
-  const initialFiles = await _globFiles([path$1.resolve(cwd, "package.json"), path$1.resolve(cwd, "package.config.cjs"), path$1.resolve(cwd, "package.config.js"), path$1.resolve(cwd, "package.config.ts")]);
+  const initialFiles = await _globFiles([path.resolve(cwd, "package.json"), path.resolve(cwd, "package.config.cjs"), path.resolve(cwd, "package.config.js"), path.resolve(cwd, "package.config.ts")]);
 
-  const fileEvent$ = _watchFiles([path$1.resolve(cwd, "package.json"), path$1.resolve(cwd, "package.config.cjs"), path$1.resolve(cwd, "package.config.js"), path$1.resolve(cwd, "package.config.ts")]);
+  const fileEvent$ = _watchFiles([path.resolve(cwd, "package.json"), path.resolve(cwd, "package.config.cjs"), path.resolve(cwd, "package.config.js"), path.resolve(cwd, "package.config.ts")]);
 
   return fileEvent$.pipe(scan((files, fileEvent) => {
     if (fileEvent.type === "add") {
@@ -5254,7 +1864,7 @@ async function _watchConfigFiles(options) {
 
     if (fileEvent.type === "change") {
       console.log("--------------------------------------------------------------------------------");
-      console.log(chalk.blue("info  "), path$1.relative(cwd, fileEvent.file), "changed");
+      console.log(chalk.blue("info  "), path.relative(cwd, fileEvent.file), "changed");
       console.log("");
       return files.slice(0);
     }
@@ -5272,7 +1882,7 @@ async function watch(options) {
     cwd
   });
   const ctx$ = configFiles$.pipe(switchMap(async configFiles => {
-    const _files = configFiles.map(f => path$1.relative(cwd, f));
+    const _files = configFiles.map(f => path.relative(cwd, f));
 
     const packageJsonPath = _files.find(f => f === "package.json");