@sanity/pkg-utils 1.7.3 → 1.8.1

package/dist/index.js

@@ -10,16 +10,20 @@ 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 from 'path';
+import path$1 from 'path';
 import { register } from 'esbuild-register/dist/node';
 import findConfig from 'find-config';
 import pkgUp from 'pkg-up';
-import fs, { readFile } from 'fs/promises';
+import fs$1, { readFile, rename } from 'fs/promises';
 import { z, ZodError } from 'zod';
 import chalk from 'chalk';
 import ts from 'typescript';
-import fs$1, { statSync } from 'fs';
+import fs$2, { statSync } from 'fs';
 import { Observable, switchMap } from 'rxjs';
+import { promisify } from 'util';
+import cpx from 'cpx';
+import require$$5 from 'assert';
+import require$$3 from 'events';
 import { ExtractorConfig, Extractor } from '@microsoft/api-extractor';
 import mkdirp from 'mkdirp';
 import prettier from 'prettier';
@@ -57,7 +61,7 @@ async function _loadConfig(options) {
     cwd
   });
   if (!pkgPath) return void 0;
-  const root = path.dirname(pkgPath);
+  const root = path$1.dirname(pkgPath);
 
   const configFile = _findConfigFile(root);
 
@@ -120,14 +124,15 @@ function defineConfig(configOptions) {
 }
 
 const pkgSchema = z.object({
-  type: z.optional(z.enum(["module"])),
+  type: z.optional(z.enum(["commonjs", "module"])),
   name: z.string(),
   version: z.string(),
+  license: z.string(),
   bin: z.optional(z.record(z.string())),
   dependencies: z.optional(z.record(z.string())),
   devDependencies: z.optional(z.record(z.string())),
   peerDependencies: z.optional(z.record(z.string())),
-  source: z.string(),
+  source: z.optional(z.string()),
   main: z.optional(z.string()),
   browser: z.optional(z.record(z.string())),
   module: z.optional(z.string()),
@@ -136,10 +141,12 @@ const pkgSchema = z.object({
     types: z.optional(z.string()),
     source: z.string(),
     browser: z.optional(z.object({
+      source: z.string(),
       require: z.optional(z.string()),
       import: z.optional(z.string())
     })),
     node: z.optional(z.object({
+      source: z.string(),
       require: z.optional(z.string()),
       import: z.optional(z.string())
     })),
@@ -150,6 +157,13 @@ const pkgSchema = z.object({
   browserslist: z.optional(z.array(z.string()))
 });
 
+function _validatePkg(input) {
+  const pkg = pkgSchema.parse(input);
+  return _objectSpread(_objectSpread({}, pkg), {}, {
+    type: pkg.type || "commonjs"
+  });
+}
+
 async function _loadPkg(options) {
   const {
     cwd
@@ -158,235 +172,3746 @@ async function _loadPkg(options) {
     cwd
   });
   if (!pkgPath) throw new Error("no package.json found");
-  const buf = await fs.readFile(pkgPath);
-  return pkgSchema.parse(JSON.parse(buf.toString()));
+  const buf = await fs$1.readFile(pkgPath);
+  return _validatePkg(JSON.parse(buf.toString()));
+}
+
+async function _loadPkgWithReporting(options) {
+  try {
+    return await _loadPkg(options);
+  } catch (err) {
+    if (err instanceof ZodError) {
+      for (const issue of err.issues) {
+        if (issue.code === "invalid_type") {
+          console.log("".concat(chalk.red("invalid type"), " in ./package.json at ").concat(chalk.magenta("`".concat(issue.path.join("."), "`")), " (expected ").concat(issue.expected, ", received ").concat(issue.received, ")"));
+        }
+      }
+    } else {
+      console.error(err);
+    }
+
+    process.exit(1);
+  }
+}
+
+function _validateExports(_exports, options) {
+  const {
+    pkg
+  } = options;
+
+  for (const exp of _exports) {
+    if (pkg.type === "commonjs") {
+      if (exp.require && !exp.require.endsWith(".js")) {
+        throw new Error("package.json with `\"type\": \"commonjs\"` - `exports[\"".concat(exp._path, "\"].require` must end with \".js\""));
+      }
+    }
+
+    if (pkg.type === "module") {
+      if (exp.require && !exp.require.endsWith(".cjs")) {
+        throw new Error("package.json with `\"type\": \"module\"` - `exports[\"".concat(exp._path, "\"].require` must end with \".cjs\""));
+      }
+    }
+  }
+
+  return _exports;
+}
+
+function _parseExports(options) {
+  const {
+    pkg
+  } = options;
+  const rootExport = {
+    _exported: true,
+    _path: ".",
+    types: pkg.types,
+    source: pkg.source || "",
+    browser: pkg.browser && {
+      source: pkg.source || "",
+      require: pkg.main && pkg.browser[pkg.main],
+      import: pkg.module && pkg.browser[pkg.module]
+    },
+    import: pkg.module,
+    require: pkg.main,
+    default: pkg.module || pkg.main || ""
+  };
+  const extraExports = [];
+
+  if (pkg.exports) {
+    for (const [exportPath, exportEntry] of Object.entries(pkg.exports)) {
+      if (_isRecord(exportEntry)) {
+        if (exportPath === ".") {
+          if (exportEntry.require && rootExport.require && exportEntry.require !== rootExport.require) {
+            throw new Error('mismatch between "main" and "require"');
+          }
+
+          if (exportEntry.import && rootExport.import && exportEntry.import !== rootExport.import) {
+            throw new Error('mismatch between "module" and "import"');
+          }
+
+          if (exportEntry.types && rootExport.types && exportEntry.types !== rootExport.types) {
+            throw new Error('mismatch between "types" and "types"');
+          }
+
+          if (exportEntry.source && rootExport.source && exportEntry.source !== rootExport.source) {
+            throw new Error('mismatch between "source" and "source"');
+          }
+
+          Object.assign(rootExport, exportEntry);
+        } else {
+          const extraExport = _objectSpread({
+            _exported: true,
+            _path: exportPath
+          }, exportEntry);
+
+          extraExports.push(extraExport);
+        }
+      } else {
+        throw new Error("string entries are not supported");
+      }
+    }
+  }
+
+  const _exports = [rootExport, ...extraExports];
+  return _validateExports(_exports, {
+    pkg
+  });
+}
+
+async function _loadTSConfig(options) {
+  const {
+    cwd,
+    tsconfigPath
+  } = options;
+  const configPath = ts.findConfigFile(cwd, ts.sys.fileExists, tsconfigPath);
+
+  if (!configPath) {
+    throw new Error("could not find a valid '".concat(tsconfigPath, "'"));
+  }
+
+  const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
+  return ts.parseJsonConfigFileContent(configFile.config, ts.sys, cwd);
+}
+
+function _resolveBuildTasks(ctx) {
+  var _a, _b, _c, _d, _e;
+
+  const {
+    cwd,
+    pkg,
+    target
+  } = ctx;
+  const tasks = [];
+  const exports = Object.entries(ctx.exports || {}).map(_ref => {
+    let [_path, exp] = _ref;
+    return _objectSpread({
+      _path
+    }, exp);
+  });
+  const dtsTask = {
+    type: "build:dts",
+    entries: []
+  };
+  const rollupTasks = {};
+
+  function _addRollupTaskEntry(format, runtime, entry) {
+    const buildId = "".concat(format, ":").concat(runtime);
+
+    if (rollupTasks[buildId]) {
+      rollupTasks[buildId].entries.push(entry);
+    } else {
+      rollupTasks[buildId] = {
+        type: "build:js",
+        buildId,
+        entries: [entry],
+        runtime,
+        format,
+        target: target[runtime]
+      };
+    }
+  }
+
+  for (const exp of exports) {
+    const importId = path$1.join(pkg.name, exp._path);
+
+    if (exp.types) {
+      dtsTask.entries.push({
+        importId,
+        exportPath: exp._path,
+        sourcePath: exp.source,
+        targetPath: exp.types
+      });
+    }
+  }
+
+  for (const exp of exports) {
+    const output = exp.require;
+    if (!output) continue;
+
+    _addRollupTaskEntry("commonjs", ctx.runtime, {
+      path: exp._path,
+      source: exp.source,
+      output
+    });
+  }
+
+  for (const exp of exports) {
+    const output = (_a = exp.browser) == null ? void 0 : _a.require;
+    if (!output) continue;
+
+    _addRollupTaskEntry("commonjs", "browser", {
+      path: exp._path,
+      source: ((_b = exp.browser) == null ? void 0 : _b.source) || exp.source,
+      output
+    });
+  }
+
+  for (const exp of exports) {
+    const output = exp.import;
+    if (!output) continue;
+
+    _addRollupTaskEntry("esm", ctx.runtime, {
+      path: exp._path,
+      source: exp.source,
+      output
+    });
+  }
+
+  for (const exp of exports) {
+    const output = (_c = exp.browser) == null ? void 0 : _c.import;
+    if (!output) continue;
+
+    _addRollupTaskEntry("esm", "browser", {
+      path: exp._path,
+      source: ((_d = exp.browser) == null ? void 0 : _d.source) || exp.source,
+      output
+    });
+  }
+
+  if (dtsTask.entries.length) {
+    tasks.push(dtsTask);
+  }
+
+  tasks.push(...Object.values(rollupTasks));
+
+  for (const exp of exports) {
+    if (exp._exported && exp._path !== ".") {
+      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"));
+      }
+    }
+  }
+
+  return tasks;
+}
+
+function _printExtractMessages(ctx, messages) {
+  const {
+    cwd,
+    logger
+  } = ctx;
+  const warnings = messages.filter(msg => msg.logLevel === "warning");
+
+  if (warnings.length) {
+    logger.log();
+  }
+
+  for (const msg of warnings) {
+    const sourceFilePath = msg.sourceFilePath && path$1.relative(cwd, msg.sourceFilePath);
+
+    if (msg.messageId === "TS6307") {
+      continue;
+    }
+
+    logger.log(["".concat(chalk.cyan(sourceFilePath || "?")), ":".concat(chalk.yellow(msg.sourceFileLine), ":").concat(chalk.yellow(msg.sourceFileColumn)), " - ".concat(chalk.yellow("warning"), " ").concat(chalk.gray(msg.messageId), "\n"), msg.text, "\n"].join(""));
+  }
+
+  const errors = messages.filter(msg => msg.logLevel === "error");
+
+  if (!warnings.length && errors.length) {
+    logger.log("");
+  }
+
+  for (const msg of errors) {
+    const sourceFilePath = msg.sourceFilePath && path$1.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(""));
+  }
+
+  if (errors.length) {
+    process.exit(1);
+  }
 }
 
-async function _loadPkgWithReporting(options) {
-  try {
-    return await _loadPkg(options);
-  } catch (err) {
-    if (err instanceof ZodError) {
-      for (const issue of err.issues) {
-        if (issue.code === "invalid_type") {
-          console.log("".concat(chalk.red("invalid type"), " in ./package.json at ").concat(chalk.magenta("`".concat(issue.path.join("."), "`")), " (expected ").concat(issue.expected, ", received ").concat(issue.received, ")"));
-        }
+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 += '/';
       }
-    } else {
-      console.error(err);
     }
 
-    process.exit(1);
-  }
-}
+    if (process.platform === 'win32') prefix = prefix.replace(/\\/g, '/'); // Mark this as a match
 
-function _parseExports(options) {
-  const {
-    pkg
-  } = options;
-  const rootExport = {
-    _exported: true,
-    _path: ".",
-    types: pkg.types,
-    source: pkg.source || "index.js",
-    browser: pkg.browser && {
-      require: pkg.main && pkg.browser[pkg.main],
-      import: pkg.module && pkg.browser[pkg.module]
-    },
-    import: pkg.module,
-    require: pkg.main,
-    default: pkg.module || pkg.main || "./index.js"
-  };
-  const extraExports = [];
+    this._emitMatch(index, prefix);
 
-  if (pkg.exports) {
-    for (const [exportPath, exportEntry] of Object.entries(pkg.exports)) {
-      if (_isRecord(exportEntry)) {
-        if (exportPath === ".") {
-          Object.assign(rootExport, exportEntry);
-        } else {
-          const extraExport = _objectSpread({
-            _exported: true,
-            _path: exportPath
-          }, exportEntry);
+    cb();
+  }; // Returns either 'DIR', 'FILE', or false
 
-          extraExports.push(extraExport);
-        }
+
+  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 {
-        throw new Error("string entries are not supported");
+        self._stat2(f, abs, er, lstat, cb);
       }
     }
-  }
+  };
 
-  return [rootExport, ...extraExports];
-}
+  Glob.prototype._stat2 = function (f, abs, er, stat, cb) {
+    if (er && (er.code === 'ENOENT' || er.code === 'ENOTDIR')) {
+      this.statCache[abs] = false;
+      return cb();
+    }
 
-async function _loadTSConfig(options) {
-  const {
-    cwd,
-    tsconfigPath
-  } = options;
-  const configPath = ts.findConfigFile(cwd, ts.sys.fileExists, tsconfigPath);
+    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);
+  };
 
-  if (!configPath) {
-    throw new Error("could not find a valid '".concat(tsconfigPath, "'"));
-  }
+  return glob_1;
+}
 
