@markw65/monkeyc-optimizer 1.0.1 → 1.0.2

package/build/optimizer.cjs

@@ -1,304 +1,6 @@
 /******/ (() => { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
 
-/***/ 5623:
-/***/ ((module) => {
-
-"use strict";
-
-module.exports = 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;
-}
-
-
-/***/ }),
-
-/***/ 3644:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-var concatMap = __webpack_require__(1048);
-var balanced = __webpack_require__(5623);
-
-module.exports = 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 identity(e) {
-  return e;
-}
-
-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;
-}
-
-
-
-/***/ }),
-
-/***/ 1048:
-/***/ ((module) => {
-
-module.exports = 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]';
-};
-
-
-/***/ }),
-
 /***/ 7187:
 /***/ ((module) => {
 
@@ -765,3078 +467,42 @@ function once(emitter, name) {
       resolve([].slice.call(arguments));
     };
 
-    eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
-    if (name !== 'error') {
-      addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
-    }
-  });
-}
-
-function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
-  if (typeof emitter.on === 'function') {
-    eventTargetAgnosticAddListener(emitter, 'error', handler, flags);
-  }
-}
-
-function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
-  if (typeof emitter.on === 'function') {
-    if (flags.once) {
-      emitter.once(name, listener);
-    } else {
-      emitter.on(name, listener);
-    }
-  } else if (typeof emitter.addEventListener === 'function') {
-    // EventTarget does not have `error` event semantics like Node
-    // EventEmitters, we do not listen for `error` events here.
-    emitter.addEventListener(name, function wrapListener(arg) {
-      // IE does not have builtin `{ once: true }` support so we
-      // have to do it manually.
-      if (flags.once) {
-        emitter.removeEventListener(name, wrapListener);
-      }
-      listener(arg);
-    });
-  } else {
-    throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
-  }
-}
-
-
-/***/ }),
-
-/***/ 7334:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-module.exports = realpath
-realpath.realpath = realpath
-realpath.sync = realpathSync
-realpath.realpathSync = realpathSync
-realpath.monkeypatch = monkeypatch
-realpath.unmonkeypatch = unmonkeypatch
-
-var fs = __webpack_require__(6231)
-var origRealpath = fs.realpath
-var origRealpathSync = fs.realpathSync
-
-var version = process.version
-var ok = /^v[0-5]\./.test(version)
-var old = __webpack_require__(7059)
-
-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
-}
-
-
-/***/ }),
-
-/***/ 7059:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-// 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 = __webpack_require__(1423);
-var isWindows = process.platform === 'win32';
-var fs = __webpack_require__(6231);
-
-// 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();
-}
-
-var normalize = pathModule.normalize;
-
-// 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 = /^[\/]*/;
-}
-
-exports.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;
-};
-
-
-exports.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();
-  }
-};
-
-
-/***/ }),
-
-/***/ 6772:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-exports.setopts = setopts
-exports.ownProp = ownProp
-exports.makeAbs = makeAbs
-exports.finish = finish
-exports.mark = mark
-exports.isIgnored = isIgnored
-exports.childrenIgnored = childrenIgnored
-
-function ownProp (obj, field) {
-  return Object.prototype.hasOwnProperty.call(obj, field)
-}
-
-var fs = __webpack_require__(6231)
-var path = __webpack_require__(1423)
-var minimatch = __webpack_require__(1171)
-var isAbsolute = __webpack_require__(4095)
-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
-
-  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))
-  })
-}
-
-
-/***/ }),
-
-/***/ 2884:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-// 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.
-
-module.exports = glob
-
-var rp = __webpack_require__(7334)
-var minimatch = __webpack_require__(1171)
-var Minimatch = minimatch.Minimatch
-var inherits = __webpack_require__(5717)
-var EE = (__webpack_require__(7187).EventEmitter)
-var path = __webpack_require__(1423)
-var assert = __webpack_require__(9084)
-var isAbsolute = __webpack_require__(4095)
-var globSync = __webpack_require__(4751)
-var common = __webpack_require__(6772)
-var setopts = common.setopts
-var ownProp = common.ownProp
-var inflight = __webpack_require__(7844)
-var util = __webpack_require__(6464)
-var childrenIgnored = common.childrenIgnored
-var isIgnored = common.isIgnored
-
-var once = __webpack_require__(778)
-
-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.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]
-    var newPattern
-    if (prefix) {
-      if (prefix !== '/')
-        e = prefix + '/' + e
-      else
-        e = prefix + e
-    }
-    this._process([e].concat(remain), index, inGlobStar, cb)
-  }
-  cb()
-}
-
-Glob.prototype._emitMatch = function (index, e) {
-  if (this.aborted)
-    return
-
-  if (isIgnored(this, e))
-    return
-
-  if (this.paused) {
-    this._emitQueue.push([index, e])
-    return
-  }
-
-  var abs = isAbsolute(e) ? e : this._makeAbs(e)
-
-  if (this.mark)
-    e = this._mark(e)
-
-  if (this.absolute)
-    e = abs
-
-  if (this.matches[index][e])
-    return
-
-  if (this.nodir) {
-    var c = this.cache[abs]
-    if (c === 'DIR' || Array.isArray(c))
-      return
-  }
-
-  this.matches[index][e] = true
-
-  var st = this.statCache[abs]
-  if (st)
-    this.emit('stat', e, st)
-
-  this.emit('match', e)
-}
-
-Glob.prototype._readdirInGlobStar = function (abs, cb) {
-  if (this.aborted)
-    return
-
-  // follow all symlinked directories forever
-  // just proceed as if this is a non-globstar situation
-  if (this.follow)
-    return this._readdir(abs, false, cb)
-
-  var lstatkey = 'lstat\0' + abs
-  var self = this
-  var lstatcb = inflight(lstatkey, lstatcb_)
-
-  if (lstatcb)
-    self.fs.lstat(abs, lstatcb)
-
-  function lstatcb_ (er, lstat) {
-    if (er && er.code === 'ENOENT')
-      return cb()
-
-    var isSym = lstat && lstat.isSymbolicLink()
-    self.symlinks[abs] = isSym
-
-    // If it's not a symlink or a dir, then it's definitely a regular file.
-    // don't bother doing a readdir in that case.
-    if (!isSym && lstat && !lstat.isDirectory()) {
-      self.cache[abs] = 'FILE'
-      cb()
-    } else
-      self._readdir(abs, false, cb)
-  }
-}
-
-Glob.prototype._readdir = function (abs, inGlobStar, cb) {
-  if (this.aborted)
-    return
-
-  cb = inflight('readdir\0'+abs+'\0'+inGlobStar, cb)
-  if (!cb)
-    return
-
-  //console.error('RD %j %j', +inGlobStar, abs)
-  if (inGlobStar && !ownProp(this.symlinks, abs))
-    return this._readdirInGlobStar(abs, cb)
-
-  if (ownProp(this.cache, abs)) {
-    var c = this.cache[abs]
-    if (!c || c === 'FILE')
-      return cb()
-
-    if (Array.isArray(c))
-      return cb(null, c)
-  }
-
-  var self = this
-  self.fs.readdir(abs, readdirCb(this, abs, cb))
-}
-
-function readdirCb (self, abs, cb) {
-  return function (er, entries) {
-    if (er)
-      self._readdirError(abs, er, cb)
-    else
-      self._readdirEntries(abs, entries, cb)
-  }
-}
-
-Glob.prototype._readdirEntries = function (abs, entries, cb) {
-  if (this.aborted)
-    return
-
-  // if we haven't asked to stat everything, then just
-  // assume that everything in there exists, so we can avoid
-  // having to stat it a second time.
-  if (!this.mark && !this.stat) {
-    for (var i = 0; i < entries.length; i ++) {
-      var e = entries[i]
-      if (abs === '/')
-        e = abs + e
-      else
-        e = abs + '/' + e
-      this.cache[e] = true
-    }
-  }
-
-  this.cache[abs] = entries
-  return cb(null, entries)
-}
-
-Glob.prototype._readdirError = function (f, er, cb) {
-  if (this.aborted)
-    return
-
-  // handle errors, and cache the information
-  switch (er.code) {
-    case 'ENOTSUP': // https://github.com/isaacs/node-glob/issues/205
-    case 'ENOTDIR': // totally normal. means it *does* exist.
-      var abs = this._makeAbs(f)
-      this.cache[abs] = 'FILE'
-      if (abs === this.cwdAbs) {
-        var error = new Error(er.code + ' invalid cwd ' + this.cwd)
-        error.path = this.cwd
-        error.code = er.code
-        this.emit('error', error)
-        this.abort()
-      }
-      break
-
-    case 'ENOENT': // not terribly unusual
-    case 'ELOOP':
-    case 'ENAMETOOLONG':
-    case 'UNKNOWN':
-      this.cache[this._makeAbs(f)] = false
-      break
-
-    default: // some unusual error.  Treat as failure.
-      this.cache[this._makeAbs(f)] = false
-      if (this.strict) {
-        this.emit('error', er)
-        // If the error is handled, then we abort
-        // if not, we threw out of here
-        this.abort()
-      }
-      if (!this.silent)
-        console.error('glob error', er)
-      break
-  }
-
-  return cb()
-}
-
-Glob.prototype._processGlobStar = function (prefix, read, abs, remain, index, inGlobStar, cb) {
-  var self = this
-  this._readdir(abs, inGlobStar, function (er, entries) {
-    self._processGlobStar2(prefix, read, abs, remain, index, inGlobStar, entries, cb)
-  })
-}
-
-
-Glob.prototype._processGlobStar2 = function (prefix, read, abs, remain, index, inGlobStar, entries, cb) {
-  //console.error('pgs2', prefix, remain[0], entries)
-
-  // no entries means not a dir, so it can never have matches
-  // foo.txt/** doesn't match foo.txt
-  if (!entries)
-    return cb()
-
-  // test without the globstar, and with every child both below
-  // and replacing the globstar.
-  var remainWithoutGlobStar = remain.slice(1)
-  var gspref = prefix ? [ prefix ] : []
-  var noGlobStar = gspref.concat(remainWithoutGlobStar)
-
-  // the noGlobStar pattern exits the inGlobStar state
-  this._process(noGlobStar, index, false, cb)
-
-  var isSym = this.symlinks[abs]
-  var len = entries.length
-
-  // If it's a symlink, and we're in a globstar, then stop
-  if (isSym && inGlobStar)
-    return cb()
-
-  for (var i = 0; i < len; i++) {
-    var e = entries[i]
-    if (e.charAt(0) === '.' && !this.dot)
-      continue
-
-    // these two cases enter the inGlobStar state
-    var instead = gspref.concat(entries[i], remainWithoutGlobStar)
-    this._process(instead, index, true, cb)
-
-    var below = gspref.concat(entries[i], remain)
-    this._process(below, index, true, cb)
-  }
-
-  cb()
-}
-
-Glob.prototype._processSimple = function (prefix, index, cb) {
-  // XXX review this.  Shouldn't it be doing the mounting etc
-  // before doing stat?  kinda weird?
-  var self = this
-  this._stat(prefix, function (er, exists) {
-    self._processSimple2(prefix, index, er, exists, cb)
-  })
-}
-Glob.prototype._processSimple2 = function (prefix, index, er, exists, cb) {
-
-  //console.error('ps2', prefix, exists)
-
-  if (!this.matches[index])
-    this.matches[index] = Object.create(null)
-
-  // If it doesn't exist, then just mark the lack of results
-  if (!exists)
-    return cb()
-
-  if (prefix && isAbsolute(prefix) && !this.nomount) {
-    var trail = /[\/\\]$/.test(prefix)
-    if (prefix.charAt(0) === '/') {
-      prefix = path.join(this.root, prefix)
-    } else {
-      prefix = path.resolve(this.root, prefix)
-      if (trail)
-        prefix += '/'
-    }
-  }
-
-  if (process.platform === 'win32')
-    prefix = prefix.replace(/\\/g, '/')
-
-  // Mark this as a match
-  this._emitMatch(index, prefix)
-  cb()
-}
-
-// Returns either 'DIR', 'FILE', or false
-Glob.prototype._stat = function (f, cb) {
-  var abs = this._makeAbs(f)
-  var needDir = f.slice(-1) === '/'
-
-  if (f.length > this.maxLength)
-    return cb()
-
-  if (!this.stat && ownProp(this.cache, abs)) {
-    var c = this.cache[abs]
-
-    if (Array.isArray(c))
-      c = 'DIR'
-
-    // It exists, but maybe not how we need it
-    if (!needDir || c === 'DIR')
-      return cb(null, c)
-
-    if (needDir && c === 'FILE')
-      return cb()
-
-    // otherwise we have to stat, because maybe c=true
-    // if we know it exists, but not what it is.
-  }
-
-  var exists
-  var stat = this.statCache[abs]
-  if (stat !== undefined) {
-    if (stat === false)
-      return cb(null, stat)
-    else {
-      var type = stat.isDirectory() ? 'DIR' : 'FILE'
-      if (needDir && type === 'FILE')
-        return cb()
-      else
-        return cb(null, type, stat)
-    }
-  }
-
-  var self = this
-  var statcb = inflight('stat\0' + abs, lstatcb_)
-  if (statcb)
-    self.fs.lstat(abs, statcb)
-
-  function lstatcb_ (er, lstat) {
-    if (lstat && lstat.isSymbolicLink()) {
-      // If it's a symlink, then treat it as the target, unless
-      // the target does not exist, then treat it as a file.
-      return self.fs.stat(abs, function (er, stat) {
-        if (er)
-          self._stat2(f, abs, null, lstat, cb)
-        else
-          self._stat2(f, abs, er, stat, cb)
-      })
-    } else {
-      self._stat2(f, abs, er, lstat, cb)
-    }
-  }
-}
-
-Glob.prototype._stat2 = function (f, abs, er, stat, cb) {
-  if (er && (er.code === 'ENOENT' || er.code === 'ENOTDIR')) {
-    this.statCache[abs] = false
-    return cb()
-  }
-
-  var needDir = f.slice(-1) === '/'
-  this.statCache[abs] = stat
-
-  if (abs.slice(-1) === '/' && stat && !stat.isDirectory())
-    return cb(null, false, stat)
-
-  var c = true
-  if (stat)
-    c = stat.isDirectory() ? 'DIR' : 'FILE'
-  this.cache[abs] = this.cache[abs] || c
-
-  if (needDir && c === 'FILE')
-    return cb()
-
-  return cb(null, c, stat)
-}
-
-
-/***/ }),
-
-/***/ 4751:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-module.exports = globSync
-globSync.GlobSync = GlobSync
-
-var rp = __webpack_require__(7334)
-var minimatch = __webpack_require__(1171)
-var Minimatch = minimatch.Minimatch
-var Glob = (__webpack_require__(2884).Glob)
-var util = __webpack_require__(6464)
-var path = __webpack_require__(1423)
-var assert = __webpack_require__(9084)
-var isAbsolute = __webpack_require__(4095)
-var common = __webpack_require__(6772)
-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(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(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.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
-  var stat
-  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) {
-  var entries
-
-  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 exists
-  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)
-}
-
-
-/***/ }),
-
-/***/ 7844:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-var wrappy = __webpack_require__(2479)
-var reqs = Object.create(null)
-var once = __webpack_require__(778)
-
-module.exports = 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
-}
-
-
-/***/ }),
-
-/***/ 5717:
-/***/ ((module) => {
-
-if (typeof Object.create === 'function') {
-  // implementation from standard node.js 'util' module
-  module.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
-  module.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
-    }
-  }
-}
-
-
-/***/ }),
-
-/***/ 1171:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-module.exports = minimatch
-minimatch.Minimatch = Minimatch
-
-var path = (function () { try { return __webpack_require__(1423) } catch (e) {}}()) || {
-  sep: '/'
-}
-minimatch.sep = path.sep
-
-var GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {}
-var expand = __webpack_require__(3644)
-
-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, '\\$&')
-}
-
-
-/***/ }),
-
-/***/ 778:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-var wrappy = __webpack_require__(2479)
-module.exports = wrappy(once)
-module.exports.strict = wrappy(onceStrict)
-
-once.proto = once(function () {
-  Object.defineProperty(Function.prototype, 'once', {
-    value: function () {
-      return once(this)
-    },
-    configurable: true
-  })
-
-  Object.defineProperty(Function.prototype, 'onceStrict', {
-    value: function () {
-      return onceStrict(this)
-    },
-    configurable: true
-  })
-})
-
-function once (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
+    eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
+    if (name !== 'error') {
+      addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
+    }
+  });
 }
 
