text: 'use strict';
  
  Object.defineProperty(exports, '__esModule', { value: true });
  
  function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
  
  var path = _interopDefault(require('path'));
  var fs = _interopDefault(require('fs'));
  var util = _interopDefault(require('util'));
  var assert = _interopDefault(require('assert'));
  var events = _interopDefault(require('events'));
  var visitor = require('graphql/language/visitor');
  var graphql = require('graphql');
  var buildASTSchema = require('graphql/utilities/buildASTSchema');
  
  function createCommonjsModule(fn, module) {
  	return module = { exports: {} }, fn(module, module.exports), module.exports;
  }
  
  var _global = createCommonjsModule(function (module) {
  // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
  var global = module.exports = typeof window != 'undefined' && window.Math == Math
    ? window : typeof self != 'undefined' && self.Math == Math ? self
    // eslint-disable-next-line no-new-func
    : Function('return this')();
  if (typeof __g == 'number') __g = global; // eslint-disable-line no-undef
  });
  
  var _core = createCommonjsModule(function (module) {
  var core = module.exports = { version: '2.5.7' };
  if (typeof __e == 'number') __e = core; // eslint-disable-line no-undef
  });
  var _core_1 = _core.version;
  
  var _isObject = function (it) {
    return typeof it === 'object' ? it !== null : typeof it === 'function';
  };
  
  var _anObject = function (it) {
    if (!_isObject(it)) throw TypeError(it + ' is not an object!');
    return it;
  };
  
  var _fails = function (exec) {
    try {
      return !!exec();
    } catch (e) {
      return true;
    }
  };
  
  // Thank's IE8 for his funny defineProperty
  var _descriptors = !_fails(function () {
    return Object.defineProperty({}, 'a', { get: function () { return 7; } }).a != 7;
  });
  
  var document = _global.document;
  // typeof document.createElement is 'object' in old IE
  var is = _isObject(document) && _isObject(document.createElement);
  var _domCreate = function (it) {
    return is ? document.createElement(it) : {};
  };
  
  var _ie8DomDefine = !_descriptors && !_fails(function () {
    return Object.defineProperty(_domCreate('div'), 'a', { get: function () { return 7; } }).a != 7;
  });
  
  // 7.1.1 ToPrimitive(input [, PreferredType])
  
  // instead of the ES6 spec version, we didn't implement @@toPrimitive case
  // and the second argument - flag - preferred type is a string
  var _toPrimitive = function (it, S) {
    if (!_isObject(it)) return it;
    var fn, val;
    if (S && typeof (fn = it.toString) == 'function' && !_isObject(val = fn.call(it))) return val;
    if (typeof (fn = it.valueOf) == 'function' && !_isObject(val = fn.call(it))) return val;
    if (!S && typeof (fn = it.toString) == 'function' && !_isObject(val = fn.call(it))) return val;
    throw TypeError("Can't convert object to primitive value");
  };
  
  var dP = Object.defineProperty;
  
  var f = _descriptors ? Object.defineProperty : function defineProperty(O, P, Attributes) {
    _anObject(O);
    P = _toPrimitive(P, true);
    _anObject(Attributes);
    if (_ie8DomDefine) try {
      return dP(O, P, Attributes);
    } catch (e) { /* empty */ }
    if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported!');
    if ('value' in Attributes) O[P] = Attributes.value;
    return O;
  };
  
  var _objectDp = {
  	f: f
  };
  
  var _propertyDesc = function (bitmap, value) {
    return {
      enumerable: !(bitmap & 1),
      configurable: !(bitmap & 2),
      writable: !(bitmap & 4),
      value: value
    };
  };
  
  var _hide = _descriptors ? function (object, key, value) {
    return _objectDp.f(object, key, _propertyDesc(1, value));
  } : function (object, key, value) {
    object[key] = value;
    return object;
  };
  
  var hasOwnProperty = {}.hasOwnProperty;
  var _has = function (it, key) {
    return hasOwnProperty.call(it, key);
  };
  
  var id = 0;
  var px = Math.random();
  var _uid = function (key) {
    return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));
  };
  
  var _redefine = createCommonjsModule(function (module) {
  var SRC = _uid('src');
  var TO_STRING = 'toString';
  var $toString = Function[TO_STRING];
  var TPL = ('' + $toString).split(TO_STRING);
  
  _core.inspectSource = function (it) {
    return $toString.call(it);
  };
  
  (module.exports = function (O, key, val, safe) {
    var isFunction = typeof val == 'function';
    if (isFunction) _has(val, 'name') || _hide(val, 'name', key);
    if (O[key] === val) return;
    if (isFunction) _has(val, SRC) || _hide(val, SRC, O[key] ? '' + O[key] : TPL.join(String(key)));
    if (O === _global) {
      O[key] = val;
    } else if (!safe) {
      delete O[key];
      _hide(O, key, val);
    } else if (O[key]) {
      O[key] = val;
    } else {
      _hide(O, key, val);
    }
  // add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
  })(Function.prototype, TO_STRING, function toString() {
    return typeof this == 'function' && this[SRC] || $toString.call(this);
  });
  });
  
  var _aFunction = function (it) {
    if (typeof it != 'function') throw TypeError(it + ' is not a function!');
    return it;
  };
  
  // optional / simple context binding
  
  var _ctx = function (fn, that, length) {
    _aFunction(fn);
    if (that === undefined) return fn;
    switch (length) {
      case 1: return function (a) {
        return fn.call(that, a);
      };
      case 2: return function (a, b) {
        return fn.call(that, a, b);
      };
      case 3: return function (a, b, c) {
        return fn.call(that, a, b, c);
      };
    }
    return function (/* ...args */) {
      return fn.apply(that, arguments);
    };
  };
  
  var PROTOTYPE = 'prototype';
  
  var $export = function (type, name, source) {
    var IS_FORCED = type & $export.F;
    var IS_GLOBAL = type & $export.G;
    var IS_STATIC = type & $export.S;
    var IS_PROTO = type & $export.P;
    var IS_BIND = type & $export.B;
    var target = IS_GLOBAL ? _global : IS_STATIC ? _global[name] || (_global[name] = {}) : (_global[name] || {})[PROTOTYPE];
    var exports = IS_GLOBAL ? _core : _core[name] || (_core[name] = {});
    var expProto = exports[PROTOTYPE] || (exports[PROTOTYPE] = {});
    var key, own, out, exp;
    if (IS_GLOBAL) source = name;
    for (key in source) {
      // contains in native
      own = !IS_FORCED && target && target[key] !== undefined;
      // export native or passed
      out = (own ? target : source)[key];
      // bind timers to global for call from export context
      exp = IS_BIND && own ? _ctx(out, _global) : IS_PROTO && typeof out == 'function' ? _ctx(Function.call, out) : out;
      // extend global
      if (target) _redefine(target, key, out, type & $export.U);
      // export
      if (exports[key] != out) _hide(exports, key, exp);
      if (IS_PROTO && expProto[key] != out) expProto[key] = out;
    }
  };
  _global.core = _core;
  // type bitmap
  $export.F = 1;   // forced
  $export.G = 2;   // global
  $export.S = 4;   // static
  $export.P = 8;   // proto
  $export.B = 16;  // bind
  $export.W = 32;  // wrap
  $export.U = 64;  // safe
  $export.R = 128; // real proto method for `library`
  var _export = $export;
  
  var toString = {}.toString;
  
  var _cof = function (it) {
    return toString.call(it).slice(8, -1);
  };
  
  // fallback for non-array-like ES3 and non-enumerable old V8 strings
  
  // eslint-disable-next-line no-prototype-builtins
  var _iobject = Object('z').propertyIsEnumerable(0) ? Object : function (it) {
    return _cof(it) == 'String' ? it.split('') : Object(it);
  };
  
  // 7.2.1 RequireObjectCoercible(argument)
  var _defined = function (it) {
    if (it == undefined) throw TypeError("Can't call method on  " + it);
    return it;
  };
  
  // to indexed object, toObject with fallback for non-array-like ES3 strings
  
  
  var _toIobject = function (it) {
    return _iobject(_defined(it));
  };
  
  // 7.1.4 ToInteger
  var ceil = Math.ceil;
  var floor = Math.floor;
  var _toInteger = function (it) {
    return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);
  };
  
  // 7.1.15 ToLength
  
  var min = Math.min;
  var _toLength = function (it) {
    return it > 0 ? min(_toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991
  };
  
  var max = Math.max;
  var min$1 = Math.min;
  var _toAbsoluteIndex = function (index, length) {
    index = _toInteger(index);
    return index < 0 ? max(index + length, 0) : min$1(index, length);
  };
  
  // false -> Array#indexOf
  // true  -> Array#includes
  
  
  
  var _arrayIncludes = function (IS_INCLUDES) {
    return function ($this, el, fromIndex) {
      var O = _toIobject($this);
      var length = _toLength(O.length);
      var index = _toAbsoluteIndex(fromIndex, length);
      var value;
      // Array#includes uses SameValueZero equality algorithm
      // eslint-disable-next-line no-self-compare
      if (IS_INCLUDES && el != el) while (length > index) {
        value = O[index++];
        // eslint-disable-next-line no-self-compare
        if (value != value) return true;
      // Array#indexOf ignores holes, Array#includes - not
      } else for (;length > index; index++) if (IS_INCLUDES || index in O) {
        if (O[index] === el) return IS_INCLUDES || index || 0;
      } return !IS_INCLUDES && -1;
    };
  };
  
  var _library = false;
  
  var _shared = createCommonjsModule(function (module) {
  var SHARED = '__core-js_shared__';
  var store = _global[SHARED] || (_global[SHARED] = {});
  
  (module.exports = function (key, value) {
    return store[key] || (store[key] = value !== undefined ? value : {});
  })('versions', []).push({
    version: _core.version,
    mode: _library ? 'pure' : 'global',
    copyright: '© 2018 Denis Pushkarev (zloirock.ru)'
  });
  });
  
  var shared = _shared('keys');
  
  var _sharedKey = function (key) {
    return shared[key] || (shared[key] = _uid(key));
  };
  
  var arrayIndexOf = _arrayIncludes(false);
  var IE_PROTO = _sharedKey('IE_PROTO');
  
  var _objectKeysInternal = function (object, names) {
    var O = _toIobject(object);
    var i = 0;
    var result = [];
    var key;
    for (key in O) if (key != IE_PROTO) _has(O, key) && result.push(key);
    // Don't enum bug & hidden keys
    while (names.length > i) if (_has(O, key = names[i++])) {
      ~arrayIndexOf(result, key) || result.push(key);
    }
    return result;
  };
  
  // IE 8- don't enum bug keys
  var _enumBugKeys = (
    'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf'
  ).split(',');
  
  // 19.1.2.14 / 15.2.3.14 Object.keys(O)
  
  
  
  var _objectKeys = Object.keys || function keys(O) {
    return _objectKeysInternal(O, _enumBugKeys);
  };
  
  var f$1 = {}.propertyIsEnumerable;
  
  var _objectPie = {
  	f: f$1
  };
  
  var isEnum = _objectPie.f;
  var _objectToArray = function (isEntries) {
    return function (it) {
      var O = _toIobject(it);
      var keys = _objectKeys(O);
      var length = keys.length;
      var i = 0;
      var result = [];
      var key;
      while (length > i) if (isEnum.call(O, key = keys[i++])) {
        result.push(isEntries ? [key, O[key]] : O[key]);
      } return result;
    };
  };
  
  // https://github.com/tc39/proposal-object-values-entries
  
  var $values = _objectToArray(false);
  
  _export(_export.S, 'Object', {
    values: function values(it) {
      return $values(it);
    }
  });
  
  var _wks = createCommonjsModule(function (module) {
  var store = _shared('wks');
  
  var Symbol = _global.Symbol;
  var USE_SYMBOL = typeof Symbol == 'function';
  
  var $exports = module.exports = function (name) {
    return store[name] || (store[name] =
      USE_SYMBOL && Symbol[name] || (USE_SYMBOL ? Symbol : _uid)('Symbol.' + name));
  };
  
  $exports.store = store;
  });
  
  // 22.1.3.31 Array.prototype[@@unscopables]
  var UNSCOPABLES = _wks('unscopables');
  var ArrayProto = Array.prototype;
  if (ArrayProto[UNSCOPABLES] == undefined) _hide(ArrayProto, UNSCOPABLES, {});
  var _addToUnscopables = function (key) {
    ArrayProto[UNSCOPABLES][key] = true;
  };
  
  // https://github.com/tc39/Array.prototype.includes
  
  var $includes = _arrayIncludes(true);
  
  _export(_export.P, 'Array', {
    includes: function includes(el /* , fromIndex = 0 */) {
      return $includes(this, el, arguments.length > 1 ? arguments[1] : undefined);
    }
  });
  
  _addToUnscopables('includes');
  
  /*!
   * is-extglob <https://github.com/jonschlinkert/is-extglob>
   *
   * Copyright (c) 2014-2016, Jon Schlinkert.
   * Licensed under the MIT License.
   */
  
  var isExtglob = function isExtglob(str) {
    if (typeof str !== 'string' || str === '') {
      return false;
    }
  
    var match;
    while ((match = /(\\).|([@?!+*]\(.*\))/g.exec(str))) {
      if (match[2]) return true;
      str = str.slice(match.index + match[0].length);
    }
  
    return false;
  };
  
  /*!
   * is-glob <https://github.com/jonschlinkert/is-glob>
   *
   * Copyright (c) 2014-2017, Jon Schlinkert.
   * Released under the MIT License.
   */
  
  
  var chars = { '{': '}', '(': ')', '[': ']'};
  
  var isGlob = function isGlob(str, options) {
    if (typeof str !== 'string' || str === '') {
      return false;
    }
  
    if (isExtglob(str)) {
      return true;
    }
  
    var regex = /\\(.)|(^!|\*|[\].+)]\?|\[[^\\\]]+\]|\{[^\\}]+\}|\(\?[:!=][^\\)]+\)|\([^|]+\|[^\\)]+\))/;
    var match;
  
    // optionally relax regex
    if (options && options.strict === false) {
      regex = /\\(.)|(^!|[*?{}()[\]]|\(\?)/;
    }
  
    while ((match = regex.exec(str))) {
      if (match[2]) return true;
      var idx = match.index + match[0].length;
  
      // if an open bracket/brace/paren is escaped,
      // set the index to the next closing character
      var open = match[1];
      var close = open ? chars[open] : null;
      if (open && close) {
        var n = str.indexOf(close, idx);
        if (n !== -1) {
          idx = n + 1;
        }
      }
  
      str = str.slice(idx);
    }
    return false;
  };
  
  // 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 isWindows = process.platform === 'win32';
  
  
  // 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 = path.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 = /^[\/]*/;
  }
  
  var realpathSync = function realpathSync(p, cache) {
    // make p is absolute
    p = path.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 = path.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 = path.resolve(resolvedLink, p.slice(pos));
      start();
    }
  
    if (cache) cache[original] = p;
  
    return p;
  };
  
  
  var realpath = function realpath(p, cache, cb) {
    if (typeof cb !== 'function') {
      cb = maybeCallback(cache);
      cache = null;
    }
  
    // make p is absolute
    p = path.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 = path.resolve(previous, target);
      if (cache) cache[base] = resolvedLink;
      gotResolvedLink(resolvedLink);
    }
  
    function gotResolvedLink(resolvedLink) {
      // resolve the link, then start over
      p = path.resolve(resolvedLink, p.slice(pos));
      start();
    }
  };
  
  var old = {
  	realpathSync: realpathSync,
  	realpath: realpath
  };
  
  var fs_realpath = realpath$1;
  realpath$1.realpath = realpath$1;
  realpath$1.sync = realpathSync$1;
  realpath$1.realpathSync = realpathSync$1;
  realpath$1.monkeypatch = monkeypatch;
  realpath$1.unmonkeypatch = unmonkeypatch;
  
  
  var origRealpath = fs.realpath;
  var origRealpathSync = fs.realpathSync;
  
  var version = process.version;
  var ok = /^v[0-5]\./.test(version);
  
  
  function newError (er) {
    return er && er.syscall === 'realpath' && (
      er.code === 'ELOOP' ||
      er.code === 'ENOMEM' ||
      er.code === 'ENAMETOOLONG'
    )
  }
  
  function realpath$1 (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$1 (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$1;
    fs.realpathSync = realpathSync$1;
  }
  
  function unmonkeypatch () {
    fs.realpath = origRealpath;
    fs.realpathSync = origRealpathSync;
  }
  
  var concatMap = function (xs, fn) {
      var res = [];
      for (var i = 0; i < xs.length; i++) {
          var x = fn(xs[i], i);
          if (isArray(x)) res.push.apply(res, x);
          else res.push(x);
      }
      return res;
  };
  
  var isArray = Array.isArray || function (xs) {
      return Object.prototype.toString.call(xs) === '[object Array]';
  };
  
  var balancedMatch = balanced;
  function balanced(a, b, str) {
    if (a instanceof RegExp) a = maybeMatch(a, str);
    if (b instanceof RegExp) b = maybeMatch(b, str);
  
    var r = range(a, b, str);
  
    return r && {
      start: r[0],
      end: r[1],
      pre: str.slice(0, r[0]),
      body: str.slice(r[0] + a.length, r[1]),
      post: str.slice(r[1] + b.length)
    };
  }
  
  function maybeMatch(reg, str) {
    var m = str.match(reg);
    return m ? m[0] : null;
  }
  
  balanced.range = range;
  function range(a, b, str) {
    var begs, beg, left, right, result;
    var ai = str.indexOf(a);
    var bi = str.indexOf(b, ai + 1);
    var i = ai;
  
    if (ai >= 0 && bi > 0) {
      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;
  }
  
  var braceExpansion = expandTop;
  
  var escSlash = '\0SLASH'+Math.random()+'\0';
  var escOpen = '\0OPEN'+Math.random()+'\0';
  var escClose = '\0CLOSE'+Math.random()+'\0';
  var escComma = '\0COMMA'+Math.random()+'\0';
  var escPeriod = '\0PERIOD'+Math.random()+'\0';
  
  function numeric(str) {
    return parseInt(str, 10) == str
      ? parseInt(str, 10)
      : str.charCodeAt(0);
  }
  
  function escapeBraces(str) {
    return str.split('\\\\').join(escSlash)
              .split('\\{').join(escOpen)
              .split('\\}').join(escClose)
              .split('\\,').join(escComma)
              .split('\\.').join(escPeriod);
  }
  
  function unescapeBraces(str) {
    return str.split(escSlash).join('\\')
              .split(escOpen).join('{')
              .split(escClose).join('}')
              .split(escComma).join(',')
              .split(escPeriod).join('.');
  }
  
  
  // Basically just str.split(","), but handling cases
  // where we have nested braced sections, which should be
  // treated as individual members, like {a,{b,c},d}
  function parseCommaParts(str) {
    if (!str)
      return [''];
  
    var parts = [];
    var m = balancedMatch('{', '}', str);
  
    if (!m)
      return str.split(',');
  
    var pre = m.pre;
    var body = m.body;
    var post = m.post;
    var p = pre.split(',');
  
    p[p.length-1] += '{' + body + '}';
    var postParts = parseCommaParts(post);
    if (post.length) {
      p[p.length-1] += postParts.shift();
      p.push.apply(p, postParts);
    }
  
    parts.push.apply(parts, p);
  
    return parts;
  }
  
  function expandTop(str) {
    if (!str)
      return [];
  
    // I don't know why Bash 4.3 does this, but it does.
    // Anything starting with {} will have the first two bytes preserved
    // but *only* at the top level, so {},a}b will not expand to anything,
    // but a{},b}c will be expanded to [a}c,abc].
    // One could argue that this is a bug in Bash, but since the goal of
    // this module is to match Bash's rules, we escape a leading {}
    if (str.substr(0, 2) === '{}') {
      str = '\\{\\}' + str.substr(2);
    }
  
    return expand(escapeBraces(str), true).map(unescapeBraces);
  }
  
  function embrace(str) {
    return '{' + str + '}';
  }
  function isPadded(el) {
    return /^-?0\d/.test(el);
  }
  
  function lte(i, y) {
    return i <= y;
  }
  function gte(i, y) {
    return i >= y;
  }
  
  function expand(str, isTop) {
    var expansions = [];
  
    var m = balancedMatch('{', '}', 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;
  }
  
  var minimatch_1 = minimatch;
  minimatch.Minimatch = Minimatch;
  
  var path$1 = { sep: '/' };
  try {
    path$1 = path;
  } catch (er) {}
  
  var GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {};
  
  
  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) {
    a = a || {};
    b = b || {};
    var t = {};
    Object.keys(b).forEach(function (k) {
      t[k] = b[k];
    });
    Object.keys(a).forEach(function (k) {
      t[k] = a[k];
    });
    return t
  }
  
  minimatch.defaults = function (def) {
    if (!def || !Object.keys(def).length) return minimatch
  
    var orig = minimatch;
  
    var m = function minimatch (p, pattern, options) {
      return orig.minimatch(p, pattern, ext(def, options))
    };
  
    m.Minimatch = function Minimatch (pattern, options) {
      return new orig.Minimatch(pattern, ext(def, options))
    };
  
    return m
  };
  
  Minimatch.defaults = function (def) {
    if (!def || !Object.keys(def).length) return Minimatch
    return minimatch.defaults(def).Minimatch
  };
  
  function minimatch (p, pattern, options) {
    if (typeof pattern !== 'string') {
      throw new TypeError('glob pattern string required')
    }
  
    if (!options) options = {};
  
    // shortcut: comments match nothing.
    if (!options.nocomment && pattern.charAt(0) === '#') {
      return false
    }
  
    // "" only matches ""
    if (pattern.trim() === '') return p === ''
  
    return new Minimatch(pattern, options).match(p)
  }
  
  function Minimatch (pattern, options) {
    if (!(this instanceof Minimatch)) {
      return new Minimatch(pattern, options)
    }
  
    if (typeof pattern !== 'string') {
      throw new TypeError('glob pattern string required')
    }
  
    if (!options) options = {};
    pattern = pattern.trim();
  
    // windows support: need to use /, not \
    if (path$1.sep !== '/') {
      pattern = pattern.split(path$1.sep).join('/');
    }
  
    this.options = options;
    this.set = [];
    this.pattern = pattern;
    this.regexp = null;
    this.negate = false;
    this.comment = false;
    this.empty = false;
  
    // make the set of regexps etc.
    this.make();
  }
  
  Minimatch.prototype.debug = function () {};
  
  Minimatch.prototype.make = make;
  function make () {
    // don't do it more than once.
    if (this._made) return
  
    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 = console.error;
  
    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;
  
    if (typeof pattern === 'undefined') {
      throw new TypeError('undefined pattern')
    }
  
    if (options.nobrace ||
      !pattern.match(/\{.*\}/)) {
      // shortcut. no need to expand.
      return [pattern]
    }
  
    return braceExpansion(pattern)
  }
  
  // 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) {
    if (pattern.length > 1024 * 64) {
      throw new TypeError('pattern is too long')
    }
  
    var options = this.options;
  
    // shortcuts
    if (!options.noglobstar && pattern === '**') return GLOBSTAR
    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) {
        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\]"
          if (inClass) {
            // 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 {
            } 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) {
      // 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) {
      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 = match;
  function match (f, 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$1.sep !== '/') {
      f = f.split(path$1.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.
      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
        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') {
        if (options.nocase) {
          hit = f.toLowerCase() === p.toLowerCase();
        } else {
          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 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/
      var emptyFileEnd = (fi === fl - 1) && (file[fi] === '');
      return emptyFileEnd
    }
  
    // should be unreachable.
    throw new Error('wtf?')
  };
  
  // replace stuff like \* with *
  function globUnescape (s) {
    return s.replace(/\\(.)/g, '$1')
  }
  
  function regExpEscape (s) {
    return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&')
  }
  
  var inherits_browser = createCommonjsModule(function (module) {
  if (typeof Object.create === 'function') {
    // implementation from standard node.js 'util' module
    module.exports = function inherits(ctor, 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) {
      ctor.super_ = superCtor;
      var TempCtor = function () {};
      TempCtor.prototype = superCtor.prototype;
      ctor.prototype = new TempCtor();
      ctor.prototype.constructor = ctor;
    };
  }
  });
  
  var inherits = createCommonjsModule(function (module) {
  try {
    var util$$1 = util;
    if (typeof util$$1.inherits !== 'function') throw '';
    module.exports = util$$1.inherits;
  } catch (e) {
    module.exports = inherits_browser;
  }
  });
  
  function posix(path$$1) {
  	return path$$1.charAt(0) === '/';
  }
  
  function win32(path$$1) {
  	// https://github.com/nodejs/node/blob/b3fcc245fb25539909ef1d5eaa01dbf92e168633/lib/path.js#L56
  	var splitDeviceRe = /^([a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?([\\\/])?([\s\S]*?)$/;
  	var result = splitDeviceRe.exec(path$$1);
  	var device = result[1] || '';
  	var isUnc = Boolean(device && device.charAt(1) !== ':');
  
  	// UNC paths are always absolute
  	return Boolean(result[2] || isUnc);
  }
  
  var pathIsAbsolute = process.platform === 'win32' ? win32 : posix;
  var posix_1 = posix;
  var win32_1 = win32;
  pathIsAbsolute.posix = posix_1;
  pathIsAbsolute.win32 = win32_1;
  
  var alphasort_1 = alphasort;
  var alphasorti_1 = alphasorti;
  var setopts_1 = setopts;
  var ownProp_1 = ownProp;
  var makeAbs_1 = makeAbs;
  var finish_1 = finish;
  var mark_1 = mark;
  var isIgnored_1 = isIgnored;
  var childrenIgnored_1 = childrenIgnored;
  
  function ownProp (obj, field) {
    return Object.prototype.hasOwnProperty.call(obj, field)
  }
  
  
  
  
  var Minimatch$1 = minimatch_1.Minimatch;
  
  function alphasorti (a, b) {
    return a.toLowerCase().localeCompare(b.toLowerCase())
  }
  
  function alphasort (a, b) {
    return a.localeCompare(b)
  }
  
  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$1(gpattern, { dot: true });
    }
  
    return {
      matcher: new Minimatch$1(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.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 = pathIsAbsolute(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$1(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(self.nocase ? alphasorti : 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 (pathIsAbsolute(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$$1) {
    if (!self.ignore.length)
      return false
  
    return self.ignore.some(function(item) {
      return item.matcher.match(path$$1) || !!(item.gmatcher && item.gmatcher.match(path$$1))
    })
  }
  
  function childrenIgnored (self, path$$1) {
    if (!self.ignore.length)
      return false
  
    return self.ignore.some(function(item) {
      return !!(item.gmatcher && item.gmatcher.match(path$$1))
    })
  }
  
  var common = {
  	alphasort: alphasort_1,
  	alphasorti: alphasorti_1,
  	setopts: setopts_1,
  	ownProp: ownProp_1,
  	makeAbs: makeAbs_1,
  	finish: finish_1,
  	mark: mark_1,
  	isIgnored: isIgnored_1,
  	childrenIgnored: childrenIgnored_1
  };
  
  var sync = globSync;
  globSync.GlobSync = GlobSync;
  var setopts$1 = common.setopts;
  var ownProp$1 = common.ownProp;
  var childrenIgnored$1 = common.childrenIgnored;
  var isIgnored$1 = 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$1(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 = fs_realpath.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 (pathIsAbsolute(prefix) || pathIsAbsolute(pattern.join('/'))) {
      if (!prefix || !pathIsAbsolute(prefix))
        prefix = '/' + prefix;
      read = prefix;
    } else
      read = prefix;
  
    var abs = this._makeAbs(read);
  
    //if ignored, skip processing
    if (childrenIgnored$1(this, read))
      return
  
    var isGlobStar = remain[0] === minimatch_1.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$1(this, e))
      return
  
    var abs = this._makeAbs(e);
  
    if (this.mark)
      e = this._mark(e);
  
    if (this.absolute) {
      e = abs;
    }
  
    if (this.matches[index][e])
      return
  
    if (this.nodir) {
      var c = this.cache[abs];
      if (c === 'DIR' || Array.isArray(c))
        return
    }
  
    this.matches[index][e] = true;
  
    if (this.stat)
      this._stat(e);
  };
  
  
  GlobSync.prototype._readdirInGlobStar = function (abs) {
    // follow all symlinked directories forever
    // just proceed as if this is a non-globstar situation
    if (this.follow)
      return this._readdir(abs, false)
  
    var entries;
    var lstat;
    try {
      lstat = fs.lstatSync(abs);
    } catch (er) {
      if (er.code === 'ENOENT') {
        // lstat failed, doesn't exist
        return null
      }
    }
  
    var isSym = lstat && lstat.isSymbolicLink();
    this.symlinks[abs] = isSym;
  
    // If it's not a symlink or a dir, then it's definitely a regular file.
    // don't bother doing a readdir in that case.
    if (!isSym && lstat && !lstat.isDirectory())
      this.cache[abs] = 'FILE';
    else
      entries = this._readdir(abs, false);
  
    return entries
  };
  
  GlobSync.prototype._readdir = function (abs, inGlobStar) {
  
    if (inGlobStar && !ownProp$1(this.symlinks, abs))
      return this._readdirInGlobStar(abs)
  
    if (ownProp$1(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, 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 && pathIsAbsolute(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$1(this.cache, abs)) {
      var c = this.cache[abs];
  
      if (Array.isArray(c))
        c = 'DIR';
  
      // It exists, but maybe not how we need it
      if (!needDir || c === 'DIR')
        return c
  
      if (needDir && c === 'FILE')
        return false
  
      // otherwise we have to stat, because maybe c=true
      // if we know it exists, but not what it is.
    }
    var stat = this.statCache[abs];
    if (!stat) {
      var lstat;
      try {
        lstat = 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 = 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)
  };
  
  // 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.
  var wrappy_1 = wrappy;
  function wrappy (fn, cb) {
    if (fn && cb) return wrappy(fn)(cb)
  
    if (typeof fn !== 'function')
      throw new TypeError('need wrapper function')
  
    Object.keys(fn).forEach(function (k) {
      wrapper[k] = fn[k];
    });
  
    return wrapper
  
    function wrapper() {
      var args = new Array(arguments.length);
      for (var i = 0; i < args.length; i++) {
        args[i] = arguments[i];
      }
      var ret = fn.apply(this, args);
      var cb = args[args.length-1];
      if (typeof ret === 'function' && ret !== cb) {
        Object.keys(cb).forEach(function (k) {
          ret[k] = cb[k];
        });
      }
      return ret
    }
  }
  
  var once_1 = wrappy_1(once);
  var strict = wrappy_1(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
  }
  
  function onceStrict (fn) {
    var f = function () {
      if (f.called)
        throw new Error(f.onceError)
      f.called = true;
      return f.value = fn.apply(this, arguments)
    };
    var name = fn.name || 'Function wrapped with `once`';
    f.onceError = name + " shouldn't be called more than once";
    f.called = false;
    return f
  }
  once_1.strict = strict;
  
  var reqs = Object.create(null);
  
  
  var inflight_1 = wrappy_1(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_1(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
  }
  
  // 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.
  
  var glob_1 = glob;
  
  var EE = events.EventEmitter;
  var setopts$2 = common.setopts;
  var ownProp$2 = common.ownProp;
  
  
  var childrenIgnored$2 = common.childrenIgnored;
  var isIgnored$2 = common.isIgnored;
  
  
  
  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 sync(pattern, options)
    }
  
    return new Glob$1(pattern, options, cb)
  }
  
  glob.sync = sync;
  var GlobSync$1 = glob.GlobSync = sync.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$1(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$1;
  inherits(Glob$1, EE);
  function Glob$1 (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$1(pattern, options)
    }
  
    if (!(this instanceof Glob$1))
      return new Glob$1(pattern, options, cb)
  
    setopts$2(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_1(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$$1 = true;
    for (var i = 0; i < n; i ++) {
      this._process(this.minimatch.set[i], i, false, done);
    }
    sync$$1 = false;
  
    function done () {
      --self._processing;
      if (self._processing <= 0) {
        if (sync$$1) {
          process.nextTick(function () {
            self._finish();
          });
        } else {
          self._finish();
        }
      }
    }
  }
  
  Glob$1.prototype._finish = function () {
    assert(this instanceof Glob$1);
    if (this.aborted)
      return
  
    if (this.realpath && !this._didRealpath)
      return this._realpath()
  
    common.finish(this);
    this.emit('end', this.found);
  };
  
  Glob$1.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$1.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);
      fs_realpath.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$1.prototype._mark = function (p) {
    return common.mark(this, p)
  };
  
  Glob$1.prototype._makeAbs = function (f) {
    return common.makeAbs(this, f)
  };
  
  Glob$1.prototype.abort = function () {
    this.aborted = true;
    this.emit('abort');
  };
  
  Glob$1.prototype.pause = function () {
    if (!this.paused) {
      this.paused = true;
      this.emit('pause');
    }
  };
  
  Glob$1.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$1.prototype._process = function (pattern, index, inGlobStar, cb) {
    assert(this instanceof Glob$1);
    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 (pathIsAbsolute(prefix) || pathIsAbsolute(pattern.join('/'))) {
      if (!prefix || !pathIsAbsolute(prefix))
        prefix = '/' + prefix;
      read = prefix;
    } else
      read = prefix;
  
    var abs = this._makeAbs(read);
  
    //if ignored, skip _processing
    if (childrenIgnored$2(this, read))
      return cb()
  
    var isGlobStar = remain[0] === minimatch_1.GLOBSTAR;
    if (isGlobStar)
      this._processGlobStar(prefix, read, abs, remain, index, inGlobStar, cb);
    else
      this._processReaddir(prefix, read, abs, remain, index, inGlobStar, cb);
  };
  
  Glob$1.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$1.prototype._processReaddir2 = function (prefix, read, abs, remain, index, inGlobStar, entries, cb) {
  
    // if the abs isn't a dir, then nothing can match!
    if (!entries)
      return cb()
  
    // It will only match dot entries if it starts with a dot, or if
    // dot is set.  Stuff like @(.foo|.bar) isn't allowed.
    var pn = remain[0];
    var negate = !!this.minimatch.negate;
    var rawGlob = pn._glob;
    var dotOk = this.dot || rawGlob.charAt(0) === '.';
  
    var matchedEntries = [];
    for (var i = 0; i < entries.length; i++) {
      var e = entries[i];
      if (e.charAt(0) !== '.' || dotOk) {
        var m;
        if (negate && !prefix) {
          m = !e.match(pn);
        } else {
          m = e.match(pn);
        }
        if (m)
          matchedEntries.push(e);
      }
    }
  
    //console.error('prd2', prefix, entries, remain[0]._glob, matchedEntries)
  
    var len = matchedEntries.length;
    // If there are no matched entries, then nothing matches.
    if (len === 0)
      return cb()
  
    // if this is the last remaining pattern bit, then no need for
    // an additional stat *unless* the user has specified mark or
    // stat explicitly.  We know they exist, since readdir returned
    // them.
  
    if (remain.length === 1 && !this.mark && !this.stat) {
      if (!this.matches[index])
        this.matches[index] = Object.create(null);
  
      for (var i = 0; i < len; i ++) {
        var e = matchedEntries[i];
        if (prefix) {
          if (prefix !== '/')
            e = prefix + '/' + e;
          else
            e = prefix + e;
        }
  
        if (e.charAt(0) === '/' && !this.nomount) {
          e = path.join(this.root, e);
        }
        this._emitMatch(index, e);
      }
      // This was the last one, and no stats were needed
      return cb()
    }
  
    // now test all matched entries as stand-ins for that part
    // of the pattern.
    remain.shift();
    for (var i = 0; i < len; i ++) {
      var e = matchedEntries[i];
      if (prefix) {
        if (prefix !== '/')
          e = prefix + '/' + e;
        else
          e = prefix + e;
      }
      this._process([e].concat(remain), index, inGlobStar, cb);
    }
    cb();
  };
  
  Glob$1.prototype._emitMatch = function (index, e) {
    if (this.aborted)
      return
  
    if (isIgnored$2(this, e))
      return
  
    if (this.paused) {
      this._emitQueue.push([index, e]);
      return
    }
  
    var abs = pathIsAbsolute(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$1.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_1(lstatkey, lstatcb_);
  
    if (lstatcb)
      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$1.prototype._readdir = function (abs, inGlobStar, cb) {
    if (this.aborted)
      return
  
    cb = inflight_1('readdir\0'+abs+'\0'+inGlobStar, cb);
    if (!cb)
      return
  
    //console.error('RD %j %j', +inGlobStar, abs)
    if (inGlobStar && !ownProp$2(this.symlinks, abs))
      return this._readdirInGlobStar(abs, cb)
  
    if (ownProp$2(this.cache, abs)) {
      var c = this.cache[abs];
      if (!c || c === 'FILE')
        return cb()
  
      if (Array.isArray(c))
        return cb(null, c)
    }
    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$1.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$1.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$1.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$1.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$1.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$1.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 && pathIsAbsolute(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$1.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$2(this.cache, abs)) {
      var c = this.cache[abs];
  
      if (Array.isArray(c))
        c = 'DIR';
  
      // It exists, but maybe not how we need it
      if (!needDir || c === 'DIR')
        return cb(null, c)
  
      if (needDir && c === 'FILE')
        return cb()
  
      // otherwise we have to stat, because maybe c=true
      // if we know it exists, but not what it is.
    }
    var stat = this.statCache[abs];
    if (stat !== undefined) {
      if (stat === false)
        return cb(null, stat)
      else {
        var type = stat.isDirectory() ? 'DIR' : 'FILE';
        if (needDir && type === 'FILE')
          return cb()
        else
          return cb(null, type, stat)
      }
    }
  
    var self = this;
    var statcb = inflight_1('stat\0' + abs, lstatcb_);
    if (statcb)
      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 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$1.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)
  };
  
  var recursiveReadDirSync = function recursiveReadDirSync(dir) {
    return fs.readdirSync(dir).reduce(function (files, file) {
      return fs.statSync(path.join(dir, file)).isDirectory() ? files.concat(recursiveReadDirSync(path.join(dir, file))) : files.concat(path.join(dir, file));
    }, []);
  };
  
  var readDirSync = function readDirSync(dir) {
    return fs.readdirSync(dir).reduce(function (files, file) {
      return fs.statSync(path.join(dir, file)).isDirectory() ? files : files.concat(path.join(dir, file));
    }, []);
  };
  
  var readGlobSync = function readGlobSync(pattern, options) {
    return glob_1.sync(pattern, options);
  };
  
  var getSchemaFiles = function getSchemaFiles(dir, recursive, globOptions) {
    if (isGlob(dir)) {
      return readGlobSync(dir, globOptions);
    }
  
    if (recursive === true) {
      return recursiveReadDirSync(dir);
    }
  
    return readDirSync(dir);
  };
  
  var DEFAULT_EXTENSIONS = ['.ts', '.js', '.gql', '.graphql', '.graphqls'];
  
  var fileLoader = function fileLoader(folderPath) {
    var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
        _ref$recursive = _ref.recursive,
        recursive = _ref$recursive === undefined ? false : _ref$recursive,
        _ref$extensions = _ref.extensions,
        extensions = _ref$extensions === undefined ? DEFAULT_EXTENSIONS : _ref$extensions,
        _ref$globOptions = _ref.globOptions,
        globOptions = _ref$globOptions === undefined ? {} : _ref$globOptions;
  
    var dir = folderPath;
    var schemafiles = getSchemaFiles(dir, recursive, globOptions);
  
    var files = schemafiles.map(function (f) {
      return { f, pathObj: path.parse(f) };
    }).filter(function (_ref2) {
      var pathObj = _ref2.pathObj;
      return pathObj.name.toLowerCase() !== 'index';
    }).filter(function (_ref3) {
      var pathObj = _ref3.pathObj;
      return extensions.includes(pathObj.ext);
    }).map(function (_ref4) {
      var f = _ref4.f,
          pathObj = _ref4.pathObj;
  
      var returnVal = void 0;
  
      switch (pathObj.ext) {
        case '.ts':
        case '.js':
          {
            var file = require(f); // eslint-disable-line
            returnVal = file.default || file;
            break;
          }
  
        case '.graphqls':
        case '.gql':
        case '.graphql':
          {
            var _file = fs.readFileSync(f, 'utf8');
            returnVal = _file;
            break;
          }
  
        default:
        // we don't know how to handle other extensions
      }
  
      return returnVal;
    }).filter(function (v) {
      return !!v;
    }); // filter files that we don't know how to handle
  
    return files;
  };
  
  /**
   * Copyright (c) 2015-present, Facebook, Inc.
   *
   * This source code is licensed under the MIT license found in the
   * LICENSE file in the root directory of this source tree.
   */
  
  /**
   * Given maybeArray, print an empty string if it is null or empty, otherwise
   * print all items together separated by separator if provided
   */
  function join(maybeArray, separator) {
    return maybeArray ? maybeArray.filter(function (x) {
      return x;
    }).join(separator || '') : '';
  }
  
  function addDescription(cb) {
    return function (node) {
      return join([node.description, cb(node)], '\n');
    };
  }
  
  function indent(maybeString) {
    return maybeString && `  ${maybeString.replace(/\n/g, '\n  ')}`;
  }
  
  /**
   * Given array, print each item on its own line, wrapped in an
   * indented "{ }" block.
   */
  function block(array) {
    return array && array.length !== 0 ? `{\n${indent(join(array, '\n'))}\n}` : '';
  }
  
  /**
   * If maybeString is not null or empty, then wrap with start and end, otherwise
   * print an empty string.
   */
  function wrap(start, maybeString, end) {
    return maybeString ? start + maybeString + (end || '') : '';
  }
  
  /**
   * Print a block string in the indented block form by adding a leading and
   * trailing blank line. However, if a block string starts with whitespace and is
   * a single-line, adding a leading blank line would strip that whitespace.
   */
  function printBlockString(value, isDescription) {
    var escaped = value.replace(/"""/g, '\\"""');
    return (value[0] === ' ' || value[0] === '\t') && value.indexOf('\n') === -1 ? `"""${escaped.replace(/"$/, '"\n')}"""` : `"""\n${isDescription ? escaped : indent(escaped)}\n"""`;
  }
  
  var printDocASTReducer = {
    Name: function Name(node) {
      return node.value;
    },
    Variable: function Variable(node) {
      return `$${node.name}`;
    },
  
    // Document
  
    Document: function Document(node) {
      return `${node.definitions.map(function (defNode) {
        return `${defNode}\n${defNode[0] === '#' ? '' : '\n'}`;
      }).join('').trim()}\n`;
    },
  
    OperationDefinition(node) {
      var op = node.operation;
      var name = node.name;
      var varDefs = wrap('(', join(node.variableDefinitions, ', '), ')');
      var directives = join(node.directives, ' ');
      var selectionSet = node.selectionSet;
      // Anonymous queries with no directives or variable definitions can use
      // the query short form.
      return !name && !directives && !varDefs && op === 'query' ? selectionSet : join([op, join([name, varDefs]), directives, selectionSet], ' ');
    },
  
    VariableDefinition: function VariableDefinition(_ref) {
      var variable = _ref.variable,
          type = _ref.type,
          defaultValue = _ref.defaultValue;
      return `${variable}: ${type}${wrap(' = ', defaultValue)}`;
    },
  
    SelectionSet: function SelectionSet(_ref2) {
      var selections = _ref2.selections;
      return block(selections);
    },
  
    Field: function Field(_ref3) {
      var alias = _ref3.alias,
          name = _ref3.name,
          args = _ref3.arguments,
          directives = _ref3.directives,
          selectionSet = _ref3.selectionSet;
      return join([wrap('', alias, ': ') + name + wrap('(', join(args, ', '), ')'), join(directives, ' '), selectionSet], '  ');
    },
  
    Argument: function Argument(_ref4) {
      var name = _ref4.name,
          value = _ref4.value;
      return `${name}: ${value}`;
    },
  
    // Fragments
  
    FragmentSpread: function FragmentSpread(_ref5) {
      var name = _ref5.name,
          directives = _ref5.directives;
      return `...${name}${wrap(' ', join(directives, ' '))}`;
    },
  
    InlineFragment: function InlineFragment(_ref6) {
      var typeCondition = _ref6.typeCondition,
          directives = _ref6.directives,
          selectionSet = _ref6.selectionSet;
      return join(['...', wrap('on ', typeCondition), join(directives, ' '), selectionSet], ' ');
    },
  
    FragmentDefinition: function FragmentDefinition(_ref7) {
      var name = _ref7.name,
          typeCondition = _ref7.typeCondition,
          variableDefinitions = _ref7.variableDefinitions,
          directives = _ref7.directives,
          selectionSet = _ref7.selectionSet;
      return (
        // Note: fragment variable definitions are experimental and may be changed
        // or removed in the future.
        `${`fragment ${name}${wrap('(', join(variableDefinitions, ', '), ')')} ` + `on ${typeCondition} ${wrap('', join(directives, ' '), ' ')}`}${selectionSet}`
      );
    },
  
    // Value
  
    IntValue: function IntValue(_ref8) {
      var value = _ref8.value;
      return value;
    },
    FloatValue: function FloatValue(_ref9) {
      var value = _ref9.value;
      return value;
    },
    StringValue: function StringValue(_ref10, key) {
      var value = _ref10.value,
          isBlockString = _ref10.block;
      return isBlockString ? printBlockString(value, key === 'description') : JSON.stringify(value);
    },
    BooleanValue: function BooleanValue(_ref11) {
      var value = _ref11.value;
      return value ? 'true' : 'false';
    },
    NullValue: function NullValue() {
      return 'null';
    },
    EnumValue: function EnumValue(_ref12) {
      var value = _ref12.value;
      return value;
    },
    ListValue: function ListValue(_ref13) {
      var values = _ref13.values;
      return `[${join(values, ', ')}]`;
    },
    ObjectValue: function ObjectValue(_ref14) {
      var fields = _ref14.fields;
      return `{${join(fields, ', ')}}`;
    },
    ObjectField: function ObjectField(_ref15) {
      var name = _ref15.name,
          value = _ref15.value;
      return `${name}: ${value}`;
    },
  
    // Directive
  
    Directive: function Directive(_ref16) {
      var name = _ref16.name,
          args = _ref16.arguments;
      return `@${name}${wrap('(', join(args, ', '), ')')}`;
    },
  
    // Type
  
    NamedType: function NamedType(_ref17) {
      var name = _ref17.name;
      return name;
    },
    ListType: function ListType(_ref18) {
      var type = _ref18.type;
      return `[${type}]`;
    },
    NonNullType: function NonNullType(_ref19) {
      var type = _ref19.type;
      return `${type}!`;
    },
  
    // Type System Definitions
  
    SchemaDefinition: function SchemaDefinition(_ref20) {
      var directives = _ref20.directives,
          operationTypes = _ref20.operationTypes;
      return join(['schema', join(directives, ' '), block(operationTypes)], ' ');
    },
  
    OperationTypeDefinition: function OperationTypeDefinition(_ref21) {
      var operation = _ref21.operation,
          type = _ref21.type;
      return `${operation}: ${type}`;
    },
  
    ScalarTypeDefinition: addDescription(function (_ref22) {
      var name = _ref22.name,
          directives = _ref22.directives;
      return join(['scalar', name, join(directives, ' ')], ' ');
    }),
  
    ObjectTypeDefinition: addDescription(function (_ref23) {
      var name = _ref23.name,
          interfaces = _ref23.interfaces,
          directives = _ref23.directives,
          fields = _ref23.fields;
      return join(['type', name, wrap('implements ', join(interfaces, ' & ')), join(directives, ' '), block(fields)], ' ');
    }),
  
    FieldDefinition: addDescription(function (_ref24) {
      var name = _ref24.name,
          args = _ref24.arguments,
          type = _ref24.type,
          directives = _ref24.directives;
      return `${name + wrap('(', join(args, ', '), ')')}: ${type}${wrap(' ', join(directives, ' '))}`;
    }),
  
    InputValueDefinition: addDescription(function (_ref25) {
      var name = _ref25.name,
          type = _ref25.type,
          defaultValue = _ref25.defaultValue,
          directives = _ref25.directives;
      return join([`${name}: ${type}`, wrap('= ', defaultValue), join(directives, ' ')], ' ');
    }),
  
    InterfaceTypeDefinition: addDescription(function (_ref26) {
      var name = _ref26.name,
          directives = _ref26.directives,
          fields = _ref26.fields;
      return join(['interface', name, join(directives, ' '), block(fields)], ' ');
    }),
  
    UnionTypeDefinition: addDescription(function (_ref27) {
      var name = _ref27.name,
          directives = _ref27.directives,
          types = _ref27.types;
      return join(['union', name, join(directives, ' '), types && types.length !== 0 ? `= ${join(types, ' | ')}` : ''], ' ');
    }),
  
    EnumTypeDefinition: addDescription(function (_ref28) {
      var name = _ref28.name,
          directives = _ref28.directives,
          values = _ref28.values;
      return join(['enum', name, join(directives, ' '), block(values)], ' ');
    }),
  
    EnumValueDefinition: addDescription(function (_ref29) {
      var name = _ref29.name,
          directives = _ref29.directives;
      return join([name, join(directives, ' ')], ' ');
    }),
  
    InputObjectTypeDefinition: addDescription(function (_ref30) {
      var name = _ref30.name,
          directives = _ref30.directives,
          fields = _ref30.fields;
      return join(['input', name, join(directives, ' '), block(fields)], ' ');
    }),
  
    ScalarTypeExtension: function ScalarTypeExtension(_ref31) {
      var name = _ref31.name,
          directives = _ref31.directives;
      return join(['extend scalar', name, join(directives, ' ')], ' ');
    },
  
    ObjectTypeExtension: function ObjectTypeExtension(_ref32) {
      var name = _ref32.name,
          interfaces = _ref32.interfaces,
          directives = _ref32.directives,
          fields = _ref32.fields;
      return join(['extend type', name, wrap('implements ', join(interfaces, ' & ')), join(directives, ' '), block(fields)], ' ');
    },
  
    InterfaceTypeExtension: function InterfaceTypeExtension(_ref33) {
      var name = _ref33.name,
          directives = _ref33.directives,
          fields = _ref33.fields;
      return join(['extend interface', name, join(directives, ' '), block(fields)], ' ');
    },
  
    UnionTypeExtension: function UnionTypeExtension(_ref34) {
      var name = _ref34.name,
          directives = _ref34.directives,
          types = _ref34.types;
      return join(['extend union', name, join(directives, ' '), types && types.length !== 0 ? `= ${join(types, ' | ')}` : ''], ' ');
    },
  
    EnumTypeExtension: function EnumTypeExtension(_ref35) {
      var name = _ref35.name,
          directives = _ref35.directives,
          values = _ref35.values;
      return join(['extend enum', name, join(directives, ' '), block(values)], ' ');
    },
  
    InputObjectTypeExtension: function InputObjectTypeExtension(_ref36) {
      var name = _ref36.name,
          directives = _ref36.directives,
          fields = _ref36.fields;
      return join(['extend input', name, join(directives, ' '), block(fields)], ' ');
    },
  
    DirectiveDefinition: addDescription(function (_ref37) {
      var name = _ref37.name,
          args = _ref37.arguments,
          locations = _ref37.locations;
      return `directive @${name}${wrap('(', join(args, ', '), ')')} on ${join(locations, ' | ')}`;
    }),
  
    Comment: function Comment(_ref38) {
      var value = _ref38.value;
      return `# ${value.replace(/\n/g, '\n # ')}`;
    }
  };
  
  /**
   * Converts an AST into a string, using one set of reasonable
   * formatting rules.
   */
  function print(ast) {
    return visitor.visit(ast, { leave: printDocASTReducer });
  }
  
  var hasDefinitionWithName = function hasDefinitionWithName(nodes, name) {
    return nodes.findIndex(function (node) {
      return node.name.value === name;
    }) !== -1;
  };
  
  var isObjectTypeDefinition = function isObjectTypeDefinition(def) {
    return def.kind === graphql.Kind.OBJECT_TYPE_DEFINITION || def.kind === graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION || def.kind === graphql.Kind.SCALAR_TYPE_DEFINITION || def.kind === graphql.Kind.ENUM_TYPE_DEFINITION || def.kind === graphql.Kind.INTERFACE_TYPE_DEFINITION;
  };
  
  var isEnumTypeDefinition = function isEnumTypeDefinition(def) {
    return def.kind === graphql.Kind.ENUM_TYPE_DEFINITION;
  };
  
  var isObjectSchemaDefinition = function isObjectSchemaDefinition(def) {
    return def.kind === graphql.Kind.SCHEMA_DEFINITION;
  };
  
  var typesMap = {
    query: 'Query',
    mutation: 'Mutation',
    subscription: 'Subscription'
  };
  
  var _mergeableOperationTypes = Object.keys(typesMap);
  
  var _makeOperationType = function _makeOperationType(operation, value) {
    return {
      kind: graphql.Kind.OPERATION_TYPE_DEFINITION,
      operation,
      type: {
        kind: graphql.Kind.NAMED_TYPE,
        name: {
          kind: graphql.Kind.NAME,
          value
        }
      }
    };
  };
  
  var mergeableTypes = Object.values(typesMap);
  
  var makeSchema = function makeSchema(definitions, schemaDefs) {
    var operationMap = {
      query: _makeOperationType(_mergeableOperationTypes[0], mergeableTypes[0]),
      mutation: null,
      subscription: null
    };
  
    mergeableTypes.slice(1).forEach(function (type, key) {
      if (hasDefinitionWithName(definitions, type)) {
        var operation = _mergeableOperationTypes[key + 1];
  
        operationMap[operation] = _makeOperationType(operation, type);
      }
    });
  
    var operationTypes = Object.values(operationMap).map(function (operation, i) {
      if (!operation) {
        var type = Object.keys(operationMap)[i];
  
        if (schemaDefs.some(function (def) {
          return def.operationTypes.some(function (op) {
            return op.operation === type;
          });
        })) {
          return _makeOperationType(type, typesMap[type]);
        }
      }
  
      return operation;
    }).filter(function (op) {
      return op;
    });
  
    return {
      kind: graphql.Kind.SCHEMA_DEFINITION,
      directives: [],
      operationTypes
    };
  };
  
  var _extends = Object.assign || function (target) {
    for (var i = 1; i < arguments.length; i++) {
      var source = arguments[i];
  
      for (var key in source) {
        if (Object.prototype.hasOwnProperty.call(source, key)) {
          target[key] = source[key];
        }
      }
    }
  
    return target;
  };
  
  var toConsumableArray = function (arr) {
    if (Array.isArray(arr)) {
      for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];
  
      return arr2;
    } else {
      return Array.from(arr);
    }
  };
  
  // NOTE: Currently using a slightly modified print instead of the exported graphql version.
  
  var _isMergeableTypeDefinition = function _isMergeableTypeDefinition(def, all) {
    return isObjectTypeDefinition(def) && (mergeableTypes.includes(def.name.value) || all);
  };
  
  var _isNonMergeableTypeDefinition = function _isNonMergeableTypeDefinition(def, all) {
    return !_isMergeableTypeDefinition(def, all);
  };
  
  var _makeCommentNode = function _makeCommentNode(value) {
    return { kind: 'Comment', value };
  };
  
  var _addCommentsToAST = function _addCommentsToAST() {
    var nodes = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
    var flatten = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
  
    var astWithComments = nodes.map(function (node) {
      var description = buildASTSchema.getDescription(node, { commentDescriptions: true });
      if (description) {
        return [_makeCommentNode(description), node];
      }
  
      return [node];
    });
  
    if (flatten) {
      return astWithComments.reduce(function (a, b) {
        return a.concat(b);
      }, []);
    }
  
    return astWithComments;
  };
  
  var _makeRestDefinitions = function _makeRestDefinitions(defs) {
    var all = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
    return defs.filter(function (def) {
      return _isNonMergeableTypeDefinition(def, all) && !isObjectSchemaDefinition(def);
    }).map(function (def) {
      if (isObjectTypeDefinition(def) || isEnumTypeDefinition(def)) {
        return _extends({}, def, {
          fields: def.fields ? _addCommentsToAST(def.fields) : undefined,
          values: def.values ? _addCommentsToAST(def.values) : undefined
        });
      }
  
      return def;
    });
  };
  
  // Gracefully handle nested pathing of GraphQL types
  // skips any attributes that can't be found in path (i.e. type.type.type.value => type.type.value)
  // returns chained-property value path of tracker attribute later used for comparison
  // (i.e. 'ListType.NamedType.SomeValue' !== 'NonNullType.ListType.NamedType.SomeValue')
  var _getGraphQLPath = function _getGraphQLPath(path$$1, theObj, tracker) {
    var result = void 0;
    path$$1.split('.').reduce(function (o, x) {
      if (o && o[x]) {
        var v = o[x].hasOwnProperty.call(tracker) ? o[x][tracker] : o[x];
        if (!result) result = v;else result += `.${v}`;
        return o[x];
      }
      return o;
    }, theObj);
    return result;
  };
  
  var _makeMergedFieldDefinitions = function _makeMergedFieldDefinitions(merged, candidate) {
    return _addCommentsToAST(candidate.fields).reduce(function (fields, field) {
      var original = merged.fields.find(function (base) {
        return base.name && typeof base.name.value !== 'undefined' && field.name && typeof field.name.value !== 'undefined' && base.name.value === field.name.value;
      });
      if (!original) {
        fields.push(field);
      } else if (field.type.kind === 'NamedType') {
        if (field.type.name.value !== original.type.name.value) {
          throw new Error(`Conflicting types for ${merged.name.value}.${field.name.value}: ` + `${field.type.name.value} != ${original.type.name.value}`);
        }
      } else if (field.type.kind === 'NonNullType' || field.type.kind === 'ListType') {
        var path$$1 = _getGraphQLPath('type.type.type.value', field, 'kind');
        var originalPath = _getGraphQLPath('type.type.type.value', original, 'kind');
  
        if (path$$1 !== originalPath) {
          throw new Error(`Conflicting types for ${merged.name.value}.${field.name.value}: ` + `${path$$1} != ${originalPath}`);
        }
      }
  
      // retain directives of both fields.
      if (original) {
        original.directives = original.directives.concat(field.directives);
      }
      return fields;
    }, merged.fields);
  };
  
  var _makeMergedDefinitions = function _makeMergedDefinitions(defs) {
    var all = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
  
    // TODO: This function can be cleaner!
    var groupedMergableDefinitions = defs.filter(function (def) {
      return _isMergeableTypeDefinition(def, all);
    }).reduce(function (mergableDefs, def) {
      var name = def.name.value;
  
      if (!mergableDefs[name]) {
        return _extends({}, mergableDefs, {
          [name]: _extends({}, def, {
            fields: def.fields ? _addCommentsToAST(def.fields) : undefined,
            values: def.values ? _addCommentsToAST(def.values) : undefined
          })
        });
      }
  
      return _extends({}, mergableDefs, {
        [name]: _extends({}, mergableDefs[name], {
          fields: _makeMergedFieldDefinitions(mergableDefs[name], def)
        })
      });
    }, {
      Query: null,
      Mutation: null,
      Subscription: null
    });
  
    return Object.values(groupedMergableDefinitions).reduce(function (array, def) {
      return def ? [].concat(toConsumableArray(array), [def]) : array;
    }, []);
  };
  
  var _makeDocumentWithDefinitions = function _makeDocumentWithDefinitions(definitions) {
    return {
      kind: 'Document',
      definitions: definitions instanceof Array ? definitions : [definitions]
    };
  };
  
  var printDefinitions = function printDefinitions(defs) {
    return print(_makeDocumentWithDefinitions(defs));
  };
  
  var mergeTypes = function mergeTypes(types) {
    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : { all: false };
  
    var allDefs = types.map(function (type) {
      if (typeof type === 'string') {
        return graphql.parse(type);
      }
      return type;
    }).map(function (ast) {
      return ast.definitions;
    }).reduce(function (defs, newDef) {
      return [].concat(toConsumableArray(defs), toConsumableArray(newDef));
    }, []);
  
    var mergedDefs = _makeMergedDefinitions(allDefs, options.all);
    var rest = _addCommentsToAST(_makeRestDefinitions(allDefs, options.all), false).map(printDefinitions);
    var schemaDefs = allDefs.filter(isObjectSchemaDefinition);
    var schema = printDefinitions([makeSchema(mergedDefs, schemaDefs)].concat(toConsumableArray(mergedDefs)));
  
    return [schema].concat(toConsumableArray(rest)).join('\n');
  };
  
  var isMergeableObject = function isMergeableObject(value) {
  	return isNonNullObject(value)
  		&& !isSpecial(value)
  };
  
  function isNonNullObject(value) {
  	return !!value && typeof value === 'object'
  }
  
  function isSpecial(value) {
  	var stringValue = Object.prototype.toString.call(value);
  
  	return stringValue === '[object RegExp]'
  		|| stringValue === '[object Date]'
  		|| isReactElement(value)
  }
  
  // see https://github.com/facebook/react/blob/b5ac963fb791d1298e7f396236383bc955f916c1/src/isomorphic/classic/element/ReactElement.js#L21-L25
  var canUseSymbol = typeof Symbol === 'function' && Symbol.for;
  var REACT_ELEMENT_TYPE = canUseSymbol ? Symbol.for('react.element') : 0xeac7;
  
  function isReactElement(value) {
  	return value.$$typeof === REACT_ELEMENT_TYPE
  }
  
  function emptyTarget(val) {
  	return Array.isArray(val) ? [] : {}
  }
  
  function cloneUnlessOtherwiseSpecified(value, options) {
  	return (options.clone !== false && options.isMergeableObject(value))
  		? deepmerge(emptyTarget(value), value, options)
  		: value
  }
  
  function defaultArrayMerge(target, source, options) {
  	return target.concat(source).map(function(element) {
  		return cloneUnlessOtherwiseSpecified(element, options)
  	})
  }
  
  function mergeObject(target, source, options) {
  	var destination = {};
  	if (options.isMergeableObject(target)) {
  		Object.keys(target).forEach(function(key) {
  			destination[key] = cloneUnlessOtherwiseSpecified(target[key], options);
  		});
  	}
  	Object.keys(source).forEach(function(key) {
  		if (!options.isMergeableObject(source[key]) || !target[key]) {
  			destination[key] = cloneUnlessOtherwiseSpecified(source[key], options);
  		} else {
  			destination[key] = deepmerge(target[key], source[key], options);
  		}
  	});
  	return destination
  }
  
  function deepmerge(target, source, options) {
  	options = options || {};
  	options.arrayMerge = options.arrayMerge || defaultArrayMerge;
  	options.isMergeableObject = options.isMergeableObject || isMergeableObject;
  
  	var sourceIsArray = Array.isArray(source);
  	var targetIsArray = Array.isArray(target);
  	var sourceAndTargetTypesMatch = sourceIsArray === targetIsArray;
  
  	if (!sourceAndTargetTypesMatch) {
  		return cloneUnlessOtherwiseSpecified(source, options)
  	} else if (sourceIsArray) {
  		return options.arrayMerge(target, source, options)
  	} else {
  		return mergeObject(target, source, options)
  	}
  }
  
  deepmerge.all = function deepmergeAll(array, options) {
  	if (!Array.isArray(array)) {
  		throw new Error('first argument should be an array')
  	}
  
  	return array.reduce(function(prev, next) {
  		return deepmerge(prev, next, options)
  	}, {})
  };
  
  var deepmerge_1 = deepmerge;
  
  var mergeResolvers = function mergeResolvers(resolvers) {
    return resolvers.length === 1 ? resolvers[0] : deepmerge_1.all(resolvers);
  };
  
  // Import these two es7 features until we drop Node 4 support
  
  exports.mergeResolvers = mergeResolvers;
  exports.mergeTypes = mergeTypes;
  exports.fileLoader = fileLoader;
  