-  const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
-  return ts.parseJsonConfigFileContent(configFile.config, ts.sys, cwd);
+const assert = require$$5;
+const path = path$1;
+const fs = fs$2;
+let glob = undefined;
+
+try {
+  glob = requireGlob();
+} catch (_err) {// treat glob as optional.
 }
 
-function _resolveBuildTasks(ctx) {
-  var _a, _b, _c, _d, _e;
+const defaultGlobOpts = {
+  nosort: true,
+  silent: true
+}; // for EMFILE handling
 
-  const {
-    cwd,
-    pkg,
-    target
-  } = ctx;
-  const tasks = [];
-  const exports = Object.entries(ctx.exports || {}).map(_ref => {
-    let [_path, exp] = _ref;
-    return _objectSpread({
-      _path
-    }, exp);
+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];
   });
-  const dtsTask = {
-    type: "build:dts",
-    entries: []
-  };
-  const rollupTasks = {};
+  options.maxBusyTries = options.maxBusyTries || 3;
+  options.emfileWait = options.emfileWait || 1000;
 
-  function _addRollupTaskEntry(format, runtime, entry) {
-    const buildId = "".concat(format, ":").concat(runtime);
+  if (options.glob === false) {
+    options.disableGlob = true;
+  }
 
-    if (rollupTasks[buildId]) {
-      rollupTasks[buildId].entries.push(entry);
-    } else {
-      rollupTasks[buildId] = {
-        type: "build:js",
-        buildId,
-        entries: [entry],
-        runtime,
-        format,
-        target: target[runtime]
-      };
-    }
+  if (options.disableGlob !== true && glob === undefined) {
+    throw Error('glob dependency not found, set `options.disableGlob = true` if intentional');
   }
 
-  for (const exp of exports) {
-    const importId = path.join(pkg.name, exp._path);
+  options.disableGlob = options.disableGlob || false;
+  options.glob = options.glob || defaultGlobOpts;
+};
 
-    if (exp.types) {
-      dtsTask.entries.push({
-        importId,
-        exportPath: exp._path,
-        sourcePath: exp.source,
-        targetPath: exp.types
-      });
-    }
+const rimraf$1 = (p, options, cb) => {
+  if (typeof options === 'function') {
+    cb = options;
+    options = {};
   }
 
-  for (const exp of exports) {
-    const output = exp.require;
-    if (!output) continue;
+  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);
+  };
 
-    _addRollupTaskEntry("commonjs", ctx.runtime, {
-      path: exp._path,
-      source: exp.source,
-      output
-    });
-  }
+  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.
 