-function onceStrict (fn) {
-  var f = function () {
-    if (f.called)
-      throw new Error(f.onceError)
-    f.called = true
-    return f.value = fn.apply(this, arguments)
+function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
+  if (typeof emitter.on === 'function') {
+    eventTargetAgnosticAddListener(emitter, 'error', handler, flags);
   }
-  var name = fn.name || 'Function wrapped with `once`'
-  f.onceError = name + " shouldn't be called more than once"
-  f.called = false
-  return f
-}
-
-
-/***/ }),
-
-/***/ 4095:
-/***/ ((module) => {
-
-"use strict";
-
-
-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);
+function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
+  if (typeof emitter.on === 'function') {
+    if (flags.once) {
+      emitter.once(name, listener);
+    } else {
+      emitter.on(name, listener);
+    }
+  } else if (typeof emitter.addEventListener === 'function') {
+    // EventTarget does not have `error` event semantics like Node
+    // EventEmitters, we do not listen for `error` events here.
+    emitter.addEventListener(name, function wrapListener(arg) {
+      // IE does not have builtin `{ once: true }` support so we
+      // have to do it manually.
+      if (flags.once) {
+        emitter.removeEventListener(name, wrapListener);
+      }
+      listener(arg);
+    });
+  } else {
+    throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
+  }
 }
 
