text: "use strict";
  var process = {
      platform: TAJS_make('AnyStr'),
      cwd: function () {
          return TAJS_make('AnyStr')
      }
  };
  
  exports.alphasort = alphasort;
  exports.alphasorti = alphasorti;
  exports.setopts = setopts;
  exports.ownProp = ownProp;
  exports.makeAbs = makeAbs;
  exports.finish = finish;
  exports.mark = mark;
  exports.isIgnored = isIgnored;
  exports.childrenIgnored = childrenIgnored;
  
  function ownProp(obj, field) {
      return Object.prototype.hasOwnProperty.call(obj, field);
  }
  
  var path = require("path");
  var minimatch = require("minimatch");
  var isAbsolute = require("path-is-absolute");
  var Minimatch = minimatch.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(gpattern, { dot: true });
      }
  
      return {
          matcher: new Minimatch(pattern, { dot: true }),
          gmatcher: gmatcher
      };
  }
  
  function setopts(self, pattern, options) {
      if (!options) options = {};
  
      // base-matching: just use globstar for that.
      if (options.matchBase && -1 === pattern.indexOf("/")) {
          if (options.noglobstar) {
              throw new Error("base matching requires globstar");
          }
          pattern = "**/" + pattern;
      }
  
      self.silent = !!options.silent;
      self.pattern = pattern;
      self.strict = options.strict !== false;
      self.realpath = !!options.realpath;
      self.realpathCache = options.realpathCache || Object.create(null);
      self.follow = !!options.follow;
      self.dot = !!options.dot;
      self.mark = !!options.mark;
      self.nodir = !!options.nodir;
      if (self.nodir) self.mark = true;
      self.sync = !!options.sync;
      self.nounique = !!options.nounique;
      self.nonull = !!options.nonull;
      self.nosort = !!options.nosort;
      self.nocase = !!options.nocase;
      self.stat = !!options.stat;
      self.noprocess = !!options.noprocess;
      self.absolute = !!options.absolute;
  
      self.maxLength = options.maxLength || Infinity;
      self.cache = options.cache || Object.create(null);
      self.statCache = options.statCache || Object.create(null);
      self.symlinks = options.symlinks || Object.create(null);
  
      setupIgnores(self, options);
  
      self.changedCwd = false;
      var cwd = process.cwd();
      if (!ownProp(options, "cwd")) self.cwd = cwd;else {
          self.cwd = path.resolve(options.cwd);
          self.changedCwd = self.cwd !== cwd;
      }
  
      self.root = options.root || path.resolve(self.cwd, "/");
      self.root = path.resolve(self.root);
      if (process.platform === "win32") self.root = self.root.replace(/\\/g, "/");
  
      // TODO: is an absolute `cwd` supposed to be resolved against `root`?
      // e.g. { cwd: '/test', root: __dirname } === path.join(__dirname, '/test')
      self.cwdAbs = isAbsolute(self.cwd) ? self.cwd : makeAbs(self, self.cwd);
      if (process.platform === "win32") self.cwdAbs = self.cwdAbs.replace(/\\/g, "/");
      self.nomount = !!options.nomount;
  
      // disable comments and negation in Minimatch.
      // Note that they are not supported in Glob itself anyway.
      options.nonegate = true;
      options.nocomment = true;
  
      self.minimatch = new Minimatch(pattern, options);
      self.options = self.minimatch.options;
  }
  
  function finish(self) {
      var nou = self.nounique;
      var all = nou ? [] : Object.create(null);
  
      for (var i = 0, l = self.matches.length; i < l; i++) {
          var matches = self.matches[i];
          if (!matches || Object.keys(matches).length === 0) {
              if (self.nonull) {
                  // do like the shell, and spit out the literal glob
                  var literal = self.minimatch.globSet[i];
                  if (nou) all.push(literal);else all[literal] = true;
              }
          } else {
              // had matches
              var m = Object.keys(matches);
              if (nou) all.push.apply(all, m);else m.forEach(function (m) {
                  all[m] = true;
              });
          }
      }
  
      if (!nou) all = Object.keys(all);
  
      if (!self.nosort) all = all.sort(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) {
      TAJS_makeContextSensitive(mark, 0);
      TAJS_makeContextSensitive(mark, 1);
      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) {
      TAJS_makeContextSensitive(makeAbs, 0);
      TAJS_makeContextSensitive(makeAbs, 1);
      var abs = f;
      if (f.charAt(0) === '/') {
          abs = path.join(self.root, f);
      } else if (isAbsolute(f) || f === '') {
          abs = f;
      } else if (self.changedCwd) {
          abs = path.resolve(self.cwd, f);
      } else {
          abs = path.resolve(f);
      }
  
      if (process.platform === 'win32') abs = abs.replace(/\\/g, '/');
  
      return abs;
  }
  
  // Return true, if pattern ends with globstar '**', for the accompanying parent directory.
  // Ex:- If node_modules/** is the pattern, add 'node_modules' to ignore list along with it's contents
  function isIgnored(self, path) {
      if (!self.ignore.length) return false;
  
      return self.ignore.some(function (item) {
          return item.matcher.match(path) || !!(item.gmatcher && item.gmatcher.match(path));
      });
  }
  
  function childrenIgnored(self, path) {
      if (!self.ignore.length) return false;
  
      return self.ignore.some(function (item) {
          return !!(item.gmatcher && item.gmatcher.match(path));
      });
  }
  