-  for (const exp of exports) {
-    const output = (_a = exp.browser) == null ? void 0 : _a.require;
-    if (!output) continue;
+            return setTimeout(() => rimraf_(p, options, CB), busyTries * 100);
+          } // this one won't happen if graceful-fs is used.
 
-    _addRollupTaskEntry("commonjs", "browser", {
-      path: exp._path,
-      source: ((_b = exp.browser) == null ? void 0 : _b.source) || exp.source,
-      output
-    });
-  }
 
-  for (const exp of exports) {
-    const output = exp.import;
-    if (!output) continue;
+          if (er.code === "EMFILE" && timeout < options.emfileWait) {
+            return setTimeout(() => rimraf_(p, options, CB), timeout++);
+          } // already gone
 
-    _addRollupTaskEntry("esm", ctx.runtime, {
-      path: exp._path,
-      source: exp.source,
-      output
+
+          if (er.code === "ENOENT") er = null;
+        }
+
+        timeout = 0;
+        next(er);
+      };
+
+      rimraf_(p, options, CB);
     });
-  }
+  };
 
-  for (const exp of exports) {
-    const output = (_c = exp.browser) == null ? void 0 : _c.import;
-    if (!output) continue;
+  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);
+      }
 
-    _addRollupTaskEntry("esm", "browser", {
-      path: exp._path,
-      source: ((_d = exp.browser) == null ? void 0 : _d.source) || exp.source,
-      output
+      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;
   }
 
-  if (dtsTask.entries.length) {
-    tasks.push(dtsTask);
+  let stats;
+
+  try {
+    stats = options.statSync(p);
+  } catch (er3) {
+    if (er3.code === "ENOENT") return;else throw er;
   }
 
-  tasks.push(...Object.values(rollupTasks));
+  if (stats.isDirectory()) rmdirSync(p, options, er);else options.unlinkSync(p);
+};
 
-  for (const exp of exports) {
-    if (exp._exported && exp._path !== ".") {
-      const relativeTargetPath = (((_e = exp.browser) == null ? void 0 : _e.import) || exp.import || "").replace(/\.[^/.]+$/, "");
+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.
 
-      if (relativeTargetPath) {
-        fs$1.writeFileSync(path.resolve(cwd, "".concat(exp._path, ".js")), ["// AUTO-GENERATED \u2013 DO NOT EDIT", "", "export * from '".concat(relativeTargetPath, "'"), ""].join("\n"));
-      }
+  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);
     }
   }
 