-module.exports = process.platform === 'win32' ? win32 : posix;
-module.exports.posix = posix;
-module.exports.win32 = win32;
-
 
 /***/ }),
 
@@ -5410,46 +2076,6 @@ module.exports.win32 = win32;
 })( false ? 0 : exports)
 
 
-/***/ }),
-
-/***/ 2479:
-/***/ ((module) => {
-
-// 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.
-module.exports = 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
-  }
-}
-
-
 /***/ }),
 
 /***/ 306:
@@ -10453,30 +7079,6 @@ function wrappy (fn, cb) {
 }).call(this);
 
 
-/***/ }),
-
-/***/ 9084:
-/***/ ((module) => {
-
-"use strict";
-module.exports = require("assert");
-
-/***/ }),
-
-/***/ 6231:
-/***/ ((module) => {
-
-"use strict";
-module.exports = require("fs");
-
-/***/ }),
-
-/***/ 1423:
-/***/ ((module) => {
-
-"use strict";
-module.exports = require("path");
-
 /***/ }),
 
 /***/ 8311:
@@ -10501,14 +7103,6 @@ module.exports = require("string_decoder");
 "use strict";
 module.exports = require("timers");
 
-/***/ }),
-
-/***/ 6464:
-/***/ ((module) => {
-
-"use strict";
-module.exports = require("util");
-
 /***/ })
 
 /******/ 	});
@@ -10577,7 +7171,7 @@ __webpack_require__.r(__webpack_exports__);
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
   "buildOptimizedProject": () => (/* binding */ buildOptimizedProject),
-  "copyRecursiveAsNeeded": () => (/* reexport */ copyRecursiveAsNeeded),
+  "copyRecursiveAsNeeded": () => (/* reexport */ external_util_cjs_namespaceObject.copyRecursiveAsNeeded),
   "defaultConfig": () => (/* binding */ defaultConfig),
   "generateApiMirTests": () => (/* binding */ generateApiMirTests),
   "generateOptimizedProject": () => (/* binding */ generateOptimizedProject),
