From 3c51c3be85bb0d1bdb87ea0d6632f1c256912f27 Mon Sep 17 00:00:00 2001
From: Dimitri Staessens <dimitri@ouroboros.rocks>
Date: Sun, 6 Oct 2019 21:37:45 +0200
Subject: build: Add some required modules for node

---
 node_modules/nanomatch/lib/cache.js     |   1 +
 node_modules/nanomatch/lib/compilers.js | 339 ++++++++++++++++++++++++++++
 node_modules/nanomatch/lib/parsers.js   | 386 ++++++++++++++++++++++++++++++++
 node_modules/nanomatch/lib/utils.js     | 379 +++++++++++++++++++++++++++++++
 4 files changed, 1105 insertions(+)
 create mode 100644 node_modules/nanomatch/lib/cache.js
 create mode 100644 node_modules/nanomatch/lib/compilers.js
 create mode 100644 node_modules/nanomatch/lib/parsers.js
 create mode 100644 node_modules/nanomatch/lib/utils.js

(limited to 'node_modules/nanomatch/lib')

diff --git a/node_modules/nanomatch/lib/cache.js b/node_modules/nanomatch/lib/cache.js
new file mode 100644
index 0000000..fffc4c1
--- /dev/null
+++ b/node_modules/nanomatch/lib/cache.js
@@ -0,0 +1 @@
+module.exports = new (require('fragment-cache'))();
diff --git a/node_modules/nanomatch/lib/compilers.js b/node_modules/nanomatch/lib/compilers.js
new file mode 100644
index 0000000..d7a786e
--- /dev/null
+++ b/node_modules/nanomatch/lib/compilers.js
@@ -0,0 +1,339 @@
+'use strict';
+
+/**
+* Nanomatch compilers
+*/
+
+module.exports = function(nanomatch, options) {
+  function slash() {
+    if (options && typeof options.slash === 'string') {
+      return options.slash;
+    }
+    if (options && typeof options.slash === 'function') {
+      return options.slash.call(nanomatch);
+    }
+    return '\\\\/';
+  }
+
+  function star() {
+    if (options && typeof options.star === 'string') {
+      return options.star;
+    }
+    if (options && typeof options.star === 'function') {
+      return options.star.call(nanomatch);
+    }
+    return '[^' + slash() + ']*?';
+  }
+
+  var ast = nanomatch.ast = nanomatch.parser.ast;
+  ast.state = nanomatch.parser.state;
+  nanomatch.compiler.state = ast.state;
+  nanomatch.compiler
+
+    /**
+     * Negation / escaping
+     */
+
+    .set('not', function(node) {
+      var prev = this.prev();
+      if (this.options.nonegate === true || prev.type !== 'bos') {
+        return this.emit('\\' + node.val, node);
+      }
+      return this.emit(node.val, node);
+    })
+    .set('escape', function(node) {
+      if (this.options.unescape && /^[-\w_.]/.test(node.val)) {
+        return this.emit(node.val, node);
+      }
+      return this.emit('\\' + node.val, node);
+    })
+    .set('quoted', function(node) {
+      return this.emit(node.val, node);
+    })
+
+    /**
+     * Regex
+     */
+
+    .set('dollar', function(node) {
+      if (node.parent.type === 'bracket') {
+        return this.emit(node.val, node);
+      }
+      return this.emit('\\' + node.val, node);
+    })
+
+    /**
+     * Dot: "."
+     */
+
+    .set('dot', function(node) {
+      if (node.dotfiles === true) this.dotfiles = true;
+      return this.emit('\\' + node.val, node);
+    })
+
+    /**
+     * Slashes: "/" and "\"
+     */
+
+    .set('backslash', function(node) {
+      return this.emit(node.val, node);
+    })
+    .set('slash', function(node, nodes, i) {
+      var val = '[' + slash() + ']';
+      var parent = node.parent;
+      var prev = this.prev();
+
+      // set "node.hasSlash" to true on all ancestor parens nodes
+      while (parent.type === 'paren' && !parent.hasSlash) {
+        parent.hasSlash = true;
+        parent = parent.parent;
+      }
+
+      if (prev.addQmark) {
+        val += '?';
+      }
+
+      // word boundary
+      if (node.rest.slice(0, 2) === '\\b') {
+        return this.emit(val, node);
+      }
+
+      // globstars
+      if (node.parsed === '**' || node.parsed === './**') {
+        this.output = '(?:' + this.output;
+        return this.emit(val + ')?', node);
+      }
+
+      // negation
+      if (node.parsed === '!**' && this.options.nonegate !== true) {
+        return this.emit(val + '?\\b', node);
+      }
+      return this.emit(val, node);
+    })
+
+    /**
+     * Square brackets
+     */
+
+    .set('bracket', function(node) {
+      var close = node.close;
+      var open = !node.escaped ? '[' : '\\[';
+      var negated = node.negated;
+      var inner = node.inner;
+      var val = node.val;
+
+      if (node.escaped === true) {
+        inner = inner.replace(/\\?(\W)/g, '\\$1');
+        negated = '';
+      }
+
+      if (inner === ']-') {
+        inner = '\\]\\-';
+      }
+
+      if (negated && inner.indexOf('.') === -1) {
+        inner += '.';
+      }
+      if (negated && inner.indexOf('/') === -1) {
+        inner += '/';
+      }
+
+      val = open + negated + inner + close;
+      return this.emit(val, node);
+    })
+
+    /**
+     * Square: "[.]" (only matches a single character in brackets)
+     */
+
+    .set('square', function(node) {
+      var val = (/^\W/.test(node.val) ? '\\' : '') + node.val;
+      return this.emit(val, node);
+    })
+
+    /**
+     * Question mark: "?"
+     */
+
+    .set('qmark', function(node) {
+      var prev = this.prev();
+      // don't use "slash" variable so that we always avoid
+      // matching backslashes and slashes with a qmark
+      var val = '[^.\\\\/]';
+      if (this.options.dot || (prev.type !== 'bos' && prev.type !== 'slash')) {
+        val = '[^\\\\/]';
+      }
+
+      if (node.parsed.slice(-1) === '(') {
+        var ch = node.rest.charAt(0);
+        if (ch === '!' || ch === '=' || ch === ':') {
+          return this.emit(node.val, node);
+        }
+      }
+
+      if (node.val.length > 1) {
+        val += '{' + node.val.length + '}';
+      }
+      return this.emit(val, node);
+    })
+
+    /**
+     * Plus
+     */
+
+    .set('plus', function(node) {
+      var prev = node.parsed.slice(-1);
+      if (prev === ']' || prev === ')') {
+        return this.emit(node.val, node);
+      }
+      if (!this.output || (/[?*+]/.test(ch) && node.parent.type !== 'bracket')) {
+        return this.emit('\\+', node);
+      }
+      var ch = this.output.slice(-1);
+      if (/\w/.test(ch) && !node.inside) {
+        return this.emit('+\\+?', node);
+      }
+      return this.emit('+', node);
+    })
+
+    /**
+     * globstar: '**'
+     */
+
+    .set('globstar', function(node, nodes, i) {
+      if (!this.output) {
+        this.state.leadingGlobstar = true;
+      }
+
+      var prev = this.prev();
+      var before = this.prev(2);
+      var next = this.next();
+      var after = this.next(2);
+      var type = prev.type;
+      var val = node.val;
+
+      if (prev.type === 'slash' && next.type === 'slash') {
+        if (before.type === 'text') {
+          this.output += '?';
+
+          if (after.type !== 'text') {
+            this.output += '\\b';
+          }
+        }
+      }
+
+      var parsed = node.parsed;
+      if (parsed.charAt(0) === '!') {
+        parsed = parsed.slice(1);
+      }
+
+      var isInside = node.isInside.paren || node.isInside.brace;
+      if (parsed && type !== 'slash' && type !== 'bos' && !isInside) {
+        val = star();
+      } else {
+        val = this.options.dot !== true
+          ? '(?:(?!(?:[' + slash() + ']|^)\\.).)*?'
+          : '(?:(?!(?:[' + slash() + ']|^)(?:\\.{1,2})($|[' + slash() + ']))(?!\\.{2}).)*?';
+      }
+
+      if ((type === 'slash' || type === 'bos') && this.options.dot !== true) {
+        val = '(?!\\.)' + val;
+      }
+
+      if (prev.type === 'slash' && next.type === 'slash' && before.type !== 'text') {
+        if (after.type === 'text' || after.type === 'star') {
+          node.addQmark = true;
+        }
+      }
+
+      if (this.options.capture) {
+        val = '(' + val + ')';
+      }
+
+      return this.emit(val, node);
+    })
+
+    /**
+     * Star: "*"
+     */
+
+    .set('star', function(node, nodes, i) {
+      var prior = nodes[i - 2] || {};
+      var prev = this.prev();
+      var next = this.next();
+      var type = prev.type;
+
+      function isStart(n) {
+        return n.type === 'bos' || n.type === 'slash';
+      }
+
+      if (this.output === '' && this.options.contains !== true) {
+        this.output = '(?![' + slash() + '])';
+      }
+
+      if (type === 'bracket' && this.options.bash === false) {
+        var str = next && next.type === 'bracket' ? star() : '*?';
+        if (!prev.nodes || prev.nodes[1].type !== 'posix') {
+          return this.emit(str, node);
+        }
+      }
+
+      var prefix = !this.dotfiles && type !== 'text' && type !== 'escape'
+        ? (this.options.dot ? '(?!(?:^|[' + slash() + '])\\.{1,2}(?:$|[' + slash() + ']))' : '(?!\\.)')
+        : '';
+
+      if (isStart(prev) || (isStart(prior) && type === 'not')) {
+        if (prefix !== '(?!\\.)') {
+          prefix += '(?!(\\.{2}|\\.[' + slash() + ']))(?=.)';
+        } else {
+          prefix += '(?=.)';
+        }
+      } else if (prefix === '(?!\\.)') {
+        prefix = '';
+      }
+
+      if (prev.type === 'not' && prior.type === 'bos' && this.options.dot === true) {
+        this.output = '(?!\\.)' + this.output;
+      }
+
+      var output = prefix + star();
+      if (this.options.capture) {
+        output = '(' + output + ')';
+      }
+
+      return this.emit(output, node);
+    })
+
+    /**
+     * Text
+     */
+
+    .set('text', function(node) {
+      return this.emit(node.val, node);
+    })
+
+    /**
+     * End-of-string
+     */
+
+    .set('eos', function(node) {
+      var prev = this.prev();
+      var val = node.val;
+
+      this.output = '(?:\\.[' + slash() + '](?=.))?' + this.output;
+      if (this.state.metachar && prev.type !== 'qmark' && prev.type !== 'slash') {
+        val += (this.options.contains ? '[' + slash() + ']?' : '(?:[' + slash() + ']|$)');
+      }
+
+      return this.emit(val, node);
+    });
+
+  /**
+   * Allow custom compilers to be passed on options
+   */
+
+  if (options && typeof options.compilers === 'function') {
+    options.compilers(nanomatch.compiler);
+  }
+};
+
diff --git a/node_modules/nanomatch/lib/parsers.js b/node_modules/nanomatch/lib/parsers.js
new file mode 100644
index 0000000..f87df8f
--- /dev/null
+++ b/node_modules/nanomatch/lib/parsers.js
@@ -0,0 +1,386 @@
+'use strict';
+
+var regexNot = require('regex-not');
+var toRegex = require('to-regex');
+
+/**
+ * Characters to use in negation regex (we want to "not" match
+ * characters that are matched by other parsers)
+ */
+
+var cached;
+var NOT_REGEX = '[\\[!*+?$^"\'.\\\\/]+';
+var not = createTextRegex(NOT_REGEX);
+
+/**
+ * Nanomatch parsers
+ */
+
+module.exports = function(nanomatch, options) {
+  var parser = nanomatch.parser;
+  var opts = parser.options;
+
+  parser.state = {
+    slashes: 0,
+    paths: []
+  };
+
+  parser.ast.state = parser.state;
+  parser
+
+    /**
+     * Beginning-of-string
+     */
+
+    .capture('prefix', function() {
+      if (this.parsed) return;
+      var m = this.match(/^\.[\\/]/);
+      if (!m) return;
+      this.state.strictOpen = !!this.options.strictOpen;
+      this.state.addPrefix = true;
+    })
+
+    /**
+     * Escape: "\\."
+     */
+
+    .capture('escape', function() {
+      if (this.isInside('bracket')) return;
+      var pos = this.position();
+      var m = this.match(/^(?:\\(.)|([$^]))/);
+      if (!m) return;
+
+      return pos({
+        type: 'escape',
+        val: m[2] || m[1]
+      });
+    })
+
+    /**
+     * Quoted strings
+     */
+
+    .capture('quoted', function() {
+      var pos = this.position();
+      var m = this.match(/^["']/);
+      if (!m) return;
+
+      var quote = m[0];
+      if (this.input.indexOf(quote) === -1) {
+        return pos({
+          type: 'escape',
+          val: quote
+        });
+      }
+
+      var tok = advanceTo(this.input, quote);
+      this.consume(tok.len);
+
+      return pos({
+        type: 'quoted',
+        val: tok.esc
+      });
+    })
+
+    /**
+     * Negations: "!"
+     */
+
+    .capture('not', function() {
+      var parsed = this.parsed;
+      var pos = this.position();
+      var m = this.match(this.notRegex || /^!+/);
+      if (!m) return;
+      var val = m[0];
+
+      var isNegated = (val.length % 2) === 1;
+      if (parsed === '' && !isNegated) {
+        val = '';
+      }
+
+      // if nothing has been parsed, we know `!` is at the start,
+      // so we need to wrap the result in a negation regex
+      if (parsed === '' && isNegated && this.options.nonegate !== true) {
+        this.bos.val = '(?!^(?:';
+        this.append = ')$).*';
+        val = '';
+      }
+      return pos({
+        type: 'not',
+        val: val
+      });
+    })
+
+    /**
+     * Dot: "."
+     */
+
+    .capture('dot', function() {
+      var parsed = this.parsed;
+      var pos = this.position();
+      var m = this.match(/^\.+/);
+      if (!m) return;
+
+      var val = m[0];
+      this.state.dot = val === '.' && (parsed === '' || parsed.slice(-1) === '/');
+
+      return pos({
+        type: 'dot',
+        dotfiles: this.state.dot,
+        val: val
+      });
+    })
+
+    /**
+     * Plus: "+"
+     */
+
+    .capture('plus', /^\+(?!\()/)
+
+    /**
+     * Question mark: "?"
+     */
+
+    .capture('qmark', function() {
+      var parsed = this.parsed;
+      var pos = this.position();
+      var m = this.match(/^\?+(?!\()/);
+      if (!m) return;
+
+      this.state.metachar = true;
+      this.state.qmark = true;
+
+      return pos({
+        type: 'qmark',
+        parsed: parsed,
+        val: m[0]
+      });
+    })
+
+    /**
+     * Globstar: "**"
+     */
+
+    .capture('globstar', function() {
+      var parsed = this.parsed;
+      var pos = this.position();
+      var m = this.match(/^\*{2}(?![*(])(?=[,)/]|$)/);
+      if (!m) return;
+
+      var type = opts.noglobstar !== true ? 'globstar' : 'star';
+      var node = pos({type: type, parsed: parsed});
+      this.state.metachar = true;
+
+      while (this.input.slice(0, 4) === '/**/') {
+        this.input = this.input.slice(3);
+      }
+
+      node.isInside = {
+        brace: this.isInside('brace'),
+        paren: this.isInside('paren')
+      };
+
+      if (type === 'globstar') {
+        this.state.globstar = true;
+        node.val = '**';
+
+      } else {
+        this.state.star = true;
+        node.val = '*';
+      }
+
+      return node;
+    })
+
+    /**
+     * Star: "*"
+     */
+
+    .capture('star', function() {
+      var pos = this.position();
+      var starRe = /^(?:\*(?![*(])|[*]{3,}(?!\()|[*]{2}(?![(/]|$)|\*(?=\*\())/;
+      var m = this.match(starRe);
+      if (!m) return;
+
+      this.state.metachar = true;
+      this.state.star = true;
+      return pos({
+        type: 'star',
+        val: m[0]
+      });
+    })
+
+    /**
+     * Slash: "/"
+     */
+
+    .capture('slash', function() {
+      var pos = this.position();
+      var m = this.match(/^\//);
+      if (!m) return;
+
+      this.state.slashes++;
+      return pos({
+        type: 'slash',
+        val: m[0]
+      });
+    })
+
+    /**
+     * Backslash: "\\"
+     */
+
+    .capture('backslash', function() {
+      var pos = this.position();
+      var m = this.match(/^\\(?![*+?(){}[\]'"])/);
+      if (!m) return;
+
+      var val = m[0];
+
+      if (this.isInside('bracket')) {
+        val = '\\';
+      } else if (val.length > 1) {
+        val = '\\\\';
+      }
+
+      return pos({
+        type: 'backslash',
+        val: val
+      });
+    })
+
+    /**
+     * Square: "[.]"
+     */
+
+    .capture('square', function() {
+      if (this.isInside('bracket')) return;
+      var pos = this.position();
+      var m = this.match(/^\[([^!^\\])\]/);
+      if (!m) return;
+
+      return pos({
+        type: 'square',
+        val: m[1]
+      });
+    })
+
+    /**
+     * Brackets: "[...]" (basic, this can be overridden by other parsers)
+     */
+
+    .capture('bracket', function() {
+      var pos = this.position();
+      var m = this.match(/^(?:\[([!^]?)([^\]]+|\]-)(\]|[^*+?]+)|\[)/);
+      if (!m) return;
+
+      var val = m[0];
+      var negated = m[1] ? '^' : '';
+      var inner = (m[2] || '').replace(/\\\\+/, '\\\\');
+      var close = m[3] || '';
+
+      if (m[2] && inner.length < m[2].length) {
+        val = val.replace(/\\\\+/, '\\\\');
+      }
+
+      var esc = this.input.slice(0, 2);
+      if (inner === '' && esc === '\\]') {
+        inner += esc;
+        this.consume(2);
+
+        var str = this.input;
+        var idx = -1;
+        var ch;
+
+        while ((ch = str[++idx])) {
+          this.consume(1);
+          if (ch === ']') {
+            close = ch;
+            break;
+          }
+          inner += ch;
+        }
+      }
+
+      return pos({
+        type: 'bracket',
+        val: val,
+        escaped: close !== ']',
+        negated: negated,
+        inner: inner,
+        close: close
+      });
+    })
+
+    /**
+     * Text
+     */
+
+    .capture('text', function() {
+      if (this.isInside('bracket')) return;
+      var pos = this.position();
+      var m = this.match(not);
+      if (!m || !m[0]) return;
+
+      return pos({
+        type: 'text',
+        val: m[0]
+      });
+    });
+
+  /**
+   * Allow custom parsers to be passed on options
+   */
+
+  if (options && typeof options.parsers === 'function') {
+    options.parsers(nanomatch.parser);
+  }
+};
+
+/**
+ * Advance to the next non-escaped character
+ */
+
+function advanceTo(input, endChar) {
+  var ch = input.charAt(0);
+  var tok = { len: 1, val: '', esc: '' };
+  var idx = 0;
+
+  function advance() {
+    if (ch !== '\\') {
+      tok.esc += '\\' + ch;
+      tok.val += ch;
+    }
+
+    ch = input.charAt(++idx);
+    tok.len++;
+
+    if (ch === '\\') {
+      advance();
+      advance();
+    }
+  }
+
+  while (ch && ch !== endChar) {
+    advance();
+  }
+  return tok;
+}
+
+/**
+ * Create text regex
+ */
+
+function createTextRegex(pattern) {
+  if (cached) return cached;
+  var opts = {contains: true, strictClose: false};
+  var not = regexNot.create(pattern, opts);
+  var re = toRegex('^(?:[*]\\((?=.)|' + not + ')', opts);
+  return (cached = re);
+}
+
+/**
+ * Expose negation string
+ */
+
+module.exports.not = NOT_REGEX;
diff --git a/node_modules/nanomatch/lib/utils.js b/node_modules/nanomatch/lib/utils.js
new file mode 100644
index 0000000..0cf1501
--- /dev/null
+++ b/node_modules/nanomatch/lib/utils.js
@@ -0,0 +1,379 @@
+'use strict';
+
+var utils = module.exports;
+var path = require('path');
+
+/**
+ * Module dependencies
+ */
+
+var isWindows = require('is-windows')();
+var Snapdragon = require('snapdragon');
+utils.define = require('define-property');
+utils.diff = require('arr-diff');
+utils.extend = require('extend-shallow');
+utils.pick = require('object.pick');
+utils.typeOf = require('kind-of');
+utils.unique = require('array-unique');
+
+/**
+ * Returns true if the given value is effectively an empty string
+ */
+
+utils.isEmptyString = function(val) {
+  return String(val) === '' || String(val) === './';
+};
+
+/**
+ * Returns true if the platform is windows, or `path.sep` is `\\`.
+ * This is defined as a function to allow `path.sep` to be set in unit tests,
+ * or by the user, if there is a reason to do so.
+ * @return {Boolean}
+ */
+
+utils.isWindows = function() {
+  return path.sep === '\\' || isWindows === true;
+};
+
+/**
+ * Return the last element from an array
+ */
+
+utils.last = function(arr, n) {
+  return arr[arr.length - (n || 1)];
+};
+
+/**
+ * Get the `Snapdragon` instance to use
+ */
+
+utils.instantiate = function(ast, options) {
+  var snapdragon;
+  // if an instance was created by `.parse`, use that instance
+  if (utils.typeOf(ast) === 'object' && ast.snapdragon) {
+    snapdragon = ast.snapdragon;
+  // if the user supplies an instance on options, use that instance
+  } else if (utils.typeOf(options) === 'object' && options.snapdragon) {
+    snapdragon = options.snapdragon;
+  // create a new instance
+  } else {
+    snapdragon = new Snapdragon(options);
+  }
+
+  utils.define(snapdragon, 'parse', function(str, options) {
+    var parsed = Snapdragon.prototype.parse.call(this, str, options);
+    parsed.input = str;
+
+    // escape unmatched brace/bracket/parens
+    var last = this.parser.stack.pop();
+    if (last && this.options.strictErrors !== true) {
+      var open = last.nodes[0];
+      var inner = last.nodes[1];
+      if (last.type === 'bracket') {
+        if (inner.val.charAt(0) === '[') {
+          inner.val = '\\' + inner.val;
+        }
+
+      } else {
+        open.val = '\\' + open.val;
+        var sibling = open.parent.nodes[1];
+        if (sibling.type === 'star') {
+          sibling.loose = true;
+        }
+      }
+    }
+
+    // add non-enumerable parser reference
+    utils.define(parsed, 'parser', this.parser);
+    return parsed;
+  });
+
+  return snapdragon;
+};
+
+/**
+ * Create the key to use for memoization. The key is generated
+ * by iterating over the options and concatenating key-value pairs
+ * to the pattern string.
+ */
+
+utils.createKey = function(pattern, options) {
+  if (typeof options === 'undefined') {
+    return pattern;
+  }
+  var key = pattern;
+  for (var prop in options) {
+    if (options.hasOwnProperty(prop)) {
+      key += ';' + prop + '=' + String(options[prop]);
+    }
+  }
+  return key;
+};
+
+/**
+ * Cast `val` to an array
+ * @return {Array}
+ */
+
+utils.arrayify = function(val) {
+  if (typeof val === 'string') return [val];
+  return val ? (Array.isArray(val) ? val : [val]) : [];
+};
+
+/**
+ * Return true if `val` is a non-empty string
+ */
+
+utils.isString = function(val) {
+  return typeof val === 'string';
+};
+
+/**
+ * Return true if `val` is a non-empty string
+ */
+
+utils.isRegex = function(val) {
+  return utils.typeOf(val) === 'regexp';
+};
+
+/**
+ * Return true if `val` is a non-empty string
+ */
+
+utils.isObject = function(val) {
+  return utils.typeOf(val) === 'object';
+};
+
+/**
+ * Escape regex characters in the given string
+ */
+
+utils.escapeRegex = function(str) {
+  return str.replace(/[-[\]{}()^$|*+?.\\/\s]/g, '\\$&');
+};
+
+/**
+ * Combines duplicate characters in the provided `input` string.
+ * @param {String} `input`
+ * @returns {String}
+ */
+
+utils.combineDupes = function(input, patterns) {
+  patterns = utils.arrayify(patterns).join('|').split('|');
+  patterns = patterns.map(function(s) {
+    return s.replace(/\\?([+*\\/])/g, '\\$1');
+  });
+  var substr = patterns.join('|');
+  var regex = new RegExp('(' + substr + ')(?=\\1)', 'g');
+  return input.replace(regex, '');
+};
+
+/**
+ * Returns true if the given `str` has special characters
+ */
+
+utils.hasSpecialChars = function(str) {
+  return /(?:(?:(^|\/)[!.])|[*?+()|[\]{}]|[+@]\()/.test(str);
+};
+
+/**
+ * Normalize slashes in the given filepath.
+ *
+ * @param {String} `filepath`
+ * @return {String}
+ */
+
+utils.toPosixPath = function(str) {
+  return str.replace(/\\+/g, '/');
+};
+
+/**
+ * Strip backslashes before special characters in a string.
+ *
+ * @param {String} `str`
+ * @return {String}
+ */
+
+utils.unescape = function(str) {
+  return utils.toPosixPath(str.replace(/\\(?=[*+?!.])/g, ''));
+};
+
+/**
+ * Strip the drive letter from a windows filepath
+ * @param {String} `fp`
+ * @return {String}
+ */
+
+utils.stripDrive = function(fp) {
+  return utils.isWindows() ? fp.replace(/^[a-z]:[\\/]+?/i, '/') : fp;
+};
+
+/**
+ * Strip the prefix from a filepath
+ * @param {String} `fp`
+ * @return {String}
+ */
+
+utils.stripPrefix = function(str) {
+  if (str.charAt(0) === '.' && (str.charAt(1) === '/' || str.charAt(1) === '\\')) {
+    return str.slice(2);
+  }
+  return str;
+};
+
+/**
+ * Returns true if `str` is a common character that doesn't need
+ * to be processed to be used for matching.
+ * @param {String} `str`
+ * @return {Boolean}
+ */
+
+utils.isSimpleChar = function(str) {
+  return str.trim() === '' || str === '.';
+};
+
+/**
+ * Returns true if the given str is an escaped or
+ * unescaped path character
+ */
+
+utils.isSlash = function(str) {
+  return str === '/' || str === '\\/' || str === '\\' || str === '\\\\';
+};
+
+/**
+ * Returns a function that returns true if the given
+ * pattern matches or contains a `filepath`
+ *
+ * @param {String} `pattern`
+ * @return {Function}
+ */
+
+utils.matchPath = function(pattern, options) {
+  return (options && options.contains)
+    ? utils.containsPattern(pattern, options)
+    : utils.equalsPattern(pattern, options);
+};
+
+/**
+ * Returns true if the given (original) filepath or unixified path are equal
+ * to the given pattern.
+ */
+
+utils._equals = function(filepath, unixPath, pattern) {
+  return pattern === filepath || pattern === unixPath;
+};
+
+/**
+ * Returns true if the given (original) filepath or unixified path contain
+ * the given pattern.
+ */
+
+utils._contains = function(filepath, unixPath, pattern) {
+  return filepath.indexOf(pattern) !== -1 || unixPath.indexOf(pattern) !== -1;
+};
+
+/**
+ * Returns a function that returns true if the given
+ * pattern is the same as a given `filepath`
+ *
+ * @param {String} `pattern`
+ * @return {Function}
+ */
+
+utils.equalsPattern = function(pattern, options) {
+  var unixify = utils.unixify(options);
+  options = options || {};
+
+  return function fn(filepath) {
+    var equal = utils._equals(filepath, unixify(filepath), pattern);
+    if (equal === true || options.nocase !== true) {
+      return equal;
+    }
+    var lower = filepath.toLowerCase();
+    return utils._equals(lower, unixify(lower), pattern);
+  };
+};
+
+/**
+ * Returns a function that returns true if the given
+ * pattern contains a `filepath`
+ *
+ * @param {String} `pattern`
+ * @return {Function}
+ */
+
+utils.containsPattern = function(pattern, options) {
+  var unixify = utils.unixify(options);
+  options = options || {};
+
+  return function(filepath) {
+    var contains = utils._contains(filepath, unixify(filepath), pattern);
+    if (contains === true || options.nocase !== true) {
+      return contains;
+    }
+    var lower = filepath.toLowerCase();
+    return utils._contains(lower, unixify(lower), pattern);
+  };
+};
+
+/**
+ * Returns a function that returns true if the given
+ * regex matches the `filename` of a file path.
+ *
+ * @param {RegExp} `re` Matching regex
+ * @return {Function}
+ */
+
+utils.matchBasename = function(re) {
+  return function(filepath) {
+    return re.test(filepath) || re.test(path.basename(filepath));
+  };
+};
+
+/**
+ * Returns the given value unchanced.
+ * @return {any}
+ */
+
+utils.identity = function(val) {
+  return val;
+};
+
+/**
+ * Determines the filepath to return based on the provided options.
+ * @return {any}
+ */
+
+utils.value = function(str, unixify, options) {
+  if (options && options.unixify === false) {
+    return str;
+  }
+  if (options && typeof options.unixify === 'function') {
+    return options.unixify(str);
+  }
+  return unixify(str);
+};
+
+/**
+ * Returns a function that normalizes slashes in a string to forward
+ * slashes, strips `./` from beginning of paths, and optionally unescapes
+ * special characters.
+ * @return {Function}
+ */
+
+utils.unixify = function(options) {
+  var opts = options || {};
+  return function(filepath) {
+    if (opts.stripPrefix !== false) {
+      filepath = utils.stripPrefix(filepath);
+    }
+    if (opts.unescape === true) {
+      filepath = utils.unescape(filepath);
+    }
+    if (opts.unixify === true || utils.isWindows()) {
+      filepath = utils.toPosixPath(filepath);
+    }
+    return filepath;
+  };
+};
-- 
cgit v1.2.3