-  return tasks;
-}
-
-function _printExtractMessages(ctx, messages) {
-  const {
-    cwd,
-    logger
-  } = ctx;
-  const warnings = messages.filter(msg => msg.logLevel === "warning");
+  if (!results.length) return;
 
-  if (warnings.length) {
-    logger.log();
-  }
+  for (let i = 0; i < results.length; i++) {
+    const p = results[i];
+    let st;
 
-  for (const msg of warnings) {
-    const sourceFilePath = msg.sourceFilePath && path.relative(cwd, msg.sourceFilePath);
+    try {
+      st = options.lstatSync(p);
+    } catch (er) {
+      if (er.code === "ENOENT") return; // Windows can EPERM on stat.  Life is suffering.
 
-    if (msg.messageId === "TS6307") {
-      continue;
+      if (er.code === "EPERM" && isWindows) fixWinEPERMSync(p, options, er);
     }
 
-    logger.log(["".concat(chalk.cyan(sourceFilePath || "?")), ":".concat(chalk.yellow(msg.sourceFileLine), ":").concat(chalk.yellow(msg.sourceFileColumn)), " - ".concat(chalk.yellow("warning"), " ").concat(chalk.gray(msg.messageId), "\n"), msg.text, "\n"].join(""));
+    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 errors = messages.filter(msg => msg.logLevel === "error");
+const rmdirSync = (p, options, originalEr) => {
+  assert(p);
+  assert(options);
 
-  if (!warnings.length && errors.length) {
-    logger.log("");
+  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);
   }
+};
 
-  for (const msg of errors) {
-    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(""));
-  }
+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.
 
-  if (errors.length) {
-    process.exit(1);
-  }
-}
+  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,
@@ -461,11 +3986,11 @@ function _createApiExtractorConfig(options) {
     },
     docModel: {
       enabled: false,
-      apiJsonFilePath: path.resolve(distPath, "".concat(exportPath, ".api.json"))
+      apiJsonFilePath: path$1.resolve(distPath, "".concat(exportPath, ".api.json"))
     },
     dtsRollup: {
       enabled: true,
-      untrimmedFilePath: path.resolve(distPath, filePath)
+      untrimmedFilePath: path$1.resolve(distPath, filePath)
     },
     tsdocMetadata: {
       enabled: false
@@ -584,7 +4109,7 @@ async function _extractTypes(options) {
     }),
     configObjectFullPath: void 0,
     tsdocConfigFile,
-    packageJsonFullPath: path.resolve(projectPath, "package.json")
+    packageJsonFullPath: path$1.resolve(projectPath, "package.json")
   });
   const messages = [];
   const extractorResult = Extractor.invoke(extractorConfig, {
@@ -597,11 +4122,11 @@ async function _extractTypes(options) {
     }
 
   });