@@ -10586,576 +7180,12 @@ __webpack_require__.d(__webpack_exports__, {
 
 ;// CONCATENATED MODULE: external "fs/promises"
 const promises_namespaceObject = require("fs/promises");
-// EXTERNAL MODULE: external "path"
-var external_path_ = __webpack_require__(1423);
-;// CONCATENATED MODULE: external "@markw65/prettier-plugin-monkeyc"
-const prettier_plugin_monkeyc_namespaceObject = require("@markw65/prettier-plugin-monkeyc");
-;// CONCATENATED MODULE: external "prettier/standalone.js"
-const standalone_js_namespaceObject = require("prettier/standalone.js");
-;// CONCATENATED MODULE: external "child_process"
-const external_child_process_namespaceObject = require("child_process");
-// EXTERNAL MODULE: external "fs"
-var external_fs_ = __webpack_require__(6231);
-// EXTERNAL MODULE: ./node_modules/glob/glob.js
-var glob = __webpack_require__(2884);
-;// CONCATENATED MODULE: external "readline"
-const external_readline_namespaceObject = require("readline");
-;// CONCATENATED MODULE: ./src/util.js
-
-
-
-
-
-
-
-const isWin = process.platform == "win32";
-
-const appSupport = isWin
-  ? `${process.env.APPDATA}`.replace(/\\/g, "/")
-  : `${process.env.HOME}/Library/Application Support`;
-
-const connectiq = `${appSupport}/Garmin/ConnectIQ`;
-
-function getSdkPath() {
-  return promises_namespaceObject.readFile(connectiq + "/current-sdk.cfg")
-    .then((contents) => contents.toString().replace(/^\s*(.*?)\s*$/s, "$1"));
-}
-
-function globa(pattern, options) {
-  return new Promise((resolve, reject) => {
-    glob.glob(pattern, options, (er, files) => {
-      if (er) {
-        reject(files);
-      } else {
-        resolve(files);
-      }
-    });
-  });
-}
-
-async function modified_times(inputs, missing) {
-  return Promise.all(
-    inputs.map(async (path) => {
-      try {
-        const stat = await promises_namespaceObject.stat(path);
-        return stat.mtimeMs;
-      } catch (e) {
-        return missing;
-      }
-    })
-  );
-}
-
-async function last_modified(inputs) {
-  return Math.max(...(await modified_times(inputs, Infinity)));
-}
-
-async function first_modified(inputs) {
-  return Math.min(...(await modified_times(inputs, 0)));
-}
-
-// return a promise that will process the output of command
-// line-by-line via lineHandlers.
-function spawnByLine(command, args, lineHandlers, options) {
-  const [lineHandler, errHandler] = Array.isArray(lineHandlers)
-    ? lineHandlers
-    : [lineHandlers, (data) => console.error(data.toString())];
-  return new Promise((resolve, reject) => {
-    const proc = external_child_process_namespaceObject.spawn(command, args, {
-      ...(options || {}),
-      shell: false,
-    });
-    const rl = external_readline_namespaceObject.createInterface({
-      input: proc.stdout,
-    });
-    const rle = external_readline_namespaceObject.createInterface({
-      input: proc.stderr,
-    });
-    proc.on("error", reject);
-    rle.on("line", errHandler);
-    rl.on("line", lineHandler);
-    proc.on("close", (code) => {
-      if (code == 0) resolve();
-      reject(code);
-    });
-  });
-}
-
-// return a promise that will process file
-// line-by-line via lineHandler.
-function readByLine(file, lineHandler) {
-  return fs.open(file, "r").then(
-    (fh) =>
-      new Promise((resolve, _reject) => {
-        const stream = fh.createReadStream();
-        const rl = readline.createInterface({
-          input: stream,
-        });
-        rl.on("line", lineHandler);
-        stream.on("close", resolve);
-      })
-  );
-}
-
-async function promiseAll(promises, parallelism) {
-  parallelism = parallelism || 4;
-  const serializer = [];
-  promises.forEach((p, i) => {
-    if (serializer.length < parallelism) {
-      serializer.push(p);
-    } else {
-      serializer[i % parallelism].then(() => p);
-    }
-  });
-  return Promise.all(serializer);
-}
-
-async function copyRecursiveAsNeeded(source, target, filter) {
-  const fstat = promises_namespaceObject.stat;
-  const sstat = await fstat(source);
-  if (sstat.isDirectory()) {
-    const stat = await fstat(target).catch(() => null);
-
-    if (!stat || !stat.isDirectory()) {
-      stat && (await promises_namespaceObject.rm(target, { force: true }));
-      await promises_namespaceObject.mkdir(target, { recursive: true });
-    }
-
-    const files = await promises_namespaceObject.readdir(source);
-    return Promise.all(
-      files.map((file) => {
-        var src = external_path_.join(source, file);
-        var tgt = external_path_.join(target, file);
-        return copyRecursiveAsNeeded(src, tgt, filter);
-      })
-    );
-  } else {
-    if (filter && !filter(source, target)) {
-      return;
-    }
-    const tstat = await fstat(target).catch(() => null);
-    if (!tstat || tstat.mtimeMs < sstat.mtimeMs) {
-      console.log(`Copying ${source} to ${target}...`);
-      return promises_namespaceObject.copyFile(source, target, external_fs_.constants.COPYFILE_FICLONE);
-    }
-  }
-}
-
-;// CONCATENATED MODULE: ./src/negative-fixups.js
-/*
- * This is strange. It pretty much has to be a bug in the sdk,
- * but its the same in every sdk.
- *
- * ${sdk}/bin/api.mir describes the Toybox api down to every module,
- * class, function, enum and constant, together with the enum
- * and constant values.
- *
- * The problem is that every enum or constant with a negative
- * value, appears with the corresponding positive value in api.mir.
- * So eg Graphics.COLOR_TRANSPARENT should be -1, but instead, it has
- * the value 1.
- *
- * This is a (currently somewhat ad-hoc) list of the negative constants
- * so we can fix them after reading api.mir.
- */
-const negativeFixups = [
-  "Toybox.Communications.BLE_CONNECTION_UNAVAILABLE",
-  "Toybox.Communications.INVALID_HTTP_BODY_IN_REQUEST",
-  "Toybox.Communications.REQUEST_CANCELLED",
-  "Toybox.Communications.UNSUPPORTED_CONTENT_TYPE_IN_RESPONSE",
-  "Toybox.Communications.UNABLE_TO_PROCESS_IMAGE",
-  "Toybox.Communications.NETWORK_RESPONSE_OUT_OF_MEMORY",
-  "Toybox.Communications.BLE_REQUEST_CANCELLED",
-  "Toybox.Communications.INVALID_HTTP_METHOD_IN_REQUEST",
-  "Toybox.Communications.BLE_NO_DATA",
-  "Toybox.Communications.INVALID_HTTP_HEADER_FIELDS_IN_REQUEST",
-  "Toybox.Communications.BLE_ERROR",
-  "Toybox.Communications.NETWORK_RESPONSE_TOO_LARGE",
-  "Toybox.Communications.INVALID_HTTP_BODY_IN_NETWORK_RESPONSE",
-  "Toybox.Communications.BLE_REQUEST_TOO_LARGE",
-  "Toybox.Communications.UNABLE_TO_PROCESS_MEDIA",
-  "Toybox.Communications.REQUEST_CONNECTION_DROPPED",
-  "Toybox.Communications.BLE_UNKNOWN_SEND_ERROR",
-  "Toybox.Communications.BLE_QUEUE_FULL",
-  "Toybox.Communications.STORAGE_FULL",
-  "Toybox.Communications.BLE_SERVER_TIMEOUT",
-  "Toybox.Communications.INVALID_HTTP_HEADER_FIELDS_IN_NETWORK_RESPONSE",
-  "Toybox.Communications.SECURE_CONNECTION_REQUIRED",
-  "Toybox.Communications.NETWORK_REQUEST_TIMED_OUT",
-  "Toybox.Communications.BLE_HOST_TIMEOUT",
-  "Toybox.Communications.UNABLE_TO_PROCESS_HLS",
-  "Toybox.Graphics.COLOR_TRANSPARENT",
-  "Toybox.AntPlus.INVALID_SPEED",
-  "Toybox.AntPlus.INVALID_CADENCE",
-  "Toybox.WatchUi.LAYOUT_VALIGN_START",
-  "Toybox.WatchUi.LAYOUT_VALIGN_TOP",
-  "Toybox.WatchUi.LAYOUT_VALIGN_BOTTOM",
-  "Toybox.WatchUi.LAYOUT_VALIGN_CENTER",
-  "Toybox.WatchUi.LAYOUT_HALIGN_RIGHT",
-  "Toybox.WatchUi.LAYOUT_HALIGN_CENTER",
-  "Toybox.WatchUi.LAYOUT_HALIGN_START",
-  "Toybox.WatchUi.LAYOUT_HALIGN_LEFT",
-];
-
-;// CONCATENATED MODULE: ./src/api.js
-
-
-
-
-
-
-const LiteralIntegerRe = /^(0x[0-9a-f]+|\d+)(l)?$/;
-/*
- * This is an unfortunate hack. I want to be able to extract things
- * like the types of all of a Class's variables (in particular the type
- * of each member of Activity.Info), and also map things like enum names
- * to their values (eg to take font names, and color names to their values).
- * The only place I can find this information is in api.mir, which is totally
- * undocumented. The same could be said of compiler.json and simulator.json,
- * but those are at least in a standard format.
- */
-
-// Extract all enum values from api.mir
-async function getApiMapping(state) {
-  // get the path to the currently active sdk
-  const parser = prettier_plugin_monkeyc_namespaceObject.parsers.monkeyc;
-
-  const sdk = await getSdkPath();
-
-  const api = (await promises_namespaceObject.readFile(`${sdk}bin/api.mir`))
-    .toString()
-    .replace(/\r\n/g, "\n")
-    .replace(/^\s*\[.*?\]\s*$/gm, "")
-    //.replace(/(COLOR_TRANSPARENT|LAYOUT_[HV]ALIGN_\w+) = (\d+)/gm, "$1 = -$2")
-    .replace(/^(\s*type)\s/gm, "$1def ");
-
-  try {
-    const result = collectNamespaces(parser.parse(api, {}), state);
-    negativeFixups.forEach((fixup) => {
-      const value = fixup.split(".").reduce((state, part) => {
-        const decls = state.decls[part];
-        if (!Array.isArray(decls) || decls.length != 1 || !decls[0]) {
-          throw `Failed to find and fix negative constant ${fixup}`;
-        }
-        return decls[0];
-      }, result);
-      if (value.type != "Literal") {
-        throw `Negative constant ${fixup} was not a Literal`;
-      }
-      if (value.value > 0) {
-        value.value = -value.value;
-        value.raw = "-" + value.raw;
-      } else {
-        console.log(`Negative fixup ${fixup} was already negative!`);
-      }
-    });
-    return result;
-  } catch (e) {
-    console.error(e.toString());
-  }
-}
-
-function hasProperty(obj, prop) {
-  return obj && Object.prototype.hasOwnProperty.call(obj, prop);
-}
-
-function collectNamespaces(ast, state) {
-  state = state || {};
-  if (!state.index) state.index = {};
-  if (!state.stack) {
-    state.stack = [{ type: "Program", name: "$", fullName: "$" }];
-  }
-  const checkOne = (ns, name) => {
-    if (hasProperty(ns.decls, name)) {
-      return ns.decls[name];
-    }
-    return null;
-  };
-  state.lookup = (node, name, stack) => {
-    stack || (stack = state.stack);
-    switch (node.type) {
-      case "MemberExpression": {
-        if (node.property.type != "Identifier" || node.computed) break;
-        const [, module] = state.lookup(node.object, name, stack);
-        if (module && module.length === 1) {
-          const result = checkOne(module[0], node.property.name);
-          if (result) {
-            return [name || node.property.name, result];
-          }
-        }
-        break;
-      }
-      case "ThisExpression":
-        return [name, stack.slice(-1)];
-      case "Identifier": {
-        if (node.name == "$") {
-          return [name || node.name, [stack[0]]];
-        }
-        for (let i = stack.length; i--; ) {
-          const result = checkOne(stack[i], node.name);
-          if (result) {
-            return [name || node.name, result];
-          }
-        }
-        break;
-      }
-    }
-    return [null, null];
-  };
-
-  const pushUnique = (arr, value) => {
-    if (arr.find((v) => v === value) != null) return;
-    arr.push(value);
-  };
-
-  traverseAst(
-    ast,
-    (node) => {
-      switch (node.type) {
-        case "Program":
-          if (state.stack.length != 1) {
-            throw "Unexpected stack length for Program node";
-          }
-          break;
-        case "BlockStatement": {
-          const [parent] = state.stack.slice(-1);
-          if (
-            parent.type != "FunctionDeclaration" &&
-            parent.type != "BlockStatement"
-          ) {
-            break;
-          }
-          // fall through
-        }
-        case "ClassDeclaration":
-        case "FunctionDeclaration":
-        case "ModuleDeclaration":
-          if (node.id || node.type == "BlockStatement") {
-            const [parent] = state.stack.slice(-1);
-            const elm = {
-              type: node.type,
-              name: node.id && node.id.name,
-              node,
-            };
-            state.stack.push(elm);
-            elm.fullName = state.stack
-              .map((e) => e.name)
-              .filter((e) => e != null)
-              .join(".");
-            if (elm.name) {
-              if (!parent.decls) parent.decls = {};
-              if (hasProperty(parent.decls, elm.name)) {
-                const what = node.type == "ModuleDeclaration" ? "type" : "node";
-                const e = parent.decls[elm.name].find(
-                  (d) => d[what] == elm[what]
-                );
-                if (e != null) {
-                  e.node = node;
-                  state.stack.splice(-1, 1, e);
-                  break;
-                }
-              } else {
-                parent.decls[elm.name] = [];
-              }
-              parent.decls[elm.name].push(elm);
-            }
-          }
-          break;
-        // an EnumDeclaration doesn't create a scope, but
-        // it does create a type (if it has a name)
-        case "EnumDeclaration": {
-          if (!node.id) break;
-          const [parent] = state.stack.slice(-1);
-          const name = (parent.fullName + "." + node.id.name).replace(
-            /^\$\./,
-            ""
-          );
-          node.body.members.forEach((m) => ((m.init || m).enumType = name));
-        }
-        // fall through
-        case "TypedefDeclaration": {
-          const [parent] = state.stack.slice(-1);
-          if (!parent.decls) parent.decls = {};
-          if (!hasProperty(parent.decls, node.id.name)) {
-            parent.decls[node.id.name] = [];
-          }
-          pushUnique(
-            parent.decls[node.id.name],
-            node.ts ? formatAst(node.ts.argument) : node.id.name
-          );
-          break;
-        }
-        case "VariableDeclaration": {
-          const [parent] = state.stack.slice(-1);
-          if (!parent.decls) parent.decls = {};
-          node.declarations.forEach((decl) => {
-            if (!hasProperty(parent.decls, decl.id.name)) {
-              parent.decls[decl.id.name] = [];
-            }
-            if (node.kind == "const") {
-              pushUnique(parent.decls[decl.id.name], decl.init);
-              if (!hasProperty(state.index, decl.id.name)) {
-                state.index[decl.id.name] = [];
-              }
-              pushUnique(state.index[decl.id.name], parent);
-            } else if (decl.id.ts) {
-              pushUnique(
-                parent.decls[decl.id.name],
-                formatAst(decl.id.ts.argument)
-              );
-            }
-          });
-          break;
-        }
-        case "EnumStringBody": {
-          const [parent] = state.stack.slice(-1);
-          const values = parent.decls || (parent.decls = {});
-          let prev = -1;
-          node.members.forEach((m) => {
-            let name, init;
-            if (m.type == "EnumStringMember") {
-              name = m.id.name;
-              init = m.init;
-              if (init.type == "Literal" && LiteralIntegerRe.test(init.raw)) {
-                prev = init.value;
-              }
-            } else {
-              name = m.name;
-              prev += 1;
-              if (!state.constants) {
-                state.constants = {};
-              }
-              const key = m.enumType ? `${m.enumType}:${prev}` : prev;
-              init = state.constants[key];
-              if (!init) {
-                init = state.constants[key] = {
-                  type: "Literal",
-                  value: prev,
-                  raw: prev.toString(),
-                  enumType: m.enumType,
-                };
-              }
-            }
-            if (!hasProperty(values, name)) {
-              values[name] = [];
-            }
-            pushUnique(values[name], init);
-            if (!hasProperty(state.index, name)) {
-              state.index[name] = [];
-            }
-            pushUnique(state.index[name], parent);
-          });
-          break;
-        }
-        case "Using":
-        case "ImportModule": {
-          const [name, module] = state.lookup(
-            node.id,
-            node.as && node.as.id.name
-          );
-          if (name && module) {
-            const [parent] = state.stack.slice(-1);
-            if (!parent.decls) parent.decls = {};
-            if (!hasProperty(parent.decls, name)) parent.decls[name] = [];
-            module.forEach((m) => {
-              if (m.type == "ModuleDeclaration") {
-                pushUnique(parent.decls[name], m);
-              }
-            });
-          }
-          break;
-        }
-      }
-      if (state.pre) return state.pre(node);
-    },
-    (node) => {
-      let ret;
-      if (state.post) ret = state.post(node);
-      if (state.stack.slice(-1).pop().node === node) {
-        state.stack.pop();
-      }
-      return ret;
-    }
-  );
-  if (state.stack.length != 1) {
-    throw "Invalid AST!";
-  }
-  return state.stack[0];
-}
-
-/*
- * Traverse the ast rooted at node, calling pre before
- * visiting each node, and post after.
- *
- *  - if pre returns false, the node is not traversed, and
- *    post is not called;
- *  - if pre returns a list of child nodes, only those will
- *    be traversed
- *  - otherwise all child nodes are traversed
- *
- *  - if post returns false, the node it was called on is
- *    removed.
- */
-function traverseAst(node, pre, post) {
-  const nodes = pre && pre(node);
-  if (nodes === false) return;
-  for (const key of nodes || Object.keys(node)) {
-    const value = node[key];
-    if (!value) continue;
-    if (Array.isArray(value)) {
-      const deletions = value.reduce((state, obj, i) => {
-        const repl = traverseAst(obj, pre, post);
-        if (repl === false) {
-          if (!state) state = {};
-          state[i] = true;
-        } else if (repl != null) {
-          value[i] = repl;
-        }
-        return state;
-      }, null);
-      if (deletions) {
-        value.splice(
-          0,
-          value.length,
-          ...value.filter((obj, i) => deletions[i] !== true)
-        );
-      }
-    } else if (typeof value == "object" && value.type) {
-      const repl = traverseAst(value, pre, post);
-      if (repl === false) {
-        delete node[key];
-      } else if (repl != null) {
-        node[key] = repl;
-      }
-    }
-  }
-  return post && post(node);
-}
-
-function formatAst(node, options) {
-  if (!node.monkeyCSource && node.comments) {
-    // Prettier inserts comments by using the source location to
-    // find the original comment, rather than using the contents
-    // of the comment as reported by the comment nodes themselves.
-    // If all we've got is the ast, rather than the actual
-    // source code, this goes horribly wrong, so just drop all
-    // the comments.
-    delete node.comments;
-  }
-  // If we *do* have the original source, pass that in ahead of the
-  // json. The parser knows to just treat the last line of the input
-  // as the ast itself, and the printers will find what they're
-  // looking for in the source.
-  const source =
-    (node.monkeyCSource ? node.monkeyCSource + "\n" : "") +
-    JSON.stringify(node);
-  return standalone_js_namespaceObject.format(source, {
-    ...(options || {}),
-    parser: "monkeyc-json",
-    plugins: [prettier_plugin_monkeyc_namespaceObject],
-  });
-}
-
+;// CONCATENATED MODULE: external "path"
+const external_path_namespaceObject = require("path");
+;// CONCATENATED MODULE: external "./api.cjs"
+const external_api_cjs_namespaceObject = require("./api.cjs");
+;// CONCATENATED MODULE: external "./util.cjs"
+const external_util_cjs_namespaceObject = require("./util.cjs");
 ;// CONCATENATED MODULE: ./src/build.js
 
 
@@ -11173,7 +7203,7 @@ async function build_project(product, options, lineCallback) {
     typeCheckLevel,
     returnCommand,
   } = options;
-  const sdk = await getSdkPath();
+  const sdk = await (0,external_util_cjs_namespaceObject.getSdkPath)();
   let extraArgs = [];
   if (compilerOptions) {
     extraArgs.push(...compilerOptions.split(/\s+/));
@@ -11204,7 +7234,7 @@ async function build_project(product, options, lineCallback) {
   if (product) {
     extraArgs.push("-d", simulatorBuild !== false ? `${product}_sim` : product);
   }
-  const exe = external_path_.resolve(sdk, "bin", isWin ? "monkeyc.bat" : "monkeyc");
+  const exe = external_path_namespaceObject.resolve(sdk, "bin", external_util_cjs_namespaceObject.isWin ? "monkeyc.bat" : "monkeyc");
   const args = [
     ["-o", program],
     ["-f", jungleFiles],
@@ -11227,7 +7257,7 @@ async function build_project(product, options, lineCallback) {
   ];
   return returnCommand
     ? { exe, args }
-    : spawnByLine(exe, args, handlers, {
+    : (0,external_util_cjs_namespaceObject.spawnByLine)(exe, args, handlers, {
         cwd: workspace,
       });
 }
@@ -11263,7 +7293,7 @@ function process_assignments(assignments, current) {
   return assignments.reduce((state, a) => {
     const { node, dot, dotnames } = a.names.reduce(
       (r, name) => {
-        if (!hasProperty(r.node, name)) r.node[name] = {};
+        if (!(0,external_api_cjs_namespaceObject.hasProperty)(r.node, name)) r.node[name] = {};
         r.dotnames.push(name);
         r.node = r.node[name];
         if (r.node["."]) {
@@ -11322,7 +7352,7 @@ function evaluate_locals(assignments) {
         if (
           v.type == "QualifiedName" &&
           v.names.length == 1 &&
-          hasProperty(locals, v.names[0])
+          (0,external_api_cjs_namespaceObject.hasProperty)(locals, v.names[0])
         ) {
           values.splice(i, 1, ...locals[v.names[0]]);
         } else if (v.type == "SubList") {
@@ -11346,7 +7376,7 @@ async function parse_one(file) {
 // return a jungle object with all local variables resolved,
 // but all qualifier references left unresolved.
 async function process_jungles(sources) {
-  const sdk = await getSdkPath();
+  const sdk = await (0,external_util_cjs_namespaceObject.getSdkPath)();
 
   if (!Array.isArray(sources)) {
     sources = [sources];
@@ -11409,8 +7439,8 @@ function resolve_node(state, node) {
 }
 
 function resolve_filename(literal, default_source) {
-  const root = external_path_.dirname(literal.source || default_source);
-  return external_path_.resolve(root, literal.value);
+  const root = external_path_namespaceObject.dirname(literal.source || default_source);
+  return external_path_namespaceObject.resolve(root, literal.value);
 }
 
 async function resolve_literals(qualifier, default_source) {
@@ -11425,7 +7455,7 @@ async function resolve_literals(qualifier, default_source) {
             // any mc file under "./". The standard way to express that
             // is "./**/*.mc", which is what glob expects, so translate.
             resolved = resolved.replace(/\/\*\*([^/])/g, "/**/*$1");
-            const match = await globa(resolved);
+            const match = await (0,external_util_cjs_namespaceObject.globa)(resolved);
             return match.length ? resolved : null;
           } else {
             const stat = await promises_namespaceObject.stat(resolved).catch(() => null);
@@ -11476,7 +7506,7 @@ function identify_optimizer_groups(targets, options) {
     if (option === "*") {
       return [];
     } else {
-      return strs.filter((a) => !hasProperty(option, a));
+      return strs.filter((a) => !(0,external_api_cjs_namespaceObject.hasProperty)(option, a));
     }
   };
   const ignoreRegExpOption = (str) => {
@@ -11501,7 +7531,7 @@ function identify_optimizer_groups(targets, options) {
             target.qualifier.sourcePath.forEach((path) => {
               const m = path.match(ignoredSourcePathsRe);
               const key = m ? "key-" + m.slice(1).join("") : path;
-              if (!hasProperty(state.keys, key)) {
+              if (!(0,external_api_cjs_namespaceObject.hasProperty)(state.keys, key)) {
                 state.keys[key] = {};
               }
               state.keys[key][path] = true;
@@ -11544,7 +7574,7 @@ function identify_optimizer_groups(targets, options) {
       optimizerConfig,
       Object.keys(optimizerConfig).sort()
     );
-    if (!hasProperty(groups, serialized)) {
+    if (!(0,external_api_cjs_namespaceObject.hasProperty)(groups, serialized)) {
       groups[serialized] = {
         key: "group" + key.toString().padStart(3, "0"),
         optimizerConfig,
@@ -11559,10 +7589,10 @@ async function get_jungle(jungles, options) {
   options = options || {};
   jungles = jungles
     .split(";")
-    .map((jungle) => external_path_.resolve(options.workspace || "./", jungle));
+    .map((jungle) => external_path_namespaceObject.resolve(options.workspace || "./", jungle));
   const data = await process_jungles(jungles);
   const manifest_node = resolve_node_by_path(data, ["project", "manifest"]);
-  if (!manifest_node) throw "No manifest found!";
+  if (!manifest_node) throw new Error("No manifest found!");
   const manifest = resolve_filename(manifest_node[0]);
   const xml = await readManifest(manifest);
   const targets = [];
@@ -11578,25 +7608,46 @@ async function get_jungle(jungles, options) {
   return { manifest, targets };
 }
 
+;// CONCATENATED MODULE: external "child_process"
+const external_child_process_namespaceObject = require("child_process");
 ;// CONCATENATED MODULE: ./src/launch.js
 
 
 
 
 function launchSimulator() {
-  return getSdkPath().then((sdk) => {
+  return (0,external_util_cjs_namespaceObject.getSdkPath)().then((sdk) => {
     const child = (0,external_child_process_namespaceObject.execFile)(
-      external_path_.resolve(sdk, "bin", isWin ? "simulator" : "connectiq")
+      external_path_namespaceObject.resolve(sdk, "bin", external_util_cjs_namespaceObject.isWin ? "simulator" : "connectiq")
     );
     child.unref();
   });
 }
 
+;// CONCATENATED MODULE: external "@markw65/prettier-plugin-monkeyc"
+const prettier_plugin_monkeyc_namespaceObject = require("@markw65/prettier-plugin-monkeyc");
 ;// CONCATENATED MODULE: ./src/mc-rewrite.js
 
 
 
 
+
+function processImports(allImports, lookup) {
+  allImports.forEach(({ node, stack }) => {
+    const [name, module] = lookup(node.id, node.as && node.as.id.name, stack);
+    if (name && module) {
+      const [parent] = stack.slice(-1);
+      if (!parent.decls) parent.decls = {};
+      if (!(0,external_api_cjs_namespaceObject.hasProperty)(parent.decls, name)) parent.decls[name] = [];
+      module.forEach((m) => {
+        if (m.type == "ModuleDeclaration") {
+          (0,external_util_cjs_namespaceObject.pushUnique)(parent.decls[name], m);
+        }
+      });
+    }
+  });
+}
+
 function collectClassInfo(state) {
   state.allClasses.forEach((elm) => {
     if (elm.node.superClass) {
@@ -11614,7 +7665,7 @@ function collectClassInfo(state) {
     scls.forEach((c) => {
       Object.values(c.decls).forEach((f) => {
         if (f.type == "FunctionDeclaration") {
-          if (hasProperty(cls.decls, f.name)) {
+          if ((0,external_api_cjs_namespaceObject.hasProperty)(cls.decls, f.name)) {
             f.hasOverride = true;
           }
         }
@@ -11640,13 +7691,14 @@ async function analyze(fileNames, buildConfig) {
         node.attrs.attrs.filter((attr) => {
           if (attr.type != "UnaryExpression") return false;
           if (attr.argument.type != "Identifier") return false;
-          return hasProperty(excludeAnnotations, attr.argument.name);
+          return (0,external_api_cjs_namespaceObject.hasProperty)(excludeAnnotations, attr.argument.name);
         }).length
       ) {
         return true;
       }
     }
   };
+  const allImports = [];
   const state = {
     allFunctions: [],
     allClasses: [],
@@ -11671,12 +7723,17 @@ async function analyze(fileNames, buildConfig) {
             ? state.allFunctions
             : state.allClasses
           ).push(scope);
+          return;
         }
+        case "Using":
+        case "ImportModule":
+          allImports.push({ node, stack: state.stack.slice() });
+          return;
       }
     },
   };
 
-  await getApiMapping(state);
+  await (0,external_api_cjs_namespaceObject.getApiMapping)(state);
 
   // Mark all functions from api.mir as "special" by
   // setting their bodies to null. In api.mir, they're
@@ -11705,14 +7762,16 @@ async function analyze(fileNames, buildConfig) {
     f.ast = prettier_plugin_monkeyc_namespaceObject.parsers.monkeyc.parse(f.monkeyCSource, {
       grammarSource: f.name,
     });
+    f.ast.source = f.name;
     f.ast.monkeyCSource = f.monkeyCSource;
     delete f.monkeyCSource;
-    collectNamespaces(f.ast, state);
+    (0,external_api_cjs_namespaceObject.collectNamespaces)(f.ast, state);
   });
 
   delete state.pre;
   delete state.post;
 
+  processImports(allImports, state.lookup);
   collectClassInfo(state);
 
   return { files, state };
@@ -11777,7 +7836,7 @@ function getNodeValue(node) {
   }
   let type = node.value === null ? "Null" : typeof node.value;
   if (type === "number") {
-    const match = LiteralIntegerRe.exec(node.raw);
+    const match = external_api_cjs_namespaceObject.LiteralIntegerRe.exec(node.raw);
     if (match) {
       type = match[2] == "l" ? "Long" : "Number";
     } else if (node.raw.endsWith("d")) {
@@ -11886,7 +7945,7 @@ function evaluateFunction(func, args) {
   let ret = null;
   const body = args ? JSON.parse(JSON.stringify(func.body)) : func.body;
   try {
-    traverseAst(
+    (0,external_api_cjs_namespaceObject.traverseAst)(
       body,
       (node) => {
         switch (node.type) {
@@ -11898,7 +7957,7 @@ function evaluateFunction(func, args) {
           case "Identifier":
             return;
           default:
-            throw "Bad node type";
+            throw new Error("Bad node type");
         }
       },
       args &&
@@ -11911,14 +7970,14 @@ function evaluateFunction(func, args) {
             case "Literal":
               return;
             case "Identifier":
-              if (hasProperty(paramValues, node.name)) {
+              if ((0,external_api_cjs_namespaceObject.hasProperty)(paramValues, node.name)) {
                 return paramValues[node.name];
               }
             // fall through;
             default: {
               const repl = optimizeNode(node);
               if (repl && repl.type === "Literal") return repl;
-              throw "Didn't optimize";
+              throw new Error("Didn't optimize");
             }
           }
         })
@@ -11969,8 +8028,8 @@ async function optimizeMonkeyC(fileNames, buildConfig) {
       // this is an api.mir function. It can be called
       return true;
     }
-    if (hasProperty(state.exposed, func.id.name)) return true;
-    if (hasProperty(state.calledFunctions, func.id.name)) {
+    if ((0,external_api_cjs_namespaceObject.hasProperty)(state.exposed, func.id.name)) return true;
+    if ((0,external_api_cjs_namespaceObject.hasProperty)(state.calledFunctions, func.id.name)) {
       return (
         state.calledFunctions[func.id.name].find((f) => f === func) !== null
       );
@@ -11984,7 +8043,7 @@ async function optimizeMonkeyC(fileNames, buildConfig) {
     elm.superClass === true ||
     elm.superClass.some(
       (sc) =>
-        (hasProperty(sc.decls, name) &&
+        ((0,external_api_cjs_namespaceObject.hasProperty)(sc.decls, name) &&
           sc.decls[name].some(
             (f) => f.type == "FunctionDeclaration" && maybeCalled(f)
           )) ||
@@ -12013,7 +8072,7 @@ async function optimizeMonkeyC(fileNames, buildConfig) {
         }
         break;
       case "Identifier": {
-        if (hasProperty(state.index, node.name)) {
+        if ((0,external_api_cjs_namespaceObject.hasProperty)(state.index, node.name)) {
           if (!lookupAndReplace(node)) {
             state.exposed[node.name] = true;
           }
@@ -12022,7 +8081,7 @@ async function optimizeMonkeyC(fileNames, buildConfig) {
       }
       case "MemberExpression":
         if (node.property.type === "Identifier" && !node.computed) {
-          if (hasProperty(state.index, node.property.name)) {
+          if ((0,external_api_cjs_namespaceObject.hasProperty)(state.index, node.property.name)) {
             if (lookupAndReplace(node)) {
               return false;
             } else {
@@ -12041,7 +8100,7 @@ async function optimizeMonkeyC(fileNames, buildConfig) {
             used = checkInherited(parent, node.id.name);
           }
           if (used) {
-            if (!hasProperty(state.calledFunctions, node.id.name)) {
+            if (!(0,external_api_cjs_namespaceObject.hasProperty)(state.calledFunctions, node.id.name)) {
               state.calledFunctions[node.id.name] = [];
             }
             state.calledFunctions[node.id.name].push(node);
@@ -12066,7 +8125,7 @@ async function optimizeMonkeyC(fileNames, buildConfig) {
         if (n) {
           state.exposed[n] = true;
         } else {
-          throw "What?";
+          throw new Error("What?");
         }
         return;
       }
@@ -12084,25 +8143,25 @@ async function optimizeMonkeyC(fileNames, buildConfig) {
           }
         }
       }
-      if (!hasProperty(state.calledFunctions, name)) {
+      if (!(0,external_api_cjs_namespaceObject.hasProperty)(state.calledFunctions, name)) {
         state.calledFunctions[name] = [];
       }
       callees.forEach((c) => state.calledFunctions[name].push(c.node));
     }
   };
   files.forEach((f) => {
-    collectNamespaces(f.ast, state);
+    (0,external_api_cjs_namespaceObject.collectNamespaces)(f.ast, state);
   });
   files.forEach((f) => {
-    traverseAst(f.ast, null, (node) => {
+    (0,external_api_cjs_namespaceObject.traverseAst)(f.ast, null, (node) => {
       switch (node.type) {
         case "EnumStringBody":
           if (
             node.members.every((m) => {
               const name = m.name || m.id.name;
               return (
-                hasProperty(state.index, name) &&
-                !hasProperty(state.exposed, name)
+                (0,external_api_cjs_namespaceObject.hasProperty)(state.index, name) &&
+                !(0,external_api_cjs_namespaceObject.hasProperty)(state.exposed, name)
               );
             })
           ) {
@@ -12111,7 +8170,9 @@ async function optimizeMonkeyC(fileNames, buildConfig) {
                 node.members.map((m) => {
                   if (!m.init) return "Number";
                   const [node, type] = getNodeValue(m.init);
-                  if (!node) throw "Failed to get type for eliminated enum";
+                  if (!node) {
+                    throw new Error("Failed to get type for eliminated enum");
+                  }
                   return type;
                 })
               ),
@@ -12123,7 +8184,7 @@ async function optimizeMonkeyC(fileNames, buildConfig) {
           if (!node.body.members.length) {
             if (!node.id) return false;
             if (!node.body.enumType) {
-              throw "Missing enumType on optimized enum";
+              throw new Error("Missing enumType on optimized enum");
             }
             replace(node, {
               type: "TypedefDeclaration",
@@ -12140,8 +8201,8 @@ async function optimizeMonkeyC(fileNames, buildConfig) {
         case "VariableDeclaration": {
           node.declarations = node.declarations.filter(
             (d) =>
-              !hasProperty(state.index, d.id.name) ||
-              hasProperty(state.exposed, d.id.name)
+              !(0,external_api_cjs_namespaceObject.hasProperty)(state.index, d.id.name) ||
+              (0,external_api_cjs_namespaceObject.hasProperty)(state.exposed, d.id.name)
           );
           if (!node.declarations.length) {
             return false;
@@ -12204,7 +8265,7 @@ async function getConfig(options) {
     if (config[key]) return;
     if (!promise) {
       promise = Promise.resolve()
-        .then(() => getVSCodeSettings(`${appSupport}/Code/User/settings.json`))
+        .then(() => getVSCodeSettings(`${external_util_cjs_namespaceObject.appSupport}/Code/User/settings.json`))
         .then((globals) =>
           getVSCodeSettings(`${config.workspace}/.vscode/settings.json`).then(
             (locals) => ({ ...globals, ...locals })
@@ -12233,16 +8294,16 @@ async function buildOptimizedProject(product, options) {
   let name = `optimized-${program}.prg`;
   if (product) {
     if (config.simulatorBuild === false) {
-      bin = external_path_.join(bin, product);
+      bin = external_path_namespaceObject.join(bin, product);
     }
   } else {
-    bin = external_path_.join(bin, "exported");
+    bin = external_path_namespaceObject.join(bin, "exported");
     name = `${program}.iq`;
-    if (!hasProperty(config, "releaseBuild")) {
+    if (!(0,external_api_cjs_namespaceObject.hasProperty)(config, "releaseBuild")) {
       config.releaseBuild = true;
     }
   }
-  config.program = external_path_.join(bin, name);
+  config.program = external_path_namespaceObject.join(bin, name);
   return build_project(product, config);
 }
 
@@ -12253,7 +8314,7 @@ async function generateOptimizedProject(options) {
   const { manifest, targets } = await get_jungle(config.jungleFiles, config);
   const buildConfigs = {};
   targets.forEach((p) => {
-    if (!hasProperty(buildConfigs, p.group.key)) {
+    if (!(0,external_api_cjs_namespaceObject.hasProperty)(buildConfigs, p.group.key)) {
       buildConfigs[p.group.key] = null;
     }
     if (!options.products || options.products.includes(p.product)) {
@@ -12263,14 +8324,14 @@ async function generateOptimizedProject(options) {
 
   // console.log(JSON.stringify(targets));
 
-  const jungle_dir = external_path_.resolve(workspace, config.outputPath);
+  const jungle_dir = external_path_namespaceObject.resolve(workspace, config.outputPath);
   await promises_namespaceObject.mkdir(jungle_dir, { recursive: true });
 
   const promises = Object.keys(buildConfigs)
     .sort()
     .map((key) => {
       const buildConfig = buildConfigs[key];
-      const outputPath = external_path_.join(config.outputPath, key);
+      const outputPath = external_path_namespaceObject.join(config.outputPath, key);
 
       return buildConfig
         ? generateOneConfig({
@@ -12278,13 +8339,13 @@ async function generateOptimizedProject(options) {
             buildConfig,
             outputPath,
           })
-        : promises_namespaceObject.rm(external_path_.resolve(workspace, outputPath), {
+        : promises_namespaceObject.rm(external_path_namespaceObject.resolve(workspace, outputPath), {
             recursive: true,
             force: true,
           });
     });
 
-  const relative_path = (s) => external_path_.relative(jungle_dir, s);
+  const relative_path = (s) => external_path_namespaceObject.relative(jungle_dir, s);
   const parts = [`project.manifest=${relative_path(manifest)}`];
   const process_field = (prefix, base, name, map) =>
     base[name] &&
@@ -12297,7 +8358,7 @@ async function generateOptimizedProject(options) {
     const { product, qualifier, group } = jungle;
     const prefix = `${product}.`;
     process_field(prefix, qualifier, "sourcePath", (s) =>
-      external_path_.join(group.key.toString(), external_path_.relative(workspace, s))
+      external_path_namespaceObject.join(group.key.toString(), external_path_namespaceObject.relative(workspace, s))
         .replace(/(\/\*\*)\/\*/g, "$1")
     );
     process_field(prefix, qualifier, "resourcePath", relative_path);
@@ -12311,20 +8372,20 @@ async function generateOptimizedProject(options) {
     }
   });
 
-  const jungleFiles = external_path_.join(jungle_dir, "monkey.jungle");
+  const jungleFiles = external_path_namespaceObject.join(jungle_dir, "monkey.jungle");
   promises.push(promises_namespaceObject.writeFile(jungleFiles, parts.join("\n")));
   await Promise.all(promises);
-  return { jungleFiles, program: external_path_.basename(external_path_.dirname(manifest)) };
+  return { jungleFiles, program: external_path_namespaceObject.basename(external_path_namespaceObject.dirname(manifest)) };
 }
 
 async function generateOneConfig(config) {
   const { workspace, buildConfig } = config;
-  const output = external_path_.join(workspace, config.outputPath);
+  const output = external_path_namespaceObject.join(workspace, config.outputPath);
 
   const paths = (
     await Promise.all(
       buildConfig.sourcePath.map((pattern) =>
-        globa(pattern, { cwd: workspace, mark: true })
+        (0,external_util_cjs_namespaceObject.globa)(pattern, { cwd: workspace, mark: true })
       )
     )
   ).flat();
@@ -12333,24 +8394,24 @@ async function generateOneConfig(config) {
     await Promise.all(
       paths.map((path) =>
         path.endsWith("/")
-          ? globa(`${path}**/*.mc`, { cwd: workspace, mark: true })
+          ? (0,external_util_cjs_namespaceObject.globa)(`${path}**/*.mc`, { cwd: workspace, mark: true })
           : path
       )
     )
   )
     .flat()
     .filter((file) => !file.endsWith("/"))
-    .map((file) => external_path_.relative(workspace, file))
+    .map((file) => external_path_namespaceObject.relative(workspace, file))
     .filter((file) => !file.startsWith("bin"));
 
   const fnMap = Object.fromEntries(
     files
       .filter((src) => /\.mc$/.test(src))
-      .map((file) => [external_path_.join(workspace, file), external_path_.join(output, file)])
+      .map((file) => [external_path_namespaceObject.join(workspace, file), external_path_namespaceObject.join(output, file)])
   );
 
-  const source_time = await last_modified(Object.keys(fnMap));
-  const opt_time = await first_modified(Object.values(fnMap));
+  const source_time = await (0,external_util_cjs_namespaceObject.last_modified)(Object.keys(fnMap));
+  const opt_time = await (0,external_util_cjs_namespaceObject.first_modified)(Object.values(fnMap));
   if (source_time < opt_time) return;
 
   await promises_namespaceObject.rm(output, { recursive: true, force: true });
@@ -12359,10 +8420,10 @@ async function generateOneConfig(config) {
   return await Promise.all(
     optFiles.map(async (file) => {
       const name = fnMap[file.name];
-      const dir = external_path_.dirname(name);
+      const dir = external_path_namespaceObject.dirname(name);
       await promises_namespaceObject.mkdir(dir, { recursive: true });
 
-      const opt_source = formatAst(file.ast);
+      const opt_source = (0,external_api_cjs_namespaceObject.formatAst)(file.ast);
       await promises_namespaceObject.writeFile(name, opt_source);
       return name;
     })
@@ -12372,13 +8433,13 @@ async function generateOneConfig(config) {
 async function generateApiMirTests(options) {
   const config = { ...defaultConfig, ...(options || {}) };
   const tests = [];
-  const api = await getApiMapping();
+  const api = await (0,external_api_cjs_namespaceObject.getApiMapping)();
   const findConstants = (node) => {
     Object.entries(node.decls).forEach(([key, decl]) => {
       if (decl.length > 1) throw `Bad decl length:${node.fullName}.${key}`;
       if (decl.length != 1) return;
       if (decl[0].type == "Literal") {
-        tests.push([`${node.fullName}.${key}`, formatAst(decl[0])]);
+        tests.push([`${node.fullName}.${key}`, (0,external_api_cjs_namespaceObject.formatAst)(decl[0])]);
       } else if (decl[0].decls) {
         findConstants(decl[0]);
       }