-  const typesPath = path.resolve(distPath, filePath);
-  const typesBuf = await fs.readFile(typesPath);
+  const typesPath = path$1.resolve(distPath, filePath);
+  const typesBuf = await fs$1.readFile(typesPath);
   const prettierConfig = await prettier.resolveConfig(typesPath);
-  await mkdirp(path.dirname(typesPath));
-  await fs.writeFile(typesPath, prettier.format(typesBuf.toString(), _objectSpread(_objectSpread({}, prettierConfig), {}, {
+  await mkdirp(path$1.dirname(typesPath));
+  await fs$1.writeFile(typesPath, prettier.format(typesBuf.toString(), _objectSpread(_objectSpread({}, prettierConfig), {}, {
     filepath: typesPath
   })));
   files.push({
@@ -614,6 +4139,8 @@ async function _extractTypes(options) {
   };
 }
 
+const rimraf = promisify(rimraf_1);
+
 async function _doExtract(ctx, task) {
   var _a;
 
@@ -624,11 +4151,16 @@ async function _doExtract(ctx, task) {
     files,
     ts
   } = ctx;
-  if (!ts.config || !ts.configPath) return {
-    type: "dts",
-    messages: []
-  };
-  const distPath = path.resolve(cwd, dist);
+
+  if (!ts.config || !ts.configPath) {
+    return {
+      type: "dts",
+      messages: [],
+      results: []
+    };
+  }
+
+  const distPath = path$1.resolve(cwd, dist);
   const {
     outDir = distPath,
     rootDir = cwd
@@ -639,10 +4171,12 @@ async function _doExtract(ctx, task) {
     tsconfig: ts.config
   });
   const messages = [];
+  const results = [];
 
   for (const entry of task.entries) {
     const exportPath = entry.exportPath === "." ? "./index" : entry.exportPath;
-    const filePath = path.relative(distPath, path.resolve(cwd, entry.targetPath));
+    const sourcePath = path$1.resolve(outDir, path$1.relative(cwd, rootDir), entry.sourcePath.replace(/\.ts$/, ".d.ts"));
+    const filePath = path$1.relative(distPath, path$1.resolve(cwd, entry.targetPath));
     const result = await _extractTypes({
       cwd,
       exportPath,
@@ -650,10 +4184,14 @@ async function _doExtract(ctx, task) {
       filePath,
       projectPath: cwd,
       rules: (_a = config == null ? void 0 : config.extract) == null ? void 0 : _a.rules,
-      sourcePath: path.resolve(outDir, path.relative(cwd, rootDir), entry.sourcePath.replace(/\.ts$/, ".d.ts")),
-      tsconfigPath: path.resolve(cwd, ts.configPath),
+      sourcePath,
+      tsconfigPath: path$1.resolve(cwd, ts.configPath),
       distPath
     });
+    results.push({
+      sourcePath,
+      filePath
+    });
     messages.push(...result.messages);
 
     if (result.messages.some(msg => msg.logLevel === "error")) {
@@ -661,9 +4199,20 @@ async function _doExtract(ctx, task) {
     }
   }
 
+  const tmpPath = path$1.resolve(distPath, "__tmp__");
+  await rename(outDir, tmpPath);
+
+  for (const result of results) {
+    const fromPath = path$1.resolve(tmpPath, path$1.relative(outDir, path$1.resolve(distPath, result.filePath)));
+    const toPath = path$1.resolve(distPath, result.filePath);
+    cpx.copySync(fromPath, path$1.dirname(toPath));
+  }
+
+  await rimraf(tmpPath);
   return {
     type: "dts",
-    messages
+    messages,
+    results
   };
 }
 
@@ -754,17 +4303,17 @@ function _resolveRollupConfig(ctx, buildTask) {
 
     var _a2;
 
-    return [key, path.resolve(cwd, ((_a2 = ts.config) == null ? void 0 : _a2.options.baseUrl) || ".", val[0])];
+    return [key, path$1.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.relative(outDir, entry.output).replace(/\.[^/.]+$/, "")
+      name: path$1.relative(outDir, entry.output).replace(/\.[^/.]+$/, "")
     });
   }, {});
 
-  const exportIds = _exports && Object.keys(_exports).map(exportPath => path.join(pkg.name, exportPath));
+  const exportIds = _exports && Object.keys(_exports).map(exportPath => path$1.join(pkg.name, exportPath));
 
-  const sourcePaths = _exports && Object.values(_exports).map(e => path.resolve(cwd, e.source));
+  const sourcePaths = _exports && Object.values(_exports).map(e => path$1.resolve(cwd, e.source));
 
   return {
     inputOptions: {
@@ -775,10 +4324,10 @@ function _resolveRollupConfig(ctx, buildTask) {
         }
 
         if (importer && (id.startsWith(".") || id.startsWith("/"))) {
-          const idPath = path.resolve(path.dirname(importer), id);
+          const idPath = path$1.resolve(path$1.dirname(importer), id);
 
           if (sourcePaths == null ? void 0 : sourcePaths.includes(idPath)) {
-            logger.warn("detected self-referencing import \u2013 treating as external: ".concat(path.relative(cwd, idPath)));
+            logger.warn("detected self-referencing import \u2013 treating as external: ".concat(path$1.relative(cwd, idPath)));
             return true;
           }
         }
@@ -808,14 +4357,14 @@ function _resolveRollupConfig(ctx, buildTask) {
         preventAssignment: true,
         values: _objectSpread({}, pkg.name === "@sanity/pkg-utils" ? {} : {
           "process.env.PKG_FILE_PATH": arg => {
-            const sourcePath = "./" + path.relative(cwd, arg);
+            const sourcePath = "./" + path$1.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.relative(cwd, path.resolve(outDir, entry.name + outputExt)));
+            return JSON.stringify(path$1.relative(cwd, path$1.resolve(outDir, entry.name + outputExt)));
           },
           "process.env.PKG_FORMAT": JSON.stringify(format),
           "process.env.PKG_RUNTIME": JSON.stringify(runtime),
@@ -873,7 +4422,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.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$1.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 => {
@@ -910,12 +4459,12 @@ async function _execPromise(ctx, task) {
     if (chunkOrAsset.type === "asset") {
       files.push({
         type: "asset",
-        path: path.resolve(outDir, chunkOrAsset.fileName)
+        path: path$1.resolve(outDir, chunkOrAsset.fileName)
       });
     } else {
       files.push({
         type: "chunk",
-        path: path.resolve(outDir, chunkOrAsset.fileName)
+        path: path$1.resolve(outDir, chunkOrAsset.fileName)
       });
     }
   }
@@ -925,7 +4474,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.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$1.join(ctx.pkg.name, e.path)), ": ").concat(e.source, " -> ").concat(e.output)).join("\n       ")),
   exec: (ctx, task) => {
     const {
       inputOptions,
@@ -952,7 +4501,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.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$1.join(ctx.pkg.name, e.path)), ": ").concat(e.source, " -> ").concat(e.output)).join("\n       ")));
       logger.log("");
       return;
     }
@@ -1100,8 +4649,8 @@ async function _resolveBuildContext(options) {
 
   const targetVersions = _resolveBrowserslistVersions(pkg.browserslist || _DEFAULTS.browserslist);
 
-  const srcPath = path.resolve(cwd, (config == null ? void 0 : config.src) || "src");
-  const distPath = path.resolve(cwd, (config == null ? void 0 : config.dist) || "dist");
+  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);
 
@@ -1143,7 +4692,7 @@ async function _resolveBuildContext(options) {
   const ctx = {
     config,
     cwd,
-    dist: path.relative(cwd, distPath),
+    dist: path$1.relative(cwd, distPath),
     exports,
     external,
     files: [],
@@ -1181,7 +4730,7 @@ async function _resolveBuildContext(options) {
       }
     },
     pkg,
-    src: path.relative(cwd, srcPath),
+    src: path$1.relative(cwd, srcPath),
     runtime: (_ref9 = config == null ? void 0 : config.runtime) !== null && _ref9 !== void 0 ? _ref9 : "*",
     target,
     ts: {
@@ -1258,7 +4807,7 @@ function _getFilesize(file) {
 
 function _fileExists(file) {
   try {
-    fs$1.accessSync(file);
+    fs$2.accessSync(file);
     return true;
   } catch (_) {
     return false;
@@ -1266,7 +4815,7 @@ function _fileExists(file) {
 }
 
 function _getFileInfo(cwd, filePath) {
-  const p = path.resolve(cwd, filePath);
+  const p = path$1.resolve(cwd, filePath);
 
   const exists = _fileExists(p);
 
@@ -1311,18 +4860,28 @@ function _printPackageTree(ctx) {
       source: entry.source,
       default: entry.default
     };
+    if (entry.types) exp.types = _fileInfo(entry.types);
 
     if (entry.browser) {
-      exp.browser = {};
+      exp.browser = {
+        source: entry.browser.source
+      };
       if (entry.browser.import) exp.browser.import = _fileInfo(entry.browser.import);
       if (entry.browser.require) exp.browser.import = _fileInfo(entry.browser.require);
     }
 
+    if (entry.node) {
+      exp.node = {
+        source: entry.node.source
+      };
+      if (entry.node.import) exp.node.import = _fileInfo(entry.node.import);
+      if (entry.node.require) exp.node.import = _fileInfo(entry.node.require);
+    }
+
     if (entry.import) exp.import = _fileInfo(entry.import);
     if (entry.require) exp.require = _fileInfo(entry.require);
-    if (entry.types) exp.types = _fileInfo(entry.types);
     exp.default = _fileInfo(entry.default);
-    return [chalk.green(path.join(pkg.name, exportPath)), exp];
+    return [chalk.green(path$1.join(pkg.name, exportPath)), exp];
   }));
   logger.log(treeify.asTree(tree, true, true));
 }
@@ -1352,19 +4911,19 @@ async function check(options) {
     const missingFiles = [];
 
     for (const [, exp] of Object.entries(ctx.exports || {})) {
-      if (exp.source && !_fileExists(path.resolve(cwd, exp.source))) {
+      if (exp.source && !_fileExists(path$1.resolve(cwd, exp.source))) {
         missingFiles.push(exp.source);
       }
 
-      if (exp.require && !_fileExists(path.resolve(cwd, exp.require))) {
+      if (exp.require && !_fileExists(path$1.resolve(cwd, exp.require))) {
         missingFiles.push(exp.require);
       }
 
-      if (exp.import && !_fileExists(path.resolve(cwd, exp.import))) {
+      if (exp.import && !_fileExists(path$1.resolve(cwd, exp.import))) {
         missingFiles.push(exp.import);
       }
 
-      if (exp.types && !_fileExists(path.resolve(cwd, exp.types))) {
+      if (exp.types && !_fileExists(path$1.resolve(cwd, exp.types))) {
         missingFiles.push(exp.types);
       }
     }
@@ -1494,7 +5053,7 @@ function _resolveWatchTasks(ctx) {
   }
 
   for (const exp of exports) {
-    const importId = path.join(pkg.name, exp._path);
+    const importId = path$1.join(pkg.name, exp._path);
 
     if (exp.types) {
       dtsTask.entries.push({
@@ -1561,7 +5120,7 @@ function _resolveWatchTasks(ctx) {
       const relativeTargetPath = (((_e = exp.browser) == null ? void 0 : _e.import) || exp.import || "").replace(/\.[^/.]+$/, "");
 
       if (relativeTargetPath) {
-        fs$1.writeFileSync(path.resolve(cwd, "".concat(exp._path, ".js")), ["// AUTO-GENERATED \u2013 DO NOT EDIT", "", "export * from '".concat(relativeTargetPath, "'"), ""].join("\n"));
+        fs$2.writeFileSync(path$1.resolve(cwd, "".concat(exp._path, ".js")), ["// AUTO-GENERATED \u2013 DO NOT EDIT", "", "export * from '".concat(relativeTargetPath, "'"), ""].join("\n"));
       }
     }
   }
@@ -1598,9 +5157,9 @@ async function _watchConfigFiles(options) {
   const {
     cwd
   } = options;
-  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 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 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")]);
+  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")]);
 
   return fileEvent$.pipe(scan((files, fileEvent) => {
     if (fileEvent.type === "add") {
@@ -1613,7 +5172,7 @@ async function _watchConfigFiles(options) {
 
     if (fileEvent.type === "change") {
       console.log("--------------------------------------------------------------------------------");
-      console.log(chalk.blue("info  "), path.relative(cwd, fileEvent.file), "changed");
+      console.log(chalk.blue("info  "), path$1.relative(cwd, fileEvent.file), "changed");
       console.log("");
       return files.slice(0);
     }
@@ -1631,7 +5190,7 @@ async function watch(options) {
     cwd
   });
   const ctx$ = configFiles$.pipe(switchMap(async configFiles => {
-    const _files = configFiles.map(f => path.relative(cwd, f));
+    const _files = configFiles.map(f => path$1.relative(cwd, f));
 
     const packageJsonPath = _files.find(f => f === "package.json");